chore(sync): isolate cloudflare credentials

chore(sync): add cloudflare workers ai sync

.github/workflows/sync-models.yml

@@ -0,0 +1,89 @@
+name: Sync Model Catalogs
+
+on:
+  schedule:
+    - cron: "17 8 * * *"
+  workflow_dispatch:
+
+permissions:
+  contents: write
+  issues: write
+  pull-requests: write
+
+concurrency: ${{ github.workflow }}-${{ github.ref }}
+
+jobs:
+  sync:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - group: aggregators
+            title: "chore(sync): update aggregator model catalogs"
+            branch: automation/sync-models-aggregators
+            labels: automation,model-sync,sync-group:aggregators,provider:openrouter
+          - group: cloudflare
+            title: "chore(sync): update cloudflare model catalogs"
+            branch: automation/sync-models-cloudflare
+            labels: automation,model-sync,sync-group:cloudflare,provider:cloudflare-workers-ai
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5
+        with:
+          ref: dev
+
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@f4d14e03ff726c06358e5557344e1da148b56cf7
+        with:
+          bun-version: latest
+
+      - name: Install dependencies
+        run: bun install
+
+      - name: Sync model catalogs
+        run: bun models:sync ${{ matrix.group }}
+        env:
+          OPENROUTER_API_KEY: ${{ secrets.OPENROUTER_API_KEY }}
+          CLOUDFLARE_WORKERS_AI_SYNC_ACCOUNT_ID: ${{ secrets.CLOUDFLARE_WORKERS_AI_SYNC_ACCOUNT_ID }}
+          CLOUDFLARE_WORKERS_AI_SYNC_API_TOKEN: ${{ secrets.CLOUDFLARE_WORKERS_AI_SYNC_API_TOKEN }}
+
+      - name: Validate models
+        run: bun validate
+
+      - name: Create pull request
+        env:
+          GH_TOKEN: ${{ github.token }}
+          BRANCH: ${{ matrix.branch }}
+          LABELS: ${{ matrix.labels }}
+          TITLE: ${{ matrix.title }}
+        run: |
+          if [ -z "$(git status --porcelain -- providers)" ]; then
+            echo "No model catalog changes found."
+            exit 0
+          fi
+
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git checkout -B "$BRANCH"
+          git add providers
+          git commit -m "$TITLE"
+          git push --force-with-lease origin "$BRANCH"
+
+          label_args=()
+          IFS=',' read -ra labels <<< "$LABELS"
+          for label in "${labels[@]}"; do
+            gh label create "$label" --color "0E8A16" --description "Automated model catalog sync" >/dev/null 2>&1 || true
+            label_args+=(--label "$label")
+          done
+
+          pr_number="$(gh pr list --head "$BRANCH" --base dev --json number --jq '.[0].number')"
+          if [ -n "$pr_number" ]; then
+            gh pr edit "$pr_number" --title "$TITLE" --body-file .sync/model-sync-report.md
+            for label in "${labels[@]}"; do
+              gh pr edit "$pr_number" --add-label "$label"
+            done
+          else
+            gh pr create --base dev --head "$BRANCH" --title "$TITLE" --body-file .sync/model-sync-report.md "${label_args[@]}"
+          fi

.gitignore

@@ -3,6 +3,7 @@
 .idea
 dist
 .DS_Store
+.sync/
 node_modules
 data/tokenspeed-monitor.sqlite
 data/tokenspeed-monitor.sqlite-shm

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:**
 

bun.lock

@@ -5,7 +5,7 @@
     "": {
       "name": "models.dev",
       "dependencies": {
-        "@cloudflare/workers-types": "^4.20250801.0",
+        "@cloudflare/workers-types": "^4.20260424.1",
         "sst": "3.17.23",
       },
     },
@@ -32,6 +32,7 @@
     "packages/web": {
       "name": "@models.dev/web",
       "dependencies": {
+        "@tanstack/virtual-core": "^3.14.0",
         "hono": "^4.8.0",
         "models.dev": "workspace:*",
       },
@@ -49,7 +50,7 @@
     "zod": "3.24.2",
   },
   "packages": {
-    "@cloudflare/workers-types": ["@cloudflare/workers-types@4.20250801.0", "", {}, "sha512-BQmMdoOGClY23TesgkR1PeGrPvPsSFD/zW7pDzWZHkOEsqkPk2A91h52bP8GbtKYTl1vdaYjQgJlGsP6Ih4G0w=="],
+    "@cloudflare/workers-types": ["@cloudflare/workers-types@4.20260424.1", "", {}, "sha512-0DLJ9yEk1KKzPbqop80Gw/P1wkKKzawmipULiJWdBXIBCoMvE0OVWms3IrL/Q/G7tfmPop9yF4XlZ69k9JLYng=="],
 
     "@modelcontextprotocol/sdk": ["@modelcontextprotocol/sdk@1.6.1", "", { "dependencies": { "content-type": "^1.0.5", "cors": "^2.8.5", "eventsource": "^3.0.2", "express": "^5.0.1", "express-rate-limit": "^7.5.0", "pkce-challenge": "^4.1.0", "raw-body": "^3.0.0", "zod": "^3.23.8", "zod-to-json-schema": "^3.24.1" } }, "sha512-oxzMzYCkZHMntzuyerehK3fV6A2Kwh5BD6CGEJSVDU2QNEhfLOptf2X7esQgaHZXHZY0oHmMsOtIDLP71UJXgA=="],
 
@@ -57,9 +58,11 @@
 
     "@models.dev/web": ["@models.dev/web@workspace:packages/web"],
 
+    "@tanstack/virtual-core": ["@tanstack/virtual-core@3.14.0", "", {}, "sha512-JLANqGy/D6k4Ujmh8Tr25lGimuOXNiaVyXaCAZS0W+1390sADdGnyUdSWNIfd49gebtIxGMij4IktRVzrdr12Q=="],
+
     "@tsconfig/bun": ["@tsconfig/bun@1.0.8", "", {}, "sha512-JlJaRaS4hBTypxtFe8WhnwV8blf0R+3yehLk8XuyxUYNx6VXsKCjACSCvOYEFUiqlhlBWxtYCn/zRlOb8BzBQg=="],
 
-    "@types/bun": ["@types/bun@1.2.16", "", { "dependencies": { "bun-types": "1.2.16" } }, "sha512-1aCZJ/6nSiViw339RsaNhkNoEloLaPzZhxMOYEa7OzRzO41IGg5n/7I43/ZIAW/c+Q6cT12Vf7fOZOoVIzb5BQ=="],
+    "@types/bun": ["@types/bun@1.3.0", "", { "dependencies": { "bun-types": "1.3.0" } }, "sha512-+lAGCYjXjip2qY375xX/scJeVRmZ5cY0wyHYyCYxNcdEXrQ4AOe3gACgd4iQ8ksOslJtW4VNxBJ8llUwc3a6AA=="],
 
     "@types/node": ["@types/node@22.13.9", "", { "dependencies": { "undici-types": "~6.20.0" } }, "sha512-acBjXdRJ3A6Pb3tqnw9HZmyR3Fiol3aGxRCK1x3d+6CDAMjl7I649wpSd+yNURCjbOUGu9tqtLKnTGxmK6CyGw=="],
 
@@ -79,7 +82,7 @@
 
     "buffer": ["buffer@4.9.2", "", { "dependencies": { "base64-js": "^1.0.2", "ieee754": "^1.1.4", "isarray": "^1.0.0" } }, "sha512-xq+q3SRMOxGivLhBNaUdC64hDTQwejJ+H0T/NB1XMtTVEwNTrfFF3gAxiyW0Bu/xWEGhjVKgUcMhCrUy2+uCWg=="],
 
-    "bun-types": ["bun-types@1.2.16", "", { "dependencies": { "@types/node": "*" } }, "sha512-ciXLrHV4PXax9vHvUrkvun9VPVGOVwbbbBF/Ev1cXz12lyEZMoJpIJABOfPcN9gDJRaiKF9MVbSygLg4NXu3/A=="],
+    "bun-types": ["bun-types@1.3.0", "", { "dependencies": { "@types/node": "*" }, "peerDependencies": { "@types/react": "^19" } }, "sha512-u8X0thhx+yJ0KmkxuEo9HAtdfgCBaM/aI9K90VQcQioAmkVp3SG3FkwWGibUFz3WdXAdcsqOcbU40lK7tbHdkQ=="],
 
     "bytes": ["bytes@3.1.2", "", {}, "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg=="],
 
@@ -325,8 +328,6 @@
 
     "http-errors/statuses": ["statuses@2.0.1", "", {}, "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ=="],
 
-    "models.dev/@types/bun": ["@types/bun@1.3.0", "", { "dependencies": { "bun-types": "1.3.0" } }, "sha512-+lAGCYjXjip2qY375xX/scJeVRmZ5cY0wyHYyCYxNcdEXrQ4AOe3gACgd4iQ8ksOslJtW4VNxBJ8llUwc3a6AA=="],
-
     "opencontrol/@tsconfig/bun": ["@tsconfig/bun@1.0.7", "", {}, "sha512-udGrGJBNQdXGVulehc1aWT73wkR9wdaGBtB6yL70RJsqwW/yJhIg6ZbRlPOfIUiFNrnBuYLBi9CSmMKfDC7dvA=="],
 
     "opencontrol/hono": ["hono@4.7.4", "", {}, "sha512-Pst8FuGqz3L7tFF+u9Pu70eI0xa5S3LPUmrNd5Jm8nTHze9FxLTK9Kaj5g/k4UcwuJSXTP65SyHOPLrffpcAJg=="],
@@ -334,11 +335,5 @@
     "openid-client/jose": ["jose@4.15.9", "", {}, "sha512-1vUQX+IdDMVPj4k8kOxgUqlcK518yluMuGZwqlr44FS1ppZB/5GWh4rZG89erpOBOJjU/OBsnCVFfapsRz6nEA=="],
 
     "bun-types/@types/node/undici-types": ["undici-types@7.8.0", "", {}, "sha512-9UJ2xGDvQ43tYyVMpuHlsgApydB8ZKfVYTsLDhXkFL/6gfkp+U8xTGdh8pMJv1SpZna0zxG1DwsKZsreLbXBxw=="],
-
-    "models.dev/@types/bun/bun-types": ["bun-types@1.3.0", "", { "dependencies": { "@types/node": "*" }, "peerDependencies": { "@types/react": "^19" } }, "sha512-u8X0thhx+yJ0KmkxuEo9HAtdfgCBaM/aI9K90VQcQioAmkVp3SG3FkwWGibUFz3WdXAdcsqOcbU40lK7tbHdkQ=="],
-
-    "models.dev/@types/bun/bun-types/@types/node": ["@types/node@24.0.3", "", { "dependencies": { "undici-types": "~7.8.0" } }, "sha512-R4I/kzCYAdRLzfiCabn9hxWfbuHS573x+r0dJMkkzThEa7pbrcDWK+9zu3e7aBOouf+rQAciqPFMnxwr0aWgKg=="],
-
-    "models.dev/@types/bun/bun-types/@types/node/undici-types": ["undici-types@7.8.0", "", {}, "sha512-9UJ2xGDvQ43tYyVMpuHlsgApydB8ZKfVYTsLDhXkFL/6gfkp+U8xTGdh8pMJv1SpZna0zxG1DwsKZsreLbXBxw=="],
   }
 }

package.json

@@ -17,13 +17,19 @@
   "scripts": {
     "validate": "bun ./packages/core/script/validate.ts",
     "compare:migrations": "bun ./packages/core/script/compare-model-migrations.ts",
+    "cloudflare:sync": "bun ./packages/core/script/sync-models.ts cloudflare-workers-ai",
+    "chutes:generate": "bun ./packages/core/script/generate-chutes.ts",
+    "databricks:generate": "bun ./packages/core/script/generate-databricks.ts",
     "helicone:generate": "bun ./packages/core/script/generate-helicone.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"
+    "wandb:generate": "bun ./packages/core/script/generate-wandb.ts",
+    "digitalocean:generate": "bun ./packages/core/script/generate-digitalocean.ts",
+    "ambient:generate": "bun ./packages/core/script/generate-ambient.ts",
+    "models:sync": "bun ./packages/core/script/sync-models.ts"
   },
   "dependencies": {
-    "@cloudflare/workers-types": "^4.20250801.0",
+    "@cloudflare/workers-types": "^4.20260424.1",
     "sst": "3.17.23"
   }
 }

packages/core/script/generate-ambient.ts

@@ -0,0 +1,172 @@
+#!/usr/bin/env bun
+
+/**
+ * Generates Ambient model TOML files from https://api.ambient.xyz/v1/models.
+ *
+ * Emits `[extends]`-format TOMLs that inherit upstream metadata
+ * (family, release_date, knowledge, capabilities) from the canonical
+ * provider model, and override only the fields Ambient's API reports:
+ * cost, limit, modalities.
+ *
+ * Flags:
+ *   --dry-run  Preview generated TOMLs without writing files.
+ */
+
+import { z } from "zod";
+import path from "node:path";
+import { mkdir } from "node:fs/promises";
+
+const API_ENDPOINT = "https://api.ambient.xyz/v1/models";
+
+// Allowlist for the initial rollout.
+const ALLOWLIST = new Set<string>([
+  "zai-org/GLM-5.1-FP8",
+  "moonshotai/kimi-k2.6",
+]);
+
+// Maps Ambient model IDs to canonical <provider>/<model> in this repo.
+// The generated TOML uses this path as `[extends].from` so capabilities
+// and metadata propagate from the upstream provider automatically.
+const EXTENDS_MAP: Record<string, string> = {
+  "zai-org/GLM-5.1-FP8": "zai/glm-5.1",
+  "moonshotai/kimi-k2.6": "moonshotai/kimi-k2.6",
+};
+
+const Pricing = z
+  .object({
+    prompt: z.string(),
+    completion: z.string(),
+    input_cache_read: z.string().optional(),
+    input_cache_write: z.string().optional(),
+  })
+  .passthrough();
+
+const AmbientModel = z
+  .object({
+    id: z.string(),
+    name: z.string(),
+    context_length: z.number(),
+    max_output_length: z.number(),
+    input_modalities: z.array(z.string()),
+    output_modalities: z.array(z.string()),
+    pricing: Pricing,
+  })
+  .passthrough();
+
+const AmbientResponse = z
+  .object({
+    object: z.literal("list"),
+    data: z.array(AmbientModel),
+  })
+  .passthrough();
+
+const ALLOWED_MODALITIES = new Set(["text", "audio", "image", "video", "pdf"]);
+
+function modalities(values: string[]): string[] {
+  return values
+    .map((v) => v.toLowerCase())
+    .filter((v) => ALLOWED_MODALITIES.has(v));
+}
+
+function perMTok(price: string): number {
+  const n = parseFloat(price);
+  if (!Number.isFinite(n)) {
+    throw new Error(`Invalid price: ${price}`);
+  }
+  // Round to 6 decimals to absorb float noise from per-token strings.
+  return Math.round(n * 1_000_000 * 1_000_000) / 1_000_000;
+}
+
+function formatToml(
+  model: z.infer<typeof AmbientModel>,
+  extendsFrom: string,
+): string {
+  const lines: string[] = [];
+  lines.push("[extends]");
+  lines.push(`from = "${extendsFrom}"`);
+  lines.push("");
+
+  lines.push("[cost]");
+  lines.push(`input = ${perMTok(model.pricing.prompt)}`);
+  lines.push(`output = ${perMTok(model.pricing.completion)}`);
+  if (model.pricing.input_cache_read !== undefined) {
+    lines.push(`cache_read = ${perMTok(model.pricing.input_cache_read)}`);
+  }
+  if (model.pricing.input_cache_write !== undefined) {
+    lines.push(`cache_write = ${perMTok(model.pricing.input_cache_write)}`);
+  }
+  lines.push("");
+
+  lines.push("[limit]");
+  lines.push(`context = ${model.context_length}`);
+  lines.push(`output = ${model.max_output_length}`);
+  lines.push("");
+
+  const input = modalities(model.input_modalities);
+  const output = modalities(model.output_modalities);
+  lines.push("[modalities]");
+  lines.push(`input = [${input.map((m) => `"${m}"`).join(", ")}]`);
+  lines.push(`output = [${output.map((m) => `"${m}"`).join(", ")}]`);
+
+  return lines.join("\n") + "\n";
+}
+
+async function main() {
+  const dryRun = process.argv.includes("--dry-run");
+
+  const outDir = path.join(
+    import.meta.dirname,
+    "..",
+    "..",
+    "..",
+    "providers",
+    "ambient",
+    "models",
+  );
+
+  const res = await fetch(API_ENDPOINT);
+  if (!res.ok) {
+    console.error(`Fetch failed: ${res.status} ${res.statusText}`);
+    process.exit(1);
+  }
+
+  const parsed = AmbientResponse.safeParse(await res.json());
+  if (!parsed.success) {
+    console.error("Invalid Ambient response:", parsed.error.issues);
+    process.exit(1);
+  }
+
+  const selected = parsed.data.data.filter((m) => ALLOWLIST.has(m.id));
+  const missing = [...ALLOWLIST].filter(
+    (id) => !selected.some((m) => m.id === id),
+  );
+  if (missing.length > 0) {
+    console.error(`Allowlisted models missing from API: ${missing.join(", ")}`);
+    process.exit(1);
+  }
+
+  let count = 0;
+  for (const model of selected) {
+    const extendsFrom = EXTENDS_MAP[model.id];
+    if (!extendsFrom) {
+      console.error(`No EXTENDS_MAP entry for ${model.id}; skipping`);
+      continue;
+    }
+    const filePath = path.join(outDir, `${model.id}.toml`);
+    const toml = formatToml(model, extendsFrom);
+    if (dryRun) {
+      console.log(`--- ${path.relative(process.cwd(), filePath)} ---`);
+      console.log(toml);
+    } else {
+      await mkdir(path.dirname(filePath), { recursive: true });
+      await Bun.write(filePath, toml);
+    }
+    count++;
+  }
+
+  console.log(
+    `${dryRun ? "Previewed" : "Wrote"} ${count} model file(s) under providers/ambient/models/`,
+  );
+}
+
+await main();

packages/core/script/generate-chutes.ts

