sync github copilot limits

add OpenRouter models for gpt-5.4 mini and gpt-5.4 nano

.github/workflows/opencode.yml

@@ -7,8 +7,10 @@ on:
 jobs:
   opencode:
     if: |
-      contains(github.event.comment.body, '/oc') ||
-      contains(github.event.comment.body, '/opencode')
+      contains(github.event.comment.body, ' /oc') ||
+      startsWith(github.event.comment.body, '/oc') ||
+      contains(github.event.comment.body, ' /opencode') ||
+      startsWith(github.event.comment.body, '/opencode')
     runs-on: ubuntu-latest
     permissions:
       contents: read
@@ -22,4 +24,4 @@ jobs:
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
         with:
-          model: anthropic/claude-sonnet-4-20250514
+          model: anthropic/claude-sonnet-4-20250514

.gitignore

@@ -1,5 +1,9 @@
 .env
 .sst
+.idea
 dist
 .DS_Store
 node_modules
+data/tokenspeed-monitor.sqlite
+data/tokenspeed-monitor.sqlite-shm
+data/tokenspeed-monitor.sqlite-wal

AGENTS.md

@@ -26,4 +26,32 @@
 - Use `export interface` for API types, `export const Schema = z.object()` for validation
 - Prefix unused variables with underscore or use `_` for ignored parameters
 - Handle undefined values explicitly in comparisons and sorting
-- Use optional chaining (`?.`) and nullish coalescing (`??`) for safe property access
+- Use optional chaining (`?.`) and nullish coalescing (`??`) for safe property access
+
+## Model Configuration
+
+- Model `id` is **auto-injected** from filename (minus `.toml`) — never put `id` in TOML files
+- Same model is duplicated across provider directories with no cross-referencing
+- Schema uses `.strict()` — extra fields cause validation errors
+
+### Bedrock Naming Patterns
+- Dated models: `-v1:0` suffix (`anthropic.claude-3-5-sonnet-20241022-v1:0.toml`)
+- Latest/undated models: bare `-v1` (`anthropic.claude-opus-4-6-v1.toml`)
+- Region prefixes: `us.`, `eu.`, `global.` (default has no prefix)
+
+### Vertex AI Naming Patterns
+- Dated models: `@YYYYMMDD` (`claude-opus-4-5@20251101.toml`)
+- Latest/undated models: `@default` (`claude-opus-4-6@default.toml`)
+
+### Cost Schema
+- `cost.context_over_200k` is a nested `Cost` object for >200K token pricing
+- Cache pricing ratios: standard models use 10%/125% (read/write), regional variants may use 30%/375%
+
+### Required vs Optional Fields
+| Field | Required? | Notes |
+|-------|-----------|-------|
+| `name`, `release_date`, `last_updated` | Yes | Human-readable metadata |
+| `attachment`, `reasoning`, `tool_call`, `open_weights` | Yes | Boolean capabilities |
+| `cost`, `limit`, `modalities` | Yes | Objects with their own required fields |
+| `family`, `knowledge`, `temperature`, `structured_output` | No | Optional metadata |
+| `status` | No | Use for `"alpha"`, `"beta"`, `"deprecated"` lifecycle |

README.md

@@ -109,7 +109,7 @@ output_audio = 10.00        # Cost per million audio output tokens (USD)
 
 [limit]
 context = 400_000           # Maximum context window (tokens)
-context = 272_000           # Maximum input tokens
+input = 272_000             # Maximum input tokens
 output = 8_192              # Maximum output tokens
 
 [modalities]
@@ -199,6 +199,17 @@ $ bun run dev
 
 And it'll open the frontend at http://localhost:3000
 
+### Manual testing with opencode
+
+You can manually check provider changes with opencode by:
+
+```bash
+$ bun install
+$ cd packages/web
+$ bun run build
+$ OPENCODE_MODELS_PATH="dist/_api.json" opencode
+```
+
 ### Questions?
 
 Open an issue if you need help or have questions about contributing.

package.json

@@ -17,7 +17,9 @@
   "scripts": {
     "validate": "bun ./packages/core/script/validate.ts",
     "helicone:generate": "bun ./packages/core/script/generate-helicone.ts",
-    "venice:generate": "bun ./packages/core/script/generate-venice.ts"
+    "venice:generate": "bun ./packages/core/script/generate-venice.ts",
+    "vercel:generate": "bun ./packages/core/script/generate-vercel.ts",
+    "wandb:generate": "bun ./packages/core/script/generate-wandb.ts"
   },
   "dependencies": {
     "@cloudflare/workers-types": "^4.20250801.0",

packages/core/script/generate-friendli.ts

@@ -48,8 +48,8 @@ const familyPatterns: [RegExp, string][] = [
   [/llama-4/i, "llama-4"],
   [/qwen3/i, "qwen3"],
   [/deepseek-r1/i, "deepseek-r1"],
-  [/exaone/i, "exaone"],
   [/glm-4/i, "glm-4"],
+  [/glm-5/i, "glm"],
 ];
 
 function inferFamily(modelId: string, modelName: string): string | undefined {

packages/core/script/generate-ollama-cloud.ts

@@ -0,0 +1,237 @@
+#!/usr/bin/env bun
+
+/**
+ * Generates model files from the data in Ollama Cloud's API.
+ *
+ * Ollama Cloud does not provide some data fields, such as release date or
+ * knowledge cutoff. The `family` field provided by Ollama Cloud may not match
+ * the values in family.ts. We expect that when TOML validaton fails, the
+ * maintainer will manually source those data points (such as from other
+ * provider TOML files, or from the internet at large). This script preserves
+ * those fields when overwriting Ollama Cloud's TOML files.
+ */
+
+import { z } from "zod";
+import path from "node:path";
+
+import type { Model } from "../src/schema";
+import type { ModelFamily } from "../src/family";
+
+const modelsDir = path.join(
+  import.meta.dirname,
+  "..",
+  "..",
+  "..",
+  "providers",
+  "ollama-cloud",
+  "models"
+);
+
+function modelFileName(modelName: string): string {
+  return modelName + ".toml";
+}
+
+type OllamaModel = Omit<Model, "id"> & {
+  limit: Model["limit"] & { output?: number };
+};
+
+type ComparableModel = Pick<Model,
+  | "name"
+  | "attachment"
+  | "reasoning"
+  | "tool_call"
+  | "knowledge"
+  | "open_weights"
+  | "modalities"
+> & {
+  limit: Pick<Model["limit"], "context">;
+};
+
+function normalizeForComparison(model: Omit<Model, "id">): ComparableModel {
+  return {
+    name: model.name,
+    attachment: model.attachment,
+    reasoning: model.reasoning,
+    tool_call: model.tool_call,
+    knowledge: model.knowledge,
+    open_weights: model.open_weights,
+    limit: { context: model.limit.context },
+    modalities: model.modalities,
+  };
+}
+
+const OllamaTagsResponse = z.object({
+  models: z.array(
+    z.object({
+      name: z.string(),
+    })
+  ),
+});
+
+type OllamaTagsResponse = z.infer<typeof OllamaTagsResponse>;
+
+const OllamaModelDetails = z.object({
+  modified_at: z.string(),
+  details: z.object({
+    parent_model: z.string(),
+    format: z.string(),
+    family: z.string(),
+    families: z.array(z.string()).nullable(),
+    parameter_size: z.string().transform(Number),
+    quantization_level: z.string(),
+  }),
+  model_info: z.record(z.union([z.string(), z.number()])),
+  capabilities: z.array(z.enum(["thinking", "completion", "tools", "vision"])),
+});
+
+type OllamaModelDetails = z.infer<typeof OllamaModelDetails>;
+
+function generateToml(modelName: string, model: OllamaModel): string {
+  const lines: string[] = [];
+
+  lines.push(`name = "${modelName}"`);
+  lines.push(`family = "${model.family}"`);
+  lines.push(`attachment = ${model.attachment}`);
+  lines.push(`reasoning = ${model.reasoning}`);
+  lines.push(`tool_call = ${model.tool_call}`);
+  if (model.release_date) {
+    lines.push(`release_date = "${model.release_date}"`);
+  }
+  if (model.knowledge) {
+    lines.push(`knowledge = "${model.knowledge}"`);
+  }
+  lines.push(`last_updated = "${model.last_updated}"`);
+  lines.push(`open_weights = ${model.open_weights}`);
+  lines.push("");
+  lines.push("[limit]");
+  lines.push(`context = ${model.limit.context}`);
+  if (model.limit.output !== undefined) {
+    lines.push(`output = ${model.limit.output}`);
+  }
+  lines.push("");
+  lines.push("[modalities]");
+  lines.push(`input = ${JSON.stringify(model.modalities.input)}`);
+  lines.push(`output = ${JSON.stringify(model.modalities.output)}`);
+  return lines.join("\n") + "\n";
+}
+
+const tagsResponse = await fetch("https://ollama.com/api/tags");
+if (!tagsResponse.ok) {
+  console.error(
+    `Failed to fetch tags: ${tagsResponse.status} ${tagsResponse.statusText}`
+  );
+  process.exit(1);
+}
+
+const tagsJson = await tagsResponse.json();
+const tagsParsed = OllamaTagsResponse.safeParse(tagsJson);
+if (!tagsParsed.success) {
+  console.error("Invalid tags response:", tagsParsed.error.errors);
+  process.exit(1);
+}
+const tagsData: OllamaTagsResponse = tagsParsed.data;
+const modelNames = tagsData.models.map((m) => m.name);
+
+console.log(`Fetching details for ${modelNames.length} models...`);
+
+const modelsData: Array<{ name: string; data: OllamaModelDetails }> = [];
+for (const modelName of modelNames) {
+  const showResponse = await fetch("https://ollama.com/api/show", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ model: modelName }),
+  });
+
+  if (!showResponse.ok) {
+    console.error(
+      `Failed to fetch details for ${modelName}: ${showResponse.status} ${showResponse.statusText}`
+    );
+    process.exit(1);
+  }
+
+  const showJson = await showResponse.json();
+  const showParsed = OllamaModelDetails.safeParse(showJson);
+  if (!showParsed.success) {
+    console.error(
+      `Invalid response for ${modelName}:`,
+      showParsed.error.errors
+    );
+    process.exit(1);
+  }
+
+  modelsData.push({ name: modelName, data: showParsed.data });
+}
+
+console.log(`Fetched all models. Syncing files...`);
+
+const existingFiles = Array.from(new Bun.Glob("*.toml").scanSync(modelsDir));
+const existingModelNames = new Set(existingFiles.map((f) => f.replace(/\.toml$/, "")));
+const apiModelNames = new Set(modelNames);
+
+let deleted = 0;
+for (const existingName of existingModelNames) {
+  if (!apiModelNames.has(existingName)) {
+    const filePath = path.join(modelsDir, modelFileName(existingName));
+    await Bun.file(filePath).delete();
+    console.log(`Deleted: ${modelFileName(existingName)}`);
+    deleted++;
+  }
+}
+
+let created = 0;
+let skipped = 0;
+for (const { name, data } of modelsData) {
+  const fileName = modelFileName(name);
+  const filePath = path.join(modelsDir, fileName);
+
+  let existingData: Omit<Model, "id"> | null = null;
+  try {
+    const existingToml = await Bun.file(filePath).text();
+    existingData = Bun.TOML.parse(existingToml) as Omit<Model, "id">;
+  } catch {
+    // File doesn't exist
+  }
+
+  const family = existingData?.family ?? (data.details.family as ModelFamily);
+  const contextLength =
+    (data.model_info[`${data.details.family}.context_length`] as number) ?? 0;
+
+  const ollamaModel: OllamaModel = {
+    name,
+    family,
+    attachment: data.capabilities.includes("vision"),
+    reasoning: data.capabilities.includes("thinking"),
+    tool_call: data.capabilities.includes("tools"),
+    release_date: existingData?.release_date,
+    knowledge: existingData?.knowledge,
+    last_updated: new Date().toISOString().slice(0, 10),
+    open_weights: true,
+    modalities: {
+      input: data.capabilities.includes("vision")
+        ? ["text", "image"]
+        : ["text"],
+      output: ["text"],
+    },
+    limit: {
+      context: contextLength,
+      output: existingData?.limit.output,
+    },
+  };
+
+  if (existingData) {
+    const normalizedExisting = normalizeForComparison(existingData);
+    const normalizedIncoming = normalizeForComparison(ollamaModel);
+
+    if (Bun.deepEquals(normalizedExisting, normalizedIncoming)) {
+      console.log(`Skipped (no changes): ${fileName}`);
+      skipped++;
+      continue;
+    }
+  }
+
+  await Bun.write(filePath, generateToml(name, ollamaModel));
+  console.log(`Created: ${fileName}`);
+  created++;
+}
+
+console.log(`\nDone. Created: ${created}, Skipped: ${skipped}, Deleted: ${deleted}`);

packages/core/script/generate-venice.ts

@@ -3,29 +3,11 @@
 import { z } from "zod";
 import path from "node:path";
 import { readdir } from "node:fs/promises";
-import * as readline from "node:readline";
+import { ModelFamilyValues } from "../src/family.js";
 
 // Venice API endpoint
 const API_ENDPOINT = "https://api.venice.ai/api/v1/models?type=text";
 
