fix(web): restore provider logo tint for external SVGs

Normalize built and served logo SVGs so currentColor resolves to the themed gray used before provider logos moved to external images.

.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

@@ -31,9 +31,27 @@
 ## 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
+- Models may reuse another model's definition via `extends` (see below); otherwise the full definition must be present in the file
 - Schema uses `.strict()` — extra fields cause validation errors
 
+### `[extends]` (inheritance between models)
+- Syntax — a table at the top of the TOML:
+  ```toml
+  [extends]
+  from = "<provider-id>/<model-id>"   # required
+  omit = ["experimental.modes.fast"]  # optional, dot-path strings
+  ```
+  Example: `from = "anthropic/claude-opus-4-6"`
+- Resolved at parse time in `generate()`; the final JSON output contains **no** `extends` field — it exists only to cut duplication in the TOMLs
+- Merge semantics:
+  - Plain objects (`[cost]`, `[limit]`, `[modalities]`, `[provider]`, `[experimental]`, …) are **deep-merged**
+  - Arrays (e.g. `modalities.input`) and primitives are **replaced** wholesale by the child
+  - Any field the child omits is inherited verbatim from the base
+- `omit` runs **after** the merge and deletes each dot-path from the result (used when the child needs to *remove* something the base defines, e.g. a provider-specific experimental mode). Every listed path must exist in the merged model, else an error is thrown. Ancestor tables that become empty as a result are also pruned, so `omit = ["experimental.modes.fast"]` yields no `experimental` key in the final JSON when `fast` was the only mode.
+- Chains are allowed (A extends B extends C); cycles throw
+- The base model must exist; `[extends.from]` pointing at a missing provider/model is an error
+- The `extends` table is stripped before schema validation, so the merged result must still satisfy the strict `Model` schema
+
 ### 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`)

README.md

@@ -120,6 +120,31 @@ output = ["text"]           # Supported output modalities
 field = "reasoning_content" # Name of the interleaved field "reasoning_content" or "reasoning_details"
 ```
 
+#### 3a. Reuse an Existing Model with `extends`
+
+For wrapper providers that mirror a model from another provider, prefer reusing the canonical model definition instead of duplicating the whole file.
+
+Use `extends` only for non-first-party wrappers and mirrors. Do not use it inside the actual lab provider directories that act as the canonical source for a model family, for example `providers/anthropic/`, `providers/openai/`, `providers/google/`, `providers/xai/`, `providers/minimax/`, or `providers/moonshot/`.
+
+```toml
+[extends]
+from = "anthropic/claude-opus-4-6"
+omit = ["experimental.modes.fast"]
+
+[provider]
+npm = "@ai-sdk/anthropic"
+```
+
+Rules:
+
+- `from` must point to another model using `<provider>/<model-id>`.
+- `omit` is optional and removes fields after the inherited model and local overrides are merged.
+- You can override any top-level model field locally.
+- If you override a nested table like `[cost]`, `[limit]`, or `[modalities]`, include the full values needed for that table.
+- `id` still comes from the filename; do not add it to the TOML.
+
+Use `extends` when the wrapper model is materially the same as the source model and only differs by a small set of overrides or omitted fields.
+
 #### 4. Submit a Pull Request
 
 1. Fork this repo
@@ -136,9 +161,17 @@ There's a GitHub Action that will automatically validate your submission against
 - Values are within acceptable ranges
 - TOML syntax is valid
 
+When converting existing wrapper models to `extends`, compare generated output before and after the change:
+
+```bash
+bun run compare:migrations
+```
+
+This prints a diff for each changed model TOML so you can confirm the generated JSON only changed where you intended.
+
 ### Schema Reference
 
-Models must conform to the following schema, as defined in `app/schemas.ts`.
+Models must conform to the following schema, as defined in `packages/core/src/schema.ts`.
 
 **Provider Schema:**
 
@@ -199,6 +232,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.

bun.lock

@@ -13,6 +13,7 @@
       "name": "models.dev",
       "version": "0.0.0",
       "dependencies": {
+        "remeda": "^2.33.7",
         "zod": "catalog:",
       },
       "devDependencies": {
@@ -240,6 +241,8 @@
 
     "raw-body": ["raw-body@3.0.0", "", { "dependencies": { "bytes": "3.1.2", "http-errors": "2.0.0", "iconv-lite": "0.6.3", "unpipe": "1.0.0" } }, "sha512-RmkhL8CAyCRPXCE28MMH0z2PNWQBNk2Q09ZdxM9IOOXwxwZbN+qbWaatPkdkWIKL2ZVDImrN/pK5HTRz2PcS4g=="],
 
+    "remeda": ["remeda@2.33.7", "", {}, "sha512-cXlyjevWx5AcslOUEETG4o8XYi9UkoCXcJmj7XhPFVbla+ITuOBxv6ijBrmbeg+ZhzmDThkNdO+iXKUfrJep1w=="],
+
     "router": ["router@2.2.0", "", { "dependencies": { "debug": "^4.4.0", "depd": "^2.0.0", "is-promise": "^4.0.0", "parseurl": "^1.3.3", "path-to-regexp": "^8.0.0" } }, "sha512-nLTrUKm2UyiL7rlhapu/Zl45FwNgkZGaCpZbIHajDYgwlJCOzLSk+cIPAnsEqV955GjILJnKbdQC1nVPz+gAYQ=="],
 
     "safe-buffer": ["safe-buffer@5.2.1", "", {}, "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ=="],

package.json

@@ -16,8 +16,11 @@
   },
   "scripts": {
     "validate": "bun ./packages/core/script/validate.ts",
+    "compare:migrations": "bun ./packages/core/script/compare-model-migrations.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/package.json

@@ -4,6 +4,7 @@
   "$schema": "https://json.schemastore.org/package.json",
   "type": "module",
   "dependencies": {
+    "remeda": "^2.33.7",
     "zod": "catalog:"
   },
   "main": "./src/index.ts",

packages/core/script/compare-model-migrations.ts

@@ -0,0 +1,89 @@
+#!/usr/bin/env bun
+
+import path from "node:path";
+import { cp, mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { generate } from "../src/generate.js";
+
+const root = path.join(import.meta.dirname, "..", "..", "..");
+const providersPath = path.join(root, "providers");
+
+const diffOutput = await Bun.$`git diff --name-only HEAD -- providers`.cwd(root).text();
+const changedProviderPaths = diffOutput
+  .split("\n")
+  .filter(Boolean)
+  .filter((filePath) => /^providers\/[^/]+\/models\/.+\.toml$/.test(filePath));
+
+if (changedProviderPaths.length === 0) {
+  process.exit(0);
+}
+
+const baselineRoot = path.join(tmpdir(), `models-dev-compare-${Date.now()}`);
+await mkdir(baselineRoot, { recursive: true });
+
+try {
+  const baselineProvidersPath = path.join(baselineRoot, "providers");
+  await cp(providersPath, baselineProvidersPath, { recursive: true });
+
+  for (const filePath of changedProviderPaths) {
+    const tempFilePath = path.join(baselineRoot, filePath);
+    const show = Bun.spawn(["git", "show", `HEAD:${filePath}`], {
+      cwd: root,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const exitCode = await show.exited;
+    if (exitCode !== 0) {
+      await rm(tempFilePath, { force: true });
+      continue;
+    }
+
+    const contents = await new Response(show.stdout).text();
+    await mkdir(path.dirname(tempFilePath), { recursive: true });
+    await writeFile(tempFilePath, contents);
+  }
+
+  const before = await generate(baselineProvidersPath);
+  const after = await generate(providersPath);
+
+  for (const filePath of changedProviderPaths) {
+    const match = /^providers\/([^/]+)\/models\/(.+)\.toml$/.exec(filePath);
+    if (!match) continue;
+
+    const [, providerID, modelID] = match;
+    const beforeModel = before[providerID]?.models[modelID];
+    const afterModel = after[providerID]?.models[modelID];
+    const beforeJson = JSON.stringify(beforeModel, null, 2);
+    const afterJson = JSON.stringify(afterModel, null, 2);
+
+    if (beforeJson === afterJson) {
+      continue;
+    }
+
+    const beforeFilePath = path.join(baselineRoot, "before.json");
+    const afterFilePath = path.join(baselineRoot, "after.json");
+    await writeFile(beforeFilePath, `${beforeJson}\n`);
+    await writeFile(afterFilePath, `${afterJson}\n`);
+
+    const diff = Bun.spawn(
+      [
+        "diff",
+        "-u",
+        "-L",
+        `${filePath} (before)`,
+        "-L",
+        `${filePath} (after)`,
+        beforeFilePath,
+        afterFilePath,
+      ],
+      {
+        stdout: "pipe",
+        stderr: "pipe",
+      },
+    );
+    const output = await new Response(diff.stdout).text();
+    process.stdout.write(output);
+  }
+} finally {
+  await rm(baselineRoot, { recursive: true, force: true });
+}

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

@@ -35,6 +35,31 @@ 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({
@@ -137,20 +162,34 @@ for (const modelName of modelNames) {
   modelsData.push({ name: modelName, data: showParsed.data });
 }
 
-console.log(`Fetched all models. Writing new files...`);
+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;
+  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
-    existingData = null;
   }
 
   const family = existingData?.family ?? (data.details.family as ModelFamily);
@@ -179,9 +218,20 @@ for (const { name, data } of modelsData) {
     },
   };
 
+  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}`);
+console.log(`\nDone. Created: ${created}, Skipped: ${skipped}, Deleted: ${deleted}`);

packages/core/script/generate-venice.ts