@@ -0,0 +1,589 @@
+#!/usr/bin/env bun
+
+/**
+ * Generates Chutes model TOML files from the Chutes LLM API.
+ *
+ * Flags:
+ * --dry-run: Preview changes without writing files
+ * --new-only: Only create new models, skip updating existing ones
+ * --keep-orphans: Don't delete TOML files for models no longer in the API
+ */
+
+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://llm.chutes.ai/v1/models";
+
+enum SkipZeroFields {
+  LimitContext = "limit.context",
+  LimitOutput = "limit.output",
+}
+
+const Pricing = z.object({
+  prompt: z.number().optional(),
+  completion: z.number().optional(),
+  input_cache_read: z.number().optional(),
+}).passthrough();
+
+const ChutesModel = z.object({
+  id: z.string(),
+  created: z.number(),
+  pricing: Pricing.optional(),
+  context_length: z.number().optional(),
+  max_output_length: z.number().optional(),
+  max_model_len: z.number().optional(),
+  input_modalities: z.array(z.string()).optional(),
+  output_modalities: z.array(z.string()).optional(),
+  supported_features: z.array(z.string()).optional(),
+  supported_sampling_parameters: z.array(z.string()).optional(),
+  quantization: z.string().optional(),
+}).passthrough();
+
+const ChutesResponse = z.object({
+  data: z.array(ChutesModel),
+}).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;
+  };
+  limit?: {
+    context?: 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;
+  };
+  limit: {
+    context: number;
+    output: number;
+  };
+  modalities: {
+    input: string[];
+    output: string[];
+  };
+}
+
+interface Changes {
+  field: string;
+  oldValue: string;
+  newValue: string;
+}
+
+// ── Utility functions ────────────────────────────────────────────────
+
+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);
+}
+
+function formatNumber(n: number): string {
+  if (n >= 1000) {
+    return n.toString().replace(/\B(?=(\d{3})+(?!\d))/g, "_");
+  }
+  return n.toString();
+}
+
+/**
+ * Humanize a model ID into a readable name.
+ * Strips the org prefix and replaces hyphens with spaces.
+ * e.g. "Qwen/Qwen3-32B-TEE" → "Qwen3 32B TEE"
+ */
+function humanizeModelName(modelId: string): string {
+  const parts = modelId.split("/");
+  const modelPart = parts[parts.length - 1];
+  return modelPart.replace(/-/g, " ");
+}
+
+// ── Family inference ───────────
+
+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;
+}
+
+// ── Load existing TOML ───────────────────────────────────────────────
+
+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;
+  }
+}
+
+// ── Merge API data with existing TOML ────────────────────────────────
+
+function mergeModel(
+  apiModel: z.infer<typeof ChutesModel>,
+  existing: ExistingModel | null,
+): MergedModel {
+  const features = new Set(apiModel.supported_features ?? []);
+  const samplingParams = new Set(apiModel.supported_sampling_parameters ?? []);
+  const inputMods = apiModel.input_modalities ?? ["text"];
+  const outputMods = apiModel.output_modalities ?? ["text"];
+
+  // Capabilities from API features
+  const hasAttachment = inputMods.some((m) =>
+    m === "image" || m === "video" || m === "pdf",
+  );
+  const hasReasoning = features.has("reasoning");
+  const hasToolCall = features.has("tools");
+  const hasStructuredOutput = features.has("structured_outputs");
+  const hasTemperature = samplingParams.size > 0
+    ? samplingParams.has("temperature")
+    : true; // default true if no sampling params info
+
+  // Preserve existing values when available (manually specified)
+  const modelName = existing?.name ?? humanizeModelName(apiModel.id);
+  const family = existing?.family ?? inferFamily(apiModel.id, modelName);
+  const knowledge = existing?.knowledge;
+  const interleaved = existing?.interleaved;
+  const status = existing?.status;
+
+  // Release date: existing > API created timestamp > today
+  const releaseDate = existing?.release_date
+    ?? timestampToDate(apiModel.created)
+    ?? getTodayDate();
+
+  // Context limit: prefer context_length, fallback to max_model_len
+  const apiContext = apiModel.context_length ?? apiModel.max_model_len ?? 0;
+  const contextLimit = apiContext > 0
+    ? apiContext
+    : (existing?.limit?.context ?? 0);
+
+  // Output limit: prefer max_output_length, fallback to existing
+  const apiOutput = apiModel.max_output_length ?? 0;
+  const outputLimit = apiOutput > 0
+    ? apiOutput
+    : (existing?.limit?.output ?? 0);
+
+  const merged: MergedModel = {
+    name: modelName,
+    family,
+    attachment: hasAttachment,
+    reasoning: hasReasoning,
+    tool_call: hasToolCall,
+    temperature: hasTemperature,
+    release_date: releaseDate,
+    last_updated: getTodayDate(),
+    open_weights: true, // Chutes hosts open-weight models
+    ...(hasStructuredOutput && { structured_output: hasStructuredOutput }),
+    ...(knowledge && { knowledge }),
+    ...(interleaved !== undefined && { interleaved }),
+    ...(status && { status }),
+    limit: {
+      context: contextLimit,
+      output: outputLimit,
+    },
+    modalities: {
+      input: inputMods,
+      output: outputMods,
+    },
+  };
+
+  // Cost: API values are already in USD per 1M tokens — use directly
+  if (apiModel.pricing) {
+    const inputPrice = apiModel.pricing.prompt;
+    const outputPrice = apiModel.pricing.completion;
+    const cacheReadPrice = apiModel.pricing.input_cache_read;
+
+    if (inputPrice !== undefined && outputPrice !== undefined) {
+      merged.cost = {
+        input: inputPrice,
+        output: outputPrice,
+        ...(cacheReadPrice !== undefined && { cache_read: cacheReadPrice }),
+      };
+    }
+  }
+
+  return merged;
+}
+
+// ── TOML formatting ──────────────────────────────────────────────────
+
+function formatToml(model: MergedModel): string {
+  const lines: string[] = [];
+
+  lines.push(`# Auto-generated by generate-chutes.ts — do not edit pricing, limits, or capabilities.`);
+  lines.push(`# Manual overrides preserved on re-run: name, family, knowledge, interleaved, status`);
+  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}`);
+  lines.push(`temperature = ${model.temperature}`);
+  lines.push(`tool_call = ${model.tool_call}`);
+  if (model.structured_output !== undefined) {
+    lines.push(`structured_output = ${model.structured_output}`);
+  }
+  lines.push(`open_weights = ${model.open_weights}`);
+  if (model.knowledge) {
+    lines.push(`knowledge = "${model.knowledge}"`);
+  }
+  if (model.status) {
+    lines.push(`status = "${model.status}"`);
+  }
+
+  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}`);
+    }
+  }
+
+  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(", ")}]`);
+
+  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}"`);
+    }
+  }
+
+  return lines.join("\n") + "\n";
+}
+
+// ── Change detection ─────────────────────────────────────────────────
+
+function detectChanges(
+  existing: ExistingModel | null,
+  merged: MergedModel,
+): Changes[] {
+  if (!existing) return [];
+
+  const changes: Changes[] = [];
+  const EPSILON = 0.001;
+
+  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 => {
+    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("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;
+}
+
+// ── Main ─────────────────────────────────────────────────────────────
+
+async function main() {
+  const args = process.argv.slice(2);
+  const dryRun = args.includes("--dry-run");
+  const newOnly = args.includes("--new-only");
+  const keepOrphans = args.includes("--keep-orphans");
+
+  const modelsDir = path.join(
+    import.meta.dirname,
+    "..",
+    "..",
+    "..",
+    "providers",
+    "chutes",
+    "models",
+  );
+
+  console.log(`${dryRun ? "[DRY RUN] " : ""}${newOnly ? "[NEW ONLY] " : ""}${keepOrphans ? "[KEEP ORPHANS] " : ""}Fetching Chutes 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 = ChutesResponse.safeParse(json);
+  if (!parsed.success) {
+    console.error("Invalid API response:", parsed.error.errors);
+    process.exit(1);
+  }
+
+  const apiModels = parsed.data.data;
+
+  // Scan existing TOML files
+  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) {
+    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);
+      const existingContent = await Bun.file(filePath).text();
+      const formatChanged = existingContent !== tomlContent;
+
+      if (changes.length > 0 || formatChanged) {
+        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}`);
+        }
+        if (changes.length === 0 && formatChanged) {
+          console.log(`  (format-only change)`);
+        }
+        console.log("");
+      } else {
+        unchanged++;
+      }
+    }
+  }
+
+  // Handle orphaned files (on disk but not in API)
+  const orphaned: string[] = [];
+  for (const file of existingFiles) {
+    if (!apiModelIds.has(file)) {
+      orphaned.push(file);
+      const orphanPath = path.join(modelsDir, file);
+      if (keepOrphans) {
+        console.log(`Orphaned (kept): ${file}`);
+      } else if (dryRun) {
+        console.log(`[DRY RUN] Would delete: ${file}`);
+      } else {
+        await Bun.file(orphanPath).delete();
+        console.log(`Deleted: ${file}`);
+
+        // Clean up empty parent directories
+        const parentDir = path.dirname(orphanPath);
+        try {
+          const remaining = [];
+          for await (const entry of new Bun.Glob("*").scan({ cwd: parentDir })) {
+            remaining.push(entry);
+          }
+          if (remaining.length === 0) {
+            const { rmdir } = await import("node:fs/promises");
+            await rmdir(parentDir);
+            console.log(`  Removed empty directory: ${path.basename(parentDir)}/`);
+          }
+        } catch {
+          // Directory not empty or other error, ignore
+        }
+      }
+    }
+  }
+
+  console.log("");
+  if (dryRun) {
+    console.log(
+      `Summary: ${created} would be created, ${updated} would be updated, ${unchanged} unchanged, ${orphaned.length} would be deleted`,
+    );
+  } else if (keepOrphans) {
+    console.log(
+      `Summary: ${created} created, ${updated} updated, ${unchanged} unchanged, ${orphaned.length} orphaned (kept)`,
+    );
+  } else {
+    console.log(
+      `Summary: ${created} created, ${updated} updated, ${unchanged} unchanged, ${orphaned.length} deleted`,
+    );
+  }
+}
+
+await main();

packages/core/script/generate-databricks.ts