-async function promptForApiKey(): Promise<string | null> {
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-  });
-
-  return new Promise((resolve) => {
-    rl.question(
-      "Enter Venice API key to include alpha models (or press Enter to skip): ",
-      (answer) => {
-        rl.close();
-        const trimmed = answer.trim();
-        resolve(trimmed.length > 0 ? trimmed : null);
-      },
-    );
-  });
-}
-
 // Zod schemas for API response validation
 const Capabilities = z
   .object({
@@ -42,12 +24,25 @@ const Capabilities = z
   })
   .passthrough();
 
+const PricingTier = z.object({ usd: z.number(), diem: z.number().optional() }).passthrough();
+
+const ExtendedPricing = z
+  .object({
+    context_token_threshold: z.number(),
+    input: PricingTier,
+    output: PricingTier,
+    cache_input: PricingTier.optional(),
+    cache_write: PricingTier.optional(),
+  })
+  .passthrough();
+
 const Pricing = z
   .object({
-    input: z.object({ usd: z.number(), diem: z.number().optional() }).passthrough(),
-    output: z.object({ usd: z.number(), diem: z.number().optional() }).passthrough(),
-    cache_input: z.object({ usd: z.number(), diem: z.number().optional() }).passthrough().optional(),
-    cache_write: z.object({ usd: z.number(), diem: z.number().optional() }).passthrough().optional(),
+    input: PricingTier,
+    output: PricingTier,
+    cache_input: PricingTier.optional(),
+    cache_write: PricingTier.optional(),
+    extended: ExtendedPricing.optional(),
   })
   .passthrough();
 
@@ -55,11 +50,13 @@ const ModelSpec = z
   .object({
     pricing: Pricing.optional(),
     availableContextTokens: z.number(),
+    maxCompletionTokens: z.number().optional(),
     capabilities: Capabilities,
     constraints: z.any().optional(),
     name: z.string(),
     modelSource: z.string().optional(),
     offline: z.boolean().optional(),
+    privacy: z.string().optional(),
     traits: z.array(z.string()).optional(),
   })
   .passthrough();
@@ -83,31 +80,35 @@ const VeniceResponse = z
   })
   .passthrough();
 