@@ -3,30 +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({
@@ -43,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();
 
@@ -56,6 +50,7 @@ const ModelSpec = z
   .object({
     pricing: Pricing.optional(),
     availableContextTokens: z.number(),
+    maxCompletionTokens: z.number().optional(),
     capabilities: Capabilities,
     constraints: z.any().optional(),
     name: z.string(),
@@ -162,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;
@@ -213,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;
@@ -232,15 +239,9 @@ function mergeModel(
   const caps = spec.capabilities;
 
   const contextTokens = spec.availableContextTokens;
-  const proposedOutputTokens = Math.floor(contextTokens / 4);
-  const outputTokens =
-    existing?.limit?.output !== undefined && existing.limit.output < proposedOutputTokens
-      ? existing.limit.output
-      : proposedOutputTokens
+  const outputTokens = spec.maxCompletionTokens ?? Math.floor(contextTokens / 4);
 
-  const openWeights = spec.modelSource
-    ? spec.modelSource.toLowerCase().includes("huggingface")
-    : spec.privacy === "private";
+  const openWeights = spec.modelSource?.toLowerCase().includes("huggingface") ?? false;
 
   const inputModalities = buildInputModalities(caps);
 
@@ -285,6 +286,16 @@ function mergeModel(
       ...(spec.pricing.cache_input && { cache_read: spec.pricing.cache_input.usd }),
       ...(spec.pricing.cache_write && { cache_write: spec.pricing.cache_write.usd }),
     };
+
+    // 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);
@@ -352,6 +363,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
@@ -414,6 +438,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);
@@ -435,7 +463,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
@@ -454,11 +482,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,589 @@
+#!/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",
+  Reranking = "reranking",
+}
+
+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 / reranking yet
+    if (
+      apiModel.type === ModelType.Image ||
+      apiModel.type === ModelType.Video ||
+      apiModel.type === ModelType.Reranking
+    ) {
+      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

@@ -8,11 +8,13 @@ export const ModelFamilyValues = [
   // OpenAI/GPT style
   "gpt",
   "gpt-codex",
+  "gpt-codex-spark",
   "gpt-codex-mini",
   "gpt-pro",
   "gpt-mini",
   "gpt-nano",
   "gpt-oss",
+  "gpt-image",
 
   // OpenAI o-series (reasoning models)
   "o",
@@ -45,6 +47,9 @@ export const ModelFamilyValues = [
 
   // Alibaba Qwen
   "qwen",
+  "qwen3.5",
+  "qwen3.6",
+  "qwen-free",
 
   // DeepSeek
   "deepseek",
@@ -95,6 +100,7 @@ export const ModelFamilyValues = [
 
   // NVIDIA Nemotron
   "nemotron",
+  "nemotron-free",
 
   // AWS Titan
   "titan",
@@ -102,11 +108,16 @@ export const ModelFamilyValues = [
 
   // MiniMax
   "minimax",
+  "minimax-m2.5",
+  "minimax-m2.7",
   "minimax-free",
 
   // Hunyuan
   "hunyuan",
 
+  // HY
+  "HY",
+
   // Yi
   "yi",
 
@@ -127,9 +138,6 @@ export const ModelFamilyValues = [
   "solar-mini",
   "solar-pro",
 
-  // Exaone
-  "exaone",
-
   // Step (StepFun)
   "step",
 
@@ -187,7 +195,6 @@ export const ModelFamilyValues = [
   // Pony
   "pony",
 
-
   // Mercury
   "mercury",
 
@@ -196,6 +203,14 @@ export const ModelFamilyValues = [
 
   // Mimo
   "mimo",
+  "mimo-pro",
+  "mimo-omni",
+  "mimo-pro-free",
+  "mimo-omni-free",
+  "mimo-flash-free",
+
+  // Clarifai
+  "mm-poly",
 
   // Longcat
   "longcat",
@@ -364,7 +379,22 @@ export const ModelFamilyValues = [
   "sourceful",
 
   // AllenAI
-  "allenai"
+  "allenai",
+
+  // Writer
+  "palmyra",
+
+  // ALLaM
+  "allam",
+
+  // Canopy Labs
+  "canopylabs",
+
+  // Groq
+  "groq",
+
+  // Elephant
+  "elephant",
 ] as const;
 
 export const ModelFamily = z.enum(ModelFamilyValues);

packages/core/src/generate.ts

@@ -1,9 +1,31 @@
 import path from "path";
+import { mergeDeep } from "remeda";
+import { z } from "zod";
 
 import { Provider, Model } from "./schema.js";
 
+const ExtendsModel = Model.sourceType()
+  .partial()
+  .extend({
+    extends: z
+      .object({
+        from: z
+          .string()
+          .regex(/^[^/]+\/[^/]+$/, "Must be in provider/model format"),
+        omit: z.array(z.string()).optional(),
+      })
+      .strict(),
+  })
+  .strict();
+
 export async function generate(directory: string) {
-  const result = {} as Record<string, Provider>;
+  const result: Record<string, Provider> = {};
+  const extendsModels: Array<{
+    providerID: string;
+    modelID: string;
+    modelPath: string;
+    model: z.infer<typeof ExtendsModel>;
+  }> = [];
   for await (const providerPath of new Bun.Glob("*/provider.toml").scan({
     cwd: directory,
     absolute: true,
@@ -35,6 +57,20 @@ export async function generate(directory: string) {
         },
       }).then((mod) => mod.default);
       toml.id = modelID;
+      if (toml.extends !== undefined) {
+        const model = ExtendsModel.safeParse(toml);
+        if (!model.success) {
+          model.error.cause = { modelPath, toml };
+          throw model.error;
+        }
+        extendsModels.push({
+          providerID,
+          modelID,
+          modelPath,
+          model: model.data,
+        });
+        continue;
+      }
       const model = Model.safeParse(toml);
       if (!model.success) {
         model.error.cause = { modelPath, toml };
@@ -45,5 +81,77 @@ export async function generate(directory: string) {
     result[providerID] = provider.data;
   }
 
+  for (const pendingModel of extendsModels) {
+    const [providerID, modelID] = pendingModel.model.extends.from.split("/");
+    const baseModel = result[providerID]?.models[modelID];
+    if (baseModel === undefined) {
+      throw new Error(`Unable to resolve extends.from: ${pendingModel.model.extends.from}`, {
+        cause: { modelPath: pendingModel.modelPath, toml: pendingModel.model },
+      });
+    }
+
+    const { extends: extendsConfig, ...overrides } = pendingModel.model;
+    const merged: Record<string, unknown> = structuredClone(
+      mergeDeep(baseModel, overrides),
+    );
+
+    for (const omit of extendsConfig.omit ?? []) {
+      const parts = omit.split(".");
+      const parents: Array<{
+        value: Record<string, unknown>;
+        key: string;
+      }> = [];
+      let current = merged;
+
+      for (const part of parts.slice(0, -1)) {
+        const next = current[part];
+        if (
+          next === undefined ||
+          next === null ||
+          typeof next !== "object" ||
+          Array.isArray(next)
+        ) {
+          throw new Error(`Unable to omit missing path: ${omit}`, {
+            cause: { modelPath: pendingModel.modelPath, toml: pendingModel.model },
+          });
+        }
+        parents.push({ value: current, key: part });
+        current = next as Record<string, unknown>;
+      }
+
+      const lastPart = parts.at(-1);
+      if (lastPart === undefined || !(lastPart in current)) {
+        throw new Error(`Unable to omit missing path: ${omit}`, {
+          cause: { modelPath: pendingModel.modelPath, toml: pendingModel.model },
+        });
+      }
+
+      delete current[lastPart];
+
+      for (let index = parents.length - 1; index >= 0; index--) {
+        const parent = parents[index];
+        const value = parent?.value[parent.key];
+        if (
+          value === null ||
+          value === undefined ||
+          typeof value !== "object" ||
+          Array.isArray(value) ||
+          Object.keys(value).length > 0
+        ) {
+          break;
+        }
+        delete parent.value[parent.key];
+      }
+    }
+
+    const model = Model.safeParse(merged);
+    if (!model.success) {
+      model.error.cause = { modelPath: pendingModel.modelPath, toml: merged };
+      throw model.error;
+    }
+
+    result[pendingModel.providerID]!.models[pendingModel.modelID] = model.data;
+  }
+
   return result;
 }

packages/core/src/schema.ts

@@ -2,6 +2,25 @@ import { z } from "zod";
 
 import { ModelFamily } from "./family";
 
+type JsonValue =
+  | string
+  | number
+  | boolean
+  | null
+  | { [key: string]: JsonValue }
+  | JsonValue[];
+
+const JsonValue: z.ZodType<JsonValue> = z.lazy(() =>
+  z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.null(),
+    z.array(JsonValue),
+    z.record(JsonValue),
+  ]),
+);
+
 const Cost = z.object({
   input: z.number().min(0, "Input price cannot be negative"),
   output: z.number().min(0, "Output price cannot be negative"),
@@ -69,10 +88,30 @@ export const Model = z
       output: z.number().min(0, "Output tokens must be positive"),
     }),
     status: z.enum(["alpha", "beta", "deprecated"]).optional(),
+    experimental: z
+      .object({
+        modes: z
+          .record(
+            z.object({
+              cost: Cost.optional(),
+              provider: z
+                .object({
+                  body: z.record(JsonValue).optional(),
+                  headers: z.record(z.string()).optional(),
+                })
+                .optional(),
+            }),
+          )
+          .optional(),
+      })
+      .optional(),
     provider: z
       .object({
         npm: z.string().optional(),
         api: z.string().optional(),
+        shape: z.enum(["responses", "completions"]).optional(),
+        body: z.record(JsonValue).optional(),
+        headers: z.record(z.string()).optional(),
       })
       .optional(),
   })

packages/web/script/build.ts

@@ -1,6 +1,7 @@
 #!/usr/bin/env bun
 
 import { Rendered, Providers } from "../src/render";
+import { normalizeLogoSvg } from "../src/logo.js";
 import fs from "fs/promises";
 import path from "path";
 import { $ } from "bun";
@@ -23,7 +24,10 @@ await fs.mkdir("./dist/logos", { recursive: true });
 const defaultLogoPath = "../../providers/logo.svg";
 const defaultLogo = Bun.file(defaultLogoPath);
 if (await defaultLogo.exists()) {
-  await Bun.write("./dist/logos/default.svg", defaultLogo);
+  await Bun.write(
+    "./dist/logos/default.svg",
+    normalizeLogoSvg(await defaultLogo.text())
+  );
 }
 
 // Then copy provider-specific logos
@@ -36,7 +40,10 @@ for (const entry of entries) {
     const logoFile = Bun.file(logoPath);
 
     if (await logoFile.exists()) {
-      await Bun.write(`./dist/logos/${provider}.svg`, logoFile);
+      await Bun.write(
+        `./dist/logos/${provider}.svg`,
+        normalizeLogoSvg(await logoFile.text())
+      );
     }
   }
 }

packages/web/src/index.css

@@ -319,15 +319,12 @@ tbody {
     gap: 0.375rem;
   }
 
-  .provider-cell span:first-child {
+  .provider-logo {
     flex: 0 0 auto;
-  }
-
-  .provider-cell svg {
     display: block;
     width: 1rem;
     height: 1rem;
-    color: var(--color-text-secondary);
+    object-fit: contain;
   }
 
   .model-id-cell {
@@ -416,6 +413,17 @@ tbody {
   .modality-icon:hover::after {
     opacity: 1;
   }
+
+  tr.loading-row td,
+  tr.error-row td {
+    padding: 1rem 0.75rem;
+    text-align: center;
+    font-family: inherit;
+    font-size: 0.875rem;
+    font-weight: 400;
+    text-transform: none;
+    color: var(--color-text-secondary);
+  }
 }
 
 dialog::backdrop {
@@ -546,4 +554,4 @@ dialog {
     }
   }
 
-}
+}

packages/web/src/index.ts

@@ -1,7 +1,248 @@
+interface ApiCost {
+  input?: number;
+  output?: number;
+  reasoning?: number;
+  cache_read?: number;
+  cache_write?: number;
+  input_audio?: number;
+  output_audio?: number;
+}
+
+interface ApiLimit {
+  context: number;
+  input?: number;
+  output: number;
+}
+
+interface ApiModel {
+  name: string;
+  family?: string;
+  status?: string;
+  tool_call: boolean;
+  reasoning: boolean;
+  modalities: {
+    input: string[];
+    output: string[];
+  };
+  cost?: ApiCost;
+  limit: ApiLimit;
+  structured_output?: boolean;
+  temperature: boolean;
+  open_weights: boolean;
+  knowledge?: string;
+  release_date: string;
+  last_updated: string;
+}
+
+interface ApiProvider {
+  name: string;
+  models: Record<string, ApiModel>;
+}
+
+type ApiResponse = Record<string, ApiProvider>;
+
+const COLUMN_COUNT = 25;
 const modal = document.getElementById("modal") as HTMLDialogElement;
 const modalClose = document.getElementById("close")!;
 const help = document.getElementById("help")!;
 const search = document.getElementById("search")! as HTMLInputElement;
+const tableBody = document.getElementById("table-body")! as HTMLTableSectionElement;
+
+const copyIcon = `
+  <svg
+    class="copy-icon"
+    xmlns="http://www.w3.org/2000/svg"
+    width="14"
+    height="14"
+    viewBox="0 0 24 24"
+    fill="none"
+    stroke="currentColor"
+    stroke-width="2"
+    stroke-linecap="round"
+    stroke-linejoin="round"
+  >
+    <rect width="14" height="14" x="8" y="8" rx="2" ry="2"></rect>
+    <path d="m4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2"></path>
+  </svg>
+`;
+
+const checkIcon = `
+  <svg
+    class="check-icon"
+    xmlns="http://www.w3.org/2000/svg"
+    width="14"
+    height="14"
+    viewBox="0 0 24 24"
+    fill="none"
+    stroke="currentColor"
+    stroke-width="2"
+    stroke-linecap="round"
+    stroke-linejoin="round"
+    style="display: none;"
+  >
+    <polyline points="20,6 9,17 4,12"></polyline>
+  </svg>
+`;
+
+const modalityIcons: Record<string, { label: string; svg: string }> = {
+  text: {
+    label: "Text",
+    svg: `
+      <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+        <polyline points="4,7 4,4 20,4 20,7"></polyline>
+        <line x1="9" y1="20" x2="15" y2="20"></line>
+        <line x1="12" y1="4" x2="12" y2="20"></line>
+      </svg>
+    `,
+  },
+  image: {
+    label: "Image",
+    svg: `
+      <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+        <rect width="18" height="18" x="3" y="3" rx="2" ry="2"></rect>
+        <circle cx="9" cy="9" r="2"></circle>
+        <path d="m21 15-3.086-3.086a2 2 0 0 0-2.828 0L6 21"></path>
+      </svg>
+    `,
+  },
+  audio: {
+    label: "Audio",
+    svg: `
+      <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+        <polygon points="11 5 6 9 2 9 2 15 6 15 11 19 11 5"></polygon>
+        <path d="m19.07 4.93a10 10 0 0 1 0 14.14M15.54 8.46a5 5 0 0 1 0 7.07"></path>
+      </svg>
+    `,
+  },
+  video: {
+    label: "Video",
+    svg: `
+      <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+        <path d="m22 8-6 4 6 4V8Z"></path>
+        <rect width="14" height="12" x="2" y="6" rx="2" ry="2"></rect>
+      </svg>
+    `,
+  },
+  pdf: {
+    label: "PDF",
+    svg: `
+      <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+        <path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"></path>
+        <polyline points="14,2 14,8 20,8"></polyline>
+        <line x1="16" y1="13" x2="8" y2="13"></line>
+        <line x1="16" y1="17" x2="8" y2="17"></line>
+        <polyline points="10,9 9,9 8,9"></polyline>
+      </svg>
+    `,
+  },
+};
+
+function escapeHtml(value: string) {
+  return value
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&#39;");
+}
+
+function renderCost(cost?: number) {
+  return cost === undefined ? "-" : `$${cost.toFixed(2)}`;
+}
+
+function renderModalityIcon(modality: string) {
+  const icon = modalityIcons[modality];
+  if (!icon) return "";
+
+  return `<span class="modality-icon" data-tooltip="${icon.label}">${icon.svg}</span>`;
+}
+
+function renderModalities(modalities: string[]) {
+  return `<div class="modalities">${modalities.map(renderModalityIcon).join("")}</div>`;
+}
+
+function renderProviderLogo(providerId: string) {
+  return `<img class="provider-logo" src="/logos/${encodeURIComponent(providerId)}.svg" alt="" width="16" height="16" loading="lazy" decoding="async" />`;
+}
+
+function renderRow(
+  providerId: string,
+  providerName: string,
+  modelId: string,
+  model: ApiModel
+) {
+  const safeProviderId = escapeHtml(providerId);
+  const safeProviderName = escapeHtml(providerName);
+  const safeModelId = escapeHtml(modelId);
+  const safeModelName = escapeHtml(model.name);
+  const safeFamily = escapeHtml(model.family ?? "-");
+  const safeKnowledge = escapeHtml(model.knowledge?.substring(0, 7) ?? "-");
+  const safeReleaseDate = escapeHtml(model.release_date);
+  const safeLastUpdated = escapeHtml(model.last_updated);
+
+  return `
+    <tr data-model-row="true">
+      <td>
+        <div class="provider-cell">
+          ${renderProviderLogo(providerId)}
+          <span>${safeProviderName}</span>
+        </div>
+      </td>
+      <td>${safeModelName}</td>
+      <td>${safeFamily}</td>
+      <td>${safeProviderId}</td>
+      <td>
+        <div class="model-id-cell">
+          <span class="model-id-text">${safeModelId}</span>
+          <button class="copy-button" type="button" data-model-id="${safeModelId}" aria-label="Copy model ID">
+            ${copyIcon}
+            ${checkIcon}
+          </button>
+        </div>
+      </td>
+      <td>${model.tool_call ? "Yes" : "No"}</td>
+      <td>${model.reasoning ? "Yes" : "No"}</td>
+      <td>${renderModalities(model.modalities.input)}</td>
+      <td>${renderModalities(model.modalities.output)}</td>
+      <td>${renderCost(model.cost?.input)}</td>
+      <td>${renderCost(model.cost?.output)}</td>
+      <td>${renderCost(model.cost?.reasoning)}</td>
+      <td>${renderCost(model.cost?.cache_read)}</td>
+      <td>${renderCost(model.cost?.cache_write)}</td>
+      <td>${renderCost(model.cost?.input_audio)}</td>
+      <td>${renderCost(model.cost?.output_audio)}</td>
+      <td>${model.limit.context.toLocaleString()}</td>
+      <td>${model.limit.input?.toLocaleString() ?? "-"}</td>
+      <td>${model.limit.output.toLocaleString()}</td>
+      <td>${model.structured_output === undefined ? "-" : model.structured_output ? "Yes" : "No"}</td>
+      <td>${model.temperature ? "Yes" : "No"}</td>
+      <td>${model.open_weights ? "Open" : "Closed"}</td>
+      <td>${safeKnowledge}</td>
+      <td>${safeReleaseDate}</td>
+      <td>${safeLastUpdated}</td>
+    </tr>
+  `;
+}
+
+function renderTableRows(providers: ApiResponse) {
+  return Object.entries(providers)
+    .sort(([, providerA], [, providerB]) =>
+      providerA.name.localeCompare(providerB.name)
+    )
+    .flatMap(([providerId, provider]) =>
+      Object.entries(provider.models)
+        .filter(([, model]) => model.status !== "alpha")
+        .sort(([, modelA], [, modelB]) => modelA.name.localeCompare(modelB.name))
+        .map(([modelId, model]) =>
+          renderRow(providerId, provider.name, modelId, model)
+        )
+    )
+    .join("");
+}
+
+function setStatusRow(message: string, className = "loading-row") {
+  tableBody.innerHTML = `<tr class="${className}"><td colspan="${COLUMN_COUNT}">${escapeHtml(message)}</td></tr>`;
+}
 
 /////////////////////////
 // URL State Management
@@ -10,7 +251,10 @@ function getQueryParams() {
   return new URLSearchParams(window.location.search);
 }
 
-function updateQueryParams(updates: Record<string, string | null>) {
+function updateQueryParams(
+  updates: Record<string, string | null>,
+  historyMode: "push" | "replace" = "push"
+) {
   const params = getQueryParams();
   for (const [key, value] of Object.entries(updates)) {
     if (value) {
@@ -19,9 +263,18 @@ function updateQueryParams(updates: Record<string, string | null>) {
       params.delete(key);
     }
   }
+
   const newPath = params.toString()
     ? `${window.location.pathname}?${params.toString()}`
     : window.location.pathname;
+
+  if (newPath === `${window.location.pathname}${window.location.search}`) return;
+
+  if (historyMode === "replace") {
+    window.history.replaceState({}, "", newPath);
+    return;
+  }
+
   window.history.pushState({}, "", newPath);
 }
 
@@ -65,66 +318,71 @@ modal.addEventListener("click", (e) => {
 ////////////////////
 // Handle Sorting
 ////////////////////
-let currentSort = { column: -1, direction: "asc" };
+let currentSort = { column: -1, direction: "asc" as "asc" | "desc" };
 
-function sortTable(column: number, direction: "asc" | "desc") {
+function updateSortIndicators(column: number, direction: "asc" | "desc") {
+  const headers = document.querySelectorAll("th.sortable");
+  headers.forEach((header, i) => {
+    const indicator = header.querySelector(".sort-indicator")!;
+    indicator.textContent = i === column ? (direction === "asc" ? "↑" : "↓") : "";
+  });
+}
+
+function clearSortIndicators() {
+  updateSortIndicators(-1, "asc");
+}
+
+function sortTable(
+  column: number,
+  direction: "asc" | "desc",
+  syncUrl = true
+) {
   const header = document.querySelectorAll("th.sortable")[column];
-  const columnType = header.getAttribute("data-type");
+  const columnType = header?.getAttribute("data-type");
   if (!columnType) return;
 
-  // update state
   currentSort = { column, direction };
-  updateQueryParams({
-    sort: getColumnNameForURL(header),
-    order: direction,
-  });
+  if (syncUrl) {
+    updateQueryParams(
+      {
+        sort: getColumnNameForURL(header),
+        order: direction,
+      },
+      "push"
+    );
+  }
 
-  // sort rows
-  const tbody = document.querySelector("table tbody")!;
   const rows = Array.from(
-    tbody.querySelectorAll("tr")
+    tableBody.querySelectorAll('tr[data-model-row="true"]')
   ) as HTMLTableRowElement[];
+
   rows.sort((a, b) => {
     const aValue = getCellValue(a.cells[column], columnType);
     const bValue = getCellValue(b.cells[column], columnType);
 
-    // Handle undefined values - always sort to bottom
     if (aValue === undefined && bValue === undefined) return 0;
     if (aValue === undefined) return 1;
     if (bValue === undefined) return -1;
 
-    let comparison = 0;
-    if (columnType === "number" || columnType === "modalities") {
-      comparison = (aValue as number) - (bValue as number);
-    } else if (columnType === "boolean") {
-      comparison = (aValue as string).localeCompare(bValue as string);
-    } else {
-      comparison = (aValue as string).localeCompare(bValue as string);
-    }
+    const comparison =
+      columnType === "number" || columnType === "modalities"
+        ? (aValue as number) - (bValue as number)
+        : (aValue as string).localeCompare(bValue as string);
 
     return direction === "asc" ? comparison : -comparison;
   });
-  rows.forEach((row) => tbody.appendChild(row));
 
-  // update sort indicators
-  const headers = document.querySelectorAll("th.sortable");
-  headers.forEach((header, i) => {
-    const indicator = header.querySelector(".sort-indicator")!;
-
-    if (i === column) {
-      indicator.textContent = direction === "asc" ? "↑" : "↓";
-    } else {
-      indicator.textContent = "";
-    }
-  });
+  rows.forEach((row) => tableBody.appendChild(row));
+  updateSortIndicators(column, direction);
 }
 
 function getCellValue(
   cell: HTMLTableCellElement,
   type: string
 ): string | number | undefined {
-  if (type === "modalities")
+  if (type === "modalities") {
     return cell.querySelectorAll(".modality-icon").length;
+  }
 
   const text = cell.textContent?.trim() || "";
   if (text === "-") return;
@@ -146,22 +404,31 @@ document.querySelectorAll("th.sortable").forEach((header) => {
 ///////////////////
 // Handle Search
 ///////////////////
-function filterTable(value: string) {
-  const lowerCaseValues = value.toLowerCase().split(",").filter(str => str.trim() !== "");
-  const rows = document.querySelectorAll(
-    "table tbody tr"
+function filterTable(value: string, syncUrl = true) {
+  const lowerCaseValues = value
+    .toLowerCase()
+    .split(",")
+    .map((part) => part.trim())
+    .filter(Boolean);
+  const rows = tableBody.querySelectorAll(
+    'tr[data-model-row="true"]'
   ) as NodeListOf<HTMLTableRowElement>;
 
   rows.forEach((row) => {
     const cellTexts = Array.from(row.cells).map((cell) =>
       cell.textContent!.toLowerCase()
     );
-    const isVisible = lowerCaseValues.length === 0 ||
-     lowerCaseValues.some((lowerCaseValue) => cellTexts.some((text) => text.includes(lowerCaseValue)));
+    const isVisible =
+      lowerCaseValues.length === 0 ||
+      lowerCaseValues.some((lowerCaseValue) =>
+        cellTexts.some((text) => text.includes(lowerCaseValue))
+      );
     row.style.display = isVisible ? "" : "none";
   });
 
-  updateQueryParams({ search: value || null });
+  if (syncUrl) {
+    updateQueryParams({ search: value || null }, "replace");
+  }
 }
 
 search.addEventListener("input", () => {
@@ -185,22 +452,22 @@ search.addEventListener("keydown", (e) => {
 ///////////////////////////////////
 // Handle Copy model ID function
 ///////////////////////////////////
-(window as any).copyModelId = async (
-  button: HTMLButtonElement,
-  modelId: string
-) => {
+tableBody.addEventListener("click", async (event) => {
+  const target = event.target as HTMLElement;
+  const button = target.closest(".copy-button") as HTMLButtonElement | null;
+  const modelId = button?.dataset.modelId;
+  if (!button || !modelId) return;
+
   try {
     if (navigator.clipboard) {
       await navigator.clipboard.writeText(modelId);
 
-      // Switch to check icon
       const copyIcon = button.querySelector(".copy-icon") as HTMLElement;
       const checkIcon = button.querySelector(".check-icon") as HTMLElement;
 
       copyIcon.style.display = "none";
       checkIcon.style.display = "block";
 
-      // Switch back after 1 second
       setTimeout(() => {
         copyIcon.style.display = "block";
         checkIcon.style.display = "none";
@@ -209,32 +476,67 @@ search.addEventListener("keydown", (e) => {
   } catch (err) {
     console.error("Failed to copy text: ", err);
   }
-};
+});
 
 ///////////////////////////////////
 // Initialize State from URL
 ///////////////////////////////////
+let tableLoaded = false;
+
 function initializeFromURL() {
+  if (!tableLoaded) return;
+
   const params = getQueryParams();
+  const searchQuery = params.get("search") ?? "";
+  search.value = searchQuery;
+  filterTable(searchQuery, false);
 
-  (() => {
-    const searchQuery = params.get("search");
-    if (!searchQuery) return;
-    search.value = searchQuery;
-    filterTable(searchQuery);
-  })();
+  const columnName = params.get("sort");
+  if (!columnName) {
+    currentSort = { column: -1, direction: "asc" };
+    clearSortIndicators();
+    return;
+  }
 
-  (() => {
-    const columnName = params.get("sort");
-    if (!columnName) return;
+  const columnIndex = getColumnIndexByUrlName(columnName);
+  if (columnIndex === -1) return;
 
-    const columnIndex = getColumnIndexByUrlName(columnName);
-    if (columnIndex === -1) return;
-
-    const direction = (params.get("order") as "asc" | "desc") || "asc";
-    sortTable(columnIndex, direction);
-  })();
+  const direction = (params.get("order") as "asc" | "desc") || "asc";
+  sortTable(columnIndex, direction, false);
 }
 
-document.addEventListener("DOMContentLoaded", initializeFromURL);
-window.addEventListener("popstate", initializeFromURL);
+async function loadTable() {
+  try {
+    const response = await fetch("/api.json");
+    if (!response.ok) {
+      throw new Error(`Failed to fetch models: ${response.status}`);
+    }
+
+    const providers = (await response.json()) as ApiResponse;
+    const rows = renderTableRows(providers);
+    tableBody.innerHTML = rows || "";
+
+    if (!rows) {
+      setStatusRow("No models found.");
+      return;
+    }
+
+    tableLoaded = true;
+    initializeFromURL();
+    window.addEventListener("popstate", initializeFromURL);
+  } catch (error) {
+    console.error("Failed to load model data:", error);
+    setStatusRow("Failed to load models.", "loading-row error-row");
+  }
+}
+
+function initializeApp() {
+  search.value = getQueryParams().get("search") ?? "";
+  void loadTable();
+}
+
+if (document.readyState === "loading") {
+  document.addEventListener("DOMContentLoaded", initializeApp);
+} else {
+  initializeApp();
+}

packages/web/src/logo.ts

@@ -0,0 +1,16 @@
+const LOGO_THEME_MARKER = "models-dev-logo-theme";
+const LOGO_THEME_STYLE = `<style id="${LOGO_THEME_MARKER}">:root{color:#666}@media (prefers-color-scheme: dark){:root{color:#AAA}}</style>`;
+
+export function normalizeLogoSvg(svgText: string) {
+  if (svgText.includes(LOGO_THEME_MARKER)) {
+    return svgText;
+  }
+
+  return svgText.replace(/<svg\b[^>]*>/i, (svgTag) => {
+    const themedTag = svgTag.includes("fill=")
+      ? svgTag
+      : svgTag.replace("<svg", '<svg fill="currentColor"');
+
+    return `${themedTag}${LOGO_THEME_STYLE}`;
+  });
+}

packages/web/src/render.tsx

@@ -1,184 +1,15 @@
 /** @jsx jsx */
 /** @jsxImportSource hono/jsx */
 
-import { generate } from "models.dev";
 import { Fragment } from "hono/jsx";
 import { renderToString } from "hono/jsx/dom/server";
-import { existsSync } from "fs";
+import { generate } from "models.dev";
 import path from "path";
 
 export const Providers = await generate(
   path.join(import.meta.dir, "..", "..", "..", "providers")
 );
 
-// Function to load SVG content
-const loadProviderSvg = async (providerId: string): Promise<string | null> => {
-  const providerLogoPath = path.join(
-    import.meta.dir,
-    "..",
-    "..",
-    "..",
-    "providers",
-    providerId,
-    "logo.svg"
-  );
-
-  const defaultLogoPath = path.join(
-    import.meta.dir,
-    "..",
-    "..",
-    "..",
-    "providers",
-    "logo.svg"
-  );
-
-  try {
-    // Try provider-specific logo first
-    if (existsSync(providerLogoPath)) {
-      const file = Bun.file(providerLogoPath);
-      return await file.text();
-    }
-    //
-    // Fall back to default logo
-    if (existsSync(defaultLogoPath)) {
-      const file = Bun.file(defaultLogoPath);
-      return await file.text();
-    }
-    return null;
-  } catch (error) {
-    console.warn(`Failed to load logo for provider ${providerId}:`, error);
-    return null;
-  }
-};
-
-// Create a cache of loaded SVGs at build time
-const providerLogos = new Map<string, string>();
-
-// Pre-load all provider logos
-for (const [providerId] of Object.entries(Providers)) {
-  const svgContent = await loadProviderSvg(providerId);
-  if (svgContent) {
-    providerLogos.set(providerId, svgContent);
-  }
-}
-
-function renderProviderLogo(providerId: string) {
-  const svgContent = providerLogos.get(providerId) || "";
-
-  return <span dangerouslySetInnerHTML={{ __html: svgContent }} />;
-}
-
-const getModalityIcon = (modality: string) => {
-  switch (modality) {
-    case "text":
-      return (
-        <span class="modality-icon" data-tooltip="Text">
-          <svg
-            xmlns="http://www.w3.org/2000/svg"
-            width="16"
-            height="16"
-            viewBox="0 0 24 24"
-            fill="none"
-            stroke="currentColor"
-            stroke-width="2"
-            stroke-linecap="round"
-            stroke-linejoin="round"
-          >
-            <polyline points="4,7 4,4 20,4 20,7"></polyline>
-            <line x1="9" y1="20" x2="15" y2="20"></line>
-            <line x1="12" y1="4" x2="12" y2="20"></line>
-          </svg>
-        </span>
-      );
-    case "image":
-      return (
-        <span class="modality-icon" data-tooltip="Image">
-          <svg
-            xmlns="http://www.w3.org/2000/svg"
-            width="16"
-            height="16"
-            viewBox="0 0 24 24"
-            fill="none"
-            stroke="currentColor"
-            stroke-width="2"
-            stroke-linecap="round"
-            stroke-linejoin="round"
-          >
-            <rect width="18" height="18" x="3" y="3" rx="2" ry="2"></rect>
-            <circle cx="9" cy="9" r="2"></circle>
-            <path d="m21 15-3.086-3.086a2 2 0 0 0-2.828 0L6 21"></path>
-          </svg>
-        </span>
-      );
-    case "audio":
-      return (
-        <span class="modality-icon" data-tooltip="Audio">
-          <svg
-            xmlns="http://www.w3.org/2000/svg"
-            width="16"
-            height="16"
-            viewBox="0 0 24 24"
-            fill="none"
-            stroke="currentColor"
-            stroke-width="2"
-            stroke-linecap="round"
-            stroke-linejoin="round"
-          >
-            <polygon points="11 5 6 9 2 9 2 15 6 15 11 19 11 5"></polygon>
-            <path d="m19.07 4.93a10 10 0 0 1 0 14.14M15.54 8.46a5 5 0 0 1 0 7.07"></path>
-          </svg>
-        </span>
-      );
-    case "video":
-      return (
-        <span class="modality-icon" data-tooltip="Video">
-          <svg
-            xmlns="http://www.w3.org/2000/svg"
-            width="16"
-            height="16"
-            viewBox="0 0 24 24"
-            fill="none"
-            stroke="currentColor"
-            stroke-width="2"
-            stroke-linecap="round"
-            stroke-linejoin="round"
-          >
-            <path d="m22 8-6 4 6 4V8Z"></path>
-            <rect width="14" height="12" x="2" y="6" rx="2" ry="2"></rect>
-          </svg>
-        </span>
-      );
-    case "pdf":
-      return (
-        <span class="modality-icon" data-tooltip="PDF">
-          <svg
-            xmlns="http://www.w3.org/2000/svg"
-            width="16"
-            height="16"
-            viewBox="0 0 24 24"
-            fill="none"
-            stroke="currentColor"
-            stroke-width="2"
-            stroke-linecap="round"
-            stroke-linejoin="round"
-          >
-            <path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"></path>
-            <polyline points="14,2 14,8 20,8"></polyline>
-            <line x1="16" y1="13" x2="8" y2="13"></line>
-            <line x1="16" y1="17" x2="8" y2="17"></line>
-            <polyline points="10,9 9,9 8,9"></polyline>
-          </svg>
-        </span>
-      );
-    default:
-      return null;
-  }
-};
-
-const renderCost = (cost?: number) => {
-  return cost === undefined ? "-" : `$${cost.toFixed(2)}`;
-};
-
 export const Rendered = renderToString(
   <Fragment>
     <header>
@@ -342,118 +173,10 @@ export const Rendered = renderToString(
           </th>
         </tr>
       </thead>
-      <tbody>
-        {Object.entries(Providers)
-          .sort(([, providerA], [, providerB]) =>
-            providerA.name.localeCompare(providerB.name)
-          )
-          .flatMap(([providerId, provider]) =>
-            Object.entries(provider.models)
-              .filter(([, model]) => model.status !== "alpha")
-              .sort(([, modelA], [, modelB]) =>
-                modelA.name.localeCompare(modelB.name)
-              )
-              .map(([modelId, model]) => (
-                <tr key={`${providerId}-${modelId}`}>
-                  <td>
-                    <div class="provider-cell">
-                      {renderProviderLogo(providerId)}
-                      <span>{provider.name}</span>
-                    </div>
-                  </td>
-                  <td>{model.name}</td>
-                  <td>{model.family ?? "-"}</td>
-                  <td>{providerId}</td>
-                  <td>
-                    <div class="model-id-cell">
-                      <span class="model-id-text">{modelId}</span>
-                      <button
-                        class="copy-button"
-                        onclick={`copyModelId(this, '${modelId}')`}
-                      >
-                        <svg
-                          class="copy-icon"
-                          xmlns="http://www.w3.org/2000/svg"
-                          width="14"
-                          height="14"
-                          viewBox="0 0 24 24"
-                          fill="none"
-                          stroke="currentColor"
-                          stroke-width="2"
-                          stroke-linecap="round"
-                          stroke-linejoin="round"
-                        >
-                          <rect
-                            width="14"
-                            height="14"
-                            x="8"
-                            y="8"
-                            rx="2"
-                            ry="2"
-                          />
-                          <path d="m4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2" />
-                        </svg>
-                        <svg
-                          class="check-icon"
-                          xmlns="http://www.w3.org/2000/svg"
-                          width="14"
-                          height="14"
-                          viewBox="0 0 24 24"
-                          fill="none"
-                          stroke="currentColor"
-                          stroke-width="2"
-                          stroke-linecap="round"
-                          stroke-linejoin="round"
-                          style="display: none;"
-                        >
-                          <polyline points="20,6 9,17 4,12" />
-                        </svg>
-                      </button>
-                    </div>
-                  </td>
-                  <td>{model.tool_call ? "Yes" : "No"}</td>
-                  <td>{model.reasoning ? "Yes" : "No"}</td>
-                  <td>
-                    <div class="modalities">
-                      {model.modalities.input.map((modality) =>
-                        getModalityIcon(modality)
-                      )}
-                    </div>
-                  </td>
-                  <td>
-                    <div class="modalities">
-                      {model.modalities.output.map((modality) =>
-                        getModalityIcon(modality)
-                      )}
-                    </div>
-                  </td>
-                  <td>{renderCost(model.cost?.input)}</td>
-                  <td>{renderCost(model.cost?.output)}</td>
-                  <td>{renderCost(model.cost?.reasoning)}</td>
-                  <td>{renderCost(model.cost?.cache_read)}</td>
-                  <td>{renderCost(model.cost?.cache_write)}</td>
-                  <td>{renderCost(model.cost?.input_audio)}</td>
-                  <td>{renderCost(model.cost?.output_audio)}</td>
-                  <td>{model.limit.context.toLocaleString()}</td>
-                  <td>{model.limit.input?.toLocaleString() ?? "-"}</td>
-                  <td>{model.limit.output.toLocaleString()}</td>
-                  <td>
-                    {model.structured_output === undefined
-                      ? "-"
-                      : model.structured_output
-                      ? "Yes"
-                      : "No"}
-                  </td>
-                  <td>{model.temperature ? "Yes" : "No"}</td>
-                  <td>{model.open_weights ? "Open" : "Closed"}</td>
-                  <td>
-                    {model.knowledge ? model.knowledge.substring(0, 7) : "-"}
-                  </td>
-                  <td>{model.release_date}</td>
-                  <td>{model.last_updated}</td>
-                </tr>
-              ))
-          )}
+      <tbody id="table-body">
+        <tr class="loading-row">
+          <td colspan={25}>Loading models...</td>
+        </tr>
       </tbody>
     </table>
     <dialog id="modal">

packages/web/src/server.ts

@@ -1,11 +1,19 @@
 import Index from "../index.html";
-import { Rendered } from "./render";
+import { normalizeLogoSvg } from "./logo.js";
+import { Providers, Rendered } from "./render";
 import path from "path";
 
 Bun.serve({
   port: 16_000,
   routes: {
     "/": Index,
+    "/api.json": () => {
+      return Response.json(Providers, {
+        headers: {
+          "Cache-Control": "public, max-age=3600",
+        },
+      });
+    },
     "/assets/*": (req) => {
       const file = Bun.file(
         path.join(import.meta.dir, new URL(req.url).pathname)
@@ -38,7 +46,7 @@ Bun.serve({
         file = Bun.file(defaultLogoPath);
       }
 
-      return new Response(file, {
+      return new Response(normalizeLogoSvg(await file.text()), {
         headers: {
           "Content-Type": "image/svg+xml",
           "Cache-Control": "public, max-age=3600",

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

@@ -0,0 +1,20 @@
+name = "MiniMax-M2.7-highspeed"
+release_date = "2026-03-19"
+last_updated = "2026-03-19"
+attachment = false
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+
+[cost]
+input = 0.600
+output = 4.800
+
+[limit]
+context = 204_800
+output = 131_072
+
+[modalities]
+input = ["text"]
+output = ["text"]

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

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

providers/302ai/models/claude-3-5-haiku-20241022.toml

@@ -1,22 +1,20 @@
-name = "Claude 3.5 Sonnet (Retiring Soon)"
+name = "claude-3-5-haiku-20241022"
 release_date = "2024-10-22"
 last_updated = "2024-10-22"
 attachment = true
 reasoning = false
 temperature = true
 tool_call = true
-knowledge = "2025-01-01"
 open_weights = false
+knowledge = "2024-07"
 
 [cost]
-input = 3.00
-output = 15.00
-cache_read = 0.30
-cache_write = 3.75
+input = 0.800
+output = 4.000
 
 [limit]
 context = 200_000
-output = 64_000
+output = 8_192
 
 [modalities]
 input = ["text", "image", "pdf"]

providers/302ai/models/claude-3-5-haiku-latest.toml

@@ -0,0 +1,21 @@
+name = "claude-3-5-haiku-latest"
+release_date = "2024-10-22"
+last_updated = "2024-10-22"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2024-07"
+
+[cost]
+input = 0.800
+output = 4.000
+
+[limit]
+context = 200_000
+output = 8_192
+
+[modalities]
+input = ["text", "image", "pdf"]
+output = ["text"]

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

@@ -2,7 +2,7 @@ name = "claude-haiku-4-5-20251001"
 release_date = "2025-10-16"
 last_updated = "2025-10-16"
 attachment = true
-reasoning = false
+reasoning = true
 temperature = true
 tool_call = true
 open_weights = false
@@ -17,5 +17,5 @@ context = 200_000
 output = 64_000
 
 [modalities]
-input = ["text", "image"]
+input = ["text", "image", "pdf"]
 output = ["text"]

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

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

providers/302ai/models/claude-opus-4-20250514.toml

@@ -0,0 +1,21 @@
+name = "claude-opus-4-20250514"
+release_date = "2025-05-22"
+last_updated = "2025-05-22"
+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", "pdf"]
+output = ["text"]

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

@@ -2,7 +2,7 @@ name = "claude-opus-4-5-20251101"
 release_date = "2025-11-25"
 last_updated = "2025-11-25"
 attachment = true
-reasoning = false
+reasoning = true
 temperature = true
 tool_call = true
 open_weights = false
@@ -17,5 +17,5 @@ context = 200_000
 output = 64_000
 
 [modalities]
-input = ["text", "image"]
+input = ["text", "image", "pdf"]
 output = ["text"]

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

@@ -0,0 +1,21 @@
+name = "claude-opus-4-5"
+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", "pdf"]
+output = ["text"]

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

@@ -0,0 +1,21 @@
+name = "claude-opus-4-6-thinking"
+release_date = "2026-02-06"
+last_updated = "2026-03-13"
+attachment = true
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2025-05"
+
+[cost]
+input = 5.000
+output = 25.000
+
+[limit]
+context = 1_000_000
+output = 128_000
+
+[modalities]
+input = ["text", "image", "pdf"]
+output = ["text"]

providers/302ai/models/claude-opus-4-6.toml

@@ -0,0 +1,21 @@
+name = "claude-opus-4-6"
+release_date = "2026-02-06"
+last_updated = "2026-03-13"
+attachment = true
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2025-05"
+
+[cost]
+input = 5.000
+output = 25.000
+
+[limit]
+context = 1_000_000
+output = 128_000
+
+[modalities]
+input = ["text", "image", "pdf"]
+output = ["text"]

providers/302ai/models/claude-opus-4-7.toml

@@ -0,0 +1,29 @@
+name = "claude-opus-4-7"
+release_date = "2026-04-17"
+last_updated = "2026-04-17"
+attachment = true
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2025-05"
+
+[cost]
+input = 5.000
+output = 25.000
+cache_read = 0.500
+cache_write = 6.250
+
+[cost.context_over_200k]
+input = 10.000
+output = 37.500
+cache_read = 1.000
+cache_write = 12.500
+
+[limit]
+context = 200_000
+output = 128_000
+
+[modalities]
+input = ["text", "image", "pdf"]
+output = ["text"]

providers/302ai/models/claude-sonnet-4-20250514.toml

@@ -0,0 +1,21 @@
+name = "claude-sonnet-4-20250514"
+release_date = "2025-05-22"
+last_updated = "2025-05-22"
+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", "pdf"]
+output = ["text"]

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

@@ -17,5 +17,5 @@ context = 200_000
 output = 64_000
 
 [modalities]
-input = ["text", "image"]
+input = ["text", "image", "pdf"]
 output = ["text"]

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

@@ -1,6 +1,6 @@
 name = "claude-sonnet-4-5-20250929"
-release_date = "2025-09-29"
-last_updated = "2025-09-29"
+release_date = "2025-09-30"
+last_updated = "2025-09-30"
 attachment = true
 reasoning = false
 temperature = true
@@ -17,5 +17,5 @@ context = 200_000
 output = 64_000
 
 [modalities]
-input = ["text", "image"]
+input = ["text", "image", "pdf"]
 output = ["text"]

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

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

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

@@ -0,0 +1,21 @@
+name = "claude-sonnet-4-6-thinking"
+release_date = "2026-02-18"
+last_updated = "2026-03-13"
+attachment = true
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2025-08"
+
+[cost]
+input = 3.000
+output = 15.000
+
+[limit]
+context = 1_000_000
+output = 64_000
+
+[modalities]
+input = ["text", "image", "pdf"]
+output = ["text"]

providers/302ai/models/claude-sonnet-4-6.toml

@@ -0,0 +1,21 @@
+name = "claude-sonnet-4-6"
+release_date = "2026-02-18"
+last_updated = "2026-03-13"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2025-08"
+
+[cost]
+input = 3.000
+output = 15.000
+
+[limit]
+context = 1_000_000
+output = 64_000
+
+[modalities]
+input = ["text", "image", "pdf"]
+output = ["text"]

providers/302ai/models/gemini-3.1-flash-image-preview.toml

@@ -0,0 +1,21 @@
+name = "gemini-3.1-flash-image-preview"
+release_date = "2026-02-27"
+last_updated = "2026-02-27"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = false
+open_weights = false
+knowledge = "2025-01"
+
+[cost]
+input = 0.500
+output = 60.000
+
+[limit]
+context = 131_072
+output = 32_768
+
+[modalities]
+input = ["text", "image", "pdf"]
+output = ["text", "image"]

providers/302ai/models/glm-4.5-air.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-air"
+release_date = "2025-07-29"
+last_updated = "2025-07-29"
 attachment = false
 reasoning = false
 temperature = true
 tool_call = true
 open_weights = false
+knowledge = "2025-04"
 
 [cost]
-input = 0.50
-output = 1.50
+input = 0.1143
+output = 0.286
 
 [limit]
 context = 128_000
-output = 4_096
+output = 98_304
 
 [modalities]
 input = ["text"]

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

@@ -0,0 +1,21 @@
+name = "glm-4.5-airx"
+release_date = "2025-07-29"
+last_updated = "2025-07-29"
+attachment = false
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2025-04"
+
+[cost]
+input = 0.572
+output = 1.714
+
+[limit]
+context = 128_000
+output = 16_384
+
+[modalities]
+input = ["text"]
+output = ["text"]

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

@@ -0,0 +1,21 @@
+name = "glm-4.5-x"
+release_date = "2025-07-29"
+last_updated = "2025-07-29"
+attachment = false
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2025-04"
+
+[cost]
+input = 1.143
+output = 2.290
+
+[limit]
+context = 128_000
+output = 16_384
+
+[modalities]
+input = ["text"]
+output = ["text"]

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

@@ -1,6 +1,6 @@
 name = "GLM-4.5V"
-release_date = "2025-07-29"
-last_updated = "2025-07-29"
+release_date = "2025-08-12"
+last_updated = "2025-08-12"
 attachment = true
 reasoning = false
 temperature = true

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

@@ -2,7 +2,7 @@ name = "glm-4.6"
 release_date = "2025-09-30"
 last_updated = "2025-09-30"
 attachment = false
-reasoning = false
+reasoning = true
 temperature = true
 tool_call = true
 open_weights = false

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

@@ -0,0 +1,21 @@
+name = "glm-4.7-flashx"
+release_date = "2026-01-20"
+last_updated = "2026-01-20"
+attachment = false
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2025-04"
+
+[cost]
+input = 0.0715
+output = 0.429
+
+[limit]
+context = 200_000
+output = 131_072
+
+[modalities]
+input = ["text"]
+output = ["text"]

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

@@ -2,7 +2,7 @@ name = "glm-4.7"
 release_date = "2025-12-22"
 last_updated = "2025-12-22"
 attachment = false
-reasoning = false
+reasoning = true
 temperature = true
 tool_call = true
 open_weights = false

providers/302ai/models/glm-5-turbo.toml

@@ -0,0 +1,20 @@
+name = "glm-5-turbo"
+release_date = "2026-03-16"
+last_updated = "2026-03-16"
+attachment = false
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = false
+
+[cost]
+input = 0.720
+output = 3.200
+
+[limit]
+context = 200_000
+output = 131_072
+
+[modalities]
+input = ["text"]
+output = ["text"]

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

@@ -0,0 +1,20 @@
+name = "glm-5.1"
+release_date = "2026-04-10"
+last_updated = "2026-04-10"
+attachment = false
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = false
+
+[cost]
+input = 0.860
+output = 3.500
+
+[limit]
+context = 200_000
+output = 131_072
+
+[modalities]
+input = ["text"]
+output = ["text"]

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

@@ -0,0 +1,20 @@
+name = "glm-5"
+release_date = "2026-02-12"
+last_updated = "2026-02-12"
+attachment = false
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = false
+
+[cost]
+input = 0.600
+output = 2.600
+
+[limit]
+context = 200_000
+output = 131_072
+
+[modalities]
+input = ["text"]
+output = ["text"]

providers/302ai/models/glm-5v-turbo.toml

@@ -0,0 +1,20 @@
+name = "glm-5v-turbo"
+release_date = "2026-04-02"
+last_updated = "2026-04-02"
+attachment = true
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = false
+
+[cost]
+input = 0.720
+output = 3.200
+
+[limit]
+context = 200_000
+output = 131_072
+
+[modalities]
+input = ["text", "image", "video", "audio", "pdf"]
+output = ["text"]

providers/302ai/models/glm-for-coding.toml

@@ -1,21 +1,19 @@
-name = "GLM 4.6"
-family = "glm"
+name = "glm-for-coding"
 release_date = "2025-09-30"
 last_updated = "2025-09-30"
 attachment = false
-reasoning = false
+reasoning = true
 temperature = true
 tool_call = true
-knowledge = "2025-09"
-open_weights = true
+open_weights = false
 
 [cost]
-input = 0.6
-output = 2.2
+input = 0.086
+output = 0.343
 
 [limit]
 context = 200_000
-output = 32_768
+output = 131_072
 
 [modalities]
 input = ["text"]

providers/302ai/models/gpt-5.4-mini-2026-03-17.toml

@@ -0,0 +1,21 @@
+name = "gpt-5.4-mini-2026-03-17"
+release_date = "2026-03-19"
+last_updated = "2026-03-19"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2025-08"
+
+[cost]
+input = 0.750
+output = 4.500
+
+[limit]
+context = 400_000
+output = 128_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

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

@@ -0,0 +1,21 @@
+name = "gpt-5.4-mini"
+release_date = "2026-03-19"
+last_updated = "2026-03-19"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2025-08"
+
+[cost]
+input = 0.750
+output = 4.500
+
+[limit]
+context = 400_000
+output = 128_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/gpt-5.4-nano-2026-03-17.toml

@@ -0,0 +1,21 @@
+name = "gpt-5.4-nano-2026-03-17"
+release_date = "2026-03-19"
+last_updated = "2026-03-19"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2025-08"
+
+[cost]
+input = 0.200
+output = 1.250
+
+[limit]
+context = 400_000
+output = 128_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

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

@@ -0,0 +1,21 @@
+name = "gpt-5.4-nano"
+release_date = "2026-03-19"
+last_updated = "2026-03-19"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2025-08"
+
+[cost]
+input = 0.200
+output = 1.250
+
+[limit]
+context = 400_000
+output = 128_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/grok-4.20-beta-0309-non-reasoning.toml

@@ -0,0 +1,20 @@
+name = "grok-4.20-beta-0309-non-reasoning"
+release_date = "2026-03-16"
+last_updated = "2026-03-16"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+
+[cost]
+input = 2.000
+output = 6.000
+
+[limit]
+context = 2_000_000
+output = 30_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/grok-4.20-beta-0309-reasoning.toml

@@ -0,0 +1,20 @@
+name = "grok-4.20-beta-0309-reasoning"
+release_date = "2026-03-16"
+last_updated = "2026-03-16"
+attachment = true
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = false
+
+[cost]
+input = 2.000
+output = 6.000
+
+[limit]
+context = 2_000_000
+output = 30_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/302ai/models/grok-4.20-multi-agent-beta-0309.toml

@@ -0,0 +1,20 @@
+name = "grok-4.20-multi-agent-beta-0309"
+release_date = "2026-03-16"
+last_updated = "2026-03-16"
+attachment = true
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = false
+
+[cost]
+input = 2.000
+output = 6.000
+
+[limit]
+context = 2_000_000
+output = 30_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

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-31"
+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-31"
 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

@@ -9,8 +9,8 @@ tool_call = true
 open_weights = true
 
 [cost]
-input = 0.14
-output = 0.28
+input = 0.55
+output = 1.66
 
 [limit]
 context = 128_000

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

@@ -0,0 +1,24 @@
+name = "GPT-5 Codex"
+family = "gpt"
+release_date = "2025-09-15"
+last_updated = "2025-09-15"
+attachment = false
+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-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

@@ -10,8 +10,8 @@ tool_call = true
 open_weights = false
 
 [cost]
-input = 1.50
-output = 12.00
+input = 1.75
+output = 14.00
 
 [limit]
 context = 400_000

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"]

providers/abacus/models/gpt-5.4.toml

@@ -0,0 +1,24 @@
+name = "GPT-5.4"
+family = "gpt"
+release_date = "2026-03-05"
+last_updated = "2026-03-05"
+attachment = true
+reasoning = true
+temperature = false
+knowledge = "2025-08-31"
+tool_call = true
+structured_output = true
+open_weights = false
+
+[cost]
+input = 2.50
+output = 15.00
+
+[limit]
+context = 1_050_000
+input = 922_000
+output = 128_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/abacus/models/kimi-k2.5.toml

@@ -0,0 +1,23 @@
+name = "Kimi K2.5"
+family = "kimi"
+release_date = "2026-01"
+last_updated = "2026-01"
+attachment = false
+reasoning = true
+structured_output = true
+temperature = true
+tool_call = true
+knowledge = "2025-01"
+open_weights = true
+
+[cost]
+input = 0.60
+output = 3.00
+
+[limit]
+context = 262_144
+output = 32_768
+
+[modalities]
+input = ["text", "image", "video"]
+output = ["text"]

providers/abacus/models/o3-pro.toml

@@ -11,7 +11,7 @@ open_weights = false
 
 [cost]
 input = 20.00
-output = 80.00
+output = 40.00
 
 [limit]
 context = 200_000

providers/abacus/models/route-llm.toml

@@ -10,8 +10,8 @@ tool_call = true
 open_weights = false
 
 [cost]
-input = 0.50
-output = 1.50
+input = 3.00
+output = 15.00
 
 [limit]
 context = 128_000

providers/abacus/models/zai-org/glm-4.7.toml

@@ -9,8 +9,8 @@ tool_call = true
 open_weights = true
 
 [cost]
-input = 0.70
-output = 2.50
+input = 0.60
+output = 2.20
 
 [limit]
 context = 128_000

providers/abacus/models/zai-org/glm-5.toml

@@ -0,0 +1,21 @@
+name = "GLM-5"
+family = "glm"
+release_date = "2026-02-11"
+last_updated = "2026-02-11"
+attachment = false
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = true
+
+[cost]
+input = 1.00
+output = 3.20
+
+[limit]
+context = 204800
+output = 131072
+
+[modalities]
+input = ["text"]
+output = ["text"]

providers/aihubmix/models/claude-opus-4-6-think.toml

@@ -0,0 +1,30 @@
+name = "Claude Opus 4.6 Think"
+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-31"
+open_weights = false
+
+[cost]
+input = 5.00
+output = 25.00
+cache_read = 0.30
+cache_write = 3.75
+
+[cost.context_over_200k]
+input = 6.00
+output = 22.00
+cache_read = 0.60
+cache_write = 7.50
+
+[limit]
+context = 200_000
+output = 128_000
+
+[modalities]
+input = ["text", "image", "pdf"]
+output = ["text"]

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

@@ -0,0 +1,30 @@
+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-31"
+open_weights = false
+
+[cost]
+input = 5.00
+output = 25.00
+cache_read = 0.30
+cache_write = 3.75
+
+[cost.context_over_200k]
+input = 6.00
+output = 22.00
+cache_read = 0.60
+cache_write = 7.50
+
+[limit]
+context = 200_000
+output = 128_000
+
+[modalities]
+input = ["text", "image", "pdf"]
+output = ["text"]

providers/aihubmix/models/claude-sonnet-4-6-think.toml

@@ -0,0 +1,30 @@
+name = "Claude Sonnet 4.6 Think"
+family = "claude-sonnet"
+release_date = "2026-02-17"
+last_updated = "2026-02-17"
+attachment = true
+reasoning = true
+temperature = true
+tool_call = true
+knowledge = "2025-08-31"
+open_weights = false
+
+[cost]
+input = 3.00
+output = 15.00
+cache_read = 0.30
+cache_write = 3.75
+
+[cost.context_over_200k]
+input = 6.00
+output = 22.50
+cache_read = 0.60
+cache_write = 7.50
+
+[limit]
+context = 200_000
+output = 64_000
+
+[modalities]
+input = ["text", "image", "pdf"]
+output = ["text"]

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

@@ -0,0 +1,30 @@
+name = "Claude Sonnet 4.6"
+family = "claude-sonnet"
+release_date = "2026-02-17"
+last_updated = "2026-02-17"
+attachment = true
+reasoning = true
+temperature = true
+tool_call = true
+knowledge = "2025-08-31"
+open_weights = false
+
+[cost]
+input = 3.00
+output = 15.00
+cache_read = 0.30
+cache_write = 3.75
+
+[cost.context_over_200k]
+input = 6.00
+output = 22.50
+cache_read = 0.60
+cache_write = 7.50
+
+[limit]
+context = 200_000
+output = 64_000
+
+[modalities]
+input = ["text", "image", "pdf"]
+output = ["text"]

providers/aihubmix/models/coding-glm-4.7.toml

@@ -13,9 +13,9 @@ open_weights = true
 field = "reasoning_details"
 
 [cost]
-input = 0.27
-output = 1.10
-cache_read = 0.548
+input = 0.06
+output = 0.22
+cache_read = 0.01
 
 [limit]
 context = 204800

providers/aihubmix/models/coding-glm-5-free.toml

@@ -0,0 +1,24 @@
+name = "Coding-GLM-5-Free"
+family = "glm"
+release_date = "2026-02-11"
+last_updated = "2026-02-11"
+attachment = false
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = false
+
+[interleaved]
+field = "reasoning_content"
+
+[cost]
+input = 0.0
+output = 0.0
+
+[limit]
+context = 204800
+output = 131072
+
+[modalities]
+input = ["text"]
+output = ["text"]

providers/aihubmix/models/coding-glm-5.1.toml

@@ -0,0 +1,24 @@
+name = "Coding-GLM-5.1"
+family = "glm"
+release_date = "2026-04-11"
+last_updated = "2026-04-11"
+attachment = false
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = false
+
+[interleaved]
+field = "reasoning_content"
+
+[cost]
+input = 0.06
+output = 0.22
+
+[limit]
+context = 200000
+output = 128000
+
+[modalities]
+input = ["text"]
+output = ["text"]

providers/aihubmix/models/gemini-3-pro-preview-search.toml

@@ -0,0 +1,23 @@
+name = "Gemini 3 Pro Preview Search"
+family = "gemini-pro"
+release_date = "2025-11-19"
+last_updated = "2025-11-19"
+attachment = true
+reasoning = true
+temperature = true
+tool_call = true
+knowledge = "2025-11"
+open_weights = false
+
+[cost]
+input = 2.00
+output = 12.00
+cache_read = 0.50
+
+[limit]
+context = 1_000_000
+output = 65_000
+
+[modalities]
+input = ["text", "image", "audio", "video"]
+output = ["text"]

providers/aihubmix/models/glm-5.1.toml

@@ -0,0 +1,24 @@
+name = "GLM-5.1"
+family = "glm"
+release_date = "2026-04-11"
+last_updated = "2026-04-11"
+attachment = false
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = false
+
+[interleaved]
+field = "reasoning_content"
+
+[cost]
+input = 0.84
+output = 3.38
+
+[limit]
+context = 200000
+output = 128000
+
+[modalities]
+input = ["text"]
+output = ["text"]

providers/aihubmix/models/glm-5.toml

@@ -0,0 +1,24 @@
+name = "GLM-5"
+family = "glm"
+release_date = "2026-02-11"
+last_updated = "2026-02-11"
+attachment = false
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = false
+
+[interleaved]
+field = "reasoning_content"
+
+[cost]
+input = 0.88
+output = 2.82
+
+[limit]
+context = 204800
+output = 131072
+
+[modalities]
+input = ["text"]
+output = ["text"]

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

@@ -0,0 +1,23 @@
+name = "GPT-5.2-Codex"
+family = "gpt-codex"
+release_date = "2026-01-14"
+last_updated = "2026-01-14"
+attachment = true
+reasoning = true
+knowledge = "2025-08-31"
+tool_call = true
+structured_output = true
+open_weights = false
+
+[cost]
+input = 1.75
+output = 14.00
+cache_read = 0.175
+
+[limit]
+context = 400_000
+output = 128_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/aihubmix/models/gpt-5.4-mini.toml

@@ -0,0 +1,23 @@
+name = "GPT-5.4-Mini"
+family = "gpt-mini"
+release_date = "2026-03-11"
+last_updated = "2026-03-11"
+attachment = true
+reasoning = false
+temperature = false
+tool_call = true
+open_weights = false
+structured_output = true
+
+[cost]
+input = 0.75
+output = 4.50
+cache_read = 0.075
+
+[limit]
+context = 400_000
+output = 128_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/aihubmix/models/gpt-5.4.toml

@@ -0,0 +1,23 @@
+name = "GPT-5.4"
+family = "gpt"
+release_date = "2026-03-11"
+last_updated = "2026-03-11"
+attachment = true
+reasoning = true
+temperature = false
+tool_call = true
+open_weights = false
+structured_output = true
+
+[cost]
+input = 2.50
+output = 15.00
+cache_read = 0.25
+
+[limit]
+context = 400_000
+output = 128_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/aihubmix/models/minimax-m2.5.toml

@@ -0,0 +1,21 @@
+name = "MiniMax-M2.5"
+family = "minimax"
+release_date = "2026-02-12"
+last_updated = "2026-02-12"
+attachment = false
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = true
+
+[cost]
+input = 0.29
+output = 1.15
+
+[limit]
+context = 204_800
+output = 131_072
+
+[modalities]
+input = ["text"]
+output = ["text"]

providers/aihubmix/models/qwen3-coder-next.toml

@@ -0,0 +1,23 @@
+name = "Qwen3 Coder Next"
+family = "qwen"
+attachment = false
+reasoning = false
+tool_call = true
+structured_output = false
+temperature = true
+release_date = "2026-02-04"
+last_updated = "2026-02-04"
+open_weights = true
+
+[cost]
+input = 0.14
+output = 0.55
+
+[limit]
+context = 262_144
+input = 262_144
+output = 65_536
+
+[modalities]
+input = ["text"]
+output = ["text"]

providers/aihubmix/models/qwen3.5-plus.toml

@@ -0,0 +1,22 @@
+name = "Qwen 3.5 Plus"
+family = "qwen"
+release_date = "2026-02-16"
+last_updated = "2026-02-16"
+attachment = false
+reasoning = true
+temperature = true
+knowledge = "2025-04"
+tool_call = true
+open_weights = false
+
+[cost]
+input = 0.11
+output = 0.66
+
+[limit]
+context = 1_000_000
+output = 65_536
+
+[modalities]
+input = ["text", "image", "video"]
+output = ["text"]

providers/aihubmix/provider.toml

@@ -1,6 +1,5 @@
 name = "AIHubMix"
-npm = "@ai-sdk/openai-compatible"
+npm = "@aihubmix/ai-sdk-provider"
 env = ["AIHUBMIX_API_KEY"]
-api = "https://aihubmix.com/v1"
 doc = "https://docs.aihubmix.com"
 

providers/alibaba-cn/models/MiniMax-M2.5.toml

@@ -0,0 +1,24 @@
+name = "MiniMax-M2.5"
+family = "minimax"
+release_date = "2026-02-12"
+last_updated = "2026-02-12"
+attachment = false
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = true
+
+[cost]
+input = 0.30
+output = 1.20
+
+[interleaved]
+field = "reasoning_content"
+
+[limit]
+context = 204_800
+output = 131_072
+
+[modalities]
+input = ["text"]
+output = ["text"]

providers/alibaba-cn/models/MiniMax/MiniMax-M2.7.toml

@@ -0,0 +1,23 @@
+name = "MiniMax-M2.7"
+family = "minimax"
+release_date = "2026-03-18"
+last_updated = "2026-03-18"
+attachment = false
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = true
+
+[cost]
+input = 0.30
+output = 1.20
+cache_read = 0.06
+cache_write = 0.375
+
+[limit]
+context = 204_800
+output = 131_072
+
+[modalities]
+input = ["text"]
+output = ["text"]

providers/alibaba-cn/models/glm-5.1.toml

@@ -0,0 +1,26 @@
+name = "GLM-5.1"
+family = "glm"
+release_date = "2026-04-14"
+last_updated = "2026-04-14"
+attachment = false
+reasoning = true
+structured_output = true
+temperature = true
+tool_call = true
+open_weights = true
+
+[interleaved]
+field = "reasoning_content"
+
+[cost]
+input = 0.87
+output = 3.48
+cache_read = 0.17
+
+[limit]
+context = 202_752
+output = 128_000
+
+[modalities]
+input = ["text"]
+output = ["text"]

providers/alibaba-cn/models/glm-5.toml

@@ -0,0 +1,24 @@
+name = "GLM-5"
+family = "glm"
+release_date = "2026-02-11"
+last_updated = "2026-02-11"
+attachment = false
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = false
+
+[interleaved]
+field = "reasoning_content"
+
+[cost]
+input = 0.86
+output = 3.15
+
+[limit]
+context = 202_752
+output = 16_384
+
+[modalities]
+input = ["text"]
+output = ["text"]