@@ -0,0 +1,287 @@
+#!/usr/bin/env bun
+
+/**
+ * Generates Databricks model TOML files from the Foundation Model API endpoint.
+ *
+ * Each Databricks endpoint exposes a model from another provider (Anthropic,
+ * OpenAI, Google, etc.), so the generated TOML uses [extends] to inherit
+ * canonical metadata from that upstream provider's TOML in models.dev.
+ *
+ * Usage:
+ *   DATABRICKS_HOST=<host> DATABRICKS_TOKEN=<pat> bun run databricks:generate
+ *   bun run databricks:generate --workspace <host> --token <pat>
+ *
+ * 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, readFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+
+const args = process.argv.slice(2);
+const flag = (name: string) => {
+  const i = args.indexOf(`--${name}`);
+  return i !== -1 ? args[i + 1] : undefined;
+};
+const dryRun = args.includes("--dry-run");
+const newOnly = args.includes("--new-only");
+
+const host = flag("workspace") ?? process.env.DATABRICKS_HOST;
+const token = flag("token") ?? process.env.DATABRICKS_TOKEN;
+
+if (!host || !token) {
+  console.error(
+    "Usage: DATABRICKS_HOST=<host> DATABRICKS_TOKEN=<pat> bun run databricks:generate",
+  );
+  process.exit(1);
+}
+
+const workspace = host.replace(/^https?:\/\//, "").replace(/\/$/, "");
+const PROVIDERS_DIR = path.join(import.meta.dirname, "..", "..", "..", "providers");
+const MODELS_DIR = path.join(PROVIDERS_DIR, "databricks", "models");
+
+// ---------------------------------------------------------------------------
+// API schemas
+// ---------------------------------------------------------------------------
+
+const FoundationModel = z
+  .object({
+    ai_gateway_v2_supported: z.boolean().optional(),
+    api_types: z.array(z.string()).optional(),
+  })
+  .passthrough();
+
+const ServedEntity = z
+  .object({
+    foundation_model: FoundationModel.optional(),
+  })
+  .passthrough();
+
+const Endpoint = z
+  .object({
+    name: z.string(),
+    config: z
+      .object({
+        served_entities: z.array(ServedEntity).optional(),
+      })
+      .passthrough()
+      .optional(),
+  })
+  .passthrough();
+
+const FoundationModelsResponse = z
+  .object({
+    endpoints: z.array(Endpoint),
+  })
+  .passthrough();
+
+// ---------------------------------------------------------------------------
+// Canonical resolution: map a Databricks endpoint name to a models.dev entry
+// ---------------------------------------------------------------------------
+
+const PREFIX_TO_PROVIDER: [string, string][] = [
+  ["claude-", "anthropic"],
+  ["gpt-", "openai"],
+  ["gemini-", "google"],
+  ["mistral-", "mistral"],
+  ["mixtral-", "mistral"],
+];
+
+type Resolution =
+  | { type: "extends"; from: string }
+  | { type: "inline"; content: string }
+  | null;
+
+async function resolveCanonical(endpointName: string): Promise<Resolution> {
+  const bare = endpointName.replace(/^databricks-/, "");
+
+  // Models in provider subdirectories (e.g. openrouter/openai/gpt-oss-*)
+  // can't use [extends] (schema requires provider/model format), so inline.
+  if (bare.startsWith("gpt-oss-")) {
+    const p = path.join(PROVIDERS_DIR, "openrouter", "models", "openai", `${bare}.toml`);
+    if (existsSync(p)) {
+      return { type: "inline", content: await readFile(p, "utf8") };
+    }
+  }
+
+  // Meta Llama: "meta-llama-3-3-70b-instruct" → "llama-3.3-70b-instruct"
+  if (bare.startsWith("meta-llama-") || bare.startsWith("llama-")) {
+    const llamaId = bare
+      .replace(/^meta-llama-/, "llama-")
+      .replace(/^(llama-\d+)-(\d+)-/, "$1.$2-");
+    const p = path.join(PROVIDERS_DIR, "llama", "models", `${llamaId}.toml`);
+    if (existsSync(p)) return { type: "extends", from: `llama/${llamaId}` };
+  }
+
+  for (const [prefix, provider] of PREFIX_TO_PROVIDER) {
+    if (!bare.startsWith(prefix)) continue;
+
+    const exact = path.join(PROVIDERS_DIR, provider, "models", `${bare}.toml`);
+    if (existsSync(exact)) return { type: "extends", from: `${provider}/${bare}` };
+
+    // Try with hyphens-as-dots in version (e.g. gpt-5-4 → gpt-5.4)
+    const dotted = bare.replace(/^((?:[a-z]+-)+\d+)-(\d)/, "$1.$2");
+    if (dotted !== bare) {
+      const dottedExact = path.join(PROVIDERS_DIR, provider, "models", `${dotted}.toml`);
+      if (existsSync(dottedExact)) return { type: "extends", from: `${provider}/${dotted}` };
+    }
+
+    // Fuzzy: longest filename that shares a prefix with bare or its dotted form
+    const candidates = [bare, ...(dotted !== bare ? [dotted] : [])];
+    const files: string[] = [];
+    try {
+      for await (const f of new Bun.Glob("*.toml").scan({
+        cwd: path.join(PROVIDERS_DIR, provider, "models"),
+      })) {
+        files.push(f);
+      }
+    } catch {
+      // provider directory may not exist
+    }
+    const match = files
+      .map((f) => f.replace(/\.toml$/, ""))
+      .filter((id) => candidates.some((c) => id.startsWith(c) || c.startsWith(id)))
+      .sort((a, b) => b.length - a.length)[0];
+    if (match) return { type: "extends", from: `${provider}/${match}` };
+  }
+
+  return null;
+}
+
+function formatToml(resolution: Resolution, endpointName: string): string {
+  if (resolution?.type === "extends") {
+    return `[extends]\nfrom = "${resolution.from}"\n`;
+  }
+  if (resolution?.type === "inline") {
+    return resolution.content;
+  }
+  return `# TODO: fill in details for ${endpointName}\nname = "${endpointName}"\n`;
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+const IGNORE_PREFIXES = [
+  "databricks-llama-",
+  "databricks-meta-llama-",
+  "databricks-qwen",
+  "databricks-gemma-",
+];
+
+async function main() {
+  console.log(
+    `${dryRun ? "[DRY RUN] " : ""}${newOnly ? "[NEW ONLY] " : ""}Fetching Databricks foundation-models...`,
+  );
+
+  const url = `https://${workspace}/api/2.0/serving-endpoints:foundation-models`;
+  const res = await fetch(url, {
+    headers: { Authorization: `Bearer ${token}` },
+  });
+  if (!res.ok) {
+    console.error(`Failed to fetch API: ${res.status} ${res.statusText}`);
+    console.error(await res.text().catch(() => ""));
+    process.exit(1);
+  }
+
+  const json = await res.json();
+  const parsed = FoundationModelsResponse.safeParse(json);
+  if (!parsed.success) {
+    console.error("Invalid API response:", parsed.error.errors);
+    process.exit(1);
+  }
+
+  const endpoints = parsed.data.endpoints.filter(
+    (e) =>
+      !IGNORE_PREFIXES.some((p) => e.name.startsWith(p)) &&
+      e.config?.served_entities?.some(
+        (se) =>
+          se.foundation_model?.ai_gateway_v2_supported === true &&
+          se.foundation_model?.api_types?.includes("mlflow/v1/chat/completions"),
+      ),
+  );
+
+  const existingFiles = new Set<string>();
+  try {
+    for await (const f of new Bun.Glob("*.toml").scan({ cwd: MODELS_DIR })) {
+      existingFiles.add(f);
+    }
+  } catch {
+    // directory may not exist yet
+  }
+
+  console.log(
+    `Found ${endpoints.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 ep of endpoints) {
+    const filename = `${ep.name}.toml`;
+    apiModelIds.add(filename);
+    const filePath = path.join(MODELS_DIR, filename);
+
+    const resolution = await resolveCanonical(ep.name);
+    const newContent = formatToml(resolution, ep.name);
+    const tag = resolution?.type === "extends" ? `extends ${resolution.from}` : resolution?.type ?? "stub";
+
+    const existed = existsSync(filePath);
+    if (!existed) {
+      created++;
+      if (dryRun) {
+        console.log(`[DRY RUN] Would create: ${filename}  →  ${tag}`);
+      } else {
+        await mkdir(MODELS_DIR, { recursive: true });
+        await Bun.write(filePath, newContent);
+        console.log(`Created: ${filename}  →  ${tag}`);
+      }
+      continue;
+    }
+
+    if (newOnly) {
+      unchanged++;
+      continue;
+    }
+
+    const existingContent = await readFile(filePath, "utf8");
+    if (existingContent === newContent) {
+      unchanged++;
+      continue;
+    }
+
+    updated++;
+    if (dryRun) {
+      console.log(`[DRY RUN] Would update: ${filename}  →  ${tag}`);
+    } else {
+      await Bun.write(filePath, newContent);
+      console.log(`Updated: ${filename}  →  ${tag}`);
+    }
+  }
+
+  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-digitalocean.ts

@@ -0,0 +1,732 @@
+#!/usr/bin/env bun
+
+/**
+ * Generates DigitalOcean model TOML files from two public APIs:
+ *
+ *   - https://api.digitalocean.com/v2/gen-ai/models   (model metadata, lifecycle, modalities, limits)
+ *   - https://www.digitalocean.com/api/static-content/v1/products  (pricing, including >200k tiers)
+ *
+ * The v2 models API requires a DigitalOcean personal access token or model access key,
+ * read from the DIGITALOCEAN_API_TOKEN environment variable (or --api-key flag).
+ * The static-content pricing API is public and requires no auth.
+ *
+ * Cache pricing (cache_read, cache_write) is NOT available from any DO API and is
+ * preserved from existing TOML files when present.
+ *
+ * Fields the APIs cannot provide (preserved from existing TOMLs, never overwritten):
+ *   family, knowledge, open_weights, interleaved, attachment, release_date,
+ *   cache_read, cache_write
+ *
+ * Flags:
+ *   --dry-run   Preview changes without writing files
+ *   --new-only  Only create new models, skip updating existing ones
+ *   --api-key=<key>  DigitalOcean API key (overrides DIGITALOCEAN_API_TOKEN env var)
+ */
+
+import { z } from "zod";
+import path from "node:path";
+import { mkdir } from "node:fs/promises";
+import { ModelFamilyValues } from "../src/family.js";
+
+const MODELS_API = "https://api.digitalocean.com/v2/gen-ai/models";
+const PRICING_API = "https://www.digitalocean.com/api/static-content/v1/products";
+
+// ---------------------------------------------------------------------------
+// v2 models API schema
+// ---------------------------------------------------------------------------
+
+const DoModel = z
+  .object({
+    id: z.string(),
+    name: z.string(),
+    lifecycle_status: z.string(),
+    type: z.string().optional(),
+    thinking: z.boolean().optional(),
+    context_window: z.union([z.number(), z.string()]).optional(),
+    modalities: z
+      .object({
+        input: z.array(z.string()).optional(),
+        output: z.array(z.string()).optional(),
+      })
+      .optional(),
+    settings: z
+      .array(
+        z.object({
+          name: z.string(),
+          max: z.number().optional(),
+          default_value: z.number().optional(),
+        }),
+      )
+      .optional(),
+    created_at: z.string().optional(),
+  })
+  .passthrough();
+
+const DoModelsResponse = z
+  .object({
+    models: z.array(DoModel),
+  })
+  .passthrough();
+
+// ---------------------------------------------------------------------------
+// static-content pricing API schema
+// ---------------------------------------------------------------------------
+
+const PricingEntry = z
+  .object({
+    name: z.string(),
+    slug: z.string(),
+    model: z.string(),
+    prompt_tokens: z.string().optional(), // "≤200k" | ">200k" | undefined
+    price: z.object({ rate: z.number() }),
+  })
+  .passthrough();
+
+const StaticContentResponse = z
+  .object({
+    gradient: z.object({
+      models: z.array(PricingEntry),
+    }),
+  })
+  .passthrough();
+
+// ---------------------------------------------------------------------------
+// Derived pricing map
+// ---------------------------------------------------------------------------
+
+interface ModelPricing {
+  input: number;
+  output: number;
+  inputOver200k?: number;
+  outputOver200k?: number;
+}
+
+// Map marketing names from /v1/products to API model IDs from /v2/gen-ai/models.
+// The pricing API uses display names, not the machine IDs, so this table is the
+// join key. Add entries here when DO adds new models with tiered pricing.
+const PRICING_NAME_MAP: Record<string, string> = {
+  // Anthropic
+  "claude sonnet 4.6": "anthropic-claude-4.6-sonnet",
+  "claude sonnet 4.5": "anthropic-claude-4.5-sonnet",
+  "claude sonnet 4": "anthropic-claude-sonnet-4",
+  "claude haiku 4.5": "anthropic-claude-haiku-4.5",
+  "claude opus 4.6": "anthropic-claude-opus-4.6",
+  "claude opus 4.5": "anthropic-claude-opus-4.5",
+  "claude opus 4.1": "anthropic-claude-4.1-opus",
+  "claude opus 4": "anthropic-claude-opus-4",
+  // OpenAI
+  "gpt-5.4": "openai-gpt-5.4",
+  "gpt-5.4 mini": "openai-gpt-5.4-mini",
+  "gpt-5.4 nano": "openai-gpt-5.4-nano",
+  "gpt-5.4 pro": "openai-gpt-5.4-pro",
+  "gpt-5.3-codex": "openai-gpt-5.3-codex",
+  "gpt-5.2": "openai-gpt-5.2",
+  "gpt-5.2 pro": "openai-gpt-5.2-pro",
+  "gpt-5.1-codex-max": "openai-gpt-5.1-codex-max",
+  "gpt-5": "openai-gpt-5",
+  "gpt-5 mini": "openai-gpt-5-mini",
+  "gpt-5 nano": "openai-gpt-5-nano",
+  "gpt-4.1": "openai-gpt-4.1",
+  "gpt image 1": "openai-gpt-image-1",
+  "gpt image 1.5": "openai-gpt-image-1.5",
+  "gpt-oss-120b": "openai-gpt-oss-120b",
+  "gpt-oss-20b": "openai-gpt-oss-20b",
+  "gpt-4o": "openai-gpt-4o",
+  "gpt-4o mini": "openai-gpt-4o-mini",
+  "o1": "openai-o1",
+  "o3-mini": "openai-o3-mini",
+  // DeepSeek
+  "deepseek r1 distill llama 70b": "deepseek-r1-distill-llama-70b",
+  // Llama
+  "llama 3.3 70b": "llama3.3-70b-instruct",
+  // DO-hosted
+  "qwen3-32b": "alibaba-qwen3-32b",
+  "minimax m2.5 (public preview)": "minimax-m2.5",
+  "kimi k2.5": "kimi-k2.5",
+  "nvidia nemotron 3 super 120b (public preview)": "nvidia-nemotron-3-super-120b",
+  "glm 5": "glm-5",
+};
+
+function normalizeDisplayName(raw: string): string {
+  // Strip " Input Tokens" / " Output Tokens" suffix and lowercase
+  return raw
+    .replace(/\s+(input|output)\s+tokens$/i, "")
+    .trim()
+    .toLowerCase();
+}
+
+function buildPricingMap(entries: z.infer<typeof PricingEntry>[]): Map<string, ModelPricing> {
+  const map = new Map<string, ModelPricing>();
+
+  for (const entry of entries) {
+    const displayName = normalizeDisplayName(entry.name);
+    const modelId = PRICING_NAME_MAP[displayName];
+    if (!modelId) continue;
+
+    const isInput = entry.name.toLowerCase().includes("input tokens");
+    const isOver200k = entry.prompt_tokens === ">200k";
+    // Round to avoid float noise (e.g. 0.9900000000000001)
+    const rate = Math.round(entry.price.rate * 10000) / 10000;
+
+    const existing = map.get(modelId) ?? ({} as ModelPricing);
+
+    if (isInput && isOver200k) existing.inputOver200k = rate;
+    else if (!isInput && isOver200k) existing.outputOver200k = rate;
+    else if (isInput) existing.input = rate;
+    else existing.output = rate;
+
+    map.set(modelId, existing);
+  }
+
+  return map;
+}
+
+// ---------------------------------------------------------------------------
+// Existing TOML shape (fields we read and may preserve)
+// ---------------------------------------------------------------------------
+
+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;
+    context_over_200k?: {
+      input?: number;
+      output?: number;
+      cache_read?: number;
+      cache_write?: number;
+      context_min?: number;
+    };
+    tiers?: Array<{
+      tier: {
+        type?: "context";
+        size: number;
+      };
+      input?: number;
+      output?: number;
+      cache_read?: number;
+      cache_write?: number;
+    }>;
+  };
+  limit?: {
+    context?: number;
+    input?: number;
+    output?: number;
+  };
+  modalities?: {
+    input?: string[];
+    output?: string[];
+  };
+}
+
+async function loadExisting(filePath: string): Promise<ExistingModel | null> {
+  const file = Bun.file(filePath);
+  if (!(await file.exists())) return null;
+  try {
+    const mod = await import(filePath, { with: { type: "toml" } });
+    return mod.default as ExistingModel;
+  } catch (e) {
+    console.warn(`Warning: failed to parse ${filePath}:`, e);
+    return null;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Merged model shape (what we write)
+// ---------------------------------------------------------------------------
+
+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;
+    context_over_200k?: {
+      input: number;
+      output: number;
+      cache_read?: number;
+      cache_write?: number;
+      context_min?: number;
+    };
+  };
+  limit: {
+    context: number;
+    output: number;
+  };
+  modalities: {
+    input: string[];
+    output: string[];
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+const VALID_INPUT_MODALITIES = new Set(["text", "audio", "image", "video", "pdf"]);
+const VALID_OUTPUT_MODALITIES = new Set(["text", "audio", "image", "video", "pdf"]);
+
+function filterInputModalities(raw: string[]): string[] {
+  return raw.filter((m) => VALID_INPUT_MODALITIES.has(m));
+}
+
+function filterOutputModalities(raw: string[]): string[] {
+  // "code" is not a valid modality in the schema — map to "text"
+  return [...new Set(raw.map((m) => (m === "code" ? "text" : m)).filter((m) => VALID_OUTPUT_MODALITIES.has(m)))];
+}
+
+function getTodayDate(): string {
+  return new Date().toISOString().slice(0, 10);
+}
+
+function formatNumber(n: number): string {
+  return n >= 1000 ? n.toString().replace(/\B(?=(\d{3})+(?!\d))/g, "_") : n.toString();
+}
+
+function inferFamily(modelId: string, modelName: string): string | undefined {
+  const sorted = [...ModelFamilyValues].sort((a, b) => b.length - a.length);
+  const targets = [modelId.toLowerCase(), modelName.toLowerCase()];
+  for (const family of sorted) {
+    const f = family.toLowerCase();
+    for (const t of targets) {
+      if (t.includes(f)) return family;
+    }
+  }
+  return undefined;
+}
+
+function getExistingLongContextCost(existing: ExistingModel | null) {
+  const tier = existing?.cost?.tiers?.find(
+    (tier) =>
+      (tier.tier.type === undefined || tier.tier.type === "context") &&
+      tier.tier.size >= 200_000,
+  );
+  if (tier) {
+    return {
+      ...tier,
+      context_min: tier.tier.size,
+    };
+  }
+
+  return existing?.cost?.context_over_200k === undefined
+    ? undefined
+    : {
+        ...existing.cost.context_over_200k,
+        context_min: 200_000,
+      };
+}
+
+function getLongContextMin(cost: { context_min?: number }) {
+  return cost.context_min ?? 200_000;
+}
+
+function formatInlineNumber(n: number): string {
+  return n >= 1000 ? n.toString().replace(/\B(?=(\d{3})+(?!\d))/g, "_") : n.toString();
+}
+
+// ---------------------------------------------------------------------------
+// Merge API data with existing TOML
+// ---------------------------------------------------------------------------
+
+function mergeModel(
+  apiModel: z.infer<typeof DoModel>,
+  pricing: ModelPricing | undefined,
+  existing: ExistingModel | null,
+): MergedModel {
+  const rawInput = apiModel.modalities?.input ?? [];
+  const rawOutput = apiModel.modalities?.output ?? [];
+  const inputMods = filterInputModalities(rawInput.length > 0 ? rawInput : existing?.modalities?.input ?? ["text"]);
+  const outputMods = filterOutputModalities(rawOutput.length > 0 ? rawOutput : existing?.modalities?.output ?? ["text"]);
+
+  const maxTokensSetting = apiModel.settings?.find((s) => s.name === "max_tokens");
+  const maxTokens = maxTokensSetting?.max ?? existing?.limit?.output ?? 0;
+
+  const rawContext = apiModel.context_window;
+  const contextWindow =
+    rawContext !== undefined
+      ? typeof rawContext === "string"
+        ? parseInt(rawContext, 10)
+        : rawContext
+      : (existing?.limit?.context ?? 0);
+
+  const isDeprecated = apiModel.lifecycle_status === "end_of_life";
+
+  // Fields preserved from existing TOML (APIs don't provide these)
+  const family = existing?.family ?? inferFamily(apiModel.id, apiModel.name);
+  const knowledge = existing?.knowledge;
+  const openWeights = existing?.open_weights ?? false;
+  const interleaved = existing?.interleaved;
+  const attachment = existing?.attachment ?? inputMods.some((m) => m !== "text");
+
+  // reasoning: trust existing if set, else use API thinking flag as a hint
+  // (thinking flag is unreliable for non-LLM models so gate on output modality)
+  const isTextOutput = outputMods.includes("text") && !outputMods.includes("image") && !outputMods.includes("video");
+  const reasoning = existing?.reasoning ?? (isTextOutput && (apiModel.thinking ?? false));
+
+  // tool_call: no API signal, preserve existing or default true for text models
+  const toolCall = existing?.tool_call ?? isTextOutput;
+
+  // temperature: no API signal, preserve or default true
+  const temperature = existing?.temperature ?? true;
+
+  // structured_output: no API signal, preserve only
+  const structuredOutput = existing?.structured_output;
+
+  const releaseDate = existing?.release_date ?? apiModel.created_at?.slice(0, 10) ?? getTodayDate();
+
+  const merged: MergedModel = {
+    name: apiModel.name,
+    family,
+    attachment,
+    reasoning,
+    tool_call: toolCall,
+    temperature,
+    release_date: releaseDate,
+    last_updated: getTodayDate(),
+    open_weights: openWeights,
+    ...(structuredOutput !== undefined && { structured_output: structuredOutput }),
+    ...(knowledge && { knowledge }),
+    ...(interleaved !== undefined && { interleaved }),
+    ...(isDeprecated && { status: "deprecated" }),
+    limit: { context: contextWindow, output: maxTokens },
+    modalities: { input: inputMods, output: outputMods },
+  };
+
+  // Pricing: static-content API is the sole source of truth for prices.
+  // The v2 models API pricing is intentionally ignored. If a model has no
+  // entry in the static-content API, preserve existing TOML prices.
+  const inputPrice = pricing?.input ?? existing?.cost?.input;
+  const outputPrice = pricing?.output ?? existing?.cost?.output;
+
+  if (inputPrice !== undefined && outputPrice !== undefined) {
+    merged.cost = {
+      input: inputPrice,
+      output: outputPrice,
+      // Always preserve cache pricing — not available from any DO API
+      ...(existing?.cost?.cache_read !== undefined && { cache_read: existing.cost.cache_read }),
+      ...(existing?.cost?.cache_write !== undefined && { cache_write: existing.cost.cache_write }),
+    };
+
+    // Context-tiered pricing (>200k) from the static-content API
+    const existingLongContextCost = getExistingLongContextCost(existing);
+    if (pricing?.inputOver200k !== undefined && pricing?.outputOver200k !== undefined) {
+      merged.cost.context_over_200k = {
+        input: pricing.inputOver200k,
+        output: pricing.outputOver200k,
+        context_min: existingLongContextCost?.context_min ?? 200_000,
+        ...(existingLongContextCost?.cache_read !== undefined && {
+          cache_read: existingLongContextCost.cache_read,
+        }),
+        ...(existingLongContextCost?.cache_write !== undefined && {
+          cache_write: existingLongContextCost.cache_write,
+        }),
+      };
+    } else if (existingLongContextCost) {
+      // Preserve manually-entered tiered pricing if API has no data
+      merged.cost.context_over_200k = {
+        input: existingLongContextCost.input ?? inputPrice,
+        output: existingLongContextCost.output ?? outputPrice,
+        context_min: existingLongContextCost.context_min,
+        ...(existingLongContextCost.cache_read !== undefined && {
+          cache_read: existingLongContextCost.cache_read,
+        }),
+        ...(existingLongContextCost.cache_write !== undefined && {
+          cache_write: existingLongContextCost.cache_write,
+        }),
+      };
+    }
+  }
+
+  return merged;
+}
+
+// ---------------------------------------------------------------------------
+// TOML serialiser
+// ---------------------------------------------------------------------------
+
+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}`);
+  lines.push(`temperature = ${model.temperature}`);
+  lines.push(`tool_call = ${model.tool_call}`);
+  if (model.structured_output !== undefined) lines.push(`structured_output = ${model.structured_output}`);
+  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 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}`);
+
+    if (model.cost.context_over_200k) {
+      lines.push("");
+      lines.push(`[[cost.tiers]]`);
+      lines.push(`tier = { size = ${formatInlineNumber(getLongContextMin(model.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}`);
+    }
+  }
+
+  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";
+}
+
+// ---------------------------------------------------------------------------
+// Change detection
+// ---------------------------------------------------------------------------
+
+interface Change {
+  field: string;
+  oldValue: string;
+  newValue: string;
+}
+
+function formatValue(val: unknown): string {
+  if (val === undefined) return "(none)";
+  if (Array.isArray(val)) return `[${val.join(", ")}]`;
+  if (typeof val === "number") return formatNumber(val);
+  return String(val);
+}
+
+function detectChanges(existing: ExistingModel | null, merged: MergedModel): Change[] {
+  if (!existing) return [];
+
+  const changes: Change[] = [];
+  const EPSILON = 0.001;
+
+  const compare = (field: string, oldVal: unknown, newVal: unknown) => {
+    if (oldVal === undefined && newVal === undefined) return;
+    const isDiff = field.startsWith("cost.")
+      ? Math.abs((oldVal as number ?? 0) - (newVal as number ?? 0)) > EPSILON
+      : JSON.stringify(oldVal) !== JSON.stringify(newVal);
+    if (isDiff) changes.push({ field, oldValue: formatValue(oldVal), newValue: formatValue(newVal) });
+  };
+
+  compare("name", existing.name, merged.name);
+  compare("reasoning", existing.reasoning, merged.reasoning);
+  compare("tool_call", existing.tool_call, merged.tool_call);
+  compare("attachment", existing.attachment, merged.attachment);
+  compare("status", existing.status, merged.status);
+  compare("cost.input", existing.cost?.input, merged.cost?.input);
+  compare("cost.output", existing.cost?.output, merged.cost?.output);
+  const existingLongContextCost = getExistingLongContextCost(existing);
+  compare("cost.context_over_200k.input", existingLongContextCost?.input, merged.cost?.context_over_200k?.input);
+  compare("cost.context_over_200k.output", existingLongContextCost?.output, merged.cost?.context_over_200k?.output);
+  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;
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+async function main() {
+  const args = process.argv.slice(2);
+  const dryRun = args.includes("--dry-run");
+  const newOnly = args.includes("--new-only");
+
+  // Resolve API key
+  const apiKeyArg = args.find((a) => a.startsWith("--api-key"));
+  const apiKey =
+    (apiKeyArg?.includes("=") ? apiKeyArg.split("=")[1] : args[args.indexOf(apiKeyArg!) + 1]) ??
+    process.env.DIGITALOCEAN_API_TOKEN;
+
+  if (!apiKey) {
+    console.error("Error: DIGITALOCEAN_API_TOKEN is required (or pass --api-key=<key>)");
+    console.error("Get one from: https://cloud.digitalocean.com/account/api/tokens");
+    process.exit(1);
+  }
+
+  const modelsDir = path.join(import.meta.dirname, "..", "..", "..", "providers", "digitalocean", "models");
+
+  const prefix = dryRun ? "[DRY RUN] " : "";
+  console.log(`${prefix}Fetching DigitalOcean models from API...`);
+
+  // Fetch both APIs in parallel
+  const [modelsRes, pricingRes] = await Promise.all([
+    fetch(MODELS_API, { headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" } }),
+    fetch(PRICING_API, { headers: { "User-Agent": "models.dev/digitalocean-sync" } }),
+  ]);
+
+  if (!modelsRes.ok) {
+    console.error(`Failed to fetch models API: ${modelsRes.status} ${modelsRes.statusText}`);
+    if (modelsRes.status === 401 || modelsRes.status === 403)
+      console.error("Check your DIGITALOCEAN_API_TOKEN has read access.");
+    process.exit(1);
+  }
+
+  if (!pricingRes.ok) {
+    console.error(`Failed to fetch pricing API: ${pricingRes.status} ${pricingRes.statusText}`);
+    process.exit(1);
+  }
+
+  const modelsParsed = DoModelsResponse.safeParse(await modelsRes.json());
+  if (!modelsParsed.success) {
+    console.error("Unexpected models API response:", modelsParsed.error.errors);
+    process.exit(1);
+  }
+
+  const pricingParsed = StaticContentResponse.safeParse(await pricingRes.json());
+  if (!pricingParsed.success) {
+    console.error("Unexpected pricing API response:", pricingParsed.error.errors);
+    process.exit(1);
+  }
+
+  const apiModels = modelsParsed.data.models;
+  const pricingMap = buildPricingMap(pricingParsed.data.gradient.models);
+
+  // Collect existing TOML filenames for orphan detection
+  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 TOML files\n`);
+
+  const apiModelFiles = new Set<string>();
+  let created = 0;
+  let updated = 0;
+  let unchanged = 0;
+
+  for (const apiModel of apiModels) {
+    // Skip non-text models that opencode can't use: image, video, audio, embedding, reranking
+    const outputMods = filterOutputModalities(apiModel.modalities?.output ?? []);
+    const isTextModel = outputMods.includes("text");
+    const isEmbedding = apiModel.type === "embedding";
+    const isReranking = apiModel.type === "reranking";
+    if (!isTextModel || isEmbedding || isReranking) continue;
+
+    // Model IDs may contain slashes (e.g. fal-ai/flux/schnell) — use as subpath
+    const relativePath = `${apiModel.id}.toml`;
+    const filePath = path.join(modelsDir, relativePath);
+    const dirPath = path.dirname(filePath);
+
+    apiModelFiles.add(relativePath);
+
+    const existing = await loadExisting(filePath);
+    const pricing = pricingMap.get(apiModel.id);
+    const merged = mergeModel(apiModel, pricing, existing);
+    const toml = formatToml(merged);
+
+    if (existing === null) {
+      created++;
+      if (dryRun) {
+        console.log(`[DRY RUN] Would create: ${relativePath}`);
+        console.log(`  name = "${merged.name}"`);
+        if (pricing) console.log(`  pricing: $${merged.cost?.input}/$${merged.cost?.output} per M tokens`);
+        if (merged.family) console.log(`  family = "${merged.family}" (inferred)`);
+        console.log("");
+      } else {
+        await mkdir(dirPath, { recursive: true });
+        await Bun.write(filePath, toml);
+        console.log(`Created: ${relativePath}`);
+      }
+      continue;
+    }
+
+    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, toml);
+        console.log(`Updated: ${relativePath}`);
+      }
+      for (const c of changes) console.log(`  ${c.field}: ${c.oldValue} → ${c.newValue}`);
+      console.log("");
+    } else {
+      unchanged++;
+    }
+  }
+
+  // Orphan detection: files in the TOML directory but not in the API
+  const orphaned: string[] = [];
+  for (const file of existingFiles) {
+    if (!apiModelFiles.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-venice.ts

@@ -162,7 +162,18 @@ interface ExistingModel {
       output?: number;
       cache_read?: number;
       cache_write?: number;
+      context_min?: number;
     };
+    tiers?: Array<{
+      tier: {
+        type?: "context";
+        size: number;
+      };
+      input?: number;
+      output?: number;
+      cache_read?: number;
+      cache_write?: number;
+    }>;
   };
   limit?: {
     context?: number;
@@ -195,6 +206,30 @@ async function loadExistingModel(filePath: string): Promise<ExistingModel | null
   }
 }
 
+function getExistingLongContextMin(existing: ExistingModel | null) {
+  return (
+    existing?.cost?.tiers?.find(
+      (tier) =>
+        (tier.tier.type === undefined || tier.tier.type === "context") &&
+        tier.tier.size >= 200_000,
+    )?.tier.size ?? 200_000
+  );
+}
+
+function getExistingLongContextCost(existing: ExistingModel | null) {
+  return (
+    existing?.cost?.tiers?.find(
+      (tier) =>
+        (tier.tier.type === undefined || tier.tier.type === "context") &&
+        tier.tier.size >= 200_000,
+    ) ?? existing?.cost?.context_over_200k
+  );
+}
+
+function getLongContextMin(cost: { context_min?: number }) {
+  return cost.context_min ?? 200_000;
+}
+
 interface MergedModel {
   name: string;
   family?: string;
@@ -219,6 +254,7 @@ interface MergedModel {
       output: number;
       cache_read?: number;
       cache_write?: number;
+      context_min?: number;
     };
   };
   limit: {
@@ -292,6 +328,7 @@ function mergeModel(
       merged.cost.context_over_200k = {
         input: spec.pricing.extended.input.usd,
         output: spec.pricing.extended.output.usd,
+        context_min: spec.pricing.extended.context_token_threshold,
         ...(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 }),
       };
@@ -366,7 +403,8 @@ function formatToml(model: MergedModel): string {
 
     if (model.cost.context_over_200k) {
       lines.push("");
-      lines.push(`[cost.context_over_200k]`);
+      lines.push(`[[cost.tiers]]`);
+      lines.push(`tier = { size = ${formatNumber(getLongContextMin(model.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) {
@@ -438,10 +476,11 @@ 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);
+  const existingLongContextCost = getExistingLongContextCost(existing);
+  compare("cost.context_over_200k.input", existingLongContextCost?.input, merged.cost?.context_over_200k?.input);
+  compare("cost.context_over_200k.output", existingLongContextCost?.output, merged.cost?.context_over_200k?.output);
+  compare("cost.context_over_200k.cache_read", existingLongContextCost?.cache_read, merged.cost?.context_over_200k?.cache_read);
+  compare("cost.context_over_200k.cache_write", existingLongContextCost?.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);

packages/core/script/sync-models.ts

@@ -0,0 +1,428 @@
+#!/usr/bin/env bun
+
+import path from "node:path";
+import { mkdir, readdir, rm } from "node:fs/promises";
+import { z } from "zod";
+
+import { AuthoredModel, AuthoredModelShape } from "../src/schema.js";
+import { cloudflareWorkersAi } from "./sync/cloudflare-workers-ai.js";
+import { google } from "./sync/google.js";
+import { openrouter } from "./sync/openrouter.js";
+import { xai } from "./sync/xai.js";
+
+const ExistingModel = AuthoredModelShape.partial()
+  .extend({
+    extends: z
+      .object({
+        from: z.string(),
+        omit: z.array(z.string()).optional(),
+      })
+      .strict()
+      .optional(),
+  })
+  .strict();
+
+export type ExistingModel = z.infer<typeof ExistingModel>;
+export type SyncedModel = Omit<z.infer<typeof AuthoredModelShape>, "id">;
+
+export interface SyncProvider<SourceModel> {
+  id: string;
+  name: string;
+  modelsDir: string;
+  skipCreates?: boolean;
+  sourceID?(model: SourceModel): string;
+  skippedNotice?(ids: string[]): string[];
+  fetchModels(): Promise<unknown>;
+  parseModels(raw: unknown): SourceModel[];
+  translateModel(
+    model: SourceModel,
+    context: { existing(id: string): ExistingModel | undefined },
+  ): { id: string; model: SyncedModel } | undefined;
+}
+
+export interface SyncResult {
+  id: string;
+  name: string;
+  status: "changed" | "unchanged";
+  created: number;
+  updated: number;
+  deleted: number;
+  unchanged: number;
+  notices: string[];
+  files: Array<{ status: "created" | "updated" | "deleted"; path: string }>;
+}
+
+export const providers: {
+  "cloudflare-workers-ai": SyncProvider<any>;
+  google: SyncProvider<any>;
+  openrouter: SyncProvider<any>;
+  xai: SyncProvider<any>;
+} = {
+  "cloudflare-workers-ai": cloudflareWorkersAi,
+  google,
+  openrouter,
+  xai,
+};
+
+export const groups = {
+  aggregators: ["openrouter"],
+  cloudflare: ["cloudflare-workers-ai"],
+  direct: ["google", "xai"],
+} as const;
+
+type ProviderID = keyof typeof providers;
+
+interface SyncOptions {
+  dryRun?: boolean;
+  newOnly?: boolean;
+}
+
+export async function syncProviderByID(id: ProviderID, options: SyncOptions = {}) {
+  return syncProvider(providers[id], options);
+}
+
+export async function syncProvider<SourceModel>(
+  provider: SyncProvider<SourceModel>,
+  options: SyncOptions = {},
+): Promise<SyncResult> {
+  console.log(`\nSyncing ${provider.name}...`);
+
+  const existing = await readExisting(provider.modelsDir);
+  const sourceModels = provider.parseModels(await provider.fetchModels());
+  const desired = new Map<string, { model: z.infer<typeof AuthoredModel>; content: string }>();
+  const skippedRemote: string[] = [];
+
+  for (const sourceModel of sourceModels) {
+    const translated = provider.translateModel(sourceModel, {
+      existing(id) {
+        return existing.get(`${id}.toml`)?.toml;
+      },
+    });
+    if (translated === undefined) {
+      if (provider.skipCreates) skippedRemote.push(provider.sourceID?.(sourceModel) ?? "unknown");
+      continue;
+    }
+
+    const relativePath = `${translated.id}.toml`;
+    if (provider.skipCreates && !existing.has(relativePath)) {
+      skippedRemote.push(translated.id);
+      continue;
+    }
+
+    if (desired.has(relativePath)) {
+      throw new Error(`Duplicate synced model path: ${provider.id}/${relativePath}`);
+    }
+
+    const parsed = AuthoredModel.safeParse({
+      id: translated.id,
+      ...translated.model,
+    });
+    if (!parsed.success) {
+      parsed.error.cause = { provider: provider.id, path: relativePath };
+      throw parsed.error;
+    }
+
+    desired.set(relativePath, {
+      model: parsed.data,
+      content: formatToml(parsed.data),
+    });
+  }
+
+  const files: SyncResult["files"] = [];
+  let unchanged = 0;
+
+  for (const [relativePath, file] of desired) {
+    const filePath = path.join(provider.modelsDir, relativePath);
+    const current = existing.get(relativePath);
+
+    if (current === undefined) {
+      files.push({ status: "created", path: filePath });
+      if (options.dryRun) {
+        console.log(`Would create ${relativePath}`);
+      } else {
+        await mkdir(path.dirname(filePath), { recursive: true });
+        await Bun.write(filePath, file.content);
+      }
+      continue;
+    }
+
+    if (!sameModel(relativePath, current.toml, file.model)) {
+      if (options.newOnly) {
+        unchanged++;
+        continue;
+      }
+
+      files.push({ status: "updated", path: filePath });
+      if (options.dryRun) {
+        console.log(`Would update ${relativePath}`);
+      } else {
+        if (current.symlink) await rm(filePath, { force: true });
+        await Bun.write(filePath, file.content);
+      }
+    } else {
+      unchanged++;
+    }
+  }
+
+  for (const relativePath of existing.keys()) {
+    if (desired.has(relativePath)) continue;
+    if (options.newOnly) {
+      console.log(`Skipping removal in new-only mode: ${relativePath}`);
+      unchanged++;
+      continue;
+    }
+
+    const filePath = path.join(provider.modelsDir, relativePath);
+    files.push({ status: "deleted", path: filePath });
+    if (options.dryRun) {
+      console.log(`Would remove ${relativePath}`);
+    } else {
+      await rm(filePath, { force: true });
+    }
+  }
+
+  const result = summarize(provider, files, unchanged, provider.skippedNotice?.(skippedRemote) ?? []);
+  console.log(
+    `${options.dryRun ? "Dry run: " : ""}${result.created} created, ${result.updated} updated, ${result.deleted} removed, ${result.unchanged} unchanged`,
+  );
+  return result;
+}
+
+export async function syncTargets(target: string, options: SyncOptions = {}) {
+  const ids = target in groups
+    ? groups[target as keyof typeof groups]
+    : target in providers
+      ? [target as ProviderID]
+      : undefined;
+
+  if (ids === undefined) {
+    throw new Error(`Unknown sync target: ${target}`);
+  }
+
+  const results: SyncResult[] = [];
+  for (const id of ids) {
+    results.push(await syncProviderByID(id as ProviderID, options));
+  }
+  return results;
+}
+
+async function readExisting(modelsDir: string) {
+  const existing = new Map<string, { text: string; toml: ExistingModel; symlink: boolean }>();
+
+  for (const { file, symlink } of await tomlFiles(modelsDir)) {
+    const text = await Bun.file(path.join(modelsDir, file)).text();
+    const parsed = ExistingModel.safeParse(Bun.TOML.parse(text));
+    if (!parsed.success) {
+      parsed.error.cause = { path: path.join(modelsDir, file) };
+      throw parsed.error;
+    }
+    existing.set(file, { text, toml: parsed.data, symlink });
+  }
+
+  return existing;
+}
+
+async function tomlFiles(root: string, dir = "") {
+  const result: Array<{ file: string; symlink: boolean }> = [];
+
+  for (const entry of await readdir(path.join(root, dir), { withFileTypes: true })) {
+    const file = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      result.push(...await tomlFiles(root, file));
+    } else if (entry.name.endsWith(".toml") && (entry.isFile() || entry.isSymbolicLink())) {
+      result.push({ file, symlink: entry.isSymbolicLink() });
+    }
+  }
+
+  return result;
+}
+
+function summarize(
+  provider: { id: string; name: string },
+  files: SyncResult["files"],
+  unchanged: number,
+  notices: string[],
+): SyncResult {
+  return {
+    id: provider.id,
+    name: provider.name,
+    status: files.length > 0 ? "changed" : "unchanged",
+    created: files.filter((file) => file.status === "created").length,
+    updated: files.filter((file) => file.status === "updated").length,
+    deleted: files.filter((file) => file.status === "deleted").length,
+    unchanged,
+    notices,
+    files,
+  };
+}
+
+function sameModel(
+  relativePath: string,
+  current: ExistingModel,
+  desired: z.infer<typeof AuthoredModel>,
+) {
+  const parsed = AuthoredModel.safeParse({
+    id: relativePath.slice(0, -5),
+    ...current,
+  });
+  return parsed.success && stable(parsed.data) === stable(desired);
+}
+
+function stable(value: unknown): string {
+  if (Array.isArray(value)) {
+    const items = value.map(stable);
+    const ordered = value.every((item) => item === null || typeof item !== "object")
+      ? items.sort()
+      : items;
+    return `[${ordered.join(",")}]`;
+  }
+  if (value !== null && typeof value === "object") {
+    return `{${Object.entries(value)
+      .filter(([, item]) => item !== undefined)
+      .sort(([a], [b]) => a.localeCompare(b))
+      .map(([key, item]) => `${JSON.stringify(key)}:${stable(item)}`)
+      .join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+
+async function writeReport(target: string, results: SyncResult[]) {
+  await mkdir(".sync", { recursive: true });
+
+  const lines = [
+    `Updates model TOMLs for the \`${target}\` sync target.`,
+    "",
+    "| Provider | Status | Created | Updated | Deleted |",
+    "| --- | --- | ---: | ---: | ---: |",
+  ];
+
+  for (const result of results) {
+    lines.push(
+      `| ${result.name} | ${result.status} | ${result.created} | ${result.updated} | ${result.deleted} |`,
+    );
+  }
+
+  for (const result of results.filter((item) => item.files.length > 0)) {
+    lines.push("", `<details><summary>${result.name} changed files</summary>`, "");
+    for (const file of result.files) {
+      lines.push(`- ${file.status}: \`${file.path}\``);
+    }
+    lines.push("", "</details>");
+  }
+
+  const noticeResults = results.filter((item) => item.notices.length > 0);
+  if (noticeResults.length > 0) {
+    lines.push("", "## Notices");
+    for (const result of noticeResults) {
+      lines.push("", `### ${result.name}`);
+      for (const notice of result.notices) {
+        lines.push(`- ${notice}`);
+      }
+    }
+  }
+
+  lines.push("", "This PR was created automatically by the daily model sync workflow.");
+  await Bun.write(".sync/model-sync-report.md", `${lines.join("\n")}\n`);
+}
+
+function quote(value: string) {
+  return `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
+}
+
+function formatInteger(n: number) {
+  return String(n).replace(/\B(?=(\d{3})+(?!\d))/g, "_");
+}
+
+function formatNumber(n: number) {
+  return Number.isInteger(n) ? formatInteger(n) : String(n);
+}
+
+function formatToml(model: z.infer<typeof AuthoredModel>) {
+  const lines: string[] = [];
+
+  lines.push(`name = ${quote(model.name)}`);
+  if (model.family !== undefined) lines.push(`family = ${quote(model.family)}`);
+  lines.push(`release_date = ${quote(model.release_date)}`);
+  lines.push(`last_updated = ${quote(model.last_updated)}`);
+  lines.push(`attachment = ${model.attachment}`);
+  lines.push(`reasoning = ${model.reasoning}`);
+  if (model.temperature !== undefined) lines.push(`temperature = ${model.temperature}`);
+  lines.push(`tool_call = ${model.tool_call}`);
+  if (model.structured_output !== undefined) {
+    lines.push(`structured_output = ${model.structured_output}`);
+  }
+  if (model.knowledge !== undefined) lines.push(`knowledge = ${quote(model.knowledge)}`);
+  lines.push(`open_weights = ${model.open_weights}`);
+  if (model.status !== undefined) lines.push(`status = ${quote(model.status)}`);
+
+  if (model.interleaved !== undefined) {
+    lines.push("");
+    if (model.interleaved === true) {
+      lines.push("interleaved = true");
+    } else {
+      lines.push("[interleaved]");
+      lines.push(`field = ${quote(model.interleaved.field)}`);
+    }
+  }
+
+  if (model.cost !== undefined) {
+    lines.push("", "[cost]");
+    lines.push(`input = ${formatNumber(model.cost.input)}`);
+    lines.push(`output = ${formatNumber(model.cost.output)}`);
+    if (model.cost.reasoning !== undefined) {
+      lines.push(`reasoning = ${formatNumber(model.cost.reasoning)}`);
+    }
+    if (model.cost.cache_read !== undefined) {
+      lines.push(`cache_read = ${formatNumber(model.cost.cache_read)}`);
+    }
+    if (model.cost.cache_write !== undefined) {
+      lines.push(`cache_write = ${formatNumber(model.cost.cache_write)}`);
+    }
+    if (model.cost.input_audio !== undefined) {
+      lines.push(`input_audio = ${formatNumber(model.cost.input_audio)}`);
+    }
+    if (model.cost.output_audio !== undefined) {
+      lines.push(`output_audio = ${formatNumber(model.cost.output_audio)}`);
+    }
+
+    for (const tier of model.cost.tiers ?? []) {
+      lines.push("", "[[cost.tiers]]");
+      lines.push(`tier = { size = ${formatInteger(tier.tier.size)} }`);
+      lines.push(`input = ${formatNumber(tier.input)}`);
+      lines.push(`output = ${formatNumber(tier.output)}`);
+      if (tier.reasoning !== undefined) lines.push(`reasoning = ${formatNumber(tier.reasoning)}`);
+      if (tier.cache_read !== undefined) lines.push(`cache_read = ${formatNumber(tier.cache_read)}`);
+      if (tier.cache_write !== undefined) lines.push(`cache_write = ${formatNumber(tier.cache_write)}`);
+    }
+  }
+
+  lines.push("", "[limit]");
+  lines.push(`context = ${formatInteger(model.limit.context)}`);
+  if (model.limit.input !== undefined) lines.push(`input = ${formatInteger(model.limit.input)}`);
+  lines.push(`output = ${formatInteger(model.limit.output)}`);
+
+  lines.push("", "[modalities]");
+  lines.push(`input = [${model.modalities.input.map(quote).join(", ")}]`);
+  lines.push(`output = [${model.modalities.output.map(quote).join(", ")}]`);
+
+  return `${lines.join("\n")}\n`;
+}
+
+export async function main(args = process.argv.slice(2)) {
+  const target = args.find((arg) => !arg.startsWith("-")) ?? "aggregators";
+  const results = await syncTargets(target, {
+    dryRun: args.includes("--dry-run"),
+    newOnly: args.includes("--new-only"),
+  });
+
+  await writeReport(target, results);
+
+  console.log("\nSync summary");
+  for (const result of results) {
+    console.log(
+      `${result.name}: ${result.created} created, ${result.updated} updated, ${result.deleted} deleted`,
+    );
+  }
+}
+
+if (import.meta.main) await main();

packages/core/script/sync/cloudflare-workers-ai.ts

@@ -0,0 +1,176 @@
+import { z } from "zod";
+
+import type { ExistingModel, SyncProvider } from "../sync-models.js";
+import {
+  buildOpenRouterModel,
+  OpenRouterModel,
+  OpenRouterResponse,
+} from "./openrouter.js";
+
+const API_BASE = "https://api.cloudflare.com/client/v4/accounts";
+
+const CloudflareOpenRouterResponse = z.object({
+  result: z.union([OpenRouterResponse, z.array(OpenRouterModel)]).optional(),
+  result_info: z.object({
+    page: z.number().optional(),
+    total_pages: z.number().optional(),
+  }).passthrough().optional(),
+}).passthrough();
+
+const CloudflareModel = z.object({
+  id: z.string(),
+  name: z.string(),
+  created: z.number(),
+  hugging_face_id: z.string().nullable().optional(),
+  context_length: z.number(),
+  max_output_length: z.number().nullable().optional(),
+  input_modalities: z.array(z.string()).optional(),
+  output_modalities: z.array(z.string()).optional(),
+  pricing: z.object({
+    prompt: z.string(),
+    completion: z.string(),
+    internal_reasoning: z.string().optional(),
+    input_cache_read: z.string().optional(),
+    input_cache_write: z.string().optional(),
+  }),
+  supported_features: z.array(z.string()).optional(),
+  supported_sampling_parameters: z.array(z.string()).optional(),
+}).passthrough();
+
+const CloudflareResponse = z.object({
+  data: z.array(CloudflareModel),
+}).passthrough();
+
+type CloudflareModel = z.infer<typeof CloudflareModel>;
+
+export const cloudflareWorkersAi = {
+  id: "cloudflare-workers-ai",
+  name: "Cloudflare Workers AI",
+  modelsDir: "providers/cloudflare-workers-ai/models",
+  async fetchModels() {
+    const accountID = process.env.CLOUDFLARE_WORKERS_AI_SYNC_ACCOUNT_ID;
+    const token = process.env.CLOUDFLARE_WORKERS_AI_SYNC_API_TOKEN;
+    if (accountID === undefined || token === undefined) {
+      throw new Error(
+        "Cloudflare Workers AI sync requires CLOUDFLARE_WORKERS_AI_SYNC_ACCOUNT_ID and CLOUDFLARE_WORKERS_AI_SYNC_API_TOKEN",
+      );
+    }
+
+    const first = await fetchPage(accountID, token, 1);
+    const models = parseCloudflareModels(first);
+    const pageInfo = CloudflareOpenRouterResponse.safeParse(first).success
+      ? CloudflareOpenRouterResponse.parse(first).result_info
+      : undefined;
+
+    for (let page = 2; page <= (pageInfo?.total_pages ?? 1); page++) {
+      models.push(...parseCloudflareModels(await fetchPage(accountID, token, page)));
+    }
+
+    return { data: models };
+  },
+  parseModels(raw) {
+    return parseCloudflareModels(raw);
+  },
+  translateModel(model, context) {
+    const normalized = normalizeModel(model);
+    const id = normalized.id.replace(/^workers-ai\//, "");
+    return {
+      id,
+      model: buildWorkersAiModel(normalized, context.existing(id)),
+    };
+  },
+} satisfies SyncProvider<CloudflareModel>;
+
+function buildWorkersAiModel(model: z.infer<typeof OpenRouterModel>, existing: ExistingModel | undefined) {
+  const synced = buildOpenRouterModel(model, existing);
+  return {
+    ...synced,
+    name: existing?.name ?? synced.name,
+    release_date: existing?.release_date ?? synced.release_date,
+    last_updated: existing?.last_updated ?? synced.last_updated,
+    limit: {
+      ...synced.limit,
+      output: existing?.limit?.output ?? synced.limit.output,
+    },
+  };
+}
+
+async function fetchPage(accountID: string, token: string, page: number) {
+  const url = new URL(`${API_BASE}/${accountID}/ai/models/search`);
+  url.searchParams.set("format", "openrouter");
+  url.searchParams.set("per_page", "1000");
+  url.searchParams.set("page", String(page));
+
+  const response = await fetch(url, {
+    headers: { Authorization: `Bearer ${token}` },
+  });
+  if (!response.ok) {
+    throw new Error(
+      `Cloudflare Workers AI models request failed: ${response.status} ${response.statusText}${await responseDetails(response)}`,
+    );
+  }
+  return response.json();
+}
+
+function parseCloudflareModels(raw: unknown) {
+  const cloudflare = CloudflareResponse.safeParse(raw);
+  if (cloudflare.success) return cloudflare.data.data;
+
+  const direct = OpenRouterResponse.safeParse(raw);
+  if (direct.success) return direct.data.data;
+
+  const wrapped = CloudflareOpenRouterResponse.parse(raw);
+  if (wrapped.result === undefined) {
+    throw new Error("Cloudflare Workers AI response did not include model data");
+  }
+  return Array.isArray(wrapped.result) ? wrapped.result : wrapped.result.data;
+}
+
+function normalizeModel(model: CloudflareModel) {
+  if ("architecture" in model && "top_provider" in model && "supported_parameters" in model) {
+    return OpenRouterModel.parse(model);
+  }
+
+  return OpenRouterModel.parse({
+    id: model.id.startsWith("@cf/") ? model.id : `@cf/${model.id.replace(/^@cf\//, "")}`,
+    name: model.name,
+    created: model.created,
+    hugging_face_id: model.hugging_face_id ?? null,
+    knowledge_cutoff: null,
+    context_length: model.context_length,
+    architecture: {
+      input_modalities: model.input_modalities ?? ["text"],
+      output_modalities: model.output_modalities ?? ["text"],
+    },
+    pricing: model.pricing,
+    top_provider: {
+      context_length: model.context_length,
+      max_completion_tokens: model.max_output_length ?? null,
+    },
+    supported_parameters: [
+      ...model.supported_sampling_parameters ?? [],
+      ...model.supported_features ?? [],
+    ],
+  });
+}
+
+async function responseDetails(response: Response) {
+  const text = await response.text();
+  if (text.length === 0) return "";
+
+  try {
+    const body = z.object({
+      errors: z.array(z.object({
+        code: z.union([z.string(), z.number()]).optional(),
+        message: z.string().optional(),
+      }).passthrough()).optional(),
+    }).passthrough().parse(JSON.parse(text));
+    const details = body.errors
+      ?.map((error) => [error.code, error.message].filter(Boolean).join(": "))
+      .filter((message) => message.length > 0)
+      .join("; ");
+    return details === undefined || details.length === 0 ? "" : ` (${details})`;
+  } catch {
+    return "";
+  }
+}

packages/core/script/sync/google.ts

@@ -0,0 +1,138 @@
+import { z } from "zod";
+
+import type { ExistingModel, SyncProvider, SyncedModel } from "../sync-models.js";
+
+const API_ENDPOINT = "https://generativelanguage.googleapis.com/v1beta/models";
+
+const GoogleModel = z.object({
+  name: z.string(),
+  baseModelId: z.string().optional(),
+  version: z.string().optional(),
+  displayName: z.string().optional(),
+  description: z.string().optional(),
+  inputTokenLimit: z.number().int().nonnegative(),
+  outputTokenLimit: z.number().int().nonnegative(),
+  supportedGenerationMethods: z.array(z.string()).optional(),
+  temperature: z.number().optional(),
+  topP: z.number().optional(),
+  topK: z.number().optional(),
+  maxTemperature: z.number().optional(),
+  thinking: z.boolean().optional(),
+}).passthrough();
+
+const GoogleResponse = z.object({
+  models: z.array(GoogleModel).optional(),
+  nextPageToken: z.string().optional(),
+}).passthrough();
+
+type GoogleModel = z.infer<typeof GoogleModel>;
+
+export const google = {
+  id: "google",
+  name: "Google",
+  modelsDir: "providers/google/models",
+  skipCreates: true,
+  sourceID(model) {
+    return model.name.replace(/^models\//, "");
+  },
+  skippedNotice(ids) {
+    if (ids.length === 0) return [];
+    return [
+      `${ids.length} Google models returned by the API were not created because the Models API does not provide authoritative modalities, pricing, knowledge cutoff, release date, tool calling, or structured output metadata. Existing models are still updated from API-authoritative fields.`,
+      `Skipped remote IDs: ${ids.map((id) => `\`${id}\``).join(", ")}`,
+    ];
+  },
+  async fetchModels() {
+    const key = process.env.GOOGLE_API_KEY
+      ?? process.env.GEMINI_API_KEY
+      ?? process.env.GOOGLE_GENERATIVE_AI_API_KEY;
+    if (key === undefined) {
+      throw new Error("Google sync requires GOOGLE_API_KEY, GEMINI_API_KEY, or GOOGLE_GENERATIVE_AI_API_KEY");
+    }
+
+    const models: GoogleModel[] = [];
+    let pageToken: string | undefined;
+
+    do {
+      const url = new URL(API_ENDPOINT);
+      url.searchParams.set("key", key);
+      url.searchParams.set("pageSize", "1000");
+      if (pageToken !== undefined) url.searchParams.set("pageToken", pageToken);
+
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new Error(`Google models request failed: ${response.status} ${response.statusText}`);
+      }
+
+      const page = GoogleResponse.parse(await response.json());
+      models.push(...page.models ?? []);
+      pageToken = page.nextPageToken;
+    } while (pageToken !== undefined);
+
+    return { models };
+  },
+  parseModels(raw) {
+    return GoogleResponse.parse(raw).models ?? [];
+  },
+  translateModel(model, context) {
+    const id = model.name.replace(/^models\//, "");
+    const existing = context.existing(id);
+    if (existing === undefined) return undefined;
+
+    return {
+      id,
+      model: buildModel(model, existing),
+    };
+  },
+} satisfies SyncProvider<GoogleModel>;
+
+function buildModel(model: GoogleModel, existing: ExistingModel): SyncedModel {
+  const name = existing.name;
+  const releaseDate = existing.release_date;
+  const lastUpdated = existing.last_updated;
+  const attachment = existing.attachment;
+  const reasoning = existing.reasoning;
+  const toolCall = existing.tool_call;
+  const openWeights = existing.open_weights;
+  const limit = existing.limit;
+  const modalities = existing.modalities;
+
+  if (
+    name === undefined
+    || releaseDate === undefined
+    || lastUpdated === undefined
+    || attachment === undefined
+    || reasoning === undefined
+    || toolCall === undefined
+    || openWeights === undefined
+    || limit === undefined
+    || modalities === undefined
+  ) {
+    throw new Error(`Google model ${model.name} has incomplete local TOML metadata required for sync`);
+  }
+
+  return {
+    name: model.displayName ?? name,
+    family: existing.family,
+    release_date: releaseDate,
+    last_updated: lastUpdated,
+    attachment,
+    reasoning: model.thinking ?? reasoning,
+    temperature: model.temperature !== undefined || model.maxTemperature !== undefined
+      ? true
+      : existing.temperature,
+    tool_call: toolCall,
+    structured_output: existing.structured_output,
+    knowledge: existing.knowledge,
+    open_weights: openWeights,
+    status: existing.status,
+    interleaved: existing.interleaved,
+    cost: existing.cost,
+    limit: {
+      input: limit.input,
+      context: model.inputTokenLimit,
+      output: model.outputTokenLimit,
+    },
+    modalities,
+  };
+}

packages/core/script/sync/openrouter.ts

@@ -0,0 +1,144 @@
+import { z } from "zod";
+
+import { ModelFamilyValues } from "../../src/family.js";
+import type { ExistingModel, SyncProvider } from "../sync-models.js";
+
+const API_ENDPOINT = "https://openrouter.ai/api/v1/models";
+
+export const OpenRouterModel = z.object({
+  id: z.string(),
+  name: z.string(),
+  created: z.number(),
+  hugging_face_id: z.string().nullable(),
+  knowledge_cutoff: z.string().nullable(),
+  context_length: z.number(),
+  architecture: z.object({
+    input_modalities: z.array(z.string()),
+    output_modalities: z.array(z.string()),
+  }),
+  pricing: z.object({
+    prompt: z.string(),
+    completion: z.string(),
+    internal_reasoning: z.string().optional(),
+    input_cache_read: z.string().optional(),
+    input_cache_write: z.string().optional(),
+  }),
+  top_provider: z.object({
+    context_length: z.number().nullable(),
+    max_completion_tokens: z.number().nullable(),
+  }),
+  supported_parameters: z.array(z.string()),
+});
+
+export const OpenRouterResponse = z.object({
+  data: z.array(OpenRouterModel),
+}).passthrough();
+
+export type OpenRouterModel = z.infer<typeof OpenRouterModel>;
+
+export const openrouter = {
+  id: "openrouter",
+  name: "OpenRouter",
+  modelsDir: "providers/openrouter/models",
+  async fetchModels() {
+    const headers = process.env.OPENROUTER_API_KEY
+      ? { Authorization: `Bearer ${process.env.OPENROUTER_API_KEY}` }
+      : undefined;
+    const response = await fetch(API_ENDPOINT, { headers });
+    if (!response.ok) {
+      throw new Error(`OpenRouter request failed: ${response.status} ${response.statusText}`);
+    }
+    return response.json();
+  },
+  parseModels(raw) {
+    return OpenRouterResponse.parse(raw).data;
+  },
+  translateModel(model, context) {
+    return {
+      id: model.id,
+      model: buildOpenRouterModel(model, context.existing(model.id)),
+    };
+  },
+} satisfies SyncProvider<OpenRouterModel>;
+
+function dateFromTimestamp(timestamp: number) {
+  return new Date(timestamp * 1000).toISOString().slice(0, 10);
+}
+
+function price(value: string | undefined) {
+  if (value === undefined) return undefined;
+  const number = Number(value);
+  return Number.isFinite(number) && number >= 0
+    ? Math.round(number * 1_000_000_000_000) / 1_000_000
+    : undefined;
+}
+
+type Modality = "text" | "audio" | "image" | "video" | "pdf";
+
+function modalities(values: string[], fallback: Modality[]): Modality[] {
+  const allowed = new Set<Modality>(["text", "audio", "image", "video", "pdf"]);
+  const result = values
+    .map((value) => value.toLowerCase())
+    .map((value) => value === "file" ? "pdf" : value)
+    .filter((value): value is Modality => allowed.has(value as Modality));
+  return [...new Set(result.length > 0 ? result : fallback)];
+}
+
+function inferFamily(model: OpenRouterModel, name: string) {
+  const target = `${model.id} ${name}`.toLowerCase();
+  return [...ModelFamilyValues]
+    .sort((a, b) => b.length - a.length)
+    .find((family) => {
+      const value = family.toLowerCase().replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      if (family === "o") {
+        return new RegExp(`(^|[^a-z0-9])${value}(?=\\d|$|[^a-z0-9])`).test(target);
+      }
+      return new RegExp(`(^|[^a-z0-9])${value}(?=$|[^a-z0-9])`).test(target);
+    });
+}
+
+export function buildOpenRouterModel(model: OpenRouterModel, existing: ExistingModel | undefined) {
+  const params = new Set(model.supported_parameters);
+  const name = model.name.replace(/^[^:]+:\s+/, "");
+  const input = modalities(model.architecture.input_modalities, ["text"]);
+  const output = modalities(model.architecture.output_modalities, ["text"]);
+  const prompt = price(model.pricing.prompt);
+  const completion = price(model.pricing.completion);
+  const reasoning = params.has("reasoning") || params.has("include_reasoning");
+  const context = model.top_provider.context_length ?? model.context_length;
+  const family = inferFamily(model, name);
+
+  return {
+    name,
+    family: existing?.family === "o" && family !== "o"
+      ? family
+      : (existing?.family ?? family),
+    release_date: dateFromTimestamp(model.created),
+    last_updated: dateFromTimestamp(model.created),
+    attachment: input.some((value) => value !== "text"),
+    reasoning,
+    temperature: params.has("temperature"),
+    tool_call: params.has("tools") || params.has("tool_choice"),
+    structured_output: params.has("structured_outputs"),
+    knowledge: model.knowledge_cutoff?.slice(0, 10) ?? existing?.knowledge,
+    open_weights: Boolean(model.hugging_face_id),
+    status: existing?.status,
+    interleaved: existing?.interleaved,
+    cost: prompt !== undefined && completion !== undefined
+      ? {
+          input: prompt,
+          output: completion,
+          reasoning: reasoning ? price(model.pricing.internal_reasoning) : undefined,
+          cache_read: price(model.pricing.input_cache_read),
+          cache_write: price(model.pricing.input_cache_write),
+          tiers: existing?.cost?.tiers,
+        }
+      : existing?.cost,
+    limit: {
+      context,
+      input: existing?.limit?.input,
+      output: model.top_provider.max_completion_tokens ?? existing?.limit?.output ?? context,
+    },
+    modalities: { input, output },
+  };
+}

packages/core/script/sync/xai.ts

@@ -0,0 +1,205 @@
+import { z } from "zod";
+
+import type { ExistingModel, SyncProvider, SyncedModel } from "../sync-models.js";
+
+const API_BASE = "https://api.x.ai/v1";
+
+const XAIModel = z.object({
+  id: z.string(),
+  canonical_id: z.string().optional(),
+  created: z.number().int().nonnegative(),
+  aliases: z.array(z.string()).optional(),
+  input_modalities: z.array(z.string()).optional(),
+  output_modalities: z.array(z.string()).optional(),
+  prompt_text_token_price: z.number().int().nonnegative().optional(),
+  cached_prompt_text_token_price: z.number().int().nonnegative().optional(),
+  completion_text_token_price: z.number().int().nonnegative().optional(),
+  max_prompt_length: z.number().int().nonnegative().optional(),
+}).passthrough();
+
+const XAIModelList = z.object({
+  models: z.array(XAIModel),
+}).passthrough();
+
+const XAIResponse = z.object({
+  models: z.array(XAIModel),
+});
+
+const XAIAPIKey = z.object({
+  acls: z.array(z.string()),
+}).passthrough();
+
+type XAIModel = z.infer<typeof XAIModel>;
+
+export const xai = {
+  id: "xai",
+  name: "xAI",
+  modelsDir: "providers/xai/models",
+  skipCreates: true,
+  sourceID(model) {
+    return model.id;
+  },
+  skippedNotice(ids) {
+    if (ids.length === 0) return [];
+    return [
+      `${ids.length} xAI models returned by the API were not created because the Models API does not provide enough authoritative metadata for the catalog, especially output token limits and some feature/capability flags. Existing models are still updated from API-authoritative fields.`,
+      `Skipped remote IDs: ${ids.map((id) => `\`${id}\``).join(", ")}`,
+    ];
+  },
+  async fetchModels() {
+    const key = process.env.XAI_API_KEY;
+    if (key === undefined) throw new Error("xAI sync requires XAI_API_KEY");
+    await assertFullModelAccess(key);
+
+    const models = await Promise.all([
+      fetchTypedModels(key, "language-models"),
+      fetchTypedModels(key, "image-generation-models"),
+      fetchTypedModels(key, "video-generation-models"),
+    ]);
+
+    return { models: models.flat() };
+  },
+  parseModels(raw) {
+    const models = XAIResponse.parse(raw).models;
+    const seen = new Set<string>();
+    const expanded: XAIModel[] = [];
+
+    for (const model of models) {
+      if (!seen.has(model.id)) {
+        seen.add(model.id);
+        expanded.push(model);
+      }
+    }
+
+    for (const model of models) {
+      for (const alias of model.aliases ?? []) {
+        if (seen.has(alias)) continue;
+        seen.add(alias);
+        expanded.push({ ...model, id: alias, canonical_id: model.id });
+      }
+    }
+
+    return expanded;
+  },
+  translateModel(model, context) {
+    const existing = context.existing(model.id);
+    if (existing === undefined) return undefined;
+
+    return {
+      id: model.id,
+      model: buildModel(model, existing),
+    };
+  },
+} satisfies SyncProvider<XAIModel>;
+
+async function assertFullModelAccess(key: string) {
+  const response = await fetch(`${API_BASE}/api-key`, {
+    headers: { Authorization: `Bearer ${key}` },
+  });
+  if (!response.ok) {
+    throw new Error(`xAI API key metadata request failed: ${response.status} ${response.statusText}`);
+  }
+
+  const apiKey = XAIAPIKey.parse(await response.json());
+  if (!apiKey.acls.includes("api-key:model:*")) {
+    throw new Error("xAI sync requires XAI_API_KEY to include api-key:model:* so the model list is not ACL-filtered");
+  }
+}
+
+async function fetchTypedModels(key: string, endpoint: string) {
+  const response = await fetch(`${API_BASE}/${endpoint}`, {
+    headers: { Authorization: `Bearer ${key}` },
+  });
+  if (!response.ok) {
+    throw new Error(`xAI ${endpoint} request failed: ${response.status} ${response.statusText}`);
+  }
+
+  return XAIModelList.parse(await response.json()).models;
+}
+
+function dateFromTimestamp(timestamp: number) {
+  return new Date(timestamp * 1000).toISOString().slice(0, 10);
+}
+
+type Modality = "text" | "audio" | "image" | "video" | "pdf";
+
+function modalities(values: string[] | undefined, fallback: Modality[]) {
+  const allowed = new Set<Modality>(["text", "audio", "image", "video", "pdf"]);
+  const result = (values ?? [])
+    .map((value) => value.toLowerCase())
+    .filter((value): value is Modality => allowed.has(value as Modality));
+  return [...new Set(result.length > 0 ? result : fallback)];
+}
+
+function tokenPrice(value: number | undefined) {
+  if (value === undefined) return undefined;
+  return value / 10_000;
+}
+
+function cost(model: XAIModel, existing: ExistingModel) {
+  const input = tokenPrice(model.prompt_text_token_price);
+  const output = tokenPrice(model.completion_text_token_price);
+  if (input === undefined || output === undefined) return existing.cost;
+
+  return {
+    input,
+    output,
+    reasoning: existing.cost?.reasoning,
+    cache_read: tokenPrice(model.cached_prompt_text_token_price),
+    cache_write: existing.cost?.cache_write,
+    input_audio: existing.cost?.input_audio,
+    output_audio: existing.cost?.output_audio,
+    tiers: existing.cost?.tiers,
+  };
+}
+
+function buildModel(model: XAIModel, existing: ExistingModel): SyncedModel {
+  const name = existing.name;
+  const attachment = existing.attachment;
+  const reasoning = existing.reasoning;
+  const toolCall = existing.tool_call;
+  const openWeights = existing.open_weights;
+  const limit = existing.limit;
+  const releaseDate = existing.release_date;
+  const lastUpdated = existing.last_updated;
+
+  if (
+    name === undefined
+    || attachment === undefined
+    || reasoning === undefined
+    || toolCall === undefined
+    || openWeights === undefined
+    || limit === undefined
+    || (model.canonical_id !== undefined && releaseDate === undefined)
+    || (model.canonical_id !== undefined && lastUpdated === undefined)
+  ) {
+    throw new Error(`xAI model ${model.id} has incomplete local TOML metadata required for sync`);
+  }
+
+  const input = modalities(model.input_modalities, existing.modalities?.input ?? ["text"]);
+  const output = modalities(model.output_modalities, existing.modalities?.output ?? ["text"]);
+  const created = dateFromTimestamp(model.created);
+
+  return {
+    name,
+    family: existing.family,
+    release_date: model.canonical_id === undefined ? created : releaseDate!,
+    last_updated: model.canonical_id === undefined ? created : lastUpdated!,
+    attachment: input.some((value) => value !== "text"),
+    reasoning,
+    temperature: existing.temperature,
+    tool_call: toolCall,
+    structured_output: existing.structured_output,
+    knowledge: existing.knowledge,
+    open_weights: openWeights,
+    status: existing.status,
+    interleaved: existing.interleaved,
+    cost: cost(model, existing),
+    limit: {
+      input: limit.input,
+      context: model.max_prompt_length ?? limit.context,
+      output: limit.output,
+    },
+    modalities: { input, output },
+  };
+}

packages/core/src/family.ts

@@ -54,12 +54,17 @@ export const ModelFamilyValues = [
   // DeepSeek
   "deepseek",
   "deepseek-thinking",
+  "deepseek-flash",
+  "deepseek-flash-free",
+  "deepseek-flash-think",
 
   // Microsoft Phi
   "phi",
 
   // Moonshot Kimi
   "kimi",
+  "kimi-k2.5",
+  "kimi-k2.6",
   "kimi-free",
   "kimi-thinking",
 
@@ -77,6 +82,7 @@ export const ModelFamilyValues = [
 
   // xAI Grok
   "grok",
+  "grok-build",
   "grok-vision",
   "grok-beta",
 
@@ -115,6 +121,9 @@ export const ModelFamilyValues = [
   // Hunyuan
   "hunyuan",
 
+  // Hy
+  "Hy",
+
   // Yi
   "yi",
 
@@ -202,6 +211,10 @@ export const ModelFamilyValues = [
   "mimo",
   "mimo-pro",
   "mimo-omni",
+  "mimo-v2-pro",
+  "mimo-v2-omni",
+  "mimo-v2.5-pro",
+  "mimo-v2.5",
   "mimo-pro-free",
   "mimo-omni-free",
   "mimo-flash-free",
@@ -277,9 +290,15 @@ export const ModelFamilyValues = [
   // RNJ
   "rnj",
 
+  // Tecent Hy
+  "hy3",
+  "hy3-free",
+
   // Ling & Ring (InclusionAI)
   "ling",
+  "ling-flash-free",
   "ring",
+  "ring-1t-free",
 
   // Kat Coder
   "kat-coder",

packages/core/src/generate.ts

@@ -2,9 +2,9 @@ import path from "path";
 import { mergeDeep } from "remeda";
 import { z } from "zod";
 
-import { Provider, Model } from "./schema.js";
+import { Provider, Model, AuthoredModel, AuthoredModelShape } from "./schema.js";
 
-const ExtendsModel = Model.sourceType()
+const ExtendsModel = AuthoredModelShape
   .partial()
   .extend({
     extends: z
@@ -71,12 +71,12 @@ export async function generate(directory: string) {
         });
         continue;
       }
-      const model = Model.safeParse(toml);
+      const model = AuthoredModel.safeParse(toml);
       if (!model.success) {
         model.error.cause = { modelPath, toml };
         throw model.error;
       }
-      provider.data.models[modelID] = model.data;
+      provider.data.models[modelID] = normalizeModelCost(model.data);
     }
     result[providerID] = provider.data;
   }
@@ -144,7 +144,7 @@ export async function generate(directory: string) {
       }
     }
 
-    const model = Model.safeParse(merged);
+    const model = Model.safeParse(normalizeCost(merged));
     if (!model.success) {
       model.error.cause = { modelPath: pendingModel.modelPath, toml: merged };
       throw model.error;
@@ -155,3 +155,51 @@ export async function generate(directory: string) {
 
   return result;
 }
+
+function normalizeModelCost(model: z.infer<typeof AuthoredModel>): Model {
+  return normalizeCost(model) as Model;
+}
+
+function normalizeCost(model: Record<string, unknown>) {
+  const cost = model.cost;
+  if (cost === undefined || cost === null || typeof cost !== "object" || Array.isArray(cost)) {
+    return model;
+  }
+
+  const tiers = (cost as { tiers?: unknown }).tiers;
+  if (!Array.isArray(tiers)) {
+    return model;
+  }
+
+  if (tiers.length !== 1) {
+    return model;
+  }
+
+  const contextOver200k = tiers.find((tier) => {
+    if (tier === null || typeof tier !== "object" || Array.isArray(tier)) return false;
+    const tierConfig = (tier as { tier?: unknown }).tier;
+    if (tierConfig === null || typeof tierConfig !== "object" || Array.isArray(tierConfig)) return false;
+    const type = (tierConfig as { type?: unknown }).type;
+    const size = (tierConfig as { size?: unknown }).size;
+    // context_over_200k is a legacy compatibility field. It intentionally
+    // includes higher thresholds; cost.tiers carries the exact threshold.
+    return (
+      (type === undefined || type === "context") &&
+      typeof size === "number" &&
+      size >= 200_000
+    );
+  });
+
+  if (contextOver200k === undefined) {
+    return model;
+  }
+
+  const { tier: _tier, ...legacyCost } = contextOver200k as Record<string, unknown>;
+  return {
+    ...model,
+    cost: {
+      ...(cost as Record<string, unknown>),
+      context_over_200k: legacyCost,
+    },
+  };
+}

packages/core/src/schema.ts

@@ -21,110 +21,164 @@ const JsonValue: z.ZodType<JsonValue> = z.lazy(() =>
   ]),
 );
 
-const Cost = z.object({
-  input: z.number().min(0, "Input price cannot be negative"),
-  output: z.number().min(0, "Output price cannot be negative"),
-  reasoning: z.number().min(0, "Input price cannot be negative").optional(),
-  cache_read: z
-    .number()
-    .min(0, "Cache read price cannot be negative")
+const Cost = z
+  .object({
+    input: z.number().min(0, "Input price cannot be negative"),
+    output: z.number().min(0, "Output price cannot be negative"),
+    reasoning: z
+      .number()
+      .min(0, "Reasoning price cannot be negative")
+      .optional(),
+    cache_read: z
+      .number()
+      .min(0, "Cache read price cannot be negative")
+      .optional(),
+    cache_write: z
+      .number()
+      .min(0, "Cache write price cannot be negative")
+      .optional(),
+    input_audio: z
+      .number()
+      .min(0, "Audio input price cannot be negative")
+      .optional(),
+    output_audio: z
+      .number()
+      .min(0, "Audio output price cannot be negative")
+      .optional(),
+  });
+
+const CostTier = Cost.extend({
+  tier: z
+    .object({
+      type: z.literal("context").default("context"),
+      size: z.number().int().min(0, "Context tier size cannot be negative"),
+    })
+    .strict(),
+}).strict();
+
+const AuthoredCost = Cost.extend({
+  context_over_200k: z.never().optional(),
+  tiers: z.array(CostTier).optional(),
+});
+
+const OutputCost = Cost.extend({
+  context_over_200k: Cost.optional(),
+  tiers: z.array(CostTier).optional(),
+});
+
+const ModelBase = z.object({
+  id: z.string(),
+  name: z.string().min(1, "Model name cannot be empty"),
+  family: ModelFamily.optional(),
+  attachment: z.boolean(),
+  reasoning: z.boolean(),
+  tool_call: z.boolean(),
+  interleaved: z
+    .union([
+      z.literal(true),
+      z
+        .object({
+          field: z.enum(["reasoning_content", "reasoning_details"]),
+        })
+        .strict(),
+    ])
     .optional(),
-  cache_write: z
-    .number()
-    .min(0, "Cache write price cannot be negative")
+  structured_output: z.boolean().optional(),
+  temperature: z.boolean().optional(),
+  knowledge: z
+    .string()
+    .regex(/^\d{4}-\d{2}(-\d{2})?$/, {
+      message: "Must be in YYYY-MM or YYYY-MM-DD format",
+    })
     .optional(),
-  input_audio: z
-    .number()
-    .min(0, "Audio input price cannot be negative")
+  release_date: z.string().regex(/^\d{4}-\d{2}(-\d{2})?$/, {
+    message: "Must be in YYYY-MM or YYYY-MM-DD format",
+  }),
+  last_updated: z.string().regex(/^\d{4}-\d{2}(-\d{2})?$/, {
+    message: "Must be in YYYY-MM or YYYY-MM-DD format",
+  }),
+  modalities: z.object({
+    input: z.array(z.enum(["text", "audio", "image", "video", "pdf"])),
+    output: z.array(z.enum(["text", "audio", "image", "video", "pdf"])),
+  }),
+  open_weights: z.boolean(),
+  limit: z.object({
+    context: z.number().min(0, "Context window must be positive"),
+    input: z.number().min(0, "Input tokens must be positive").optional(),
+    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(),
-  output_audio: z
-    .number()
-    .min(0, "Audio output price cannot be negative")
+  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(),
 });
-export const Model = z
+
+function refineModel<T extends z.ZodTypeAny>(schema: T) {
+  return schema
+    .refine(
+      (data) => {
+        return !(data.reasoning === false && data.cost?.reasoning !== undefined);
+      },
+      {
+        message: "Cannot set cost.reasoning when reasoning is false",
+        path: ["cost", "reasoning"],
+      },
+    )
+    .refine(
+      (data) => {
+        const tiers = data.cost?.tiers;
+        if (tiers === undefined) return true;
+
+        const sizes = tiers.map((tier: { tier: { size: number } }) => tier.tier.size);
+        return new Set(sizes).size === sizes.length;
+      },
+      {
+        message: "Cost context tiers must not have duplicate sizes",
+        path: ["cost", "tiers"],
+      },
+    );
+}
+
+export const ModelShape = z
   .object({
-    id: z.string(),
-    name: z.string().min(1, "Model name cannot be empty"),
-    family: ModelFamily.optional(),
-    attachment: z.boolean(),
-    reasoning: z.boolean(),
-    tool_call: z.boolean(),
-    interleaved: z
-      .union([
-        z.literal(true),
-        z
-          .object({
-            field: z.enum(["reasoning_content", "reasoning_details"]),
-          })
-          .strict(),
-      ])
-      .optional(),
-    structured_output: z.boolean().optional(),
-    temperature: z.boolean().optional(),
-    knowledge: z
-      .string()
-      .regex(/^\d{4}-\d{2}(-\d{2})?$/, {
-        message: "Must be in YYYY-MM or YYYY-MM-DD format",
-      })
-      .optional(),
-    release_date: z.string().regex(/^\d{4}-\d{2}(-\d{2})?$/, {
-      message: "Must be in YYYY-MM or YYYY-MM-DD format",
-    }),
-    last_updated: z.string().regex(/^\d{4}-\d{2}(-\d{2})?$/, {
-      message: "Must be in YYYY-MM or YYYY-MM-DD format",
-    }),
-    modalities: z.object({
-      input: z.array(z.enum(["text", "audio", "image", "video", "pdf"])),
-      output: z.array(z.enum(["text", "audio", "image", "video", "pdf"])),
-    }),
-    open_weights: z.boolean(),
-    cost: Cost.extend({
-      context_over_200k: Cost.optional(),
-    }).optional(),
-    limit: z.object({
-      context: z.number().min(0, "Context window must be positive"),
-      input: z.number().min(0, "Input tokens must be positive").optional(),
-      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(),
+    ...ModelBase.shape,
+    cost: OutputCost.optional(),
   })
-  .strict()
-  .refine(
-    (data) => {
-      return !(data.reasoning === false && data.cost?.reasoning !== undefined);
-    },
-    {
-      message: "Cannot set cost.reasoning when reasoning is false",
-      path: ["cost", "reasoning"],
-    },
-  );
+  .strict();
+
+export const AuthoredModelShape = z
+  .object({
+    ...ModelBase.shape,
+    cost: AuthoredCost.optional(),
+  })
+  .strict();
+
+export const Model = refineModel(ModelShape);
+
+export const AuthoredModel = refineModel(AuthoredModelShape);
 
 export type Model = z.infer<typeof Model>;
 
@@ -150,6 +204,7 @@ export const Provider = z
       const isOpenAIcompatible = data.npm === "@ai-sdk/openai-compatible";
       const isOpenrouter = data.npm === "@openrouter/ai-sdk-provider";
       const isAnthropic = data.npm === "@ai-sdk/anthropic";
+      const isKiro = data.npm === "kiro-acp-ai-provider";
       const hasApi = data.api !== undefined;
 
       return (
@@ -161,17 +216,20 @@ export const Provider = z
         isAnthropic ||
         // openai: api optional (always allowed)
         isOpenAI ||
+        // kiro: api optional (always allowed)
+        isKiro ||
         // all others: must NOT have api
         (!isOpenAI &&
           !isOpenAIcompatible &&
           !isOpenrouter &&
           !isAnthropic &&
+          !isKiro &&
           !hasApi)
       );
     },
     {
       message:
-        "'api' is required for openai-compatible and openrouter, optional for anthropic and openai, forbidden otherwise",
+        "'api' is required for openai-compatible and openrouter, optional for anthropic, openai, and kiro, forbidden otherwise",
       path: ["api"],
     },
   );

packages/web/package.json

@@ -6,6 +6,7 @@
     "build": "./script/build.ts"
   },
   "dependencies": {
+    "@tanstack/virtual-core": "^3.14.0",
     "hono": "^4.8.0",
     "models.dev": "workspace:*"
   },

packages/web/src/index.css

@@ -41,6 +41,8 @@
 
 html,
 body {
+  height: 100%;
+  overflow: hidden;
   font-family: 'Rubik', sans-serif;
   line-height: 1.6;
   color: var(--color-text);
@@ -205,12 +207,17 @@ header {
   }
 }
 
+.table-viewport {
+  height: calc(100svh - var(--header-height));
+  margin-top: var(--header-height);
+  overflow: auto;
+}
+
 table {
   border-collapse: separate;
   border-spacing: 0;
   font-size: 0.875rem;
   width: 100%;
-  margin-top: var(--header-height);
 }
 
 thead,
@@ -218,7 +225,7 @@ tbody {}
 
 table thead th {
   position: sticky;
-  top: var(--header-height);
+  top: 0;
   border-top: 1px solid var(--color-border);
   border-bottom: 1px solid var(--color-border);
   font-size: 0.75rem;
@@ -264,6 +271,7 @@ td {
   text-align: left;
   border-bottom: 1px solid var(--color-border);
   white-space: nowrap;
+  height: 48px;
 }
 
 tbody {
@@ -319,21 +327,37 @@ tbody {
     gap: 0.375rem;
   }
 
-  .provider-cell span:first-child {
-    flex: 0 0 auto;
-  }
-
+  .provider-cell img,
   .provider-cell svg {
+    flex: 0 0 auto;
     display: block;
     width: 1rem;
     height: 1rem;
     color: var(--color-text-secondary);
   }
 
+  .virtual-spacer td {
+    height: inherit;
+    padding: 0;
+    border-bottom: 0;
+  }
+
+  .empty-row td {
+    padding: 2rem 0.75rem;
+    color: var(--color-text-tertiary);
+  }
+
+  .empty-row div {
+    position: sticky;
+    left: 0;
+    width: calc(100vw - 1.5rem);
+    text-align: center;
+  }
+
   .model-id-cell {
     display: flex;
     align-items: center;
-    justify-content: space-between;
+    justify-content: flex-start;
     gap: 0.375rem;
   }
 
@@ -546,4 +570,4 @@ dialog {
     }
   }
 
-}
+}

packages/web/src/index.ts

@@ -1,7 +1,53 @@
+import {
+  Virtualizer,
+  elementScroll,
+  observeElementOffset,
+  observeElementRect,
+} from "@tanstack/virtual-core";
+import {
+  type TableRow,
+  renderRow,
+  escapeHtml,
+  booleanText,
+  knowledgeText,
+  weightsText,
+} from "./shared.js";
+
+declare global {
+  interface Window {
+    __TABLE_DATA__: TableRow[];
+  }
+}
+
+interface VirtualizedRow extends TableRow {
+  key: string;
+  searchText: string;
+  sortValues: Array<string | number | undefined>;
+}
+
+type SortDirection = "asc" | "desc";
+
+const ESTIMATED_ROW_HEIGHT = 48;
+const VIRTUAL_OVERSCAN = 5;
+
 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 viewport = document.getElementById("table-viewport") as HTMLElement;
+const tbody = document.getElementById(
+  "models-table-body"
+) as HTMLTableSectionElement;
+const headers = Array.from(document.querySelectorAll("th.sortable"));
+const columnCount = document.querySelectorAll("thead th").length;
+
+let isLoaded = false;
+let allRows: VirtualizedRow[] = [];
+let visibleRows: VirtualizedRow[] = [];
+let currentSort: { column: number; direction: SortDirection } = {
+  column: -1,
+  direction: "asc",
+};
 
 /////////////////////////
 // URL State Management
@@ -31,10 +77,7 @@ function getColumnNameForURL(headerEl: Element): string {
 }
 
 function getColumnIndexByUrlName(name: string): number {
-  const headers = document.querySelectorAll("th.sortable");
-  return Array.from(headers).findIndex(
-    (header) => getColumnNameForURL(header) === name
-  );
+  return headers.findIndex((header) => getColumnNameForURL(header) === name);
 }
 
 /////////////////////////
@@ -63,32 +106,181 @@ modal.addEventListener("click", (e) => {
 });
 
 ////////////////////
-// Handle Sorting
+// Row Data
 ////////////////////
-let currentSort = { column: -1, direction: "asc" };
+function lockColumnWidths() {
+  const ths = document.querySelectorAll("#models-table thead th");
+  const widths = Array.from(ths).map((th) => th.getBoundingClientRect().width);
 
-function sortTable(column: number, direction: "asc" | "desc") {
-  const header = document.querySelectorAll("th.sortable")[column];
-  const columnType = header.getAttribute("data-type");
-  if (!columnType) return;
+  const measurementRow = tbody.querySelector('tr[aria-hidden="true"]');
+  if (measurementRow) measurementRow.remove();
 
-  // update state
-  currentSort = { column, direction };
-  updateQueryParams({
-    sort: getColumnNameForURL(header),
-    order: direction,
-  });
+  const table = document.getElementById("models-table")!;
+  table.style.tableLayout = "fixed";
 
-  // sort rows
-  const tbody = document.querySelector("table tbody")!;
-  const rows = Array.from(
-    tbody.querySelectorAll("tr")
-  ) as HTMLTableRowElement[];
-  rows.sort((a, b) => {
-    const aValue = getCellValue(a.cells[column], columnType);
-    const bValue = getCellValue(b.cells[column], columnType);
+  const colgroup = document.createElement("colgroup");
+  for (const width of widths) {
+    const col = document.createElement("col");
+    col.style.width = `${width}px`;
+    colgroup.appendChild(col);
+  }
+  table.insertBefore(colgroup, table.firstChild);
+}
+
+function prepareRow(row: TableRow): VirtualizedRow {
+  const sortValues: VirtualizedRow["sortValues"] = [
+    row.providerName,
+    row.modelName,
+    row.family,
+    row.providerId,
+    row.modelId,
+    booleanText(row.toolCall),
+    booleanText(row.reasoning),
+    row.input.length,
+    row.output.length,
+    row.inputCost,
+    row.outputCost,
+    row.reasoningCost,
+    row.cacheReadCost,
+    row.cacheWriteCost,
+    row.audioInputCost,
+    row.audioOutputCost,
+    row.contextLimit,
+    row.inputLimit,
+    row.outputLimit,
+    row.structuredOutput === undefined
+      ? undefined
+      : booleanText(row.structuredOutput),
+    booleanText(row.temperature),
+    weightsText(row.openWeights),
+    row.knowledge ? knowledgeText(row.knowledge) : undefined,
+    row.releaseDate,
+    row.lastUpdated,
+  ];
+
+  const searchableValues = [
+    row.providerName,
+    row.modelName,
+    row.family ?? "",
+    row.providerId,
+    row.modelId,
+    row.releaseDate,
+    row.lastUpdated,
+  ];
+
+  return {
+    ...row,
+    key: `${row.providerId}/${row.modelId}`,
+    searchText: searchableValues.join(" ").toLowerCase(),
+    sortValues,
+  };
+}
+
+////////////////////
+// Virtual Table
+////////////////////
+function getVirtualizerOptions(count: number) {
+  return {
+    count,
+    getScrollElement: () => viewport,
+    estimateSize: () => ESTIMATED_ROW_HEIGHT,
+    getItemKey: (index: number) => visibleRows[index]?.key ?? index,
+    initialRect: {
+      width: viewport.clientWidth || window.innerWidth,
+      height: viewport.clientHeight || window.innerHeight,
+    },
+    overscan: VIRTUAL_OVERSCAN,
+    observeElementRect,
+    observeElementOffset,
+    scrollToFn: elementScroll,
+    onChange: () => renderVirtualRows(),
+  };
+}
+
+const virtualizer = new Virtualizer<HTMLElement, HTMLTableRowElement>(
+  getVirtualizerOptions(0)
+);
+const cleanupVirtualizer = virtualizer._didMount();
+virtualizer._willUpdate();
+window.addEventListener("pagehide", () => cleanupVirtualizer());
+
+function renderStatusRow(message: string) {
+  tbody.innerHTML = `<tr class="empty-row"><td colspan="${columnCount}"><div>${escapeHtml(
+    message
+  )}</div></td></tr>`;
+}
+
+function setVirtualizerCount(count: number, resetScroll: boolean) {
+  virtualizer.setOptions(getVirtualizerOptions(count));
+  virtualizer._willUpdate();
+  if (resetScroll) virtualizer.scrollToOffset(0);
+  renderVirtualRows();
+}
+
+function renderVirtualRows() {
+  if (!isLoaded) return;
+  if (visibleRows.length === 0) {
+    renderStatusRow("No models found");
+    return;
+  }
+
+  const virtualRows = virtualizer.getVirtualItems();
+  if (virtualRows.length === 0) return;
+
+  const firstRow = virtualRows[0]!;
+  const lastRow = virtualRows[virtualRows.length - 1]!;
+  const paddingTop = firstRow.start;
+  const paddingBottom = Math.max(virtualizer.getTotalSize() - lastRow.end, 0);
+  const html: string[] = [];
+
+  if (paddingTop > 0) html.push(renderSpacerRow(paddingTop));
+  for (const virtualRow of virtualRows) {
+    const row = visibleRows[virtualRow.index];
+    if (row) html.push(renderRow(row, virtualRow.index));
+  }
+  if (paddingBottom > 0) html.push(renderSpacerRow(paddingBottom));
+
+  tbody.innerHTML = html.join("");
+  tbody.querySelectorAll<HTMLTableRowElement>("tr[data-index]").forEach((row) =>
+    virtualizer.measureElement(row)
+  );
+}
+
+function renderSpacerRow(height: number) {
+  return `<tr class="virtual-spacer" style="height: ${height}px"><td colspan="${columnCount}"></td></tr>`;
+}
+
+function applyRows(resetScroll = true) {
+  if (!isLoaded) return;
+  visibleRows = getRowsForDisplay();
+  setVirtualizerCount(visibleRows.length, resetScroll);
+}
+
+////////////////////
+// Sorting
+////////////////////
+function getRowsForDisplay() {
+  const terms = search.value
+    .toLowerCase()
+    .split(",")
+    .map((term) => term.trim())
+    .filter(Boolean);
+  const filteredRows =
+    terms.length === 0
+      ? allRows
+      : allRows.filter((row) =>
+          terms.some((term) => row.searchText.includes(term))
+        );
+
+  if (currentSort.column === -1) return filteredRows;
+
+  const columnType = headers[currentSort.column]?.getAttribute("data-type");
+  if (!columnType) return filteredRows;
+
+  return [...filteredRows].sort((a, b) => {
+    const aValue = a.sortValues[currentSort.column];
+    const bValue = b.sortValues[currentSort.column];
 
-    // Handle undefined values - always sort to bottom
     if (aValue === undefined && bValue === undefined) return 0;
     if (aValue === undefined) return 1;
     if (bValue === undefined) return -1;
@@ -96,45 +288,48 @@ function sortTable(column: number, direction: "asc" | "desc") {
     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);
+      comparison = String(aValue).localeCompare(String(bValue));
     }
 
-    return direction === "asc" ? comparison : -comparison;
+    return currentSort.direction === "asc" ? comparison : -comparison;
   });
-  rows.forEach((row) => tbody.appendChild(row));
+}
 
-  // update sort indicators
-  const headers = document.querySelectorAll("th.sortable");
+function sortTable(
+  column: number,
+  direction: SortDirection,
+  updateURL = true
+) {
+  const header = headers[column];
+  if (!header?.getAttribute("data-type")) return;
+
+  currentSort = { column, direction };
+  if (updateURL) {
+    updateQueryParams({
+      sort: getColumnNameForURL(header),
+      order: direction,
+    });
+  }
+
+  updateSortIndicators();
+  applyRows();
+}
+
+function updateSortIndicators() {
   headers.forEach((header, i) => {
     const indicator = header.querySelector(".sort-indicator")!;
-
-    if (i === column) {
-      indicator.textContent = direction === "asc" ? "↑" : "↓";
-    } else {
-      indicator.textContent = "";
-    }
+    indicator.textContent =
+      i === currentSort.column
+        ? currentSort.direction === "asc"
+          ? "↑"
+          : "↓"
+        : "";
   });
 }
 
-function getCellValue(
-  cell: HTMLTableCellElement,
-  type: string
-): string | number | undefined {
-  if (type === "modalities")
-    return cell.querySelectorAll(".modality-icon").length;
-
-  const text = cell.textContent?.trim() || "";
-  if (text === "-") return;
-  if (type === "number") return parseFloat(text.replace(/[$,]/g, "")) || 0;
-  return text;
-}
-
-document.querySelectorAll("th.sortable").forEach((header) => {
+headers.forEach((header, column) => {
   header.addEventListener("click", () => {
-    const column = Array.from(header.parentElement!.children).indexOf(header);
     const direction =
       currentSort.column === column && currentSort.direction === "asc"
         ? "desc"
@@ -144,34 +339,19 @@ document.querySelectorAll("th.sortable").forEach((header) => {
 });
 
 ///////////////////
-// Handle Search
+// Search
 ///////////////////
-function filterTable(value: string) {
-  const lowerCaseValues = value.toLowerCase().split(",").filter(str => str.trim() !== "");
-  const rows = document.querySelectorAll(
-    "table tbody tr"
-  ) 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)));
-    row.style.display = isVisible ? "" : "none";
-  });
-
-  updateQueryParams({ search: value || null });
-}
-
 search.addEventListener("input", () => {
-  filterTable(search.value);
+  updateQueryParams({ search: search.value || null });
+  applyRows();
 });
 
 document.addEventListener("keydown", (e) => {
-  if ((e.metaKey || e.ctrlKey) && e.key === "k") {
+  const key = e.key.toLowerCase();
+  if ((e.metaKey || e.ctrlKey) && (key === "k" || key === "f")) {
     e.preventDefault();
     search.focus();
+    search.select();
   }
 });
 
@@ -185,10 +365,7 @@ search.addEventListener("keydown", (e) => {
 ///////////////////////////////////
 // Handle Copy model ID function
 ///////////////////////////////////
-(window as any).copyModelId = async (
-  button: HTMLButtonElement,
-  modelId: string
-) => {
+async function copyModelId(button: HTMLButtonElement, modelId: string) {
   try {
     if (navigator.clipboard) {
       await navigator.clipboard.writeText(modelId);
@@ -209,7 +386,18 @@ search.addEventListener("keydown", (e) => {
   } catch (err) {
     console.error("Failed to copy text: ", err);
   }
-};
+}
+
+document.addEventListener("click", (event) => {
+  if (!(event.target instanceof Element)) return;
+  const button = event.target.closest<HTMLButtonElement>(
+    ".copy-button[data-model-id]"
+  );
+  if (!button) return;
+
+  const modelId = button.dataset.modelId;
+  if (modelId) void copyModelId(button, modelId);
+});
 
 ///////////////////////////////////
 // Initialize State from URL
@@ -217,24 +405,37 @@ search.addEventListener("keydown", (e) => {
 function initializeFromURL() {
   const params = getQueryParams();
 
-  (() => {
-    const searchQuery = params.get("search");
-    if (!searchQuery) return;
-    search.value = searchQuery;
-    filterTable(searchQuery);
-  })();
-
-  (() => {
-    const columnName = params.get("sort");
-    if (!columnName) return;
+  search.value = params.get("search") ?? "";
 
+  currentSort = { column: -1, direction: "asc" };
+  const columnName = params.get("sort");
+  if (columnName) {
     const columnIndex = getColumnIndexByUrlName(columnName);
-    if (columnIndex === -1) return;
+    if (columnIndex !== -1) {
+      currentSort = {
+        column: columnIndex,
+        direction: params.get("order") === "desc" ? "desc" : "asc",
+      };
+    }
+  }
 
-    const direction = (params.get("order") as "asc" | "desc") || "asc";
-    sortTable(columnIndex, direction);
-  })();
+  updateSortIndicators();
+  applyRows(false);
 }
 
-document.addEventListener("DOMContentLoaded", initializeFromURL);
+function loadRows() {
+  try {
+    allRows = window.__TABLE_DATA__.map(prepareRow);
+    lockColumnWidths();
+    isLoaded = true;
+    initializeFromURL();
+  } catch (error) {
+    console.error(error);
+    isLoaded = true;
+    visibleRows = [];
+    renderStatusRow("Failed to load model data");
+  }
+}
+
+loadRows();
 window.addEventListener("popstate", initializeFromURL);

packages/web/src/render.tsx

@@ -6,6 +6,7 @@ import { Fragment } from "hono/jsx";
 import { renderToString } from "hono/jsx/dom/server";
 import { existsSync } from "fs";
 import path from "path";
+import { type TableRow, renderRow, getLargestRow } from "./shared.js";
 
 export const Providers = await generate(
   path.join(import.meta.dir, "..", "..", "..", "providers")
@@ -38,7 +39,6 @@ const loadProviderSvg = async (providerId: string): Promise<string | null> => {
       const file = Bun.file(providerLogoPath);
       return await file.text();
     }
-    //
     // Fall back to default logo
     if (existsSync(defaultLogoPath)) {
       const file = Bun.file(defaultLogoPath);
@@ -62,122 +62,47 @@ for (const [providerId] of Object.entries(Providers)) {
   }
 }
 
-function renderProviderLogo(providerId: string) {
-  const svgContent = providerLogos.get(providerId) || "";
+export const INITIAL_ROW_COUNT = 50;
 
-  return <span dangerouslySetInnerHTML={{ __html: svgContent }} />;
-}
+export const TableRows: TableRow[] = 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]) => ({
+        providerId,
+        providerName: provider.name,
+        providerLogoSvg: providerLogos.get(providerId) || "",
+        modelId,
+        modelName: model.name,
+        family: model.family,
+        toolCall: model.tool_call,
+        reasoning: model.reasoning,
+        input: model.modalities.input,
+        output: model.modalities.output,
+        inputCost: model.cost?.input,
+        outputCost: model.cost?.output,
+        reasoningCost: model.cost?.reasoning,
+        cacheReadCost: model.cost?.cache_read,
+        cacheWriteCost: model.cost?.cache_write,
+        audioInputCost: model.cost?.input_audio,
+        audioOutputCost: model.cost?.output_audio,
+        contextLimit: model.limit.context,
+        inputLimit: model.limit.input,
+        outputLimit: model.limit.output,
+        structuredOutput: model.structured_output,
+        temperature: model.temperature ?? false,
+        openWeights: model.open_weights,
+        knowledge: model.knowledge,
+        releaseDate: model.release_date,
+        lastUpdated: model.last_updated,
+      }))
+  );
 
-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)}`;
-};
+const largestRow = getLargestRow(TableRows);
 
 export const Rendered = renderToString(
   <Fragment>
@@ -213,7 +138,8 @@ export const Rendered = renderToString(
         <button id="help">How to use</button>
       </div>
     </header>
-    <table>
+    <div id="table-viewport" class="table-viewport">
+      <table id="models-table">
       <thead>
         <tr>
           <th class="sortable" data-type="text">
@@ -342,120 +268,12 @@ 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>
-    </table>
+      <tbody id="models-table-body" dangerouslySetInnerHTML={{
+        __html: TableRows.slice(0, INITIAL_ROW_COUNT).map((row, i) => renderRow(row, i)).join('')
+          + renderRow(largestRow, -1).replace('<tr', '<tr style="visibility:hidden" aria-hidden="true"')
+      }} />
+      </table>
+    </div>
     <dialog id="modal">
       <div class="header">
         <h2>How to use</h2>
@@ -565,10 +383,15 @@ export const Rendered = renderToString(
         >
           Edit on GitHub
         </a>
-        <a href="https://sst.dev" target="_blank" rel="noopener noreferrer">
-          Created by SST
+        <a href="https://opencode.ai" target="_blank" rel="noopener noreferrer">
+          Created by OpenCode
         </a>
       </div>
     </dialog>
+    <script
+      dangerouslySetInnerHTML={{
+        __html: `window.__TABLE_DATA__ = ${JSON.stringify(TableRows)}`,
+      }}
+    ></script>
   </Fragment>
 );

packages/web/src/shared.ts

@@ -0,0 +1,176 @@
+export interface TableRow {
+  providerId: string;
+  providerName: string;
+  providerLogoSvg: string;
+  modelId: string;
+  modelName: string;
+  family?: string;
+  toolCall: boolean;
+  reasoning: boolean;
+  input: string[];
+  output: string[];
+  inputCost?: number;
+  outputCost?: number;
+  reasoningCost?: number;
+  cacheReadCost?: number;
+  cacheWriteCost?: number;
+  audioInputCost?: number;
+  audioOutputCost?: number;
+  contextLimit: number;
+  inputLimit?: number;
+  outputLimit: number;
+  structuredOutput?: boolean;
+  temperature: boolean;
+  openWeights: boolean;
+  knowledge?: string;
+  releaseDate: string;
+  lastUpdated: string;
+}
+
+const MODALITY_ICONS: Record<string, string> = {
+  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>`,
+  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>`,
+  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>`,
+  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>`,
+  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>`,
+};
+
+export function escapeHtml(value: string | number) {
+  return String(value).replace(/[&<>'"]/g, (char) => {
+    switch (char) {
+      case "&":
+        return "&amp;";
+      case "<":
+        return "&lt;";
+      case ">":
+        return "&gt;";
+      case "'":
+        return "&#39;";
+      case '"':
+        return "&quot;";
+      default:
+        return char;
+    }
+  });
+}
+
+export function booleanText(value: boolean) {
+  return value ? "Yes" : "No";
+}
+
+export function optionalBooleanText(value?: boolean) {
+  return value === undefined ? "-" : booleanText(value);
+}
+
+export function formatCost(cost?: number) {
+  return cost === undefined ? "-" : `$${cost.toFixed(2)}`;
+}
+
+export function formatNumber(value?: number) {
+  return value === undefined ? "-" : value.toLocaleString();
+}
+
+export function knowledgeText(value?: string) {
+  return value ? value.substring(0, 7) : "-";
+}
+
+export function weightsText(value: boolean) {
+  return value ? "Open" : "Closed";
+}
+
+export function renderModalityIcon(modality: string) {
+  const label =
+    modality === "pdf"
+      ? "PDF"
+      : modality[0]!.toUpperCase() + modality.slice(1);
+  const icon = MODALITY_ICONS[modality];
+  if (!icon) return "";
+  return `<span class="modality-icon" data-tooltip="${label}">${icon}</span>`;
+}
+
+export function renderModalities(modalities: string[]) {
+  return `<div class="modalities">${modalities
+    .map(renderModalityIcon)
+    .join("")}</div>`;
+}
+
+export function renderCopyButton(modelId: string) {
+  const escapedModelId = escapeHtml(modelId);
+  return `<button type="button" class="copy-button" data-model-id="${escapedModelId}" aria-label="Copy model ID"><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><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></button>`;
+}
+
+export function renderRow(row: TableRow, index: number) {
+  return `<tr data-index="${index}">
+    <td><div class="provider-cell">${row.providerLogoSvg}<span>${escapeHtml(
+    row.providerName
+  )}</span></div></td>
+    <td>${escapeHtml(row.modelName)}</td>
+    <td>${escapeHtml(row.family ?? "-")}</td>
+    <td>${escapeHtml(row.providerId)}</td>
+    <td><div class="model-id-cell"><span class="model-id-text">${escapeHtml(
+      row.modelId
+    )}</span>${renderCopyButton(row.modelId)}</div></td>
+    <td>${booleanText(row.toolCall)}</td>
+    <td>${booleanText(row.reasoning)}</td>
+    <td>${renderModalities(row.input)}</td>
+    <td>${renderModalities(row.output)}</td>
+    <td>${formatCost(row.inputCost)}</td>
+    <td>${formatCost(row.outputCost)}</td>
+    <td>${formatCost(row.reasoningCost)}</td>
+    <td>${formatCost(row.cacheReadCost)}</td>
+    <td>${formatCost(row.cacheWriteCost)}</td>
+    <td>${formatCost(row.audioInputCost)}</td>
+    <td>${formatCost(row.audioOutputCost)}</td>
+    <td>${formatNumber(row.contextLimit)}</td>
+    <td>${formatNumber(row.inputLimit)}</td>
+    <td>${formatNumber(row.outputLimit)}</td>
+    <td>${optionalBooleanText(row.structuredOutput)}</td>
+    <td>${booleanText(row.temperature)}</td>
+    <td>${weightsText(row.openWeights)}</td>
+    <td>${knowledgeText(row.knowledge)}</td>
+    <td>${escapeHtml(row.releaseDate)}</td>
+    <td>${escapeHtml(row.lastUpdated)}</td>
+  </tr>`;
+}
+
+export function getLargestRow(rows: TableRow[]): TableRow {
+  const worst: TableRow = {
+    providerId: "", providerName: "", providerLogoSvg: "", modelId: "", modelName: "",
+    toolCall: true, reasoning: true,
+    input: [], output: [],
+    contextLimit: 0, outputLimit: 0,
+    structuredOutput: true, temperature: true, openWeights: false,
+    releaseDate: "", lastUpdated: "",
+  };
+
+  for (const row of rows) {
+    if (row.providerName.length > worst.providerName.length) worst.providerName = row.providerName;
+    if (row.modelName.length > worst.modelName.length) worst.modelName = row.modelName;
+    if ((row.family ?? "").length > (worst.family ?? "").length) worst.family = row.family;
+    if (row.providerId.length > worst.providerId.length) worst.providerId = row.providerId;
+    if (row.modelId.length > worst.modelId.length) worst.modelId = row.modelId;
+    if ((row.knowledge ?? "").length > (worst.knowledge ?? "").length) worst.knowledge = row.knowledge;
+    if (row.releaseDate.length > worst.releaseDate.length) worst.releaseDate = row.releaseDate;
+    if (row.lastUpdated.length > worst.lastUpdated.length) worst.lastUpdated = row.lastUpdated;
+    if (row.input.length > worst.input.length) worst.input = row.input;
+    if (row.output.length > worst.output.length) worst.output = row.output;
+
+    const costWider = (a: number | undefined, b: number | undefined) =>
+      b !== undefined && (a === undefined || formatCost(b).length > formatCost(a).length);
+    if (costWider(worst.inputCost, row.inputCost)) worst.inputCost = row.inputCost;
+    if (costWider(worst.outputCost, row.outputCost)) worst.outputCost = row.outputCost;
+    if (costWider(worst.reasoningCost, row.reasoningCost)) worst.reasoningCost = row.reasoningCost;
+    if (costWider(worst.cacheReadCost, row.cacheReadCost)) worst.cacheReadCost = row.cacheReadCost;
+    if (costWider(worst.cacheWriteCost, row.cacheWriteCost)) worst.cacheWriteCost = row.cacheWriteCost;
+    if (costWider(worst.audioInputCost, row.audioInputCost)) worst.audioInputCost = row.audioInputCost;
+    if (costWider(worst.audioOutputCost, row.audioOutputCost)) worst.audioOutputCost = row.audioOutputCost;
+
+    const numWider = (a: number | undefined, b: number | undefined) =>
+      b !== undefined && (a === undefined || formatNumber(b).length > formatNumber(a).length);
+    if (numWider(worst.contextLimit as number | undefined, row.contextLimit)) worst.contextLimit = row.contextLimit;
+    if (numWider(worst.inputLimit, row.inputLimit)) worst.inputLimit = row.inputLimit;
+    if (numWider(worst.outputLimit as number | undefined, row.outputLimit)) worst.outputLimit = row.outputLimit;
+  }
+
+  return worst;
+}

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

@@ -1,6 +1,6 @@
-name = "xAI: Grok 3"
-release_date = "2025-02-17"
-last_updated = "2025-02-17"
+name = "MiniMax-M2.7-highspeed"
+release_date = "2026-03-19"
+last_updated = "2026-03-19"
 attachment = false
 reasoning = false
 temperature = true
@@ -8,13 +8,12 @@ tool_call = true
 open_weights = false
 
 [cost]
-input = 3.0
-output = 15.0
-cache_read = 0.75
+input = 0.600
+output = 4.800
 
 [limit]
-context = 131072
-output = 26215
+context = 204_800
+output = 131_072
 
 [modalities]
 input = ["text"]

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

@@ -1,6 +1,6 @@
-name = "Qwen: Qwen-Max "
-release_date = "2024-04-03"
-last_updated = "2026-03-15"
+name = "MiniMax-M2.7"
+release_date = "2026-03-19"
+last_updated = "2026-03-19"
 attachment = false
 reasoning = false
 temperature = true
@@ -8,13 +8,12 @@ tool_call = true
 open_weights = false
 
 [cost]
-input = 1.04
-output = 4.16
-cache_read = 0.32
+input = 0.300
+output = 1.200
 
 [limit]
-context = 32768
-output = 8192
+context = 204_800
+output = 131_072
 
 [modalities]
 input = ["text"]

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

@@ -1,19 +1,17 @@
-name = "Claude Sonnet 3.5 v2"
-family = "claude-sonnet"
+name = "claude-3-5-haiku-20241022"
+family = "claude-haiku"
 release_date = "2024-10-22"
 last_updated = "2024-10-22"
 attachment = true
 reasoning = false
 temperature = true
-knowledge = "2024-04"
 tool_call = true
 open_weights = false
+knowledge = "2024-07-31"
 
 [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

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

@@ -1,21 +1,21 @@
-name = "Claude Haiku 3"
+name = "claude-3-5-haiku-latest"
 family = "claude-haiku"
-release_date = "2024-03-13"
-last_updated = "2024-03-13"
+release_date = "2024-10-22"
+last_updated = "2024-10-22"
 attachment = true
 reasoning = false
 temperature = true
-knowledge = "2024-02"
 tool_call = true
 open_weights = false
+knowledge = "2024-07-31"
 
 [cost]
-input = 0.25
-output = 1.25
+input = 0.800
+output = 4.000
 
 [limit]
 context = 200_000
-output = 4_096
+output = 8_192
 
 [modalities]
 input = ["text", "image", "pdf"]

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

@@ -1,12 +1,13 @@
 name = "claude-haiku-4-5-20251001"
+family = "claude-haiku"
 release_date = "2025-10-16"
 last_updated = "2025-10-16"
 attachment = true
-reasoning = false
+reasoning = true
 temperature = true
 tool_call = true
 open_weights = false
-knowledge = "2025-03"
+knowledge = "2025-02-28"
 
 [cost]
 input = 1.000
@@ -17,5 +18,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,22 @@
+name = "claude-haiku-4-5"
+family = "claude-haiku"
+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-28"
+
+[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-1-20250805.toml

@@ -1,12 +1,13 @@
 name = "claude-opus-4-1-20250805"
+family = "claude-opus"
 release_date = "2025-08-05"
 last_updated = "2025-08-05"
 attachment = true
-reasoning = false
+reasoning = true
 temperature = true
 tool_call = true
 open_weights = false
-knowledge = "2025-03"
+knowledge = "2025-03-31"
 
 [cost]
 input = 15.000
@@ -17,5 +18,5 @@ context = 200_000
 output = 32_000
 
 [modalities]
-input = ["text", "image"]
+input = ["text", "image", "pdf"]
 output = ["text"]

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

@@ -1,19 +1,17 @@
-name = "Claude Opus 4 (US)"
+name = "claude-opus-4-20250514"
 family = "claude-opus"
 release_date = "2025-05-22"
 last_updated = "2025-05-22"
 attachment = true
 reasoning = true
 temperature = true
-knowledge = "2024-04"
 tool_call = true
 open_weights = false
+knowledge = "2025-03-31"
 
 [cost]
-input = 15.00
-output = 75.00
-cache_read = 1.50
-cache_write = 18.75
+input = 15.000
+output = 75.000
 
 [limit]
 context = 200_000

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

@@ -1,12 +1,13 @@
 name = "claude-opus-4-5-20251101"
+family = "claude-opus"
 release_date = "2025-11-25"
 last_updated = "2025-11-25"
 attachment = true
-reasoning = false
+reasoning = true
 temperature = true
 tool_call = true
 open_weights = false
-knowledge = "2025-03"
+knowledge = "2025-03-31"
 
 [cost]
 input = 5.000
@@ -17,5 +18,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,22 @@
+name = "claude-opus-4-5"
+family = "claude-opus"
+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-31"
+
+[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,22 @@
+name = "claude-opus-4-6"
+family = "claude-opus"
+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-31"
+
+[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,31 @@
+name = "claude-opus-4-7"
+family = "claude-opus"
+release_date = "2026-04-17"
+last_updated = "2026-04-17"
+attachment = true
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2026-01-31"
+
+[cost]
+input = 5.000
+output = 25.000
+cache_read = 0.500
+cache_write = 6.250
+
+[[cost.tiers]]
+tier = { size = 200_000 }
+input = 10.000
+output = 37.500
+cache_read = 1.000
+cache_write = 12.500
+
+[limit]
+context = 1_000_000
+output = 128_000
+
+[modalities]
+input = ["text", "image", "pdf"]
+output = ["text"]

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

@@ -1,19 +1,17 @@
-name = "Claude Sonnet 4"
+name = "claude-sonnet-4-20250514"
 family = "claude-sonnet"
 release_date = "2025-05-22"
 last_updated = "2025-05-22"
 attachment = true
 reasoning = true
 temperature = true
-knowledge = "2024-04"
 tool_call = true
 open_weights = false
+knowledge = "2025-03-31"
 
 [cost]
-input = 3.00
-output = 15.00
-cache_read = 0.30
-cache_write = 3.75
+input = 3.000
+output = 15.000
 
 [limit]
 context = 200_000

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,12 +1,13 @@
 name = "claude-sonnet-4-5-20250929"
-release_date = "2025-09-29"
-last_updated = "2025-09-29"
+family = "claude-sonnet"
+release_date = "2025-09-30"
+last_updated = "2025-09-30"
 attachment = true
-reasoning = false
+reasoning = true
 temperature = true
 tool_call = true
 open_weights = false
-knowledge = "2025-03"
+knowledge = "2025-07-31"
 
 [cost]
 input = 3.000
@@ -17,5 +18,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,22 @@
+name = "claude-sonnet-4-5"
+family = "claude-sonnet"
+release_date = "2025-09-30"
+last_updated = "2025-09-30"
+attachment = true
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = false
+knowledge = "2025-07-31"
+
+[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,22 @@
+name = "claude-sonnet-4-6"
+family = "claude-sonnet"
+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-31"
+
+[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,19 +1,17 @@
-name = "GLM-4.5"
-family = "glm"
-release_date = "2025-07-28"
-last_updated = "2025-07-28"
+name = "glm-4.5-air"
+family = "glm-air"
+release_date = "2025-07-29"
+last_updated = "2025-07-29"
 attachment = false
 reasoning = true
 temperature = true
 tool_call = true
-knowledge = "2025-04"
 open_weights = true
+knowledge = "2025-04"
 
 [cost]
-input = 0
-output = 0
-cache_read = 0
-cache_write = 0
+input = 0.1143
+output = 0.286
 
 [limit]
 context = 131_072

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

@@ -1,21 +1,21 @@
-name = "Qwen3 Coder 480B A35B Instruct"
-family = "qwen"
-release_date = "2025-07-23"
-last_updated = "2025-10-04"
+name = "glm-4.5-airx"
+family = "glm"
+release_date = "2025-07-29"
+last_updated = "2025-07-29"
 attachment = false
 reasoning = false
 temperature = true
-knowledge = "2025-04"
 tool_call = true
 open_weights = false
+knowledge = "2025-04"
 
 [cost]
-input = 0.40
-output = 1.80
+input = 0.572
+output = 1.714
 
 [limit]
-context = 262144
-output = 66536
+context = 128_000
+output = 16_384
 
 [modalities]
 input = ["text"]

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

@@ -0,0 +1,22 @@
+name = "glm-4.5-x"
+family = "glm"
+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.5.toml

@@ -1,19 +1,20 @@
 name = "GLM-4.5"
+family = "glm"
 release_date = "2025-07-29"
 last_updated = "2025-07-29"
 attachment = false
-reasoning = false
+reasoning = true
 temperature = true
 tool_call = true
-open_weights = false
-knowledge = "2024-10"
+open_weights = true
+knowledge = "2025-04"
 
 [cost]
 input = 0.286
 output = 1.142
 
 [limit]
-context = 128_000
+context = 131_072
 output = 98_304
 
 [modalities]

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

@@ -1,12 +1,13 @@
 name = "GLM-4.5V"
-release_date = "2025-07-29"
-last_updated = "2025-07-29"
+family = "glm"
+release_date = "2025-08-12"
+last_updated = "2025-08-12"
 attachment = true
-reasoning = false
+reasoning = true
 temperature = true
 tool_call = true
-open_weights = false
-knowledge = "2024-10"
+open_weights = true
+knowledge = "2025-04"
 
 [cost]
 input = 0.290
@@ -17,5 +18,5 @@ context = 64_000
 output = 16_384
 
 [modalities]
-input = ["text", "image"]
+input = ["text", "image", "video"]
 output = ["text"]

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

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

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

@@ -1,12 +1,13 @@
 name = "GLM-4.6V"
+family = "glm"
 release_date = "2025-12-08"
 last_updated = "2025-12-08"
 attachment = true
-reasoning = false
+reasoning = true
 temperature = true
 tool_call = true
-open_weights = false
-knowledge = "2025-03"
+open_weights = true
+knowledge = "2025-04"
 
 [cost]
 input = 0.145
@@ -17,5 +18,5 @@ context = 128_000
 output = 32_768
 
 [modalities]
-input = ["text", "image"]
+input = ["text", "image", "video"]
 output = ["text"]

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

@@ -1,19 +1,17 @@
-name = "GLM-4.7-FlashX"
+name = "glm-4.7-flashx"
 family = "glm-flash"
-release_date = "2026-01-19"
-last_updated = "2026-01-19"
+release_date = "2026-01-20"
+last_updated = "2026-01-20"
 attachment = false
 reasoning = true
 temperature = true
 tool_call = true
-knowledge = "2025-04"
 open_weights = true
+knowledge = "2025-04"
 
 [cost]
-input = 0.07
-output = 0.40
-cache_read = 0.01
-cache_write = 0
+input = 0.0715
+output = 0.429
 
 [limit]
 context = 200_000

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

@@ -1,19 +1,23 @@
 name = "glm-4.7"
+family = "glm"
 release_date = "2025-12-22"
 last_updated = "2025-12-22"
 attachment = false
-reasoning = false
+reasoning = true
 temperature = true
 tool_call = true
-open_weights = false
-knowledge = "2025-06"
+open_weights = true
+knowledge = "2025-04"
+
+[interleaved]
+field = "reasoning_content"
 
 [cost]
 input = 0.286
 output = 1.142
 
 [limit]
-context = 200_000
+context = 204_800
 output = 131_072
 
 [modalities]

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

@@ -0,0 +1,25 @@
+name = "glm-5-turbo"
+family = "glm"
+release_date = "2026-03-16"
+last_updated = "2026-03-16"
+attachment = false
+reasoning = true
+temperature = true
+tool_call = true
+structured_output = true
+open_weights = false
+
+[interleaved]
+field = "reasoning_content"
+
+[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,25 @@
+name = "glm-5.1"
+family = "glm"
+release_date = "2026-04-10"
+last_updated = "2026-04-10"
+attachment = false
+reasoning = true
+temperature = true
+tool_call = true
+structured_output = true
+open_weights = false
+
+[interleaved]
+field = "reasoning_content"
+
+[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

@@ -1,4 +1,4 @@
-name = "GLM5"
+name = "glm-5"
 family = "glm"
 release_date = "2026-02-12"
 last_updated = "2026-02-12"
@@ -6,19 +6,18 @@ attachment = false
 reasoning = true
 temperature = true
 tool_call = true
-structured_output = true
 open_weights = true
 
 [interleaved]
 field = "reasoning_content"
 
 [cost]
-input = 0.0
-output = 0.0
+input = 0.600
+output = 2.600
 
 [limit]
-context = 202752
-output = 131000
+context = 204_800
+output = 131_072
 
 [modalities]
 input = ["text"]

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

@@ -0,0 +1,24 @@
+name = "GLM-5V-Turbo"
+family = "glm"
+release_date = "2026-04-02"
+last_updated = "2026-04-02"
+attachment = true
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = false
+
+[interleaved]
+field = "reasoning_content"
+
+[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,4 +1,4 @@
-name = "GLM 4.6 (exacto)"
+name = "glm-for-coding"
 family = "glm"
 release_date = "2025-09-30"
 last_updated = "2025-09-30"
@@ -6,18 +6,15 @@ attachment = false
 reasoning = true
 temperature = true
 tool_call = true
-structured_output = true
-knowledge = "2025-09"
-open_weights = true
+open_weights = false
 
 [cost]
-input = 0.60
-output = 1.90
-cache_read = 0.11
+input = 0.086
+output = 0.343
 
 [limit]
 context = 200_000
-output = 128_000
+output = 131_072
 
 [modalities]
 input = ["text"]

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

@@ -6,6 +6,7 @@ attachment = true
 reasoning = false
 temperature = true
 tool_call = true
+structured_output = true
 open_weights = false
 knowledge = "2024-04"
 
@@ -14,9 +15,9 @@ input = 0.400
 output = 1.600
 
 [limit]
-context = 1_000_000
+context = 1_047_576
 output = 32_768
 
 [modalities]
-input = ["text", "image"]
+input = ["text", "image", "pdf"]
 output = ["text"]

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

@@ -6,6 +6,7 @@ attachment = true
 reasoning = false
 temperature = true
 tool_call = true
+structured_output = true
 open_weights = false
 knowledge = "2024-04"
 
@@ -14,7 +15,7 @@ input = 0.100
 output = 0.400
 
 [limit]
-context = 1_000_000
+context = 1_047_576
 output = 32_768
 
 [modalities]

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

@@ -6,6 +6,7 @@ attachment = true
 reasoning = false
 temperature = true
 tool_call = true
+structured_output = true
 open_weights = false
 knowledge = "2024-04"
 
@@ -14,9 +15,9 @@ input = 2.000
 output = 8.000
 
 [limit]
-context = 1_000_000
+context = 1_047_576
 output = 32_768
 
 [modalities]
-input = ["text", "image"]
+input = ["text", "image", "pdf"]
 output = ["text"]

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

@@ -6,6 +6,7 @@ attachment = true
 reasoning = false
 temperature = true
 tool_call = true
+structured_output = true
 open_weights = false
 knowledge = "2023-09"
 
@@ -18,5 +19,5 @@ context = 128_000
 output = 16_384
 
 [modalities]
-input = ["text", "image"]
+input = ["text", "image", "pdf"]
 output = ["text"]

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

@@ -1,12 +1,14 @@
 name = "gpt-5-mini"
+family = "gpt-mini"
 release_date = "2025-08-08"
 last_updated = "2025-08-08"
 attachment = true
-reasoning = false
-temperature = true
+reasoning = true
+temperature = false
 tool_call = true
+structured_output = true
 open_weights = false
-knowledge = "2024-10"
+knowledge = "2024-05-30"
 
 [cost]
 input = 0.250
@@ -14,6 +16,7 @@ output = 2.000
 
 [limit]
 context = 400_000
+input = 272_000
 output = 128_000
 
 [modalities]

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

@@ -1,12 +1,14 @@
 name = "gpt-5-pro"
+family = "gpt-pro"
 release_date = "2025-10-08"
 last_updated = "2025-10-08"
 attachment = true
-reasoning = false
-temperature = true
+reasoning = true
+temperature = false
 tool_call = true
+structured_output = true
 open_weights = false
-knowledge = "2024-10"
+knowledge = "2024-09-30"
 
 [cost]
 input = 15.000
@@ -14,6 +16,7 @@ output = 120.000
 
 [limit]
 context = 400_000
+input = 272_000
 output = 272_000
 
 [modalities]

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

@@ -1,12 +1,14 @@
 name = "gpt-5.1-chat-latest"
+family = "gpt-codex"
 release_date = "2025-11-14"
 last_updated = "2025-11-14"
 attachment = true
-reasoning = false
-temperature = true
+reasoning = true
+temperature = false
 tool_call = true
+structured_output = true
 open_weights = false
-knowledge = "2024-10"
+knowledge = "2024-09-30"
 
 [cost]
 input = 1.250

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

@@ -1,12 +1,14 @@
 name = "gpt-5.1"
+family = "gpt"
 release_date = "2025-11-14"
 last_updated = "2025-11-14"
 attachment = true
-reasoning = false
-temperature = true
+reasoning = true
+temperature = false
 tool_call = true
+structured_output = true
 open_weights = false
-knowledge = "2024-10"
+knowledge = "2024-09-30"
 
 [cost]
 input = 1.250
@@ -14,6 +16,7 @@ output = 10.000
 
 [limit]
 context = 400_000
+input = 272_000
 output = 128_000
 
 [modalities]

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

@@ -1,12 +1,14 @@
 name = "gpt-5.2-chat-latest"
+family = "gpt-codex"
 release_date = "2025-12-12"
 last_updated = "2025-12-12"
 attachment = true
-reasoning = false
-temperature = true
+reasoning = true
+temperature = false
 tool_call = true
+structured_output = true
 open_weights = false
-knowledge = "2024-10"
+knowledge = "2025-08-31"
 
 [cost]
 input = 1.750

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

@@ -1,12 +1,14 @@
 name = "gpt-5.2"
+family = "gpt"
 release_date = "2025-12-12"
 last_updated = "2025-12-12"
 attachment = true
-reasoning = false
-temperature = true
+reasoning = true
+temperature = false
 tool_call = true
+structured_output = true
 open_weights = false
-knowledge = "2024-10"
+knowledge = "2025-08-31"
 
 [cost]
 input = 1.750
@@ -14,6 +16,7 @@ output = 14.000
 
 [limit]
 context = 400_000
+input = 272_000
 output = 128_000
 
 [modalities]

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,31 @@
+name = "gpt-5.4-pro"
+family = "gpt-pro"
+release_date = "2026-03-05"
+last_updated = "2026-03-05"
+attachment = true
+reasoning = true
+temperature = false
+tool_call = true
+structured_output = false
+open_weights = false
+knowledge = "2025-08-31"
+
+[cost]
+input = 30.000
+output = 180.000
+cache_read = 0
+cache_write = 0
+
+[[cost.tiers]]
+tier = { size = 272_000 }
+input = 60.000
+output = 270.000
+
+[limit]
+context = 1_050_000
+input = 922_000
+output = 128_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

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

@@ -0,0 +1,31 @@
+name = "gpt-5.4"
+family = "gpt"
+release_date = "2026-03-05"
+last_updated = "2026-03-05"
+attachment = true
+reasoning = true
+temperature = false
+tool_call = true
+structured_output = true
+open_weights = false
+knowledge = "2025-08-31"
+
+[cost]
+input = 2.500
+output = 15.000
+cache_read = 0.250
+cache_write = 0
+
+[[cost.tiers]]
+tier = { size = 272_000 }
+input = 5.000
+output = 22.500
+
+[limit]
+context = 1_050_000
+input = 922_000
+output = 128_000
+
+[modalities]
+input = ["text", "image", "pdf"]
+output = ["text"]

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

@@ -1,12 +1,14 @@
 name = "gpt-5"
+family = "gpt"
 release_date = "2025-08-08"
 last_updated = "2025-08-08"
 attachment = true
-reasoning = false
-temperature = true
+reasoning = true
+temperature = false
 tool_call = true
+structured_output = true
 open_weights = false
-knowledge = "2024-10"
+knowledge = "2024-09-30"
 
 [cost]
 input = 1.250
@@ -14,6 +16,7 @@ output = 10.000
 
 [limit]
 context = 400_000
+input = 272_000
 output = 128_000
 
 [modalities]

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

@@ -1,18 +1,15 @@
-name = "Grok 4 Fast (Non-Reasoning)"
-family = "grok"
-release_date = "2025-09-19"
-last_updated = "2025-09-19"
+name = "grok-4.20-beta-0309-non-reasoning"
+release_date = "2026-03-16"
+last_updated = "2026-03-16"
 attachment = true
 reasoning = false
 temperature = true
-knowledge = "2025-07"
 tool_call = true
 open_weights = false
 
 [cost]
-input = 0.20
-output = 0.50
-cache_read = 0.05
+input = 2.000
+output = 6.000
 
 [limit]
 context = 2_000_000

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

@@ -1,18 +1,15 @@
-name = "Grok 4 Fast"
-family = "grok"
-release_date = "2025-09-19"
-last_updated = "2025-09-19"
+name = "grok-4.20-beta-0309-reasoning"
+release_date = "2026-03-16"
+last_updated = "2026-03-16"
 attachment = true
 reasoning = true
 temperature = true
-knowledge = "2025-07"
 tool_call = true
 open_weights = false
 
 [cost]
-input = 0.20
-output = 0.50
-cache_read = 0.05
+input = 2.000
+output = 6.000
 
 [limit]
 context = 2_000_000

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

@@ -1,18 +1,15 @@
-name = "Grok 4.1 Fast"
-family = "grok"
-release_date = "2025-11-19"
-last_updated = "2025-11-19"
+name = "grok-4.20-multi-agent-beta-0309"
+release_date = "2026-03-16"
+last_updated = "2026-03-16"
 attachment = true
 reasoning = true
 temperature = true
-knowledge = "2025-07"
 tool_call = true
 open_weights = false
 
 [cost]
-input = 0.20
-output = 0.50
-cache_read = 0.05
+input = 2.000
+output = 6.000
 
 [limit]
 context = 2_000_000
@@ -20,4 +17,4 @@ output = 30_000
 
 [modalities]
 input = ["text", "image"]
-output = ["text"]
+output = ["text"]

providers/abliteration-ai/logo.svg

@@ -0,0 +1,6 @@
+<svg viewBox="0 0 220 32" xmlns="http://www.w3.org/2000/svg">
+  <text x="0" y="24" fill="currentColor">
+    <tspan font-size="24">Abliteration</tspan>
+    <tspan dx="8" dy="2" font-size="12" fill-opacity="0.6">.ai</tspan>
+  </text>
+</svg>

providers/abliteration-ai/models/abliterated-model.toml

@@ -0,0 +1,22 @@
+name = "Abliterated Model"
+release_date = "2026-01-06"
+last_updated = "2026-01-06"
+attachment = true
+reasoning = false
+tool_call = true
+structured_output = false
+temperature = true
+open_weights = true
+
+[cost]
+input = 3.00
+output = 3.00
+
+[limit]
+context = 150_000
+input = 150_000
+output = 8_192
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]

providers/abliteration-ai/provider.toml

@@ -0,0 +1,5 @@
+name = "abliteration.ai"
+env = ["ABLIT_KEY"]
+npm = "@ai-sdk/openai-compatible"
+api = "https://api.abliteration.ai/v1"
+doc = "https://docs.abliteration.ai/models"

providers/aihubmix/models/Kimi-K2-0905.toml

@@ -1,22 +0,0 @@
-name = "Kimi K2 0905"
-family = "kimi"
-release_date = "2025-09-05"
-last_updated = "2025-09-05"
-attachment = false
-reasoning = false
-temperature = true
-tool_call = true
-knowledge = "2024-10"
-open_weights = true
-
-[cost]
-input = 0.55
-output = 2.19
-
-[limit]
-context = 262_144
-output = 262_144
-
-[modalities]
-input = ["text"]
-output = ["text"]

providers/aihubmix/models/alicloud-deepseek-v4-flash.toml

@@ -0,0 +1,27 @@
+name = "DeepSeek V4 Flash (Alibaba Cloud)"
+family = "deepseek-flash"
+release_date = "2026-04-24"
+last_updated = "2026-04-24"
+attachment = false
+reasoning = true
+temperature = true
+tool_call = true
+structured_output = true
+knowledge = "2025-05"
+open_weights = true
+
+[interleaved]
+field = "reasoning_content"
+
+[cost]
+input = 0.14
+output = 0.28
+cache_read = 0.028
+
+[limit]
+context = 1_000_000
+output = 384_000
+
+[modalities]
+input = ["text"]
+output = ["text"]

providers/aihubmix/models/alicloud-deepseek-v4-pro.toml

@@ -0,0 +1,27 @@
+name = "DeepSeek V4 Pro (Alibaba Cloud)"
+family = "deepseek-thinking"
+release_date = "2026-04-24"
+last_updated = "2026-04-24"
+attachment = false
+reasoning = true
+temperature = true
+tool_call = true
+structured_output = true
+knowledge = "2025-05"
+open_weights = true
+
+[interleaved]
+field = "reasoning_content"
+
+[cost]
+input = 1.69
+output = 3.38
+cache_read = 0.13
+
+[limit]
+context = 1_000_000
+output = 384_000
+
+[modalities]
+input = ["text"]
+output = ["text"]

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

@@ -1,7 +1,7 @@
-name = "GLM 4.6 TEE"
+name = "GLM-5.1 (Alibaba Cloud)"
 family = "glm"
-release_date = "2025-12-29"
-last_updated = "2026-01-10"
+release_date = "2026-03-27"
+last_updated = "2026-03-27"
 attachment = false
 reasoning = true
 temperature = true
@@ -9,18 +9,19 @@ tool_call = true
 structured_output = true
 open_weights = true
 
+[interleaved]
+field = "reasoning_content"
+
 [cost]
-input = 0.40
-output = 1.70
-cache_read = 0.20
+input = 0.84
+output = 3.38
+cache_read = 0.169
+cache_write = 1.05625
 
 [limit]
-context = 202_752
-output = 65_536
+context = 200_000
+output = 128_000
 
 [modalities]
 input = ["text"]
 output = ["text"]
-
-[interleaved]
-field = "reasoning_content"

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

@@ -1,28 +1,33 @@
-name = "Claude Opus 4.6 Think"
+name = "Claude Opus 4.6 Thinking"
 family = "claude-opus"
 release_date = "2026-02-05"
-last_updated = "2026-02-05"
+last_updated = "2026-03-13"
 attachment = true
 reasoning = true
 temperature = true
 tool_call = true
+structured_output = true
 knowledge = "2025-05-31"
 open_weights = false
 
-[cost]
-input = 5.00
-output = 25.00
-cache_read = 0.30
-cache_write = 3.75
+[interleaved]
+field = "reasoning_content"
 
-[cost.context_over_200k]
-input = 6.00
-output = 22.00
-cache_read = 0.60
-cache_write = 7.50
+[cost]
+input = 5
+output = 25
+cache_read = 0.5
+cache_write = 6.25
+
+[[cost.tiers]]
+tier = { size = 200_000 }
+input = 10
+output = 37.5
+cache_read = 1.0
+cache_write = 12.5
 
 [limit]
-context = 200_000
+context = 1_000_000
 output = 128_000
 
 [modalities]

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

@@ -1,28 +1,32 @@
 name = "Claude Opus 4.6"
 family = "claude-opus"
 release_date = "2026-02-05"
-last_updated = "2026-02-05"
+last_updated = "2026-03-13"
 attachment = true
 reasoning = true
 temperature = true
 tool_call = true
+structured_output = true
 knowledge = "2025-05-31"
 open_weights = false
 
-[cost]
-input = 5.00
-output = 25.00
-cache_read = 0.30
-cache_write = 3.75
+interleaved = true
 
-[cost.context_over_200k]
-input = 6.00
-output = 22.00
-cache_read = 0.60
-cache_write = 7.50
+[cost]
+input = 5
+output = 25
+cache_read = 0.5
+cache_write = 6.25
+
+[[cost.tiers]]
+tier = { size = 200_000 }
+input = 10
+output = 37.5
+cache_read = 1.0
+cache_write = 12.5
 
 [limit]
-context = 200_000
+context = 1_000_000
 output = 128_000
 
 [modalities]

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

@@ -0,0 +1,35 @@
+name = "Claude Opus 4.7 Thinking"
+family = "claude-opus"
+release_date = "2026-04-16"
+last_updated = "2026-04-16"
+attachment = true
+reasoning = true
+temperature = false
+tool_call = true
+structured_output = true
+knowledge = "2026-01-31"
+open_weights = false
+
+[interleaved]
+field = "reasoning_content"
+
+[cost]
+input = 5
+output = 25
+cache_read = 0.5
+cache_write = 6.25
+
+[[cost.tiers]]
+tier = { size = 200_000 }
+input = 10
+output = 37.5
+cache_read = 1.0
+cache_write = 12.5
+
+[limit]
+context = 1_000_000
+output = 128_000
+
+[modalities]
+input = ["text", "image", "pdf"]
+output = ["text"]

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

@@ -0,0 +1,34 @@
+name = "Claude Opus 4.7"
+family = "claude-opus"
+release_date = "2026-04-16"
+last_updated = "2026-04-16"
+attachment = true
+reasoning = true
+temperature = false
+tool_call = true
+structured_output = true
+knowledge = "2026-01-31"
+open_weights = false
+
+interleaved = true
+
+[cost]
+input = 5
+output = 25
+cache_read = 0.5
+cache_write = 6.25
+
+[[cost.tiers]]
+tier = { size = 200_000 }
+input = 10
+output = 37.5
+cache_read = 1.0
+cache_write = 12.5
+
+[limit]
+context = 1_000_000
+output = 128_000
+
+[modalities]
+input = ["text", "image", "pdf"]
+output = ["text"]

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

@@ -1,28 +1,33 @@
-name = "Claude Sonnet 4.6 Think"
+name = "Claude Sonnet 4.6 Thinking"
 family = "claude-sonnet"
 release_date = "2026-02-17"
-last_updated = "2026-02-17"
+last_updated = "2026-03-13"
 attachment = true
 reasoning = true
 temperature = true
 tool_call = true
+structured_output = true
 knowledge = "2025-08-31"
 open_weights = false
 
+[interleaved]
+field = "reasoning_content"
+
 [cost]
 input = 3.00
 output = 15.00
 cache_read = 0.30
 cache_write = 3.75
 
-[cost.context_over_200k]
+[[cost.tiers]]
+tier = { size = 200_000 }
 input = 6.00
 output = 22.50
 cache_read = 0.60
 cache_write = 7.50
 
 [limit]
-context = 200_000
+context = 1_000_000
 output = 64_000
 
 [modalities]

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

@@ -1,28 +1,32 @@
 name = "Claude Sonnet 4.6"
 family = "claude-sonnet"
 release_date = "2026-02-17"
-last_updated = "2026-02-17"
+last_updated = "2026-03-13"
 attachment = true
 reasoning = true
 temperature = true
 tool_call = true
+structured_output = true
 knowledge = "2025-08-31"
 open_weights = false
 
+interleaved = true
+
 [cost]
 input = 3.00
 output = 15.00
 cache_read = 0.30
 cache_write = 3.75
 
-[cost.context_over_200k]
+[[cost.tiers]]
+tier = { size = 200_000 }
 input = 6.00
 output = 22.50
 cache_read = 0.60
 cache_write = 7.50
 
 [limit]
-context = 200_000
+context = 1_000_000
 output = 64_000
 
 [modalities]

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

@@ -1,28 +0,0 @@
-name = "Coding GLM 4.7 Free"
-family = "glm"
-release_date = "2025-12-22"
-last_updated = "2025-12-22"
-attachment = false
-reasoning = true
-temperature = true
-tool_call = true
-knowledge = "2025-04"
-open_weights = true
-
-[interleaved]
-field = "reasoning_details"
-
-[cost]
-input = 0
-output = 0
-cache_read = 0
-cache_write = 0
-
-[limit]
-context = 204800
-output = 131072
-
-[modalities]
-input = ["text"]
-output = ["text"]
-

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

@@ -1,27 +0,0 @@
-name = "Coding-GLM-4.7"
-family = "glm"
-release_date = "2025-12-22"
-last_updated = "2025-12-22"
-attachment = false
-reasoning = true
-temperature = true
-tool_call = true
-knowledge = "2025-04"
-open_weights = true
-
-[interleaved]
-field = "reasoning_details"
-
-[cost]
-input = 0.06
-output = 0.22
-cache_read = 0.01
-
-[limit]
-context = 204800
-output = 131072
-
-[modalities]
-input = ["text"]
-output = ["text"]
-

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

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

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

@@ -1,4 +1,4 @@
-name = "Coding-GLM-5.1"
+name = "Coding GLM 5.1"
 family = "glm"
 release_date = "2026-04-11"
 last_updated = "2026-04-11"
@@ -6,7 +6,8 @@ attachment = false
 reasoning = true
 temperature = true
 tool_call = true
-open_weights = false
+structured_output = true
+open_weights = true
 
 [interleaved]
 field = "reasoning_content"
@@ -14,10 +15,11 @@ field = "reasoning_content"
 [cost]
 input = 0.06
 output = 0.22
+cache_read = 0.013
 
 [limit]
-context = 200000
-output = 128000
+context = 200_000
+output = 128_000
 
 [modalities]
 input = ["text"]

providers/aihubmix/models/coding-minimax-m2.7-free.toml

@@ -1,7 +1,7 @@
-name = "Hermes 4 405B FP8 TEE"
-family = "nousresearch"
-release_date = "2025-12-29"
-last_updated = "2026-01-10"
+name = "Coding MiniMax M2.7 (Free)"
+family = "minimax-free"
+release_date = "2026-03-18"
+last_updated = "2026-03-18"
 attachment = false
 reasoning = true
 temperature = true
@@ -9,17 +9,17 @@ tool_call = true
 structured_output = true
 open_weights = true
 
+[interleaved]
+field = "reasoning_content"
+
 [cost]
-input = 0.30
-output = 1.20
+input = 0
+output = 0
 
 [limit]
-context = 131_072
-output = 65_536
+context = 204_800
+output = 128_100
 
 [modalities]
 input = ["text"]
 output = ["text"]
-
-[interleaved]
-field = "reasoning_content"

providers/aihubmix/models/coding-minimax-m2.7-highspeed.toml

@@ -0,0 +1,25 @@
+name = "Coding MiniMax M2.7 Highspeed"
+family = "minimax"
+release_date = "2026-03-18"
+last_updated = "2026-03-18"
+attachment = false
+reasoning = true
+temperature = true
+tool_call = true
+structured_output = true
+open_weights = true
+
+[interleaved]
+field = "reasoning_content"
+
+[cost]
+input = 0.2
+output = 0.2
+
+[limit]
+context = 204_800
+output = 128_100
+
+[modalities]
+input = ["text"]
+output = ["text"]

providers/aihubmix/models/coding-minimax-m2.7.toml

@@ -1,7 +1,7 @@
-name = "MiniMax M2.1 TEE"
+name = "Coding MiniMax M2.7"
 family = "minimax"
-release_date = "2025-12-29"
-last_updated = "2026-01-27"
+release_date = "2026-03-18"
+last_updated = "2026-03-18"
 attachment = false
 reasoning = true
 temperature = true
@@ -9,17 +9,17 @@ tool_call = true
 structured_output = true
 open_weights = true
 
+[interleaved]
+field = "reasoning_content"
+
 [cost]
-input = 0.27
-output = 1.12
+input = 0.2
+output = 0.2
 
 [limit]
-context = 196_608
-output = 65_536
+context = 204_800
+output = 128_100
 
 [modalities]
 input = ["text"]
 output = ["text"]
-
-[interleaved]
-field = "reasoning_content"

providers/aihubmix/models/coding-xiaomi-mimo-v2.5-pro.toml

@@ -0,0 +1,17 @@
+name = "Coding Xiaomi MiMo-V2.5-Pro"
+family = "mimo-v2.5-pro"
+last_updated = "2026-05-13"
+
+[extends]
+from = "xiaomi/mimo-v2.5-pro"
+
+[cost]
+input = 0.20
+output = 0.60
+cache_read = 0.04
+
+[[cost.tiers]]
+tier = { size = 256_000 }
+input = 0.40
+output = 1.20
+cache_read = 0.08

providers/aihubmix/models/coding-xiaomi-mimo-v2.5.toml

@@ -0,0 +1,17 @@
+name = "Coding Xiaomi MiMo-V2.5"
+family = "mimo-v2.5"
+last_updated = "2026-05-13"
+
+[extends]
+from = "xiaomi/mimo-v2.5"
+
+[cost]
+input = 0.08
+output = 0.40
+cache_read = 0.016
+
+[[cost.tiers]]
+tier = { size = 256_000 }
+input = 0.16
+output = 0.80
+cache_read = 0.032