-// Family inference patterns
-const familyPatterns: [RegExp, string][] = [
-  [/^llama-3\.3/i, "llama-3.3"],
-  [/^llama-3\.2/i, "llama-3.2"],
-  [/^qwen3/i, "qwen3"],
-  [/^deepseek/i, "deepseek"],
-  [/^mistral/i, "mistral"],
-  [/^devstral/i, "devstral"],
-  [/^gemini/i, "gemini"],
-  [/^grok/i, "grok"],
-  [/^claude/i, "claude"],
-  [/^hermes/i, "hermes"],
-  [/^google-gemma/i, "gemma"],
-  [/^kimi/i, "kimi"],
-  [/glm-4.6/i, "glm-4.6"],
-  [/^venice/i, "venice-uncensored"],
-  [/^openai-gpt/i, "openai-gpt"],
-];
+function matchesFamily(target: string, family: string): boolean {
+  const targetLower = target.toLowerCase();
+  const familyLower = family.toLowerCase();
+  let familyIdx = 0;
+
+  for (let i = 0; i < targetLower.length && familyIdx < familyLower.length; i++) {
+    if (targetLower[i] === familyLower[familyIdx]) {
+      familyIdx++;
+    }
+  }
+
+  return familyIdx === familyLower.length;
+}
 
 function inferFamily(modelId: string, modelName: string): string | undefined {
-  for (const [pattern, family] of familyPatterns) {
-    if (pattern.test(modelId) || pattern.test(modelName)) {
+  const sortedFamilies = [...ModelFamilyValues].sort((a, b) => b.length - a.length);
+
+  for (const family of sortedFamilies) {
+    if (matchesFamily(modelId, family)) {
       return family;
     }
   }
+
+  for (const family of sortedFamilies) {
+    if (matchesFamily(modelName, family)) {
+      return family;
+    }
+  }
+
   return undefined;
 }
 
@@ -156,6 +157,12 @@ interface ExistingModel {
     reasoning?: number;
     cache_read?: number;
     cache_write?: number;
+    context_over_200k?: {
+      input?: number;
+      output?: number;
+      cache_read?: number;
+      cache_write?: number;
+    };
   };
   limit?: {
     context?: number;
@@ -207,6 +214,12 @@ interface MergedModel {
     output: number;
     cache_read?: number;
     cache_write?: number;
+    context_over_200k?: {
+      input: number;
+      output: number;
+      cache_read?: number;
+      cache_write?: number;
+    };
   };
   limit: {
     context: number;
@@ -226,29 +239,24 @@ function mergeModel(
   const caps = spec.capabilities;
 
   const contextTokens = spec.availableContextTokens;
-  const outputTokens = Math.floor(contextTokens / 4);
+  const outputTokens = spec.maxCompletionTokens ?? Math.floor(contextTokens / 4);
 
-  // Determine open_weights from modelSource
   const openWeights = spec.modelSource
     ? spec.modelSource.toLowerCase().includes("huggingface")
-    : false;
+    : spec.privacy === "private";
 
-  // Build input modalities from API (no auto-PDF)
   const inputModalities = buildInputModalities(caps);
 
-  // Check if existing has PDF in modalities - preserve it
   if (existing?.modalities?.input?.includes("pdf") && !inputModalities.includes("pdf")) {
     inputModalities.push("pdf");
   }
 
-  // Determine attachment based on vision/audio/video support
   const attachment =
     caps.supportsVision === true ||
     caps.supportsAudioInput === true ||
     caps.supportsVideoInput === true;
 
   const merged: MergedModel = {
-    // Always from API
     name: spec.name,
     attachment,
     reasoning: caps.supportsReasoning === true,
@@ -280,18 +288,21 @@ function mergeModel(
       ...(spec.pricing.cache_input && { cache_read: spec.pricing.cache_input.usd }),
       ...(spec.pricing.cache_write && { cache_write: spec.pricing.cache_write.usd }),
     };
-  }
 
-  // Preserve from existing OR infer
-  if (existing?.family) {
-    merged.family = existing.family;
-  } else {
-    const inferred = inferFamily(apiModel.id, spec.name);
-    if (inferred) {
-      merged.family = inferred;
+    // Extended pricing maps to context_over_200k
+    if (spec.pricing.extended) {
+      merged.cost.context_over_200k = {
+        input: spec.pricing.extended.input.usd,
+        output: spec.pricing.extended.output.usd,
+        ...(spec.pricing.extended.cache_input && { cache_read: spec.pricing.extended.cache_input.usd }),
+        ...(spec.pricing.extended.cache_write && { cache_write: spec.pricing.extended.cache_write.usd }),
+      };
     }
   }
 
+  const inferred = inferFamily(apiModel.id, spec.name);
+  merged.family = inferred ?? existing?.family;
+
   // Preserve manual fields from existing
   if (existing?.knowledge) {
     merged.knowledge = existing.knowledge;
@@ -354,6 +365,19 @@ function formatToml(model: MergedModel): string {
     if (model.cost.cache_write !== undefined) {
       lines.push(`cache_write = ${model.cost.cache_write}`);
     }
+
+    if (model.cost.context_over_200k) {
+      lines.push("");
+      lines.push(`[cost.context_over_200k]`);
+      lines.push(`input = ${model.cost.context_over_200k.input}`);
+      lines.push(`output = ${model.cost.context_over_200k.output}`);
+      if (model.cost.context_over_200k.cache_read !== undefined) {
+        lines.push(`cache_read = ${model.cost.context_over_200k.cache_read}`);
+      }
+      if (model.cost.context_over_200k.cache_write !== undefined) {
+        lines.push(`cache_write = ${model.cost.context_over_200k.cache_write}`);
+      }
+    }
   }
 
   // Limit section
@@ -416,6 +440,10 @@ function detectChanges(
   compare("cost.output", existing.cost?.output, merged.cost?.output);
   compare("cost.cache_read", existing.cost?.cache_read, merged.cost?.cache_read);
   compare("cost.cache_write", existing.cost?.cache_write, merged.cost?.cache_write);
+  compare("cost.context_over_200k.input", existing.cost?.context_over_200k?.input, merged.cost?.context_over_200k?.input);
+  compare("cost.context_over_200k.output", existing.cost?.context_over_200k?.output, merged.cost?.context_over_200k?.output);
+  compare("cost.context_over_200k.cache_read", existing.cost?.context_over_200k?.cache_read, merged.cost?.context_over_200k?.cache_read);
+  compare("cost.context_over_200k.cache_write", existing.cost?.context_over_200k?.cache_write, merged.cost?.context_over_200k?.cache_write);
   compare("limit.context", existing.limit?.context, merged.limit.context);
   compare("limit.output", existing.limit?.output, merged.limit.output);
   compare("modalities.input", existing.modalities?.input, merged.modalities.input);
@@ -437,7 +465,7 @@ async function main() {
     "models",
   );
 
-  // Check for API key from CLI argument, environment, or prompt
+  // Check for API key from CLI argument or environment variable
   let apiKey: string | null = null;
 
   // Check CLI args for --api-key=xxx or --api-key xxx
@@ -456,11 +484,6 @@ async function main() {
     apiKey = process.env.VENICE_API_KEY ?? null;
   }
 
-  // Prompt if still no key
-  if (!apiKey) {
-    apiKey = await promptForApiKey();
-  }
-
   const includeAlpha = apiKey !== null;
 
   if (dryRun) {

packages/core/script/generate-vercel.ts

@@ -0,0 +1,584 @@
+#!/usr/bin/env bun
+
+/**
+ * Generates Vercel model TOML files from the AI Gateway API.
+ *
+ * Flags:
+ * --dry-run: Preview changes without writing files
+ * --new-only: Only create new models, skip updating existing ones
+ */
+
+import { z } from "zod";
+import path from "node:path";
+import { mkdir } from "node:fs/promises";
+import { ModelFamilyValues } from "../src/family.js";
+
+const API_ENDPOINT = "https://ai-gateway.vercel.sh/v1/models";
+
+enum ModelType {
+  Language = "language",
+  Embedding = "embedding",
+  Image = "image",
+  Video = "video",
+}
+
+enum SkipZeroFields {
+  LimitContext = "limit.context",
+  LimitInput = "limit.input",
+  LimitOutput = "limit.output",
+}
+
+const PricingTier = z.object({
+  cost: z.string(),
+  min: z.number(),
+  max: z.number().optional(),
+});
+
+const Pricing = z.object({
+  input: z.string().optional(),
+  output: z.string().optional(),
+  input_cache_read: z.string().optional(),
+  input_cache_write: z.string().optional(),
+  input_tiers: z.array(PricingTier).optional(),
+  output_tiers: z.array(PricingTier).optional(),
+  input_cache_read_tiers: z.array(PricingTier).optional(),
+  input_cache_write_tiers: z.array(PricingTier).optional(),
+}).passthrough();
+
+const VercelModel = z.object({
+  id: z.string(),
+  name: z.string(),
+  created: z.number(),
+  released: z.number().optional(),
+  context_window: z.number(),
+  max_tokens: z.number(),
+  type: z.nativeEnum(ModelType),
+  tags: z.array(z.string()).optional().default([]),
+  pricing: Pricing.optional(),
+}).passthrough();
+
+const VercelResponse = z.object({
+  data: z.array(VercelModel),
+}).passthrough();
+
+interface ExistingModel {
+  name?: string;
+  family?: string;
+  attachment?: boolean;
+  reasoning?: boolean;
+  tool_call?: boolean;
+  structured_output?: boolean;
+  temperature?: boolean;
+  knowledge?: string;
+  release_date?: string;
+  last_updated?: string;
+  open_weights?: boolean;
+  interleaved?: boolean | { field: string };
+  status?: string;
+  cost?: {
+    input?: number;
+    output?: number;
+    cache_read?: number;
+    cache_write?: number;
+  };
+  limit?: {
+    context?: number;
+    input?: number;
+    output?: number;
+  };
+  modalities?: {
+    input?: string[];
+    output?: string[];
+  };
+}
+
+interface MergedModel {
+  name: string;
+  family?: string;
+  attachment: boolean;
+  reasoning: boolean;
+  tool_call: boolean;
+  structured_output?: boolean;
+  temperature: boolean;
+  knowledge?: string;
+  release_date: string;
+  last_updated: string;
+  open_weights: boolean;
+  interleaved?: boolean | { field: string };
+  status?: string;
+  cost?: {
+    input: number;
+    output: number;
+    cache_read?: number;
+    cache_write?: number;
+  };
+  limit: {
+    context: number;
+    input?: number;
+    output: number;
+  };
+  modalities: {
+    input: string[];
+    output: string[];
+  };
+}
+
+interface Changes {
+  field: string;
+  oldValue: string;
+  newValue: string;
+}
+
+function timestampToDate(timestamp: number): string {
+  const date = new Date(timestamp * 1000);
+  return date.toISOString().slice(0, 10);
+}
+
+function getTodayDate(): string {
+  return new Date().toISOString().slice(0, 10);
+}
+
+// Number utilities
+function formatNumber(n: number): string {
+  if (n >= 1000) {
+    return n.toString().replace(/\B(?=(\d{3})+(?!\d))/g, "_");
+  }
+  return n.toString();
+}
+
+function isSubstring(target: string, family: string): boolean {
+  return target.toLowerCase().includes(family.toLowerCase());
+}
+
+function matchesFamily(target: string, family: string): boolean {
+  const targetLower = target.toLowerCase();
+  const familyLower = family.toLowerCase();
+  let familyIdx = 0;
+
+  for (let i = 0; i < targetLower.length && familyIdx < familyLower.length; i++) {
+    if (targetLower[i] === familyLower[familyIdx]) {
+      familyIdx++;
+    }
+  }
+
+  return familyIdx === familyLower.length;
+}
+
+function inferFamily(modelId: string, modelName: string): string | undefined {
+  const sortedFamilies = [...ModelFamilyValues].sort((a, b) => b.length - a.length);
+
+  // First pass: try exact substring matches
+  for (const family of sortedFamilies) {
+    if (isSubstring(modelId, family)) {
+      return family;
+    }
+  }
+
+  for (const family of sortedFamilies) {
+    if (isSubstring(modelName, family)) {
+      return family;
+    }
+  }
+
+  // Second pass: fall back to subsequence matching
+  for (const family of sortedFamilies) {
+    if (matchesFamily(modelId, family)) {
+      return family;
+    }
+  }
+
+  for (const family of sortedFamilies) {
+    if (matchesFamily(modelName, family)) {
+      return family;
+    }
+  }
+
+  return undefined;
+}
+
+function buildInputModalities(tags: string[]): string[] {
+  const mods: string[] = ["text"];
+  const tagSet = new Set(tags);
+
+  if (tagSet.has("vision")) mods.push("image");
+  if (tagSet.has("file-input")) mods.push("pdf");
+
+  return mods;
+}
+
+function buildOutputModalities(modelType: ModelType, tags: string[]): string[] {
+  const mods: string[] = ["text"];
+  const tagSet = new Set(tags);
+
+  if (modelType === ModelType.Image || tagSet.has("image-generation")) {
+    mods.push("image");
+  } else if (modelType === ModelType.Video) {
+    mods.push("video");
+  }
+
+  return mods;
+}
+
+async function loadExistingModel(filePath: string): Promise<ExistingModel | null> {
+  try {
+    const file = Bun.file(filePath);
+    if (!(await file.exists())) {
+      return null;
+    }
+    const toml = await import(filePath, { with: { type: "toml" } }).then(
+      (mod) => mod.default,
+    );
+    return toml as ExistingModel;
+  } catch (e) {
+    console.warn(`Warning: Failed to parse existing file ${filePath}:`, e);
+    return null;
+  }
+}
+
+function isOpenAIModel(modelId: string): boolean {
+  return modelId.startsWith("openai/");
+}
+
+function mergeModel(
+  apiModel: z.infer<typeof VercelModel>,
+  existing: ExistingModel | null,
+): MergedModel {
+  const tagSet = new Set(apiModel.tags);
+  const inputModalities = buildInputModalities(apiModel.tags);
+  const outputModalities = buildOutputModalities(apiModel.type, apiModel.tags);
+
+  // Preserve existing values when available (previously manually specified)
+  const name = existing?.name ?? apiModel.name;
+  const attachment = existing?.attachment ?? (tagSet.has("vision") || tagSet.has("file-input"));
+  const reasoning = existing?.reasoning ?? tagSet.has("reasoning");
+  const toolCall = existing?.tool_call ?? tagSet.has("tool-use");
+  const openWeights = existing?.open_weights ?? false;
+  const family = existing?.family ?? inferFamily(apiModel.id, apiModel.name);
+  const structuredOutput = existing?.structured_output;
+  const knowledge = existing?.knowledge;
+  const interleaved = existing?.interleaved;
+  const status = existing?.status;
+
+  // Release date: use API, fallback to existing, then today
+  const releaseDate = apiModel.released
+    ? timestampToDate(apiModel.released)
+    : (existing?.release_date ?? getTodayDate());
+
+  // Preserve existing limits if API returns 0 (indicates missing/invalid data)
+  const contextLimit = apiModel.context_window > 0
+    ? apiModel.context_window
+    : (existing?.limit?.context ?? 0);
+  const outputLimit = apiModel.max_tokens > 0
+    ? apiModel.max_tokens
+    : (existing?.limit?.output ?? 0);
+
+  const merged: MergedModel = {
+    name,
+    family,
+    attachment,
+    reasoning,
+    tool_call: toolCall,
+    temperature: true,
+    release_date: releaseDate,
+    last_updated: getTodayDate(),
+    open_weights: openWeights,
+    ...(structuredOutput !== undefined && { structured_output: structuredOutput }),
+    ...(knowledge && { knowledge }),
+    ...(interleaved !== undefined && { interleaved }),
+    ...(status && { status }),
+    limit: {
+      context: contextLimit,
+      ...(isOpenAIModel(apiModel.id) && contextLimit > outputLimit && { input: contextLimit - outputLimit }),
+      output: outputLimit,
+    },
+    modalities: {
+      input: inputModalities,
+      output: outputModalities,
+    },
+  };
+
+  if (apiModel.pricing) {
+    const inputPrice = apiModel.pricing.input_tiers?.[0]?.cost ?? apiModel.pricing.input;
+    const outputPrice = apiModel.pricing.output_tiers?.[0]?.cost ?? apiModel.pricing.output;
+    const cacheReadPrice = apiModel.pricing.input_cache_read_tiers?.[0]?.cost ?? apiModel.pricing.input_cache_read;
+    const cacheWritePrice = apiModel.pricing.input_cache_write_tiers?.[0]?.cost ?? apiModel.pricing.input_cache_write;
+
+    if (inputPrice && outputPrice) {
+      merged.cost = {
+        input: parseFloat(inputPrice) * 1_000_000,
+        output: parseFloat(outputPrice) * 1_000_000,
+        ...(cacheReadPrice && {
+          cache_read: parseFloat(cacheReadPrice) * 1_000_000,
+        }),
+        ...(cacheWritePrice && {
+          cache_write: parseFloat(cacheWritePrice) * 1_000_000,
+        }),
+      };
+    }
+  }
+
+  return merged;
+}
+
+function formatToml(model: MergedModel): string {
+  const lines: string[] = [];
+
+  lines.push(`name = "${model.name.replace(/"/g, '\\"')}"`);
+  if (model.family) {
+    lines.push(`family = "${model.family}"`);
+  }
+  lines.push(`attachment = ${model.attachment}`);
+  lines.push(`reasoning = ${model.reasoning}`);
+  lines.push(`tool_call = ${model.tool_call}`);
+  if (model.structured_output !== undefined) {
+    lines.push(`structured_output = ${model.structured_output}`);
+  }
+  lines.push(`temperature = ${model.temperature}`);
+  if (model.knowledge) {
+    lines.push(`knowledge = "${model.knowledge}"`);
+  }
+  lines.push(`release_date = "${model.release_date}"`);
+  lines.push(`last_updated = "${model.last_updated}"`);
+  lines.push(`open_weights = ${model.open_weights}`);
+  if (model.status) {
+    lines.push(`status = "${model.status}"`);
+  }
+
+  if (model.interleaved !== undefined) {
+    lines.push("");
+    if (model.interleaved === true) {
+      lines.push(`interleaved = true`);
+    } else if (typeof model.interleaved === "object") {
+      lines.push(`[interleaved]`);
+      lines.push(`field = "${model.interleaved.field}"`);
+    }
+  }
+
+  if (model.cost) {
+    lines.push("");
+    lines.push(`[cost]`);
+    lines.push(`input = ${model.cost.input}`);
+    lines.push(`output = ${model.cost.output}`);
+    if (model.cost.cache_read !== undefined) {
+      lines.push(`cache_read = ${model.cost.cache_read}`);
+    }
+    if (model.cost.cache_write !== undefined) {
+      lines.push(`cache_write = ${model.cost.cache_write}`);
+    }
+  }
+
+  lines.push("");
+  lines.push(`[limit]`);
+  lines.push(`context = ${formatNumber(model.limit.context)}`);
+  if (model.limit.input !== undefined) {
+    lines.push(`input = ${formatNumber(model.limit.input)}`);
+  }
+  lines.push(`output = ${formatNumber(model.limit.output)}`);
+
+  lines.push("");
+  lines.push(`[modalities]`);
+  lines.push(`input = [${model.modalities.input.map((m) => `"${m}"`).join(", ")}]`);
+  lines.push(`output = [${model.modalities.output.map((m) => `"${m}"`).join(", ")}]`);
+
+  return lines.join("\n") + "\n";
+}
+
+function detectChanges(
+  existing: ExistingModel | null,
+  merged: MergedModel,
+): Changes[] {
+  if (!existing) return [];
+
+  const changes: Changes[] = [];
+  const EPSILON = 0.001; // price diff to ignore (per million tokens)
+
+  const shouldSkipZero = (field: string, oldVal: unknown, newVal: unknown): boolean => {
+    if (!Object.values(SkipZeroFields).includes(field as SkipZeroFields)) {
+      return false;
+    }
+    return (typeof oldVal === "number" && oldVal === 0) || (typeof newVal === "number" && newVal === 0);
+  };
+
+  const formatValue = (val: unknown): string => {
+    if (typeof val === "number") return formatNumber(val);
+    if (Array.isArray(val)) return `[${val.join(", ")}]`;
+    if (val === undefined) return "(none)";
+    return String(val);
+  };
+
+  const isMaterialPriceDiff = (oldPrice: unknown, newPrice: unknown): boolean => {
+    // 0 → undefined is not material (cost removed)
+    if (oldPrice === 0 && newPrice === undefined) return false;
+
+    if (oldPrice !== undefined && newPrice !== undefined) {
+      return Math.abs((oldPrice as number) - (newPrice as number)) > EPSILON;
+    }
+
+    return oldPrice !== newPrice;
+  };
+
+  const compare = (field: string, oldVal: unknown, newVal: unknown) => {
+    if (shouldSkipZero(field, oldVal, newVal)) return;
+
+    const isDiff = field.startsWith("cost.")
+      ? isMaterialPriceDiff(oldVal, newVal)
+      : JSON.stringify(oldVal) !== JSON.stringify(newVal);
+
+    if (isDiff) {
+      changes.push({
+        field,
+        oldValue: formatValue(oldVal),
+        newValue: formatValue(newVal),
+      });
+    }
+  };
+
+  compare("name", existing.name, merged.name);
+  compare("family", existing.family, merged.family);
+  compare("attachment", existing.attachment, merged.attachment);
+  compare("reasoning", existing.reasoning, merged.reasoning);
+  compare("tool_call", existing.tool_call, merged.tool_call);
+  compare("structured_output", existing.structured_output, merged.structured_output);
+  compare("open_weights", existing.open_weights, merged.open_weights);
+  compare("release_date", existing.release_date, merged.release_date);
+  compare("cost.input", existing.cost?.input, merged.cost?.input);
+  compare("cost.output", existing.cost?.output, merged.cost?.output);
+  compare("cost.cache_read", existing.cost?.cache_read, merged.cost?.cache_read);
+  compare("cost.cache_write", existing.cost?.cache_write, merged.cost?.cache_write);
+  compare("limit.context", existing.limit?.context, merged.limit.context);
+  compare("limit.input", existing.limit?.input, merged.limit.input);
+  compare("limit.output", existing.limit?.output, merged.limit.output);
+  compare("modalities.input", existing.modalities?.input, merged.modalities.input);
+
+  return changes;
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const dryRun = args.includes("--dry-run");
+  const newOnly = args.includes("--new-only");
+
+  const modelsDir = path.join(
+    import.meta.dirname,
+    "..",
+    "..",
+    "..",
+    "providers",
+    "vercel",
+    "models",
+  );
+
+  console.log(`${dryRun ? "[DRY RUN] " : ""}${newOnly ? "[NEW ONLY] " : ""}Fetching Vercel models from API...`);
+
+  const res = await fetch(API_ENDPOINT);
+  if (!res.ok) {
+    console.error(`Failed to fetch API: ${res.status} ${res.statusText}`);
+    process.exit(1);
+  }
+
+  const json = await res.json();
+  const parsed = VercelResponse.safeParse(json);
+  if (!parsed.success) {
+    console.error("Invalid API response:", parsed.error.errors);
+    process.exit(1);
+  }
+
+  const apiModels = parsed.data.data;
+
+  const existingFiles = new Set<string>();
+  try {
+    for await (const file of new Bun.Glob("**/*.toml").scan({
+      cwd: modelsDir,
+      absolute: false,
+    })) {
+      existingFiles.add(file);
+    }
+  } catch {
+  }
+
+  console.log(`Found ${apiModels.length} models in API, ${existingFiles.size} existing files\n`);
+
+  const apiModelIds = new Set<string>();
+
+  let created = 0;
+  let updated = 0;
+  let unchanged = 0;
+
+  for (const apiModel of apiModels) {
+    // Skip these since OpenCode does not support image / video generation yet
+    if (apiModel.type === ModelType.Image || apiModel.type === ModelType.Video) {
+      continue;
+    }
+
+    const relativePath = `${apiModel.id}.toml`;
+    const filePath = path.join(modelsDir, relativePath);
+    const dirPath = path.dirname(filePath);
+
+    apiModelIds.add(relativePath);
+
+    const existing = await loadExistingModel(filePath);
+    const merged = mergeModel(apiModel, existing);
+    const tomlContent = formatToml(merged);
+
+    if (existing === null) {
+      created++;
+      if (dryRun) {
+        console.log(`[DRY RUN] Would create: ${relativePath}`);
+        console.log(`  name = "${merged.name}"`);
+        if (merged.family) {
+          console.log(`  family = "${merged.family}" (inferred)`);
+        }
+        console.log("");
+      } else {
+        await mkdir(dirPath, { recursive: true });
+        await Bun.write(filePath, tomlContent);
+        console.log(`Created: ${relativePath}`);
+      }
+    } else {
+      if (newOnly) {
+        unchanged++;
+        continue;
+      }
+
+      const changes = detectChanges(existing, merged);
+
+      if (changes.length > 0) {
+        updated++;
+        if (dryRun) {
+          console.log(`[DRY RUN] Would update: ${relativePath}`);
+        } else {
+          await mkdir(dirPath, { recursive: true });
+          await Bun.write(filePath, tomlContent);
+          console.log(`Updated: ${relativePath}`);
+        }
+        for (const change of changes) {
+          console.log(`  ${change.field}: ${change.oldValue} → ${change.newValue}`);
+        }
+        console.log("");
+      } else {
+        unchanged++;
+      }
+    }
+  }
+
+  const orphaned: string[] = [];
+  for (const file of existingFiles) {
+    if (!apiModelIds.has(file)) {
+      orphaned.push(file);
+      console.log(`Warning: Orphaned file (not in API): ${file}`);
+    }
+  }
+
+  console.log("");
+  if (dryRun) {
+    console.log(
+      `Summary: ${created} would be created, ${updated} would be updated, ${unchanged} unchanged, ${orphaned.length} orphaned`,
+    );
+  } else {
+    console.log(
+      `Summary: ${created} created, ${updated} updated, ${unchanged} unchanged, ${orphaned.length} orphaned`,
+    );
+  }
+}
+
+await main();

packages/core/script/generate-wandb.ts

@@ -0,0 +1,525 @@
+#!/usr/bin/env bun
+
+import path from "node:path";
+import { mkdir } from "node:fs/promises";
+import { z } from "zod";
+import { ModelFamilyValues } from "../src/family.js";
+
+const API_ENDPOINT = "https://trace.wandb.ai/inference/analysis/artificialanalysis/models";
+
+const Pricing = z
+  .object({
+    prompt: z.string().optional(),
+    completion: z.string().optional(),
+    image: z.string().optional(),
+    request: z.string().optional(),
+    input_cache_reads: z.string().optional(),
+    input_cache_writes: z.string().optional(),
+  })
+  .passthrough();
+
+const WandbModel = z
+  .object({
+    id: z.string(),
+    name: z.string(),
+    created: z.number(),
+    input_modalities: z.array(z.string()),
+    output_modalities: z.array(z.string()),
+    context_length: z.number(),
+    max_output_length: z.number(),
+    pricing: Pricing.optional(),
+    supported_sampling_parameters: z.array(z.string()).default([]),
+    supported_features: z.array(z.string()).default([]),
+  })
+  .passthrough();
+
+const WandbResponse = z
+  .object({
+    data: z.array(WandbModel),
+  })
+  .strict();
+
+interface ExistingModel {
+  name?: string;
+  family?: string;
+  attachment?: boolean;
+  reasoning?: boolean;
+  tool_call?: boolean;
+  structured_output?: boolean;
+  temperature?: boolean;
+  knowledge?: string;
+  release_date?: string;
+  last_updated?: string;
+  open_weights?: boolean;
+  interleaved?: boolean | { field: string };
+  status?: string;
+  cost?: {
+    input?: number;
+    output?: number;
+    cache_read?: number;
+    cache_write?: number;
+  };
+  limit?: {
+    context?: number;
+    input?: number;
+    output?: number;
+  };
+  modalities?: {
+    input?: string[];
+    output?: string[];
+  };
+}
+
+interface MergedModel {
+  name: string;
+  family?: string;
+  attachment: boolean;
+  reasoning: boolean;
+  tool_call: boolean;
+  structured_output?: boolean;
+  temperature: boolean;
+  knowledge?: string;
+  release_date: string;
+  last_updated: string;
+  open_weights: boolean;
+  interleaved?: boolean | { field: string };
+  status?: string;
+  cost?: {
+    input: number;
+    output: number;
+    cache_read?: number;
+    cache_write?: number;
+  };
+  limit: {
+    context: number;
+    output: number;
+  };
+  modalities: {
+    input: Array<"text" | "audio" | "image" | "video" | "pdf">;
+    output: Array<"text" | "audio" | "image" | "video" | "pdf">;
+  };
+}
+
+interface Changes {
+  field: string;
+  oldValue: string;
+  newValue: string;
+}
+
+type SupportedModality = "text" | "audio" | "image" | "video" | "pdf";
+
+const modalityMap: Record<string, SupportedModality | undefined> = {
+  text: "text",
+  image: "image",
+  audio: "audio",
+  video: "video",
+  pdf: "pdf",
+  file: "pdf",
+  files: "pdf",
+};
+
+const openWeightsPrefixes = new Set([
+  "deepseek-ai/",
+  "meta-llama/",
+  "microsoft/",
+  "MiniMaxAI/",
+  "moonshotai/",
+  "nvidia/",
+  "OpenPipe/",
+  "Qwen/",
+  "zai-org/",
+]);
+
+function timestampToDate(timestamp: number): string {
+  return new Date(timestamp * 1000).toISOString().slice(0, 10);
+}
+
+function getTodayDate(): string {
+  return new Date().toISOString().slice(0, 10);
+}
+
+function formatNumber(n: number): string {
+  if (n >= 1000) {
+    return n.toString().replace(/\B(?=(\d{3})+(?!\d))/g, "_");
+  }
+  return n.toString();
+}
+
+function formatDecimal(n: number): string {
+  return Number(n.toFixed(6)).toString();
+}
+
+function priceToPerMillion(value: string): number {
+  return Number((parseFloat(value) * 1_000_000).toFixed(6));
+}
+
+function isSubstring(target: string, family: string): boolean {
+  return target.toLowerCase().includes(family.toLowerCase());
+}
+
+function matchesFamily(target: string, family: string): boolean {
+  const targetLower = target.toLowerCase();
+  const familyLower = family.toLowerCase();
+  let familyIdx = 0;
+
+  for (let i = 0; i < targetLower.length && familyIdx < familyLower.length; i++) {
+    if (targetLower[i] === familyLower[familyIdx]) {
+      familyIdx++;
+    }
+  }
+
+  return familyIdx === familyLower.length;
+}
+
+function inferFamily(modelId: string, modelName: string): string | undefined {
+  const sortedFamilies = [...ModelFamilyValues].sort((a, b) => b.length - a.length);
+
+  for (const family of sortedFamilies) {
+    if (isSubstring(modelId, family) || isSubstring(modelName, family)) {
+      return family;
+    }
+  }
+
+  for (const family of sortedFamilies) {
+    if (matchesFamily(modelId, family) || matchesFamily(modelName, family)) {
+      return family;
+    }
+  }
+
+  return undefined;
+}
+
+function normalizeName(apiModel: z.infer<typeof WandbModel>): string {
+  const stripped = apiModel.name.replace(/^[^:]+:\s*/, "").trim();
+  return stripped || path.basename(apiModel.id);
+}
+
+function inferReasoning(apiModel: z.infer<typeof WandbModel>): boolean {
+  const text = `${apiModel.id} ${apiModel.name}`.toLowerCase();
+  return text.includes("thinking") || /\br1\b/.test(text) || text.includes("reasoning");
+}
+
+function inferOpenWeights(modelId: string): boolean {
+  for (const prefix of openWeightsPrefixes) {
+    if (modelId.startsWith(prefix)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function normalizeModalities(values: string[]): SupportedModality[] {
+  const normalized = values
+    .map((value) => modalityMap[value.toLowerCase()])
+    .filter((value): value is SupportedModality => value !== undefined);
+
+  return [...new Set(normalized)];
+}
+
+async function loadExistingModel(filePath: string): Promise<ExistingModel | null> {
+  try {
+    const file = Bun.file(filePath);
+    if (!(await file.exists())) {
+      return null;
+    }
+
+    const toml = await import(filePath, { with: { type: "toml" } }).then((mod) => mod.default);
+    return toml as ExistingModel;
+  } catch (cause) {
+    console.warn(`Warning: Failed to parse existing file ${filePath}:`, cause);
+    return null;
+  }
+}
+
+function mergeModel(
+  apiModel: z.infer<typeof WandbModel>,
+  existing: ExistingModel | null,
+): MergedModel {
+  const featureSet = new Set(apiModel.supported_features);
+  const samplingSet = new Set(apiModel.supported_sampling_parameters);
+  const inputModalities = normalizeModalities(apiModel.input_modalities);
+  const outputModalities = normalizeModalities(apiModel.output_modalities);
+
+  const merged: MergedModel = {
+    name: existing?.name ?? normalizeName(apiModel),
+    family: existing?.family ?? inferFamily(apiModel.id, apiModel.name),
+    attachment: existing?.attachment ?? inputModalities.some((m) => m !== "text"),
+    reasoning: existing?.reasoning ?? inferReasoning(apiModel),
+    tool_call: existing?.tool_call ?? featureSet.has("tools"),
+    temperature: existing?.temperature ?? samplingSet.has("temperature"),
+    release_date: existing?.release_date ?? timestampToDate(apiModel.created),
+    last_updated: getTodayDate(),
+    open_weights: existing?.open_weights ?? inferOpenWeights(apiModel.id),
+    ...(existing?.structured_output !== undefined
+      ? { structured_output: existing.structured_output }
+      : featureSet.has("structured_outputs")
+        ? { structured_output: true }
+        : {}),
+    ...(existing?.knowledge ? { knowledge: existing.knowledge } : {}),
+    ...(existing?.interleaved !== undefined ? { interleaved: existing.interleaved } : {}),
+    ...(existing?.status ? { status: existing.status } : {}),
+    limit: {
+      context: apiModel.context_length > 0 ? apiModel.context_length : (existing?.limit?.context ?? 0),
+      output: apiModel.max_output_length > 0
+        ? apiModel.max_output_length
+        : (existing?.limit?.output ?? 0),
+    },
+    modalities: {
+      input: inputModalities.length > 0
+        ? inputModalities
+        : ((existing?.modalities?.input as SupportedModality[] | undefined) ?? ["text"]),
+      output: outputModalities.length > 0
+        ? outputModalities
+        : ((existing?.modalities?.output as SupportedModality[] | undefined) ?? ["text"]),
+    },
+  };
+
+  const prompt = apiModel.pricing?.prompt;
+  const completion = apiModel.pricing?.completion;
+  const cacheRead = apiModel.pricing?.input_cache_reads;
+  const cacheWrite = apiModel.pricing?.input_cache_writes;
+
+  if (prompt && completion) {
+    merged.cost = {
+      input: priceToPerMillion(prompt),
+      output: priceToPerMillion(completion),
+      ...(cacheRead && parseFloat(cacheRead) > 0
+        ? { cache_read: priceToPerMillion(cacheRead) }
+        : {}),
+      ...(cacheWrite && parseFloat(cacheWrite) > 0
+        ? { cache_write: priceToPerMillion(cacheWrite) }
+        : {}),
+    };
+  } else if (existing?.cost?.input !== undefined && existing.cost.output !== undefined) {
+    merged.cost = {
+      input: existing.cost.input,
+      output: existing.cost.output,
+      ...(existing.cost.cache_read !== undefined ? { cache_read: existing.cost.cache_read } : {}),
+      ...(existing.cost.cache_write !== undefined ? { cache_write: existing.cost.cache_write } : {}),
+    };
+  }
+
+  return merged;
+}
+
+function formatToml(model: MergedModel): string {
+  const lines: string[] = [];
+
+  lines.push(`name = "${model.name.replace(/"/g, '\\"')}"`);
+  if (model.family) {
+    lines.push(`family = "${model.family}"`);
+  }
+  lines.push(`release_date = "${model.release_date}"`);
+  lines.push(`last_updated = "${model.last_updated}"`);
+  lines.push(`attachment = ${model.attachment}`);
+  lines.push(`reasoning = ${model.reasoning}`);
+  if (model.structured_output !== undefined) {
+    lines.push(`structured_output = ${model.structured_output}`);
+  }
+  lines.push(`temperature = ${model.temperature}`);
+  lines.push(`tool_call = ${model.tool_call}`);
+  if (model.knowledge) {
+    lines.push(`knowledge = "${model.knowledge}"`);
+  }
+  lines.push(`open_weights = ${model.open_weights}`);
+  if (model.status) {
+    lines.push(`status = "${model.status}"`);
+  }
+
+  if (model.interleaved !== undefined) {
+    lines.push("");
+    if (model.interleaved === true) {
+      lines.push("interleaved = true");
+    } else {
+      lines.push("[interleaved]");
+      lines.push(`field = "${model.interleaved.field}"`);
+    }
+  }
+
+  if (model.cost) {
+    lines.push("");
+    lines.push("[cost]");
+    lines.push(`input = ${formatDecimal(model.cost.input)}`);
+    lines.push(`output = ${formatDecimal(model.cost.output)}`);
+    if (model.cost.cache_read !== undefined) {
+      lines.push(`cache_read = ${formatDecimal(model.cost.cache_read)}`);
+    }
+    if (model.cost.cache_write !== undefined) {
+      lines.push(`cache_write = ${formatDecimal(model.cost.cache_write)}`);
+    }
+  }
+
+  lines.push("");
+  lines.push("[limit]");
+  lines.push(`context = ${formatNumber(model.limit.context)}`);
+  lines.push(`output = ${formatNumber(model.limit.output)}`);
+
+  lines.push("");
+  lines.push("[modalities]");
+  lines.push(`input = [${model.modalities.input.map((m) => `"${m}"`).join(", ")}]`);
+  lines.push(`output = [${model.modalities.output.map((m) => `"${m}"`).join(", ")}]`);
+
+  return `${lines.join("\n")}\n`;
+}
+
+function detectChanges(existing: ExistingModel | null, merged: MergedModel): Changes[] {
+  if (!existing) {
+    return [];
+  }
+
+  const changes: Changes[] = [];
+  const epsilon = 0.001;
+
+  const formatValue = (value: unknown): string => {
+    if (typeof value === "number") return formatNumber(value);
+    if (Array.isArray(value)) return `[${value.join(", ")}]`;
+    if (value === undefined) return "(none)";
+    return String(value);
+  };
+
+  const compare = (field: string, oldValue: unknown, newValue: unknown) => {
+    const changed = field.startsWith("cost.")
+      ? (
+          oldValue === undefined && newValue === undefined
+            ? false
+            : oldValue === undefined || newValue === undefined
+              ? true
+              : Math.abs((oldValue as number) - (newValue as number)) > epsilon
+        )
+      : JSON.stringify(oldValue) !== JSON.stringify(newValue);
+
+    if (changed) {
+      changes.push({
+        field,
+        oldValue: formatValue(oldValue),
+        newValue: formatValue(newValue),
+      });
+    }
+  };
+
+  compare("name", existing.name, merged.name);
+  compare("family", existing.family, merged.family);
+  compare("release_date", existing.release_date, merged.release_date);
+  compare("attachment", existing.attachment, merged.attachment);
+  compare("reasoning", existing.reasoning, merged.reasoning);
+  compare("structured_output", existing.structured_output, merged.structured_output);
+  compare("temperature", existing.temperature, merged.temperature);
+  compare("tool_call", existing.tool_call, merged.tool_call);
+  compare("open_weights", existing.open_weights, merged.open_weights);
+  compare("cost.input", existing.cost?.input, merged.cost?.input);
+  compare("cost.output", existing.cost?.output, merged.cost?.output);
+  compare("cost.cache_read", existing.cost?.cache_read, merged.cost?.cache_read);
+  compare("cost.cache_write", existing.cost?.cache_write, merged.cost?.cache_write);
+  compare("limit.context", existing.limit?.context, merged.limit.context);
+  compare("limit.output", existing.limit?.output, merged.limit.output);
+  compare("modalities.input", existing.modalities?.input, merged.modalities.input);
+  compare("modalities.output", existing.modalities?.output, merged.modalities.output);
+
+  return changes;
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const dryRun = args.includes("--dry-run");
+  const newOnly = args.includes("--new-only");
+
+  const modelsDir = path.join(import.meta.dirname, "..", "..", "..", "providers", "wandb", "models");
+
+  console.log(`${dryRun ? "[DRY RUN] " : ""}${newOnly ? "[NEW ONLY] " : ""}Fetching WandB models from API...`);
+
+  const res = await fetch(API_ENDPOINT);
+  if (!res.ok) {
+    console.error(`Failed to fetch API: ${res.status} ${res.statusText}`);
+    process.exit(1);
+  }
+
+  const json = await res.json();
+  const parsed = WandbResponse.safeParse(json);
+  if (!parsed.success) {
+    console.error("Invalid API response:", parsed.error.errors);
+    process.exit(1);
+  }
+
+  const apiModels = parsed.data.data;
+  const existingFiles = new Set<string>();
+
+  for await (const file of new Bun.Glob("**/*.toml").scan({ cwd: modelsDir, absolute: false })) {
+    existingFiles.add(file);
+  }
+
+  console.log(`Found ${apiModels.length} models in API, ${existingFiles.size} existing files\n`);
+
+  const apiModelIds = new Set<string>();
+  let created = 0;
+  let updated = 0;
+  let unchanged = 0;
+
+  for (const apiModel of apiModels) {
+    const relativePath = `${apiModel.id}.toml`;
+    const filePath = path.join(modelsDir, relativePath);
+    const dirPath = path.dirname(filePath);
+
+    apiModelIds.add(relativePath);
+
+    const existing = await loadExistingModel(filePath);
+    const merged = mergeModel(apiModel, existing);
+    const tomlContent = formatToml(merged);
+
+    if (existing === null) {
+      created++;
+      if (dryRun) {
+        console.log(`[DRY RUN] Would create: ${relativePath}`);
+        console.log(`  name = "${merged.name}"`);
+        if (merged.family) {
+          console.log(`  family = "${merged.family}"`);
+        }
+        console.log("");
+      } else {
+        await mkdir(dirPath, { recursive: true });
+        await Bun.write(filePath, tomlContent);
+        console.log(`Created: ${relativePath}`);
+      }
+      continue;
+    }
+
+    if (newOnly) {
+      unchanged++;
+      continue;
+    }
+
+    const changes = detectChanges(existing, merged);
+    if (changes.length === 0) {
+      unchanged++;
+      continue;
+    }
+
+    updated++;
+    if (dryRun) {
+      console.log(`[DRY RUN] Would update: ${relativePath}`);
+    } else {
+      await mkdir(dirPath, { recursive: true });
+      await Bun.write(filePath, tomlContent);
+      console.log(`Updated: ${relativePath}`);
+    }
+
+    for (const change of changes) {
+      console.log(`  ${change.field}: ${change.oldValue} → ${change.newValue}`);
+    }
+    console.log("");
+  }
+
+  const orphaned = [...existingFiles].filter((file) => !apiModelIds.has(file));
+  for (const file of orphaned) {
+    console.log(`Warning: Orphaned file (not in API): ${file}`);
+  }
+
+  console.log("");
+  console.log(
+    dryRun
+      ? `Summary: ${created} would be created, ${updated} would be updated, ${unchanged} unchanged, ${orphaned.length} orphaned`
+      : `Summary: ${created} created, ${updated} updated, ${unchanged} unchanged, ${orphaned.length} orphaned`,
+  );
+}
+
+await main();

packages/core/src/family.ts

@@ -1,9 +1,14 @@
 import { z } from "zod";
 
 export const ModelFamilyValues = [
+  // Arcee
+  "trinity",
+  "trinity-mini",
+
   // OpenAI/GPT style
   "gpt",
   "gpt-codex",
+  "gpt-codex-spark",
   "gpt-codex-mini",
   "gpt-pro",
   "gpt-mini",
@@ -51,6 +56,7 @@ export const ModelFamilyValues = [
 
   // Moonshot Kimi
   "kimi",
+  "kimi-free",
   "kimi-thinking",
 
   // Mistral family
@@ -90,6 +96,7 @@ export const ModelFamilyValues = [
 
   // NVIDIA Nemotron
   "nemotron",
+  "nemotron-free",
 
   // AWS Titan
   "titan",
@@ -97,6 +104,9 @@ export const ModelFamilyValues = [
 
   // MiniMax
   "minimax",
+  "minimax-m2.5",
+  "minimax-m2.7",
+  "minimax-free",
 
   // Hunyuan
   "hunyuan",
@@ -121,9 +131,6 @@ export const ModelFamilyValues = [
   "solar-mini",
   "solar-pro",
 
-  // Exaone
-  "exaone",
-
   // Step (StepFun)
   "step",
 
@@ -140,6 +147,7 @@ export const ModelFamilyValues = [
   "dall-e",
   "flux",
   "imagen",
+  "recraft",
   "stable-diffusion",
   "ideogram",
   "dreamshaper",
@@ -177,6 +185,9 @@ export const ModelFamilyValues = [
   // Sherlock
   "sherlock",
 
+  // Pony
+  "pony",
+
   // Mercury
   "mercury",
 
@@ -185,6 +196,12 @@ export const ModelFamilyValues = [
 
   // Mimo
   "mimo",
+  "mimo-pro-free",
+  "mimo-omni-free",
+  "mimo-flash-free",
+
+  // Clarifai
+  "mm-poly",
 
   // Longcat
   "longcat",
@@ -218,6 +235,12 @@ export const ModelFamilyValues = [
   // Falcon
   "falcon",
 
+  // Baichuan
+  "baichuan",
+
+  // Skywork
+  "skywork",
+
   // BART
   "bart",
 
@@ -270,8 +293,6 @@ export const ModelFamilyValues = [
   // NeMo
   "nemoretriever",
 
-
-
   // Nano Banana
   "nano-banana",
 
@@ -338,6 +359,21 @@ export const ModelFamilyValues = [
 
   // Neural Chat
   "neural-chat",
+
+  // Pangu (Ascend Tribe)
+  "pangu",
+
+  // LiquidAI
+  "liquid",
+
+  // Sourceful
+  "sourceful",
+
+  // AllenAI
+  "allenai",
+
+  // Writer
+  "palmyra",
 ] as const;
 
 export const ModelFamily = z.enum(ModelFamilyValues);

packages/core/src/schema.ts

@@ -73,6 +73,7 @@ export const Model = z
       .object({
         npm: z.string().optional(),
         api: z.string().optional(),
+        shape: z.enum(["responses", "completions"]).optional(),
       })
       .optional(),
   })

packages/function/src/worker.ts

@@ -11,6 +11,7 @@ export default {
   ): Promise<Response> {
     const url = new URL(request.url);
     const ip = request.headers.get("cf-connecting-ip") || "unknown";
+    const country = request.headers.get("cf-ipcountry") || "unknown";
     const agent = request.headers.get("user-agent") || "unknown";
     if (agent.includes("opencode") || agent.includes("bun")) {
       ctx.waitUntil(
@@ -26,6 +27,7 @@ export default {
             properties: {
               $process_person_profile: false,
               user_agent: agent,
+              country,
               path: url.pathname,
             },
           }),
@@ -33,6 +35,44 @@ export default {
       );
     }
 
+    if (url.pathname === "/model-schema.json") {
+      const apiUrl = new URL(url);
+      apiUrl.pathname = "/_api.json";
+      const apiResponse = await env.ASSETS.fetch(
+        new Request(apiUrl.toString(), request),
+      );
+      const providers = (await apiResponse.json()) as Record<
+        string,
+        { models: Record<string, unknown> }
+      >;
+
+      const modelIds: string[] = [];
+      for (const [providerId, provider] of Object.entries(providers)) {
+        for (const modelId of Object.keys(provider.models)) {
+          modelIds.push(`${providerId}/${modelId}`);
+        }
+      }
+
+      const schema = {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        $id: "https://models.dev/model-schema.json",
+        $defs: {
+          Model: {
+            type: "string",
+            enum: modelIds.sort(),
+            description: "AI model identifier in provider/model format",
+          },
+        },
+      };
+
+      return new Response(JSON.stringify(schema, null, 2), {
+        headers: {
+          "Content-Type": "application/json",
+          "Cache-Control": "public, max-age=3600",
+        },
+      });
+    }
+
     if (url.pathname === "/api.json") {
       url.pathname = "/_api.json";
     } else if (

providers/302ai/logo.svg

@@ -0,0 +1,7 @@
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" style="display: block;" viewBox="0 0 2048 2048" width="1046" height="1046" preserveAspectRatio="none">
+<path transform="translate(0,0)" fill="rgb(156,155,155)" d="M 388.193 1682.23 C 380.878 1674.23 349.014 1650.79 338.487 1642.13 C 148.161 1485.91 28.1107 1260.14 5.01063 1015 C -18.4493 771.014 55.9168 527.694 211.767 338.509 C 367.861 148.455 593.42 28.6444 838.288 5.7197 C 1092.75 -18.7181 1345.95 63.524 1537.48 232.828 C 1567.76 259.726 1596.32 288.496 1623 318.968 C 1631.78 329.058 1640.32 339.36 1648.6 349.865 C 1654.15 356.824 1662.64 368.871 1669.4 374.06 C 1866.4 518.124 1998.49 734.204 2036.88 975.222 C 2041.98 1007.66 2045.11 1039.38 2046.62 1072.12 C 2046.85 1077.09 2047.16 1082.22 2048 1087.12 L 2048 1155.79 L 2047.85 1156.71 C 2045.71 1170.93 2045.27 1196.57 2043.86 1212.22 C 2040.62 1246.59 2035.38 1280.75 2028.17 1314.51 C 1981.27 1534.16 1856.1 1729.25 1675.99 1863.43 C 1479.61 2010.02 1232.99 2072.49 990.498 2037.07 C 801.767 2009.86 626.135 1924.74 487.842 1793.46 C 455.956 1763.37 418.158 1722.72 392.022 1687.5 C 390.729 1685.76 389.452 1684 388.193 1682.23 z"/>
+<path transform="translate(0,0)" fill="rgb(117,116,116)" d="M 1669.4 374.06 C 1866.4 518.124 1998.49 734.204 2036.88 975.222 C 2041.98 1007.66 2045.11 1039.38 2046.62 1072.12 C 2046.85 1077.09 2047.16 1082.22 2048 1087.12 L 2048 1155.79 L 2047.85 1156.71 C 2045.71 1170.93 2045.27 1196.57 2043.86 1212.22 C 2040.62 1246.59 2035.38 1280.75 2028.17 1314.51 C 1981.27 1534.16 1856.1 1729.25 1675.99 1863.43 C 1479.61 2010.02 1232.99 2072.49 990.498 2037.07 C 801.767 2009.86 626.135 1924.74 487.842 1793.46 C 455.956 1763.37 418.158 1722.72 392.022 1687.5 C 390.729 1685.76 389.452 1684 388.193 1682.23 C 394.373 1684.07 421.092 1702.62 428.047 1707.15 C 439.611 1714.6 451.324 1721.83 463.177 1728.82 C 490.564 1744.99 528.003 1763.59 557.361 1776.32 C 782.899 1873.92 1037.96 1878.01 1266.51 1787.69 C 1495.36 1696.62 1678.57 1518.24 1775.72 1291.9 C 1877.79 1053.06 1875.1 782.375 1768.31 545.611 C 1753.03 511.993 1733.8 474.565 1714.15 443.177 C 1706.81 431.355 1699.2 419.704 1691.32 408.231 C 1685.67 400.055 1672.56 382.889 1669.4 374.06 z"/>
+<path transform="translate(0,0)" fill="rgb(254,254,254)" d="M 907.581 300.401 C 923.66 299.084 947.483 300.532 962.897 302.556 C 1041.39 313.102 1112.41 354.577 1160.17 417.755 C 1202.42 473.452 1228.57 555 1218.78 624.854 C 1256.03 619.819 1285.79 618.643 1323.38 625.442 C 1401.3 639.582 1470.3 684.357 1514.95 749.754 C 1560.04 815.479 1576.85 896.56 1561.6 974.792 C 1546.59 1052.29 1501.28 1120.59 1435.71 1164.55 C 1366.19 1211.67 1287.89 1223.85 1206.7 1207.99 L 1208.16 1225.92 C 1213.72 1304.44 1187.72 1381.94 1135.93 1441.23 C 1080.14 1505.71 1008.69 1536.8 924.661 1542.84 C 910.37 1543.02 898.883 1543.12 884.551 1541.84 C 806.009 1534.5 733.606 1496.24 683.294 1435.48 C 630.495 1371.76 609.152 1293.49 617.004 1211.82 C 577.182 1218.28 543.704 1219.15 503.598 1211.31 C 425.862 1195.87 357.514 1150.02 313.752 1083.94 C 269.997 1017.95 254.398 937.224 270.419 859.682 C 286.452 782.387 332.522 714.62 398.502 671.28 C 468.674 625.191 546.96 613.555 628.149 630.32 C 625.459 583.013 627.036 545.389 643.173 499.662 C 684.204 383.394 785.737 308.984 907.581 300.401 z"/>
+<path transform="translate(0,0)" fill="rgb(156,155,155)" d="M 907.659 407.406 C 928.022 404.422 959.425 408.947 978.901 414.989 C 1028.11 429.972 1069.15 464.261 1092.65 510.025 C 1116.27 555.792 1120.24 609.2 1103.65 657.957 C 1098.74 672.384 1090.33 686.336 1086.3 699.186 C 1082.14 712.53 1083.57 726.994 1090.26 739.265 C 1100.24 757.657 1118.84 768.259 1139.57 767.119 C 1155.78 766.227 1164.63 759.273 1178.02 751.678 C 1221.56 726.903 1273.23 720.668 1321.41 734.376 C 1370.6 748.209 1412.18 781.215 1436.82 825.985 C 1461.35 870.569 1467.02 923.112 1452.58 971.905 C 1438.06 1020.82 1404.54 1061.88 1359.51 1085.9 C 1280.31 1128.12 1181.39 1108.75 1124.87 1039.74 C 1113.7 1026.12 1105.83 1013.42 1087.4 1008.03 C 1041 993.798 1000.36 1044.75 1026.36 1086.49 C 1041.95 1111.53 1062.76 1127.17 1078.18 1153.03 C 1090.26 1175.57 1097.84 1197.66 1100.84 1223.2 C 1107.04 1273.73 1092.65 1324.64 1060.9 1364.44 C 1029.42 1404.28 983.238 1429.79 932.752 1435.23 C 882.189 1440.86 831.491 1425.87 792.121 1393.65 C 752.588 1361.54 727.605 1314.91 722.781 1264.21 C 718.894 1225.82 727.653 1167.83 758.478 1141.35 C 771.141 1130.47 781.921 1118.81 792.404 1105.84 C 869.373 1010.12 879.456 876.886 817.771 770.669 C 809.316 756.055 799.574 742.224 788.661 729.342 C 782.235 721.815 773.191 712.791 767.461 705.187 C 749.008 680.699 737.483 646.859 734.444 616.659 C 729.188 565.849 744.584 515.06 777.168 475.721 C 810.289 435.451 856.055 412.394 907.659 407.406 z"/>
+<path transform="translate(0,0)" fill="rgb(156,155,155)" d="M 554.228 729.711 C 659.104 725.931 747.227 807.802 751.164 912.672 C 755.1 1017.54 673.362 1105.79 568.498 1109.88 C 463.411 1113.98 374.937 1032.03 370.992 926.942 C 367.047 821.849 449.129 733.498 554.228 729.711 z"/>
+</svg>

providers/302ai/models/MiniMax-M1.toml

@@ -0,0 +1,21 @@
+name = "MiniMax-M1"
+family = "minimax"
+release_date = "2025-06-16"
+last_updated = "2025-06-16"
+attachment = false
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+
+[cost]
+input = 0.132
+output = 1.254
+
+[limit]
+context = 1_000_000
+output = 128_000
+
+[modalities]
+input = ["text"]
+output = ["text"]

providers/302ai/models/MiniMax-M2.1.toml

@@ -0,0 +1,20 @@
+name = "MiniMax-M2.1"
+release_date = "2025-12-19"
+last_updated = "2025-12-19"
+attachment = false
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+
+[cost]
+input = 0.300
+output = 1.200
+
+[limit]
+context = 1_000_000
+output = 131_072
+
+[modalities]
+input = ["text"]
+output = ["text"]

providers/302ai/models/MiniMax-M2.toml

@@ -0,0 +1,20 @@
+name = "MiniMax-M2"
+release_date = "2025-10-26"
+last_updated = "2025-10-26"
+attachment = false
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+
+[cost]
+input = 0.330
+output = 1.320
+
+[limit]
+context = 1_000_000
+output = 128_000
+
+[modalities]
+input = ["text"]
+output = ["text"]

providers/302ai/models/chatgpt-4o-latest.toml

@@ -0,0 +1,22 @@
+name = "chatgpt-4o-latest"
+family = "gpt"
+release_date = "2024-08-08"
+last_updated = "2024-08-08"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = false
+open_weights = false
+knowledge = "2023-09"
+
+[cost]
+input = 5.000
+output = 15.000
+
+[limit]
+context = 128_000
+output = 16_384
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/claude-haiku-4-5-20251001.toml

@@ -0,0 +1,21 @@
+name = "claude-haiku-4-5-20251001"
+release_date = "2025-10-16"
+last_updated = "2025-10-16"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2025-03"
+
+[cost]
+input = 1.000
+output = 5.000
+
+[limit]
+context = 200_000
+output = 64_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/claude-opus-4-1-20250805-thinking.toml

@@ -0,0 +1,21 @@
+name = "claude-opus-4-1-20250805-thinking"
+release_date = "2025-05-27"
+last_updated = "2025-05-27"
+attachment = true
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2025-03"
+
+[cost]
+input = 15.000
+output = 75.000
+
+[limit]
+context = 200_000
+output = 32_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/claude-opus-4-1-20250805.toml

@@ -0,0 +1,21 @@
+name = "claude-opus-4-1-20250805"
+release_date = "2025-08-05"
+last_updated = "2025-08-05"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2025-03"
+
+[cost]
+input = 15.000
+output = 75.000
+
+[limit]
+context = 200_000
+output = 32_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/claude-opus-4-5-20251101-thinking.toml

@@ -0,0 +1,21 @@
+name = "claude-opus-4-5-20251101-thinking"
+release_date = "2025-11-25"
+last_updated = "2025-11-25"
+attachment = true
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2025-03"
+
+[cost]
+input = 5.000
+output = 25.000
+
+[limit]
+context = 200_000
+output = 64_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/claude-opus-4-5-20251101.toml

@@ -1,22 +1,21 @@
-name = "stepfun-ai/step3"
-family = "step"
-release_date = "2025-08-06"
+name = "claude-opus-4-5-20251101"
+release_date = "2025-11-25"
 last_updated = "2025-11-25"
 attachment = true
 reasoning = false
 temperature = true
 tool_call = true
-structured_output = true
 open_weights = false
+knowledge = "2025-03"
 
 [cost]
-input = 0.57
-output = 1.42
+input = 5.000
+output = 25.000
 
 [limit]
-context = 66_000
-output = 66_000
+context = 200_000
+output = 64_000
 
 [modalities]
 input = ["text", "image"]
-output = ["text"]
+output = ["text"]

providers/302ai/models/claude-sonnet-4-5-20250929-thinking.toml

@@ -0,0 +1,21 @@
+name = "claude-sonnet-4-5-20250929-thinking"
+release_date = "2025-09-30"
+last_updated = "2025-09-30"
+attachment = true
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2025-03"
+
+[cost]
+input = 3.000
+output = 15.000
+
+[limit]
+context = 200_000
+output = 64_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/claude-sonnet-4-5-20250929.toml

@@ -0,0 +1,21 @@
+name = "claude-sonnet-4-5-20250929"
+release_date = "2025-09-29"
+last_updated = "2025-09-29"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2025-03"
+
+[cost]
+input = 3.000
+output = 15.000
+
+[limit]
+context = 200_000
+output = 64_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/deepseek-chat.toml

@@ -0,0 +1,22 @@
+name = "Deepseek-Chat"
+family = "deepseek"
+release_date = "2024-11-29"
+last_updated = "2024-11-29"
+attachment = false
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2024-07"
+
+[cost]
+input = 0.290
+output = 0.430
+
+[limit]
+context = 128_000
+output = 8_192
+
+[modalities]
+input = ["text"]
+output = ["text"]

providers/302ai/models/deepseek-reasoner.toml

@@ -1,24 +1,21 @@
-name = "DeepSeek Reasoner"
+name = "Deepseek-Reasoner"
 family = "deepseek-thinking"
 release_date = "2025-01-20"
-last_updated = "2025-09-29"
-attachment = true
+last_updated = "2025-01-20"
+attachment = false
 reasoning = true
 temperature = true
-knowledge = "2024-07"
 tool_call = true
 open_weights = false
-
-[interleaved]
-field = "reasoning_content"
+knowledge = "2024-07"
 
 [cost]
-input = 0
-output = 0
+input = 0.290
+output = 0.430
 
 [limit]
 context = 128_000
-output = 65_536
+output = 128_000
 
 [modalities]
 input = ["text"]

providers/302ai/models/deepseek-v3.2-thinking.toml

@@ -0,0 +1,21 @@
+name = "DeepSeek-V3.2-Thinking"
+release_date = "2025-12-01"
+last_updated = "2025-12-01"
+attachment = false
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2024-12"
+
+[cost]
+input = 0.290
+output = 0.430
+
+[limit]
+context = 128_000
+output = 128_000
+
+[modalities]
+input = ["text"]
+output = ["text"]

providers/302ai/models/deepseek-v3.2.toml

@@ -0,0 +1,21 @@
+name = "deepseek-v3.2"
+release_date = "2025-12-01"
+last_updated = "2025-12-01"
+attachment = false
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2024-12"
+
+[cost]
+input = 0.290
+output = 0.430
+
+[limit]
+context = 128_000
+output = 8_192
+
+[modalities]
+input = ["text"]
+output = ["text"]

providers/302ai/models/doubao-seed-1-6-thinking-250715.toml

@@ -0,0 +1,20 @@
+name = "doubao-seed-1-6-thinking-250715"
+release_date = "2025-07-15"
+last_updated = "2025-07-15"
+attachment = true
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = false
+
+[cost]
+input = 0.121
+output = 1.210
+
+[limit]
+context = 256_000
+output = 16_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/doubao-seed-1-6-vision-250815.toml

@@ -0,0 +1,20 @@
+name = "doubao-seed-1-6-vision-250815"
+release_date = "2025-09-30"
+last_updated = "2025-09-30"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+
+[cost]
+input = 0.114
+output = 1.143
+
+[limit]
+context = 256_000
+output = 32_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/doubao-seed-1-8-251215.toml

@@ -0,0 +1,20 @@
+name = "doubao-seed-1-8-251215"
+release_date = "2025-12-18"
+last_updated = "2025-12-18"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+
+[cost]
+input = 0.114
+output = 0.286
+
+[limit]
+context = 224_000
+output = 64_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/doubao-seed-code-preview-251028.toml

@@ -0,0 +1,20 @@
+name = "doubao-seed-code-preview-251028"
+release_date = "2025-11-11"
+last_updated = "2025-11-11"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+
+[cost]
+input = 0.170
+output = 1.140
+
+[limit]
+context = 256_000
+output = 32_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/gemini-2.0-flash-lite.toml

@@ -0,0 +1,22 @@
+name = "gemini-2.0-flash-lite"
+family = "gemini-flash-lite"
+release_date = "2025-06-16"
+last_updated = "2025-06-16"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = false
+open_weights = false
+knowledge = "2024-11"
+
+[cost]
+input = 0.075
+output = 0.300
+
+[limit]
+context = 2_000_000
+output = 8_192
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/gemini-2.5-flash-image.toml

@@ -0,0 +1,21 @@
+name = "gemini-2.5-flash-image"
+release_date = "2025-10-08"
+last_updated = "2025-10-08"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = false
+open_weights = false
+knowledge = "2025-01"
+
+[cost]
+input = 0.300
+output = 30.000
+
+[limit]
+context = 32_768
+output = 32_768
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/gemini-2.5-flash-lite-preview-09-2025.toml

@@ -0,0 +1,21 @@
+name = "gemini-2.5-flash-lite-preview-09-2025"
+release_date = "2025-09-26"
+last_updated = "2025-09-26"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2025-01"
+
+[cost]
+input = 0.100
+output = 0.400
+
+[limit]
+context = 1_000_000
+output = 65_536
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/gemini-2.5-flash-nothink.toml

@@ -0,0 +1,22 @@
+name = "gemini-2.5-flash-nothink"
+family = "gemini-flash"
+release_date = "2025-06-24"
+last_updated = "2025-06-24"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2025-01"
+
+[cost]
+input = 0.300
+output = 2.500
+
+[limit]
+context = 1_000_000
+output = 65_536
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/gemini-2.5-flash-preview-09-2025.toml

@@ -0,0 +1,21 @@
+name = "gemini-2.5-flash-preview-09-2025"
+release_date = "2025-09-26"
+last_updated = "2025-09-26"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2025-01"
+
+[cost]
+input = 0.300
+output = 2.500
+
+[limit]
+context = 1_000_000
+output = 65_536
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/gemini-2.5-flash.toml

@@ -0,0 +1,22 @@
+name = "gemini-2.5-flash"
+family = "gemini-flash"
+release_date = "2025-06-17"
+last_updated = "2025-06-17"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2025-01"
+
+[cost]
+input = 0.300
+output = 2.500
+
+[limit]
+context = 1_000_000
+output = 65_536
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/gemini-2.5-pro.toml

@@ -0,0 +1,22 @@
+name = "gemini-2.5-pro"
+family = "gemini-pro"
+release_date = "2025-06-17"
+last_updated = "2025-06-17"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2025-01"
+
+[cost]
+input = 1.250
+output = 10.000
+
+[limit]
+context = 1_000_000
+output = 65_536
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/gemini-3-flash-preview.toml

@@ -0,0 +1,21 @@
+name = "gemini-3-flash-preview"
+release_date = "2025-12-18"
+last_updated = "2025-12-18"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2025-06"
+
+[cost]
+input = 0.500
+output = 3.000
+
+[limit]
+context = 1_000_000
+output = 65_536
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/gemini-3-pro-image-preview.toml

@@ -0,0 +1,21 @@
+name = "gemini-3-pro-image-preview"
+release_date = "2025-11-20"
+last_updated = "2025-11-20"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = false
+open_weights = false
+knowledge = "2025-06"
+
+[cost]
+input = 2.000
+output = 120.000
+
+[limit]
+context = 32_768
+output = 64_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/gemini-3-pro-preview.toml

@@ -0,0 +1,21 @@
+name = "gemini-3-pro-preview"
+release_date = "2025-11-19"
+last_updated = "2025-11-19"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2025-06"
+
+[cost]
+input = 2.000
+output = 12.000
+
+[limit]
+context = 1_000_000
+output = 64_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/glm-4.5.toml

@@ -1,20 +1,20 @@
-name = "Mistral Large (24.02)"
-family = "mistral-large"
-release_date = "2024-12-01"
-last_updated = "2024-12-01"
+name = "GLM-4.5"
+release_date = "2025-07-29"
+last_updated = "2025-07-29"
 attachment = false
 reasoning = false
 temperature = true
 tool_call = true
 open_weights = false
+knowledge = "2024-10"
 
 [cost]
-input = 0.50
-output = 1.50
+input = 0.286
+output = 1.142
 
 [limit]
 context = 128_000
-output = 4_096
+output = 98_304
 
 [modalities]
 input = ["text"]

providers/302ai/models/glm-4.5v.toml

@@ -0,0 +1,21 @@
+name = "GLM-4.5V"
+release_date = "2025-07-29"
+last_updated = "2025-07-29"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2024-10"
+
+[cost]
+input = 0.290
+output = 0.860
+
+[limit]
+context = 64_000
+output = 16_384
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/glm-4.6.toml

@@ -0,0 +1,21 @@
+name = "glm-4.6"
+release_date = "2025-09-30"
+last_updated = "2025-09-30"
+attachment = false
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2025-03"
+
+[cost]
+input = 0.286
+output = 1.142
+
+[limit]
+context = 200_000
+output = 131_072
+
+[modalities]
+input = ["text"]
+output = ["text"]

providers/302ai/models/glm-4.6v.toml

@@ -0,0 +1,21 @@
+name = "GLM-4.6V"
+release_date = "2025-12-08"
+last_updated = "2025-12-08"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2025-03"
+
+[cost]
+input = 0.145
+output = 0.430
+
+[limit]
+context = 128_000
+output = 32_768
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/glm-4.7.toml

@@ -0,0 +1,21 @@
+name = "glm-4.7"
+release_date = "2025-12-22"
+last_updated = "2025-12-22"
+attachment = false
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2025-06"
+
+[cost]
+input = 0.286
+output = 1.142
+
+[limit]
+context = 200_000
+output = 131_072
+
+[modalities]
+input = ["text"]
+output = ["text"]

providers/302ai/models/gpt-4.1-mini.toml

@@ -0,0 +1,22 @@
+name = "gpt-4.1-mini"
+family = "gpt-mini"
+release_date = "2025-04-14"
+last_updated = "2025-04-14"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2024-04"
+
+[cost]
+input = 0.400
+output = 1.600
+
+[limit]
+context = 1_000_000
+output = 32_768
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/gpt-4.1-nano.toml

@@ -0,0 +1,22 @@
+name = "gpt-4.1-nano"
+family = "gpt-nano"
+release_date = "2025-04-14"
+last_updated = "2025-04-14"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2024-04"
+
+[cost]
+input = 0.100
+output = 0.400
+
+[limit]
+context = 1_000_000
+output = 32_768
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/gpt-4.1.toml

@@ -0,0 +1,22 @@
+name = "gpt-4.1"
+family = "gpt"
+release_date = "2025-04-14"
+last_updated = "2025-04-14"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2024-04"
+
+[cost]
+input = 2.000
+output = 8.000
+
+[limit]
+context = 1_000_000
+output = 32_768
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/gpt-4o.toml

@@ -0,0 +1,22 @@
+name = "gpt-4o"
+family = "gpt"
+release_date = "2024-05-13"
+last_updated = "2024-05-13"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2023-09"
+
+[cost]
+input = 2.500
+output = 10.000
+
+[limit]
+context = 128_000
+output = 16_384
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/gpt-5-mini.toml

@@ -0,0 +1,21 @@
+name = "gpt-5-mini"
+release_date = "2025-08-08"
+last_updated = "2025-08-08"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2024-10"
+
+[cost]
+input = 0.250
+output = 2.000
+
+[limit]
+context = 400_000
+output = 128_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/gpt-5-pro.toml

@@ -0,0 +1,21 @@
+name = "gpt-5-pro"
+release_date = "2025-10-08"
+last_updated = "2025-10-08"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2024-10"
+
+[cost]
+input = 15.000
+output = 120.000
+
+[limit]
+context = 400_000
+output = 272_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/gpt-5-thinking.toml

@@ -0,0 +1,21 @@
+name = "gpt-5-thinking"
+release_date = "2025-08-08"
+last_updated = "2025-08-08"
+attachment = true
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2024-10"
+
+[cost]
+input = 1.250
+output = 10.000
+
+[limit]
+context = 400_000
+output = 128_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/gpt-5.1-chat-latest.toml

@@ -0,0 +1,21 @@
+name = "gpt-5.1-chat-latest"
+release_date = "2025-11-14"
+last_updated = "2025-11-14"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2024-10"
+
+[cost]
+input = 1.250
+output = 10.000
+
+[limit]
+context = 128_000
+output = 16_384
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/gpt-5.1.toml

@@ -0,0 +1,21 @@
+name = "gpt-5.1"
+release_date = "2025-11-14"
+last_updated = "2025-11-14"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2024-10"
+
+[cost]
+input = 1.250
+output = 10.000
+
+[limit]
+context = 400_000
+output = 128_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/gpt-5.2-chat-latest.toml

@@ -0,0 +1,21 @@
+name = "gpt-5.2-chat-latest"
+release_date = "2025-12-12"
+last_updated = "2025-12-12"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2024-10"
+
+[cost]
+input = 1.750
+output = 14.000
+
+[limit]
+context = 128_000
+output = 16_384
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/gpt-5.2.toml

@@ -0,0 +1,21 @@
+name = "gpt-5.2"
+release_date = "2025-12-12"
+last_updated = "2025-12-12"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2024-10"
+
+[cost]
+input = 1.750
+output = 14.000
+
+[limit]
+context = 400_000
+output = 128_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/gpt-5.toml

@@ -0,0 +1,21 @@
+name = "gpt-5"
+release_date = "2025-08-08"
+last_updated = "2025-08-08"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2024-10"
+
+[cost]
+input = 1.250
+output = 10.000
+
+[limit]
+context = 400_000
+output = 128_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/grok-4-1-fast-non-reasoning.toml

@@ -0,0 +1,21 @@
+name = "grok-4-1-fast-non-reasoning"
+release_date = "2025-11-20"
+last_updated = "2025-11-20"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2025-06"
+
+[cost]
+input = 0.200
+output = 0.500
+
+[limit]
+context = 2_000_000
+output = 30_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/grok-4-1-fast-reasoning.toml

@@ -0,0 +1,21 @@
+name = "grok-4-1-fast-reasoning"
+release_date = "2025-11-20"
+last_updated = "2025-11-20"
+attachment = true
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2025-06"
+
+[cost]
+input = 0.200
+output = 0.500
+
+[limit]
+context = 2_000_000
+output = 30_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/grok-4-fast-non-reasoning.toml

@@ -0,0 +1,21 @@
+name = "grok-4-fast-non-reasoning"
+release_date = "2025-09-23"
+last_updated = "2025-09-23"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2025-06"
+
+[cost]
+input = 0.200
+output = 0.500
+
+[limit]
+context = 2_000_000
+output = 30_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/grok-4-fast-reasoning.toml

@@ -1,17 +1,16 @@
-name = "Grok 4 Fast (Reasoning)"
-family = "grok"
-release_date = "2025-09-19"
-last_updated = "2025-09-19"
+name = "grok-4-fast-reasoning"
+release_date = "2025-09-23"
+last_updated = "2025-09-23"
 attachment = true
 reasoning = true
 temperature = true
-knowledge = "2025-07"
 tool_call = true
 open_weights = false
+knowledge = "2025-06"
 
 [cost]
-input = 0
-output = 0
+input = 0.200
+output = 0.500
 
 [limit]
 context = 2_000_000

providers/302ai/models/grok-4.1.toml

@@ -1,18 +1,21 @@
-name = "Gemini 3 Pro Preview"
-family = "gemini-pro"
+name = "grok-4.1"
 release_date = "2025-11-18"
 last_updated = "2025-11-18"
 attachment = true
 reasoning = false
-tool_call = true
-structured_output = true
 temperature = true
+tool_call = true
 open_weights = false
+knowledge = "2025-06"
+
+[cost]
+input = 2.000
+output = 10.000
 
 [limit]
-context = 1_000_000
+context = 200_000
 output = 64_000
 
 [modalities]
-input = ["text", "image", "audio", "video"]
-output = ["text"]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/kimi-k2-0905-preview.toml

@@ -0,0 +1,21 @@
+name = "kimi-k2-0905-preview"
+release_date = "2025-09-05"
+last_updated = "2025-09-05"
+attachment = false
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2025-06"
+
+[cost]
+input = 0.632
+output = 2.530
+
+[limit]
+context = 262_144
+output = 262_144
+
+[modalities]
+input = ["text"]
+output = ["text"]

providers/302ai/models/kimi-k2-thinking-turbo.toml

@@ -0,0 +1,21 @@
+name = "kimi-k2-thinking-turbo"
+release_date = "2025-09-05"
+last_updated = "2025-09-05"
+attachment = false
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2025-06"
+
+[cost]
+input = 1.265
+output = 9.119
+
+[limit]
+context = 262_144
+output = 262_144
+
+[modalities]
+input = ["text"]
+output = ["text"]

providers/302ai/models/kimi-k2-thinking.toml

@@ -0,0 +1,21 @@
+name = "kimi-k2-thinking"
+release_date = "2025-09-05"
+last_updated = "2025-09-05"
+attachment = false
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2025-06"
+
+[cost]
+input = 0.575
+output = 2.300
+
+[limit]
+context = 262_144
+output = 262_144
+
+[modalities]
+input = ["text"]
+output = ["text"]

providers/302ai/models/ministral-14b-2512.toml

@@ -0,0 +1,21 @@
+name = "ministral-14b-2512"
+release_date = "2025-12-16"
+last_updated = "2025-12-16"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2024-12"
+
+[cost]
+input = 0.330
+output = 0.330
+
+[limit]
+context = 128_000
+output = 128_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/mistral-large-2512.toml

@@ -0,0 +1,21 @@
+name = "mistral-large-2512"
+release_date = "2025-12-16"
+last_updated = "2025-12-16"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2024-12"
+
+[cost]
+input = 1.100
+output = 3.300
+
+[limit]
+context = 128_000
+output = 262_144
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/qwen-flash.toml

@@ -0,0 +1,20 @@
+name = "Qwen-Flash"
+release_date = "2025-07-28"
+last_updated = "2025-07-28"
+attachment = false
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+
+[cost]
+input = 0.022
+output = 0.220
+
+[limit]
+context = 1_000_000
+output = 32_768
+
+[modalities]
+input = ["text"]
+output = ["text"]

providers/302ai/models/qwen-max-latest.toml

@@ -0,0 +1,22 @@
+name = "Qwen-Max-Latest"
+family = "qwen"
+release_date = "2024-04-03"
+last_updated = "2025-01-25"
+attachment = false
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2024-11"
+
+[cost]
+input = 0.343
+output = 1.372
+
+[limit]
+context = 131_072
+output = 8_192
+
+[modalities]
+input = ["text"]
+output = ["text"]

providers/302ai/models/qwen-plus.toml

@@ -0,0 +1,22 @@
+name = "Qwen-Plus"
+family = "qwen"
+release_date = "2024-07-23"
+last_updated = "2024-07-23"
+attachment = false
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2024-10"
+
+[cost]
+input = 0.120
+output = 1.200
+
+[limit]
+context = 1_000_000
+output = 32_768
+
+[modalities]
+input = ["text"]
+output = ["text"]

providers/302ai/models/qwen3-235b-a22b-instruct-2507.toml

@@ -0,0 +1,21 @@
+name = "qwen3-235b-a22b-instruct-2507"
+release_date = "2025-07-30"
+last_updated = "2025-07-30"
+attachment = false
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2025-04"
+
+[cost]
+input = 0.290
+output = 1.143
+
+[limit]
+context = 128_000
+output = 65_536
+
+[modalities]
+input = ["text"]
+output = ["text"]

providers/302ai/models/qwen3-235b-a22b.toml

@@ -1,17 +1,17 @@
-name = "Qwen3 235B-A22B"
+name = "Qwen3-235B-A22B"
 family = "qwen"
 release_date = "2025-04-29"
 last_updated = "2025-04-29"
 attachment = false
-reasoning = true
+reasoning = false
 temperature = true
-knowledge = "2025-04"
 tool_call = true
-open_weights = true
+open_weights = false
+knowledge = "2025-04"
 
 [cost]
-input = 0.22
-output = 0.88
+input = 0.290
+output = 2.860
 
 [limit]
 context = 128_000

providers/302ai/models/qwen3-30b-a3b.toml

@@ -0,0 +1,22 @@
+name = "Qwen3-30B-A3B"
+family = "qwen"
+release_date = "2025-04-29"
+last_updated = "2025-04-29"
+attachment = false
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2025-04"
+
+[cost]
+input = 0.110
+output = 1.080
+
+[limit]
+context = 128_000
+output = 8_192
+
+[modalities]
+input = ["text"]
+output = ["text"]

providers/302ai/models/qwen3-coder-480b-a35b-instruct.toml

@@ -0,0 +1,21 @@
+name = "qwen3-coder-480b-a35b-instruct"
+release_date = "2025-07-23"
+last_updated = "2025-07-23"
+attachment = false
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2025-04"
+
+[cost]
+input = 0.860
+output = 3.430
+
+[limit]
+context = 262_144
+output = 65_536
+
+[modalities]
+input = ["text"]
+output = ["text"]

providers/302ai/models/qwen3-max-2025-09-23.toml

@@ -0,0 +1,21 @@
+name = "qwen3-max-2025-09-23"
+release_date = "2025-09-24"
+last_updated = "2025-09-24"
+attachment = false
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2025-04"
+
+[cost]
+input = 0.860
+output = 3.430
+
+[limit]
+context = 258_048
+output = 65_536
+
+[modalities]
+input = ["text"]
+output = ["text"]

providers/302ai/provider.toml

@@ -0,0 +1,5 @@
+name = "302.AI"
+env = ["302AI_API_KEY"]
+npm = "@ai-sdk/openai-compatible"
+doc = "https://doc.302.ai"
+api = "https://api.302.ai/v1"

providers/abacus/models/claude-opus-4-6.toml

@@ -0,0 +1,22 @@
+name = "Claude Opus 4.6"
+family = "claude-opus"
+release_date = "2026-02-05"
+last_updated = "2026-02-05"
+attachment = true
+reasoning = true
+temperature = true
+tool_call = true
+knowledge = "2025-05"
+open_weights = false
+
+[cost]
+input = 5.00
+output = 25.00
+
+[limit]
+context = 200_000
+output = 128_000
+
+[modalities]
+input = ["text", "image", "pdf"]
+output = ["text"]

providers/abacus/models/claude-sonnet-4-6.toml

@@ -1,12 +1,12 @@
-name = "Claude Sonnet 3"
+name = "Claude Sonnet 4.6"
 family = "claude-sonnet"
-release_date = "2024-03-04"
-last_updated = "2024-03-04"
+release_date = "2026-02-17"
+last_updated = "2026-02-17"
 attachment = true
-reasoning = false
+reasoning = true
 temperature = true
-knowledge = "2023-08"
 tool_call = true
+knowledge = "2025-08"
 open_weights = false
 
 [cost]
@@ -15,7 +15,7 @@ output = 15.00
 
 [limit]
 context = 200_000
-output = 4_096
+output = 64_000
 
 [modalities]
 input = ["text", "image", "pdf"]

providers/abacus/models/deepseek/deepseek-v3.1.toml

@@ -1,7 +1,7 @@
 name = "DeepSeek V3.1"
 family = "deepseek"
-release_date = "2025-08-01"
-last_updated = "2025-08-01"
+release_date = "2025-01-20"
+last_updated = "2025-01-20"
 attachment = false
 reasoning = true
 temperature = true

providers/abacus/models/gemini-3.1-flash-lite-preview.toml

@@ -0,0 +1,24 @@
+name = "Gemini 3.1 Flash Lite Preview"
+family = "gemini-flash"
+release_date = "2026-03-01"
+last_updated = "2026-03-01"
+attachment = true
+reasoning = true
+temperature = true
+tool_call = true
+structured_output = true
+open_weights = false
+
+[cost]
+input = 0.25
+output = 1.50
+cache_read = 0.025
+cache_write = 1.00
+
+[limit]
+context = 1_048_576
+output = 65_536
+
+[modalities]
+input = ["text", "image", "audio", "video", "pdf"]
+output = ["text"]

providers/abacus/models/gemini-3.1-pro-preview.toml

@@ -0,0 +1,23 @@
+name = "Gemini 3.1 Pro Preview"
+family = "gemini-pro"
+release_date = "2026-02-19"
+last_updated = "2026-02-19"
+attachment = true
+reasoning = true
+temperature = true
+tool_call = true
+structured_output = true
+knowledge = "2025-01"
+open_weights = false
+
+[cost]
+input = 2.00
+output = 12.00
+
+[limit]
+context = 1_048_576
+output = 65_536
+
+[modalities]
+input = ["text", "image", "video", "audio", "pdf"]
+output = ["text"]

providers/abacus/models/gpt-5-codex.toml

@@ -1,5 +1,5 @@
-name = "GPT-5-Codex"
-family = "gpt-codex"
+name = "GPT-5 Codex"
+family = "gpt"
 release_date = "2025-09-15"
 last_updated = "2025-09-15"
 attachment = false
@@ -7,14 +7,16 @@ reasoning = true
 temperature = false
 knowledge = "2024-09-30"
 tool_call = true
+structured_output = true
 open_weights = false
 
 [cost]
-input = 0
-output = 0
+input = 1.25
+output = 10.00
 
 [limit]
-context = 128_000
+context = 400_000
+input = 272_000
 output = 128_000
 
 [modalities]

providers/abacus/models/gpt-5.1-codex-max.toml

@@ -0,0 +1,24 @@
+name = "GPT-5.1 Codex Max"
+family = "gpt"
+release_date = "2025-11-13"
+last_updated = "2025-11-13"
+attachment = true
+reasoning = true
+temperature = false
+knowledge = "2024-09-30"
+tool_call = true
+structured_output = true
+open_weights = false
+
+[cost]
+input = 1.25
+output = 10.00
+
+[limit]
+context = 400_000
+input = 272_000
+output = 128_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/abacus/models/gpt-5.1-codex.toml

@@ -0,0 +1,24 @@
+name = "GPT-5.1 Codex"
+family = "gpt"
+release_date = "2025-11-13"
+last_updated = "2025-11-13"
+attachment = true
+reasoning = true
+temperature = false
+knowledge = "2024-09-30"
+tool_call = true
+structured_output = true
+open_weights = false
+
+[cost]
+input = 1.25
+output = 10.00
+
+[limit]
+context = 400_000
+input = 272_000
+output = 128_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/abacus/models/gpt-5.2-chat-latest.toml

@@ -0,0 +1,22 @@
+name = "GPT-5.2 Chat Latest"
+family = "gpt"
+release_date = "2026-01-01"
+last_updated = "2026-01-01"
+attachment = true
+reasoning = true
+temperature = true
+knowledge = "2024-09-30"
+tool_call = true
+open_weights = false
+
+[cost]
+input = 1.75
+output = 14.00
+
+[limit]
+context = 400_000
+output = 128_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/abacus/models/gpt-5.2-codex.toml

@@ -0,0 +1,24 @@
+name = "GPT-5.2 Codex"
+family = "gpt"
+release_date = "2025-12-11"
+last_updated = "2025-12-11"
+attachment = true
+reasoning = true
+temperature = false
+knowledge = "2025-08-31"
+tool_call = true
+structured_output = true
+open_weights = false
+
+[cost]
+input = 1.75
+output = 14.00
+
+[limit]
+context = 400_000
+input = 272_000
+output = 128_000
+
+[modalities]
+input = ["text", "image", "pdf"]
+output = ["text"]

providers/abacus/models/gpt-5.3-chat-latest.toml

@@ -0,0 +1,21 @@
+name = "GPT-5.3 Chat Latest"
+family = "gpt"
+release_date = "2026-03-01"
+last_updated = "2026-03-01"
+attachment = true
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = false
+
+[cost]
+input = 1.75
+output = 14.00
+
+[limit]
+context = 400_000
+output = 128_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/abacus/models/gpt-5.3-codex-xhigh.toml

@@ -0,0 +1,24 @@
+name = "GPT-5.3 Codex XHigh"
+family = "gpt"
+release_date = "2026-02-05"
+last_updated = "2026-02-05"
+attachment = true
+reasoning = true
+temperature = false
+knowledge = "2025-08-31"
+tool_call = true
+structured_output = true
+open_weights = false
+
+[cost]
+input = 1.75
+output = 14.00
+
+[limit]
+context = 400_000
+input = 272_000
+output = 128_000
+
+[modalities]
+input = ["text", "image", "pdf"]
+output = ["text"]

providers/abacus/models/gpt-5.3-codex.toml

@@ -0,0 +1,24 @@
+name = "GPT-5.3 Codex"
+family = "gpt"
+release_date = "2026-02-05"
+last_updated = "2026-02-05"
+attachment = true
+reasoning = true
+temperature = false
+knowledge = "2025-08-31"
+tool_call = true
+structured_output = true
+open_weights = false
+
+[cost]
+input = 1.75
+output = 14.00
+
+[limit]
+context = 400_000
+input = 272_000
+output = 128_000
+
+[modalities]
+input = ["text", "image", "pdf"]
+output = ["text"]