Made api optional for @ai-sdk/openai

Co-authored-by: rekram1-node <rekram1-node@users.noreply.github.com>
Merge pull request #600 from xiaojiezj/zenmux_dev
2026-01-06 04:41:52 +00:00 · 2026-01-04 23:27:39 -08:00 · 2026-01-05 15:23:24 +08:00 · 2026-01-04 22:49:06 -08:00 · 2026-01-05 14:18:23 +08:00 · 2026-01-04 20:06:15 -08:00
2219 changed files with 43570 additions and 3040 deletions
@@ -0,0 +1,25 @@
+name: opencode
+
+on:
+  issue_comment:
+    types: [created]
+
+jobs:
+  opencode:
+    if: |
+      contains(github.event.comment.body, '/oc') ||
+      contains(github.event.comment.body, '/opencode')
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Run opencode
+        uses: sst/opencode/github@latest
+        env:
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+        with:
+          model: anthropic/claude-sonnet-4-20250514
@@ -21,4 +21,4 @@ jobs:
        run: bun install

      - name: Run validation script
-        run: script/validate.ts
+        run: bun validate
@@ -1,4 +1,5 @@
 .env
 .sst
 dist
+.DS_Store
 node_modules
@@ -0,0 +1,29 @@
+# Agent Guidelines for models.dev
+
+## Commands
+- **Validate**: `bun validate` - Validates all provider/model configurations
+- **Build web**: `cd packages/web && bun run build` - Builds the web interface
+- **Dev server**: `cd packages/web && bun run dev` - Runs development server
+- **No test framework** - No dedicated test commands found
+
+## Code Style
+- **Runtime**: Bun with TypeScript ESM modules
+- **Imports**: Use `.js` extensions for local imports (e.g., `./schema.js`)
+- **Types**: Strict Zod schemas for validation, inferred types with `z.infer<typeof Schema>`
+- **Naming**: camelCase for variables/functions, PascalCase for types/schemas
+- **Error handling**: Use Zod's `safeParse()` with structured error objects including `cause`
+- **Async**: Use `async/await`, `for await` loops for file operations
+- **File operations**: Use Bun's native APIs (`Bun.Glob`, `Bun.file`, `Bun.write`)
+
+## Architecture
+- **Monorepo**: Workspace packages in `packages/` (core, web, function)
+- **Config**: TOML files for providers/models in `providers/` directory
+- **Validation**: Core package validates all configurations via `generate()` function
+- **Web**: Static site generation with Hono server and vanilla TypeScript
+- **Deploy**: Cloudflare Workers for function, static assets for web
+
+## Conventions
+- Use `export interface` for API types, `export const Schema = z.object()` for validation
+- Prefix unused variables with underscore or use `_` for ignored parameters
+- Handle undefined values explicitly in comparisons and sorting
+- Use optional chaining (`?.`) and nullish coalescing (`??`) for safe property access
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 models.dev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
@@ -24,9 +24,19 @@ curl https://models.dev/api.json

 Use the **Model ID** field to do a lookup on any model; it's the identifier used by [AI SDK](https://ai-sdk.dev/).

+### Logos
+
+Provider logos are available as SVG files:
+
+```bash
+curl https://models.dev/logos/{provider}.svg
+```
+
+Replace `{provider}` with the **Provider ID** (e.g., `anthropic`, `openai`, `google`). If we don't have a provider's logo, a default logo is served instead.
+
 ## Contributing

-The data is stored in the repo as TOML files; organized by provider and model. This is used to generate this page and power the API.
+The data is stored in the repo as TOML files; organized by provider and model. The logo is stored as an SVG. This is used to generate this page and power the API.

 We need your help keeping the data up to date.

@@ -36,37 +46,81 @@ To add a new model, start by checking if the provider already exists in the `pro

 #### 1. Create a Provider

-If the AI provider doesn't already exist in the `providers/` directory:
+If the provider isn't already in `providers/`:

 1. Create a new folder in `providers/` with the provider's ID. For example, `providers/newprovider/`.
-2. Add a `provider.toml` file with the provider information:
+2. Add a `provider.toml` with the provider details:

   ```toml
   name = "Provider Name"
+   npm = "@ai-sdk/provider" # AI SDK Package name
+   env = ["PROVIDER_API_KEY"] # Environment Variable keys used for auth
+   doc = "https://example.com/docs/models" # Link to provider's documentation
   ```

-#### 2. Add a Model Definition
+   If the provider doesn’t publish an npm package but exposes an OpenAI-compatible endpoint, set the npm field accordingly and include the base URL:

-Create a new TOML file in the provider's `models/` directory where the filename is the model ID:
+   ```toml
+   npm = "@ai-sdk/openai-compatible" # Use OpenAI-compatible SDK
+   api = "https://api.example.com/v1" # Required with openai-compatible
+   ```
+
+#### 2. Add a Logo (optional)
+
+To add a logo for the provider:
+
+1. Add a `logo.svg` file to the provider's directory (e.g., `providers/newprovider/logo.svg`)
+2. Use SVG format with no fixed size or colors - use `currentColor` for fills/strokes
+
+Example SVG structure:
+
+```svg
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="currentColor">
+  <!-- Logo paths here -->
+</svg>
+```
+
+#### 3. Add a Model Definition
+
+Create a new TOML file in the provider's `models/` directory where the filename is the model ID.
+
+If the model ID contains `/`, use subfolders. For example, for the model ID `openai/gpt-5`, create a folder `openai/` and place a file named `gpt-5.toml` inside it.

 ```toml
 name = "Model Display Name"
-attachment = true  # or false - supports file attachments
-reasoning = false  # or true - supports reasoning/chain-of-thought
-temperature = true # or false - supports temperature parameter
+attachment = true           # or false - supports file attachments
+reasoning = false           # or true - supports reasoning / chain-of-thought
+tool_call = true            # or false - supports tool calling
+structured_output = true    # or false - supports a dedicated structured output feature
+temperature = true          # or false - supports temperature control
+knowledge = "2024-04"       # Knowledge-cutoff date
+release_date = "2025-02-19" # First public release date
+last_updated = "2025-02-19" # Most recent update date
+open_weights = true         # or false  - model’s trained weights are publicly available

 [cost]
-input = 3.00          # Cost per million input tokens (USD)
-output = 15.00        # Cost per million output tokens (USD)
-inputCached = 0.30    # Cost per million cached input tokens (USD)
-outputCached = 0.30   # Cost per million cached output tokens (USD)
+input = 3.00                # Cost per million input tokens (USD)
+output = 15.00              # Cost per million output tokens (USD)
+reasoning = 15.00           # Cost per million reasoning tokens (USD)
+cache_read = 0.30           # Cost per million cached read tokens (USD)
+cache_write = 3.75          # Cost per million cached write tokens (USD)
+input_audio = 1.00          # Cost per million audio input tokens (USD)
+output_audio = 10.00        # Cost per million audio output tokens (USD)

 [limit]
-context = 200_000     # Maximum context window (tokens)
-output = 8_192        # Maximum output tokens
+context = 400_000           # Maximum context window (tokens)
+context = 272_000           # Maximum input tokens
+output = 8_192              # Maximum output tokens
+
+[modalities]
+input = ["text", "image"]   # Supported input modalities
+output = ["text"]           # Supported output modalities
+
+[interleaved]
+field = "reasoning_content" # Name of the interleaved field "reasoning_content" or "reasoning_details"
 ```

-#### 3. Submit a Pull Request
+#### 4. Submit a Pull Request

 1. Fork this repo
 2. Create a new branch with your changes
@@ -89,19 +143,41 @@ Models must conform to the following schema, as defined in `app/schemas.ts`.
 **Provider Schema:**

 - `name`: String - Display name of the provider
+- `npm`: String - AI SDK Package name
+- `env`: String[] - Environment variable keys used for auth
+- `doc`: String - Link to the provider's documentation
+- `api` _(optional)_: String - OpenAI-compatible API endpoint. Required only when using `@ai-sdk/openai-compatible` as the npm package

 **Model Schema:**

- `name`: String - Display name of the model
- `attachment`: Boolean - Whether the model supports file attachments
- `reasoning`: Boolean - Whether the model supports reasoning capabilities
- `temperature`: Boolean - Whether the model supports temperature control
- `cost.input`: Number - Cost per million input tokens (USD)
- `cost.output`: Number - Cost per million output tokens (USD)
- `cost.inputCached`: Number - Cost per million cached input tokens (USD)
- `cost.outputCached`: Number - Cost per million cached output tokens (USD)
- `limit.context`: Number - Maximum context window in tokens
- `limit.output`: Number - Maximum output tokens
+- `name`: String — Display name of the model
+- `attachment`: Boolean — Supports file attachments
+- `reasoning`: Boolean — Supports reasoning / chain-of-thought
+- `tool_call`: Boolean - Supports tool calling
+- `structured_output` _(optional)_: Boolean — Supports structured output feature
+- `temperature` _(optional)_: Boolean — Supports temperature control
+- `knowledge` _(optional)_: String — Knowledge-cutoff date in `YYYY-MM` or `YYYY-MM-DD` format
+- `release_date`: String — First public release date in `YYYY-MM` or `YYYY-MM-DD`
+- `last_updated`: String — Most recent update date in `YYYY-MM` or `YYYY-MM-DD`
+- `open_weights`: Boolean - Indicate the model's trained weights are publicly available
+- `interleaved` _(optional)_: Boolean or Object — Supports interleaved reasoning. Use `true` for general support or an object with `field` to specify the format
+- `interleaved.field`: String — Name of the interleaved field (`"reasoning_content"` or `"reasoning_details"`)
+- `cost.input`: Number — Cost per million input tokens (USD)
+- `cost.output`: Number — Cost per million output tokens (USD)
+- `cost.reasoning` _(optional)_: Number — Cost per million reasoning tokens (USD)
+- `cost.cache_read` _(optional)_: Number — Cost per million cached read tokens (USD)
+- `cost.cache_write` _(optional)_: Number — Cost per million cached write tokens (USD)
+- `cost.input_audio` _(optional)_: Number — Cost per million audio input tokens, if billed separately (USD)
+- `cost.output_audio` _(optional)_: Number — Cost per million audio output tokens, if billed separately (USD)
+- `limit.context`: Number — Maximum context window (tokens)
+- `limit.input`: Number — Maximum input tokens
+- `limit.output`: Number — Maximum output tokens
+- `modalities.input`: Array of strings — Supported input modalities (e.g., ["text", "image", "audio", "video", "pdf"])
+- `modalities.output`: Array of strings — Supported output modalities (e.g., ["text"])
+- `status` _(optional)_: String — Supported status:
+  - `alpha` - Indicate the model is in alpha testing
+  - `beta` - Indicate the model is in beta testing
+  - `deprecated` - Indicate the model is no longer served by the provider's public API

 ### Examples

@@ -1,44 +1,69 @@
 {
  "lockfileVersion": 1,
+  "configVersion": 0,
  "workspaces": {
    "": {
      "name": "models.dev",
      "dependencies": {
+        "@cloudflare/workers-types": "^4.20250801.0",
        "sst": "3.17.5",
      },
    },
    "packages/core": {
-      "name": "@models.dev/core",
+      "name": "models.dev",
+      "version": "0.0.0",
      "dependencies": {
        "zod": "catalog:",
      },
      "devDependencies": {
        "@tsconfig/bun": "catalog:",
+        "@types/bun": "catalog:",
+        "@types/node": "catalog:",
+      },
+    },
+    "packages/function": {
+      "name": "@models.dev/function",
+      "devDependencies": {
+        "@cloudflare/workers-types": "4.20250522.0",
+        "@tsconfig/bun": "catalog:",
      },
    },
    "packages/web": {
      "name": "@models.dev/web",
      "dependencies": {
        "hono": "^4.8.0",
+        "models.dev": "workspace:*",
+      },
+      "devDependencies": {
+        "@types/bun": "^1.2.16",
      },
    },
  },
  "catalog": {
    "@tsconfig/bun": "^1.0.8",
+    "@types/bun": "1.3.0",
    "@types/node": "22.13.9",
    "ai": "4.3.16",
    "typescript": "5.8.2",
    "zod": "3.24.2",
  },
  "packages": {
+    "@cloudflare/workers-types": ["@cloudflare/workers-types@4.20250801.0", "", {}, "sha512-BQmMdoOGClY23TesgkR1PeGrPvPsSFD/zW7pDzWZHkOEsqkPk2A91h52bP8GbtKYTl1vdaYjQgJlGsP6Ih4G0w=="],
+
    "@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=="],

-    "@models.dev/core": ["@models.dev/core@workspace:packages/core"],
+    "@models.dev/function": ["@models.dev/function@workspace:packages/function"],

    "@models.dev/web": ["@models.dev/web@workspace:packages/web"],

    "@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/node": ["@types/node@22.13.9", "", { "dependencies": { "undici-types": "~6.20.0" } }, "sha512-acBjXdRJ3A6Pb3tqnw9HZmyR3Fiol3aGxRCK1x3d+6CDAMjl7I649wpSd+yNURCjbOUGu9tqtLKnTGxmK6CyGw=="],
+
+    "@types/react": ["@types/react@19.2.2", "", { "dependencies": { "csstype": "^3.0.2" } }, "sha512-6mDvHUFSjyT2B2yeNx2nUgMxh9LtOWvkhIU3uePn2I2oyNymUAX1NIsdgviM4CH+JSrp2D2hsMvJOkxY+0wNRA=="],
+
    "accepts": ["accepts@2.0.0", "", { "dependencies": { "mime-types": "^3.0.0", "negotiator": "^1.0.0" } }, "sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng=="],

    "available-typed-arrays": ["available-typed-arrays@1.0.7", "", { "dependencies": { "possible-typed-array-names": "^1.0.0" } }, "sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ=="],
@@ -53,6 +78,8 @@

    "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=="],
+
    "bytes": ["bytes@3.1.2", "", {}, "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg=="],

    "call-bind": ["call-bind@1.0.8", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.0", "es-define-property": "^1.0.0", "get-intrinsic": "^1.2.4", "set-function-length": "^1.2.2" } }, "sha512-oKlSFMcMwpUg2ednkhQ454wfWiU/ul3CkJe/PEHcTKuiX6RpbehUiFMXu13HalGZxfUwCQzZG747YXBn1im9ww=="],
@@ -71,6 +98,8 @@

    "cors": ["cors@2.8.5", "", { "dependencies": { "object-assign": "^4", "vary": "^1" } }, "sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g=="],

+    "csstype": ["csstype@3.1.3", "", {}, "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw=="],
+
    "debug": ["debug@4.4.1", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ=="],

    "define-data-property": ["define-data-property@1.1.4", "", { "dependencies": { "es-define-property": "^1.0.0", "es-errors": "^1.3.0", "gopd": "^1.0.1" } }, "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A=="],
@@ -169,6 +198,8 @@

    "mime-types": ["mime-types@3.0.1", "", { "dependencies": { "mime-db": "^1.54.0" } }, "sha512-xRc4oEhT6eaBpU1XF7AjpOFD+xQmXNB5OVKwp4tqCuBpHLS/ZbBDrc07mYTDqVMg6PfxUjjNp85O6Cd2Z/5HWA=="],

+    "models.dev": ["models.dev@workspace:packages/core"],
+
    "ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="],

    "negotiator": ["negotiator@1.0.0", "", {}, "sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg=="],
@@ -259,6 +290,8 @@

    "type-is": ["type-is@2.0.1", "", { "dependencies": { "content-type": "^1.0.5", "media-typer": "^1.1.0", "mime-types": "^3.0.0" } }, "sha512-OZs6gsjF4vMp32qrCbiVSkrFmXtG/AZhY3t0iAMrMBiAZyV9oALtXO8hsrHbMXF9x6L3grlFuwW2oAz7cav+Gw=="],

+    "undici-types": ["undici-types@6.20.0", "", {}, "sha512-Ny6QZ2Nju20vw1SRHe3d9jVu6gJ+4e3+MMpqu7pqE5HT6WsTSlce++GQmK5UXS8mzV8DSYHrQH+Xrf2jVcuKNg=="],
+
    "unpipe": ["unpipe@1.0.0", "", {}, "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ=="],

    "url": ["url@0.10.3", "", { "dependencies": { "punycode": "1.3.2", "querystring": "0.2.0" } }, "sha512-hzSUW2q06EqL1gKM/a+obYHLIO6ct2hwPuviqTTOcfFVc61UbfJ2Q32+uGL/HCPxKqrdGB5QUwIe7UqlDgwsOQ=="],
@@ -283,12 +316,26 @@

    "zod-to-json-schema": ["zod-to-json-schema@3.24.3", "", { "peerDependencies": { "zod": "^3.24.1" } }, "sha512-HIAfWdYIt1sssHfYZFCXp4rU1w2r8hVVXYIlmoa0r0gABLs5di3RCqPU5DDROogVz1pAdYBaz7HK5n9pSUNs3A=="],

+    "@models.dev/function/@cloudflare/workers-types": ["@cloudflare/workers-types@4.20250522.0", "", {}, "sha512-9RIffHobc35JWeddzBguGgPa4wLDr5x5F94+0/qy7LiV6pTBQ/M5qGEN9VA16IDT3EUpYI0WKh6VpcmeVEtVtw=="],
+
+    "bun-types/@types/node": ["@types/node@24.0.3", "", { "dependencies": { "undici-types": "~7.8.0" } }, "sha512-R4I/kzCYAdRLzfiCabn9hxWfbuHS573x+r0dJMkkzThEa7pbrcDWK+9zu3e7aBOouf+rQAciqPFMnxwr0aWgKg=="],
+
    "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=="],

    "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=="],
  }
 }
@@ -8,12 +8,19 @@
    "catalog": {
      "typescript": "5.8.2",
      "@types/node": "22.13.9",
+      "@types/bun": "1.3.0",
      "zod": "3.24.2",
      "ai": "4.3.16",
      "@tsconfig/bun": "^1.0.8"
    }
  },
+"scripts": {
+    "validate": "bun ./packages/core/script/validate.ts",
+    "helicone:generate": "bun ./packages/core/script/generate-helicone.ts",
+    "venice:generate": "bun ./packages/core/script/generate-venice.ts"
+  },
  "dependencies": {
+    "@cloudflare/workers-types": "^4.20250801.0",
    "sst": "3.17.5"
  }
 }
@@ -1,5 +1,6 @@
 {
-  "name": "@models.dev/core",
+  "name": "models.dev",
+  "version": "0.0.0",
  "$schema": "https://json.schemastore.org/package.json",
  "type": "module",
  "dependencies": {
@@ -7,6 +8,8 @@
  },
  "main": "./src/index.ts",
  "devDependencies": {
-    "@tsconfig/bun": "catalog:"
+    "@tsconfig/bun": "catalog:",
+    "@types/bun": "catalog:",
+    "@types/node": "catalog:"
  }
 }
@@ -0,0 +1,505 @@
+#!/usr/bin/env bun
+
+import { mkdir } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+
+// Friendli API endpoint
+const API_ENDPOINT = "https://api.friendli.ai/serverless/v1/models";
+
+// Zod schemas for API response validation
+const Functionality = z.object({
+  tool_call: z.boolean(),
+  parallel_tool_call: z.boolean(),
+  structured_output: z.boolean(),
+});
+
+const Pricing = z.object({
+  input: z.number(),
+  output: z.number(),
+  response_time: z.number(),
+  unit_type: z.enum(["TOKEN", "SECOND"]),
+});
+
+const FriendliModel = z
+  .object({
+    id: z.string(),
+    name: z.string(),
+    max_completion_tokens: z.number(),
+    context_length: z.number(),
+    functionality: Functionality,
+    pricing: Pricing,
+    hugging_face_url: z.string().optional(),
+    description: z.string().optional(),
+    license: z.string().optional(),
+    policy: z.string().optional().nullable(),
+    created: z.number(), // Unix timestamp
+  })
+  .passthrough();
+
+const FriendliResponse = z.object({
+  data: z.array(FriendliModel),
+});
+
+// Family inference patterns
+const familyPatterns: [RegExp, string][] = [
+  [/llama-3\.3/i, "llama-3.3"],
+  [/llama-3\.1/i, "llama-3.1"],
+  [/llama-4/i, "llama-4"],
+  [/qwen3/i, "qwen3"],
+  [/deepseek-r1/i, "deepseek-r1"],
+  [/exaone/i, "exaone"],
+  [/glm-4/i, "glm-4"],
+];
+
+function inferFamily(modelId: string, modelName: string): string | undefined {
+  for (const [pattern, family] of familyPatterns) {
+    if (pattern.test(modelId) || pattern.test(modelName)) {
+      return family;
+    }
+  }
+  return undefined;
+}
+
+function extractModelName(fullName: string): string {
+  // "meta-llama/Llama-3.3-70B-Instruct" -> "Llama 3.3 70B Instruct"
+  const parts = fullName.split("/");
+  const modelName = parts.at(-1) ?? fullName;
+  return modelName
+    .replace(/-/g, " ")
+    .replace(/\b\w/g, (l) => l.toUpperCase());
+}
+
+// TODO: Replace with functionality.parse_reasoning from API when available
+function isReasoningModel(modelId: string): boolean {
+  // Non-reasoning: Llama 3.x Instruct, Qwen3 Instruct
+  const nonReasoningPatterns = [
+    /llama-3\.\d.*instruct/i,
+    /qwen3.*instruct/i,
+  ];
+
+  for (const pattern of nonReasoningPatterns) {
+    if (pattern.test(modelId)) {
+      return false;
+    }
+  }
+
+  // Everything else is reasoning or hybrid reasoning
+  return true;
+}
+
+function formatNumber(n: number): string {
+  if (n >= 1000) {
+    // Format with underscores for readability (e.g., 131_072)
+    return n.toString().replace(/\B(?=(\d{3})+(?!\d))/g, "_");
+  }
+  return n.toString();
+}
+
+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);
+}
+
+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;
+    reasoning?: number;
+    cache_read?: number;
+    cache_write?: number;
+  };
+  limit?: {
+    context?: number;
+    input?: number;
+    output?: number;
+  };
+  modalities?: {
+    input?: string[];
+    output?: string[];
+  };
+  provider?: {
+    npm?: string;
+    api?: string;
+  };
+}
+
+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;
+  }
+}
+
+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;
+  };
+  limit: {
+    context: number;
+    output: number;
+  };
+  modalities: {
+    input: string[];
+    output: string[];
+  };
+}
+
+function mergeModel(
+  apiModel: z.infer<typeof FriendliModel>,
+  existing: ExistingModel | null,
+): MergedModel {
+  const contextTokens = apiModel.context_length;
+  const outputTokens = apiModel.max_completion_tokens;
+
+  const openWeights = Boolean(apiModel.hugging_face_url);
+
+  const merged: MergedModel = {
+    // Always from API
+    name: extractModelName(apiModel.name),
+    attachment: false, // All Friendli models are text-only currently
+    reasoning: isReasoningModel(apiModel.id),
+    tool_call: apiModel.functionality.tool_call,
+    temperature: true,
+    release_date: timestampToDate(apiModel.created),
+    last_updated: getTodayDate(),
+    open_weights: openWeights,
+    limit: {
+      context: contextTokens,
+      output: outputTokens,
+    },
+    modalities: {
+      input: ["text"],
+      output: ["text"],
+    },
+  };
+
+  // structured_output only if true
+  if (apiModel.functionality.structured_output === true) {
+    merged.structured_output = true;
+  }
+
+  // Cost from API - ONLY include if unit_type is TOKEN
+  if (apiModel.pricing.unit_type === "TOKEN") {
+    merged.cost = {
+      input: apiModel.pricing.input,
+      output: apiModel.pricing.output,
+    };
+  } else {
+    console.log(
+      `  Note: ${apiModel.id} uses ${apiModel.pricing.unit_type} pricing - cost section omitted`,
+    );
+  }
+
+  // Preserve from existing OR infer
+  if (existing?.family) {
+    merged.family = existing.family;
+  } else {
+    const inferred = inferFamily(apiModel.id, apiModel.name);
+    if (inferred) {
+      merged.family = inferred;
+    }
+  }
+
+  // Preserve manual fields from existing
+  if (existing?.knowledge) {
+    merged.knowledge = existing.knowledge;
+  }
+  if (existing?.interleaved !== undefined) {
+    merged.interleaved = existing.interleaved;
+  }
+  if (existing?.status !== undefined) {
+    merged.status = existing.status;
+  }
+
+  return merged;
+}
+
+function formatToml(model: MergedModel): string {
+  const lines: string[] = [];
+
+  // Basic fields
+  lines.push(`name = "${model.name.replace(/"/g, '\\"')}"`);
+  if (model.family) {
+    lines.push(`family = "${model.family}"`);
+  }
+  lines.push(`attachment = ${model.attachment}`);
+  lines.push(`reasoning = ${model.reasoning}`);
+  lines.push(`tool_call = ${model.tool_call}`);
+  if (model.structured_output !== undefined) {
+    lines.push(`structured_output = ${model.structured_output}`);
+  }
+  lines.push(`temperature = ${model.temperature}`);
+  if (model.knowledge) {
+    lines.push(`knowledge = "${model.knowledge}"`);
+  }
+  lines.push(`release_date = "${model.release_date}"`);
+  lines.push(`last_updated = "${model.last_updated}"`);
+  lines.push(`open_weights = ${model.open_weights}`);
+  if (model.status) {
+    lines.push(`status = "${model.status}"`);
+  }
+
+  // Interleaved section (if present)
+  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}"`);
+    }
+  }
+
+  // Cost section (only if present)
+  if (model.cost) {
+    lines.push("");
+    lines.push(`[cost]`);
+    lines.push(`input = ${model.cost.input}`);
+    lines.push(`output = ${model.cost.output}`);
+  }
+
+  // Limit section
+  lines.push("");
+  lines.push(`[limit]`);
+  lines.push(`context = ${formatNumber(model.limit.context)}`);
+  lines.push(`output = ${formatNumber(model.limit.output)}`);
+
+  // Modalities section
+  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";
+}
+
+interface Changes {
+  field: string;
+  oldValue: string;
+  newValue: string;
+}
+
+function detectChanges(
+  existing: ExistingModel | null,
+  merged: MergedModel,
+): Changes[] {
+  if (!existing) return [];
+
+  const changes: Changes[] = [];
+
+  const compare = (field: string, oldVal: unknown, newVal: unknown) => {
+    const oldStr = JSON.stringify(oldVal);
+    const newStr = JSON.stringify(newVal);
+    if (oldStr !== newStr) {
+      changes.push({
+        field,
+        oldValue: formatValue(oldVal),
+        newValue: formatValue(newVal),
+      });
+    }
+  };
+
+  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);
+  };
+
+  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("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);
+
+  return changes;
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const dryRun = args.includes("--dry-run");
+
+  const modelsDir = path.join(
+    import.meta.dirname,
+    "..",
+    "..",
+    "..",
+    "providers",
+    "friendli",
+    "models",
+  );
+
+  if (dryRun) {
+    console.log(`[DRY RUN] Fetching Friendli models from API...`);
+  } else {
+    console.log(`Fetching Friendli models from API...`);
+  }
+
+  // Fetch API data
+  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 = FriendliResponse.safeParse(json);
+  if (!parsed.success) {
+    console.error("Invalid API response:", parsed.error.errors);
+    process.exit(1);
+  }
+
+  const apiModels = parsed.data.data;
+
+  // Get existing files (recursively)
+  const existingFiles = new Set<string>();
+  try {
+    for await (const file of new Bun.Glob("**/*.toml").scan({
+      cwd: modelsDir,
+      absolute: false,
+    })) {
+      existingFiles.add(file);
+    }
+  } catch {
+    // Directory might not exist yet
+  }
+
+  console.log(
+    `Found ${apiModels.length} models in API, ${existingFiles.size} existing files\n`,
+  );
+
+  // Track API model IDs for orphan detection
+  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 {
+      const changes = detectChanges(existing, merged);
+
+      if (changes.length > 0) {
+        updated++;
+        if (dryRun) {
+          console.log(`[DRY RUN] Would update: ${relativePath}`);
+        } else {
+          await Bun.write(filePath, tomlContent);
+          console.log(`Updated: ${relativePath}`);
+        }
+        for (const change of changes) {
+          console.log(`  ${change.field}: ${change.oldValue} → ${change.newValue}`);
+        }
+        console.log("");
+      } else {
+        unchanged++;
+      }
+    }
+  }
+
+  // Check for orphaned files
+  const orphaned: string[] = [];
+  for (const file of existingFiles) {
+    if (!apiModelIds.has(file)) {
+      orphaned.push(file);
+      console.log(`Warning: Orphaned file (not in API): ${file}`);
+    }
+  }
+
+  // Summary
+  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();
@@ -0,0 +1,208 @@
+#!/usr/bin/env bun
+
+import { z } from "zod";
+import path from "node:path";
+import { mkdir, rm, readdir, stat } from "node:fs/promises";
+
+// Helicone public model registry endpoint
+const DEFAULT_ENDPOINT =
+  "https://jawn.helicone.ai/v1/public/model-registry/models";
+
+// Zod schemas to validate the Helicone response
+const Pricing = z
+  .object({
+    prompt: z.number().optional(),
+    completion: z.number().optional(),
+    cacheRead: z.number().optional(),
+    cacheWrite: z.number().optional(),
+    reasoning: z.number().optional(),
+  })
+  .passthrough();
+
+const Endpoint = z
+  .object({
+    provider: z.string(),
+    providerSlug: z.string().optional(),
+    supportsPtb: z.boolean().optional(),
+    pricing: Pricing.optional(),
+  })
+  .passthrough();
+
+const ModelItem = z
+  .object({
+    id: z.string(),
+    name: z.string(),
+    author: z.string().optional(),
+    contextLength: z.number().optional(),
+    maxOutput: z.number().optional(),
+    trainingDate: z.string().optional(),
+    description: z.string().optional(),
+    inputModalities: z.array(z.string()).optional(),
+    outputModalities: z.array(z.string()).optional(),
+    supportedParameters: z.array(z.string()).optional(),
+    endpoints: z.array(Endpoint).optional(),
+  })
+  .passthrough();
+
+const HeliconeResponse = z
+  .object({
+    data: z.object({
+      models: z.array(ModelItem),
+      total: z.number().optional(),
+      filters: z.any().optional(),
+    }),
+  })
+  .passthrough();
+
+function pickEndpoint(m: z.infer<typeof ModelItem>) {
+  if (!m.endpoints || m.endpoints.length === 0) return undefined;
+  // Prefer endpoint that matches author if available
+  if (m.author) {
+    const match = m.endpoints.find((e) => e.provider === m.author);
+    if (match) return match;
+  }
+  return m.endpoints[0];
+}
+
+function boolFromParams(params: string[] | undefined, keys: string[]): boolean {
+  if (!params) return false;
+  const set = new Set(params.map((p) => p.toLowerCase()));
+  return keys.some((k) => set.has(k.toLowerCase()));
+}
+
+function sanitizeModalities(values: string[] | undefined): string[] {
+  if (!values) return ["text"]; // default to text
+  const allowed = new Set(["text", "audio", "image", "video", "pdf"]);
+  const out = values.map((v) => v.toLowerCase()).filter((v) => allowed.has(v));
+  return out.length > 0 ? out : ["text"];
+}
+
+function formatToml(model: z.infer<typeof ModelItem>) {
+  const ep = pickEndpoint(model);
+  const pricing = ep?.pricing;
+
+  const supported = model.supportedParameters ?? [];
+
+  const nowISO = new Date().toISOString().slice(0, 10);
+  const rdRaw = model.trainingDate ? String(model.trainingDate) : nowISO;
+  const releaseDate = rdRaw.slice(0, 10);
+  const lastUpdated = releaseDate;
+  const knowledge = model.trainingDate
+    ? String(model.trainingDate).slice(0, 7)
+    : undefined;
+
+  const attachment = false; // Not exposed by Helicone registry
+  const temperature = boolFromParams(supported, ["temperature"]);
+  const toolCall = boolFromParams(supported, ["tools", "tool_choice"]);
+  const reasoning = boolFromParams(supported, [
+    "reasoning",
+    "include_reasoning",
+  ]);
+
+  const inputMods = sanitizeModalities(model.inputModalities);
+  const outputMods = sanitizeModalities(model.outputModalities);
+
+  const lines: string[] = [];
+  lines.push(`name = "${model.name.replaceAll('"', '\\"')}"`);
+  lines.push(`release_date = "${releaseDate}"`);
+  lines.push(`last_updated = "${lastUpdated}"`);
+  lines.push(`attachment = ${attachment}`);
+  lines.push(`reasoning = ${reasoning}`);
+  lines.push(`temperature = ${temperature}`);
+  lines.push(`tool_call = ${toolCall}`);
+  if (knowledge) lines.push(`knowledge = "${knowledge}"`);
+  lines.push(`open_weights = false`);
+  lines.push("");
+
+  if (
+    pricing &&
+    (pricing.prompt ??
+      pricing.completion ??
+      pricing.cacheRead ??
+      pricing.cacheWrite ??
+      (reasoning && pricing.reasoning)) !== undefined
+  ) {
+    lines.push(`[cost]`);
+    if (pricing.prompt !== undefined) lines.push(`input = ${pricing.prompt}`);
+    if (pricing.completion !== undefined)
+      lines.push(`output = ${pricing.completion}`);
+    if (reasoning && pricing.reasoning !== undefined)
+      lines.push(`reasoning = ${pricing.reasoning}`);
+    if (pricing.cacheRead !== undefined)
+      lines.push(`cache_read = ${pricing.cacheRead}`);
+    if (pricing.cacheWrite !== undefined)
+      lines.push(`cache_write = ${pricing.cacheWrite}`);
+    lines.push("");
+  }
+
+  const context = model.contextLength ?? 0;
+  const output = model.maxOutput ?? 4096;
+  lines.push(`[limit]`);
+  lines.push(`context = ${context}`);
+  lines.push(`output = ${output}`);
+  lines.push("");
+
+  lines.push(`[modalities]`);
+  lines.push(`input = [${inputMods.map((m) => `"${m}"`).join(", ")}]`);
+  lines.push(`output = [${outputMods.map((m) => `"${m}"`).join(", ")}]`);
+
+  return lines.join("\n") + "\n";
+}
+
+async function main() {
+  const endpoint = DEFAULT_ENDPOINT;
+
+  const outDir = path.join(
+    import.meta.dirname,
+    "..",
+    "..",
+    "..",
+    "providers",
+    "helicone",
+    "models",
+  );
+
+  const res = await fetch(endpoint);
+  if (!res.ok) {
+    console.error(`Failed to fetch registry: ${res.status} ${res.statusText}`);
+    process.exit(1);
+  }
+  const json = await res.json();
+
+  const parsed = HeliconeResponse.safeParse(json);
+  if (!parsed.success) {
+    parsed.error.cause = json;
+    console.error("Invalid Helicone response:", parsed.error.errors);
+    console.error("When parsing:", parsed.error.cause);
+    process.exit(1);
+  }
+
+  const models = parsed.data.data.models;
+
+  // Clean output directory: remove subfolders and existing TOML files
+  await mkdir(outDir, { recursive: true });
+  for (const entry of await readdir(outDir)) {
+    const p = path.join(outDir, entry);
+    const st = await stat(p);
+    if (st.isDirectory()) {
+      await rm(p, { recursive: true, force: true });
+    } else if (st.isFile() && entry.endsWith(".toml")) {
+      await rm(p, { force: true });
+    }
+  }
+  let created = 0;
+
+  for (const m of models) {
+    const fileSafeId = m.id.replaceAll("/", "-");
+    const filePath = path.join(outDir, `${fileSafeId}.toml`);
+    const toml = formatToml(m);
+    await Bun.write(filePath, toml);
+    created++;
+  }
+
+  console.log(
+    `Generated ${created} model file(s) under providers/helicone/models/*.toml`,
+  );
+}
+
+await main();
@@ -0,0 +1,586 @@
+#!/usr/bin/env bun
+
+import { z } from "zod";
+import path from "node:path";
+import { readdir } from "node:fs/promises";
+import * as readline from "node:readline";
+
+// Venice API endpoint
+const API_ENDPOINT = "https://api.venice.ai/api/v1/models?type=text";
+
+async function promptForApiKey(): Promise<string | null> {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question(
+      "Enter Venice API key to include alpha models (or press Enter to skip): ",
+      (answer) => {
+        rl.close();
+        const trimmed = answer.trim();
+        resolve(trimmed.length > 0 ? trimmed : null);
+      },
+    );
+  });
+}
+
+// Zod schemas for API response validation
+const Capabilities = z
+  .object({
+    optimizedForCode: z.boolean().optional(),
+    quantization: z.string().optional(),
+    supportsAudioInput: z.boolean().optional(),
+    supportsFunctionCalling: z.boolean().optional(),
+    supportsLogProbs: z.boolean().optional(),
+    supportsReasoning: z.boolean().optional(),
+    supportsResponseSchema: z.boolean().optional(),
+    supportsVideoInput: z.boolean().optional(),
+    supportsVision: z.boolean().optional(),
+    supportsWebSearch: z.boolean().optional(),
+  })
+  .passthrough();
+
+const Pricing = z
+  .object({
+    input: z.object({ usd: z.number(), diem: z.number().optional() }).passthrough(),
+    output: z.object({ usd: z.number(), diem: z.number().optional() }).passthrough(),
+    cache_input: z.object({ usd: z.number(), diem: z.number().optional() }).passthrough().optional(),
+  })
+  .passthrough();
+
+const ModelSpec = z
+  .object({
+    pricing: Pricing.optional(),
+    availableContextTokens: z.number(),
+    capabilities: Capabilities,
+    constraints: z.any().optional(),
+    name: z.string(),
+    modelSource: z.string().optional(),
+    offline: z.boolean().optional(),
+    traits: z.array(z.string()).optional(),
+  })
+  .passthrough();
+
+const VeniceModel = z
+  .object({
+    created: z.number(),
+    id: z.string(),
+    model_spec: ModelSpec,
+    object: z.string(),
+    owned_by: z.string(),
+    type: z.string(),
+  })
+  .passthrough();
+
+const VeniceResponse = z
+  .object({
+    data: z.array(VeniceModel),
+    object: z.string(),
+    type: z.string(),
+  })
+  .passthrough();
+
+// Family inference patterns
+const familyPatterns: [RegExp, string][] = [
+  [/^llama-3\.3/i, "llama-3.3"],
+  [/^llama-3\.2/i, "llama-3.2"],
+  [/^qwen3/i, "qwen3"],
+  [/^deepseek/i, "deepseek"],
+  [/^mistral/i, "mistral"],
+  [/^devstral/i, "devstral"],
+  [/^gemini/i, "gemini"],
+  [/^grok/i, "grok"],
+  [/^claude/i, "claude"],
+  [/^hermes/i, "hermes"],
+  [/^google-gemma/i, "gemma"],
+  [/^kimi/i, "kimi"],
+  [/glm-4.6/i, "glm-4.6"],
+  [/^venice/i, "venice-uncensored"],
+  [/^openai-gpt/i, "openai-gpt"],
+];
+
+function inferFamily(modelId: string, modelName: string): string | undefined {
+  for (const [pattern, family] of familyPatterns) {
+    if (pattern.test(modelId) || pattern.test(modelName)) {
+      return family;
+    }
+  }
+  return undefined;
+}
+
+function buildInputModalities(capabilities: z.infer<typeof Capabilities>): string[] {
+  const mods: string[] = ["text"];
+  if (capabilities.supportsVision) mods.push("image");
+  if (capabilities.supportsAudioInput) mods.push("audio");
+  if (capabilities.supportsVideoInput) mods.push("video");
+  return mods;
+}
+
+function formatNumber(n: number): string {
+  if (n >= 1000) {
+    // Format with underscores for readability (e.g., 131_072)
+    return n.toString().replace(/\B(?=(\d{3})+(?!\d))/g, "_");
+  }
+  return n.toString();
+}
+
+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);
+}
+
+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;
+    reasoning?: number;
+    cache_read?: number;
+    cache_write?: number;
+  };
+  limit?: {
+    context?: number;
+    input?: number;
+    output?: number;
+  };
+  modalities?: {
+    input?: string[];
+    output?: string[];
+  };
+  provider?: {
+    npm?: string;
+    api?: string;
+  };
+}
+
+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;
+  }
+}
+
+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[];
+  };
+}
+
+function mergeModel(
+  apiModel: z.infer<typeof VeniceModel>,
+  existing: ExistingModel | null,
+): MergedModel {
+  const spec = apiModel.model_spec;
+  const caps = spec.capabilities;
+
+  const contextTokens = spec.availableContextTokens;
+  const outputTokens = Math.floor(contextTokens / 4);
+
+  // Determine open_weights from modelSource
+  const openWeights = spec.modelSource
+    ? spec.modelSource.toLowerCase().includes("huggingface")
+    : false;
+
+  // Build input modalities from API (no auto-PDF)
+  const inputModalities = buildInputModalities(caps);
+
+  // Check if existing has PDF in modalities - preserve it
+  if (existing?.modalities?.input?.includes("pdf") && !inputModalities.includes("pdf")) {
+    inputModalities.push("pdf");
+  }
+
+  // Determine attachment based on vision/audio/video support
+  const attachment =
+    caps.supportsVision === true ||
+    caps.supportsAudioInput === true ||
+    caps.supportsVideoInput === true;
+
+  const merged: MergedModel = {
+    // Always from API
+    name: spec.name,
+    attachment,
+    reasoning: caps.supportsReasoning === true,
+    tool_call: caps.supportsFunctionCalling === true,
+    temperature: true,
+    release_date: timestampToDate(apiModel.created),
+    last_updated: getTodayDate(),
+    open_weights: openWeights,
+    limit: {
+      context: contextTokens,
+      output: outputTokens,
+    },
+    modalities: {
+      input: inputModalities,
+      output: ["text"],
+    },
+  };
+
+  // structured_output only if true
+  if (caps.supportsResponseSchema === true) {
+    merged.structured_output = true;
+  }
+
+  // Cost from API
+  if (spec.pricing) {
+    merged.cost = {
+      input: spec.pricing.input.usd,
+      output: spec.pricing.output.usd,
+      ...(spec.pricing.cache_input && { cache_read: spec.pricing.cache_input.usd }),
+    };
+  }
+
+  // Preserve from existing OR infer
+  if (existing?.family) {
+    merged.family = existing.family;
+  } else {
+    const inferred = inferFamily(apiModel.id, spec.name);
+    if (inferred) {
+      merged.family = inferred;
+    }
+  }
+
+  // Preserve manual fields from existing
+  if (existing?.knowledge) {
+    merged.knowledge = existing.knowledge;
+  }
+  if (existing?.interleaved !== undefined) {
+    merged.interleaved = existing.interleaved;
+  }
+  if (existing?.status !== undefined) {
+    merged.status = existing.status;
+  }
+
+  return merged;
+}
+
+function formatToml(model: MergedModel): string {
+  const lines: string[] = [];
+
+  // Basic fields
+  lines.push(`name = "${model.name.replace(/"/g, '\\"')}"`);
+  if (model.family) {
+    lines.push(`family = "${model.family}"`);
+  }
+  lines.push(`attachment = ${model.attachment}`);
+  lines.push(`reasoning = ${model.reasoning}`);
+  lines.push(`tool_call = ${model.tool_call}`);
+  if (model.structured_output !== undefined) {
+    lines.push(`structured_output = ${model.structured_output}`);
+  }
+  lines.push(`temperature = ${model.temperature}`);
+  if (model.knowledge) {
+    lines.push(`knowledge = "${model.knowledge}"`);
+  }
+  lines.push(`release_date = "${model.release_date}"`);
+  lines.push(`last_updated = "${model.last_updated}"`);
+  lines.push(`open_weights = ${model.open_weights}`);
+  if (model.status) {
+    lines.push(`status = "${model.status}"`);
+  }
+
+  // Interleaved section (if present)
+  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}"`);
+    }
+  }
+
+  // Cost section
+  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}`);
+    }
+  }
+
+  // Limit section
+  lines.push("");
+  lines.push(`[limit]`);
+  lines.push(`context = ${formatNumber(model.limit.context)}`);
+  lines.push(`output = ${formatNumber(model.limit.output)}`);
+
+  // Modalities section
+  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";
+}
+
+interface Changes {
+  field: string;
+  oldValue: string;
+  newValue: string;
+}
+
+function detectChanges(
+  existing: ExistingModel | null,
+  merged: MergedModel,
+): Changes[] {
+  if (!existing) return [];
+
+  const changes: Changes[] = [];
+
+  const compare = (field: string, oldVal: unknown, newVal: unknown) => {
+    const oldStr = JSON.stringify(oldVal);
+    const newStr = JSON.stringify(newVal);
+    if (oldStr !== newStr) {
+      changes.push({
+        field,
+        oldValue: formatValue(oldVal),
+        newValue: formatValue(newVal),
+      });
+    }
+  };
+
+  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);
+  };
+
+  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);
+
+  return changes;
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const dryRun = args.includes("--dry-run");
+
+  const modelsDir = path.join(
+    import.meta.dirname,
+    "..",
+    "..",
+    "..",
+    "providers",
+    "venice",
+    "models",
+  );
+
+  // Check for API key from CLI argument, environment, or prompt
+  let apiKey: string | null = null;
+
+  // Check CLI args for --api-key=xxx or --api-key xxx
+  const apiKeyArgIndex = args.findIndex((arg) => arg.startsWith("--api-key"));
+  if (apiKeyArgIndex !== -1) {
+    const arg = args[apiKeyArgIndex];
+    if (arg.includes("=")) {
+      apiKey = arg.split("=")[1];
+    } else if (args[apiKeyArgIndex + 1]) {
+      apiKey = args[apiKeyArgIndex + 1];
+    }
+  }
+
+  // Fall back to environment variable
+  if (!apiKey) {
+    apiKey = process.env.VENICE_API_KEY ?? null;
+  }
+
+  // Prompt if still no key
+  if (!apiKey) {
+    apiKey = await promptForApiKey();
+  }
+
+  const includeAlpha = apiKey !== null;
+
+  if (dryRun) {
+    console.log(
+      `[DRY RUN] Fetching Venice models from API${includeAlpha ? " (including alpha models)" : ""}...`,
+    );
+  } else {
+    console.log(
+      `Fetching Venice models from API${includeAlpha ? " (including alpha models)" : ""}...`,
+    );
+  }
+
+  // Fetch API data
+  const fetchOptions: RequestInit = {};
+  if (apiKey) {
+    fetchOptions.headers = {
+      Authorization: `Bearer ${apiKey}`,
+    };
+  }
+
+  const res = await fetch(API_ENDPOINT, fetchOptions);
+  if (!res.ok) {
+    console.error(`Failed to fetch API: ${res.status} ${res.statusText}`);
+    if (res.status === 401) {
+      console.error("Invalid API key. Please check your VENICE_API_KEY.");
+    }
+    process.exit(1);
+  }
+
+  const json = await res.json();
+  const parsed = VeniceResponse.safeParse(json);
+  if (!parsed.success) {
+    console.error("Invalid API response:", parsed.error.errors);
+    process.exit(1);
+  }
+
+  const apiModels = parsed.data.data;
+
+  // Get existing files
+  const existingFiles = new Set<string>();
+  try {
+    const files = await readdir(modelsDir);
+    for (const file of files) {
+      if (file.endsWith(".toml")) {
+        existingFiles.add(file);
+      }
+    }
+  } catch {
+    // Directory might not exist yet
+  }
+
+  console.log(`Found ${apiModels.length} models in API, ${existingFiles.size} existing files\n`);
+
+  // Track API model IDs for orphan detection
+  const apiModelIds = new Set<string>();
+
+  let created = 0;
+  let updated = 0;
+  let unchanged = 0;
+
+  for (const apiModel of apiModels) {
+    const safeId = apiModel.id.replace(/\//g, "-");
+    const filename = `${safeId}.toml`;
+    const filePath = path.join(modelsDir, filename);
+
+    apiModelIds.add(filename);
+
+    const existing = await loadExistingModel(filePath);
+    const merged = mergeModel(apiModel, existing);
+    const tomlContent = formatToml(merged);
+
+    if (existing === null) {
+      // New file
+      created++;
+      if (dryRun) {
+        console.log(`[DRY RUN] Would create: ${filename}`);
+        console.log(`  name = "${merged.name}"`);
+        if (merged.family) {
+          console.log(`  family = "${merged.family}" (inferred)`);
+        }
+        console.log("");
+      } else {
+        await Bun.write(filePath, tomlContent);
+        console.log(`Created: ${filename}`);
+      }
+    } else {
+      // Check for changes
+      const changes = detectChanges(existing, merged);
+
+      if (changes.length > 0) {
+        updated++;
+        if (dryRun) {
+          console.log(`[DRY RUN] Would update: ${filename}`);
+        } else {
+          await Bun.write(filePath, tomlContent);
+          console.log(`Updated: ${filename}`);
+        }
+        for (const change of changes) {
+          console.log(`  ${change.field}: ${change.oldValue} → ${change.newValue}`);
+        }
+        console.log("");
+      } else {
+        unchanged++;
+      }
+    }
+  }
+
+  // Check for orphaned files
+  const orphaned: string[] = [];
+  for (const file of existingFiles) {
+    if (!apiModelIds.has(file)) {
+      orphaned.push(file);
+      console.log(`Warning: Orphaned file (not in API): ${file}`);
+    }
+  }
+
+  // Summary
+  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();
@@ -0,0 +1,19 @@
+#!/usr/bin/env bun
+
+import { generate } from "../src/generate";
+import path from "path";
+import { ZodError } from "zod";
+
+try {
+  const result = await generate(
+    path.join(import.meta.dirname, "..", "..", "..", "providers"),
+  );
+  console.log(JSON.stringify(result, null, 2));
+} catch (e: any) {
+  if (e instanceof ZodError) {
+    console.error("Validation error:", e.errors);
+    console.error("When parsing:", e.cause);
+    process.exit(1);
+  }
+  throw e;
+}
@@ -16,11 +16,17 @@ export async function generate(directory: string) {
    }).then((mod) => mod.default);
    toml.id = providerID;
    toml.models = {};
-    const provider = Provider.parse(toml);
+    const provider = Provider.safeParse(toml);
+    if (!provider.success) {
+      provider.error.cause = { providerPath, toml };
+      throw provider.error;
+    }
+
    const modelsPath = path.join(directory, providerID, "models");
    for await (const modelPath of new Bun.Glob("**/*.toml").scan({
      cwd: modelsPath,
      absolute: true,
+      followSymlinks: true,
    })) {
      const modelID = path.relative(modelsPath, modelPath).slice(0, -5);
      const toml = await import(modelPath, {
@@ -29,10 +35,14 @@ export async function generate(directory: string) {
        },
      }).then((mod) => mod.default);
      toml.id = modelID;
-      const model = Model.parse(toml);
-      provider.models[modelID] = model;
+      const model = Model.safeParse(toml);
+      if (!model.success) {
+        model.error.cause = { modelPath, toml };
+        throw model.error;
+      }
+      provider.data.models[modelID] = model.data;
    }
-    result[providerID] = provider;
+    result[providerID] = provider.data;
  }

  return result;
@@ -1,40 +1,134 @@
 import { z } from "zod";

+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")
+    .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(),
+});
 export const Model = z
  .object({
-    id: z.string().toLowerCase(),
+    id: z.string(),
    name: z.string().min(1, "Model name cannot be empty"),
+    family: z.string().optional(),
    attachment: z.boolean(),
    reasoning: z.boolean(),
-    temperature: z.boolean(),
-    cost: z.object({
-      input: z.number().min(0, "Input price cannot be negative"),
-      output: z.number().min(0, "Output price cannot be negative"),
-      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(),
+    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(),
+    provider: z
+      .object({
+        npm: z.string().optional(),
+        api: z.string().optional(),
+      })
+      .optional(),
  })
-  .strict();
+  .strict()
+  .refine(
+    (data) => {
+      return !(data.reasoning === false && data.cost?.reasoning !== undefined);
+    },
+    {
+      message: "Cannot set cost.reasoning when reasoning is false",
+      path: ["cost", "reasoning"],
+    },
+  );

 export type Model = z.infer<typeof Model>;

 export const Provider = z
  .object({
-    id: z.string().toLowerCase(),
+    id: z.string(),
    env: z.array(z.string()).min(1, "Provider env cannot be empty"),
-    npm: z.string().min(1, "Provider npm module cannot be empty").optional(),
+    npm: z.string().min(1, "Provider npm module cannot be empty"),
+    api: z.string().optional(),
    name: z.string().min(1, "Provider name cannot be empty"),
+    doc: z
+      .string()
+      .min(
+        1,
+        "Please provide a link to the provider documentation where models are listed",
+      ),
    models: z.record(Model),
  })
-  .strict();
+  .strict()
+  .refine(
+    (data) => {
+      const isOpenAI = data.npm === "@ai-sdk/openai";
+      const isOpenAIcompatible = data.npm === "@ai-sdk/openai-compatible";
+      const isOpenrouter = data.npm === "@openrouter/ai-sdk-provider";
+      const isAnthropic = data.npm === "@ai-sdk/anthropic";
+      const hasApi = data.api !== undefined;
+
+      return (
+        // openai-compatible: must have api
+        (isOpenAIcompatible && hasApi) ||
+        // openrouter: must have api
+        (isOpenrouter && hasApi) ||
+        // anthropic: api optional (always allowed)
+        isAnthropic ||
+        // openai: api optional (always allowed)
+        isOpenAI ||
+        // all others: must NOT have api
+        (!isOpenAI && !isOpenAIcompatible && !isOpenrouter && !isAnthropic && !hasApi)
+      );
+    },
+    {
+      message:
+        "'api' is required for openai-compatible and openrouter, optional for anthropic and openai, forbidden otherwise",
+      path: ["api"],
+    },
+  );
+
 export type Provider = z.infer<typeof Provider>;
@@ -0,0 +1,10 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "name": "@models.dev/function",
+  "private": true,
+  "type": "module",
+  "devDependencies": {
+    "@cloudflare/workers-types": "4.20250522.0",
+    "@tsconfig/bun": "catalog:"
+  }
+}
@@ -0,0 +1,66 @@
+export interface Env {
+  ASSETS: any;
+  PosthogToken: string;
+}
+
+export default {
+  async fetch(
+    request: Request,
+    env: Env,
+    ctx: ExecutionContext,
+  ): Promise<Response> {
+    const url = new URL(request.url);
+    const ip = request.headers.get("cf-connecting-ip") || "unknown";
+    const agent = request.headers.get("user-agent") || "unknown";
+    if (agent.includes("opencode") || agent.includes("bun")) {
+      ctx.waitUntil(
+        fetch("https://us.i.posthog.com/i/v0/e/", {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+          },
+          body: JSON.stringify({
+            api_key: JSON.parse(env.PosthogToken).value,
+            event: "hit",
+            distinct_id: ip,
+            properties: {
+              $process_person_profile: false,
+              user_agent: agent,
+              path: url.pathname,
+            },
+          }),
+        }),
+      );
+    }
+
+    if (url.pathname === "/api.json") {
+      url.pathname = "/_api.json";
+    } else if (
+      url.pathname === "/" ||
+      url.pathname === "/index.html" ||
+      url.pathname === "/index"
+    ) {
+      url.pathname = "/_index";
+    } else if (url.pathname.startsWith("/logos/")) {
+      // Check if the specific provider logo exists in static assets
+      const logoResponse = await env.ASSETS.fetch(new Request(url.toString(), request));
+
+      if (logoResponse.status === 404) {
+        // Fallback to default logo
+        const defaultUrl = new URL(url);
+        defaultUrl.pathname = "/logos/default.svg";
+        return await env.ASSETS.fetch(new Request(defaultUrl.toString(), request));
+      }
+
+      return logoResponse;
+    } else {
+      // redirect to "/"
+      return new Response(null, {
+        status: 302,
+        headers: { Location: "/" },
+      });
+    }
+
+    return await env.ASSETS.fetch(new Request(url.toString(), request));
+  },
+};
@@ -0,0 +1,24 @@
+/* This file is auto-generated by SST. Do not edit. */
+/* tslint:disable */
+/* eslint-disable */
+/* deno-fmt-ignore-file */
+
+import "sst"
+declare module "sst" {
+  export interface Resource {
+    "PosthogToken": {
+      "type": "sst.sst.Secret"
+      "value": string
+    }
+  }
+}
+// cloudflare 
+import * as cloudflare from "@cloudflare/workers-types";
+declare module "sst" {
+  export interface Resource {
+    "Server": cloudflare.Service
+  }
+}
+
+import "sst"
+export {}
@@ -0,0 +1,7 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "@tsconfig/bun/tsconfig.json",
+  "compilerOptions": {
+    "types": ["@cloudflare/workers-types"]
+  }
+}
@@ -1,4 +1,4 @@
-<!doctype html>
+<!DOCTYPE html>
 <html>
  <head>
    <title>Models.dev &mdash; An open-source database of AI models</title>
@@ -6,7 +6,7 @@
      name="description"
      content="Models.dev is a comprehensive open-source database of AI model specifications, pricing, and features."
    />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no" />
    <link rel="preconnect" href="https://fonts.googleapis.com" />
    <link
      rel="preconnect"
@@ -24,6 +24,7 @@
      type="image/svg+xml"
    />
    <meta property="og:image" content="https://models.dev/social-share.png" />
+    <meta charset="UTF-8" />
    <link rel="stylesheet" href="./src/index.css" />
  </head>
  <body>
@@ -6,6 +6,10 @@
    "build": "./script/build.ts"
  },
  "dependencies": {
-    "hono": "^4.8.0"
+    "hono": "^4.8.0",
+    "models.dev": "workspace:*"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.2.16"
  }
 }
@@ -0,0 +1,2 @@
+/*
+  Access-Control-Allow-Origin: *
@@ -2,6 +2,8 @@

 import { Rendered, Providers } from "../src/render";
 import fs from "fs/promises";
+import path from "path";
+import { $ } from "bun";

 await fs.rm("./dist", { recursive: true, force: true });
 await Bun.build({
@@ -14,7 +16,35 @@ for await (const file of new Bun.Glob("./public/*").scan()) {
  await Bun.write(file.replace("./public/", "./dist/"), Bun.file(file));
 }

+// Copy provider logos to dist/logos/
+await fs.mkdir("./dist/logos", { recursive: true });
+
+// First, copy the default logo
+const defaultLogoPath = "../../providers/logo.svg";
+const defaultLogo = Bun.file(defaultLogoPath);
+if (await defaultLogo.exists()) {
+  await Bun.write("./dist/logos/default.svg", defaultLogo);
+}
+
+// Then copy provider-specific logos
+const providersDir = "../../providers";
+const entries = await fs.readdir(providersDir, { withFileTypes: true });
+for (const entry of entries) {
+  if (entry.isDirectory()) {
+    const provider = entry.name;
+    const logoPath = path.join(providersDir, provider, "logo.svg");
+    const logoFile = Bun.file(logoPath);
+
+    if (await logoFile.exists()) {
+      await Bun.write(`./dist/logos/${provider}.svg`, logoFile);
+    }
+  }
+}
+
 let html = await Bun.file("./dist/index.html").text();
 html = html.replace("<!--static-->", Rendered);
 await Bun.write("./dist/index.html", html);
 await Bun.write("./dist/api.json", JSON.stringify(Providers));
+
+await $`mv ./dist/index.html ./dist/_index.html`;
+await $`mv ./dist/api.json ./dist/_api.json`;
@@ -79,6 +79,7 @@ header {
  background-color: var(--color-background);
  position: fixed;
  width: 100%;
+  z-index: 10;

  &>div {
    display: flex;
@@ -128,6 +129,7 @@ header {

  a.github {
    flex: 0 0 auto;
+    height: 24px;
    color: var(--color-text-secondary);

    svg {
@@ -135,15 +137,22 @@ header {
    }
  }

-  input {
+  .search-container {
+    position: relative;
    flex: 1 1 auto;
+    min-width: 12.5rem;
+  }
+
+  input {
+    width: 100%;
    font-size: 0.8125rem;
    line-height: 1.1;
-    padding: 0.5rem 0.625rem;
+    padding: 0.5rem 2.5rem 0.5rem 0.625rem;
    border-radius: 0.25rem;
    border: 1px solid var(--color-border);
    height: 2rem;
    background: none;
+    color: var(--color-text);

    &:focus {
      border-color: var(--color-brand);
@@ -151,6 +160,17 @@ header {
    }
  }

+  .search-shortcut {
+    position: absolute;
+    right: 0.5rem;
+    top: 50%;
+    transform: translateY(-50%);
+    font-size: 0.75rem;
+    color: var(--color-text-tertiary);
+    pointer-events: none;
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', system-ui, sans-serif;
+  }
+
  button {
    flex: 0 0 auto;
    cursor: pointer;
@@ -178,7 +198,7 @@ header {
    div.right {

      .github,
-      input {
+      .search-container {
        display: none;
      }
    }
@@ -210,12 +230,29 @@ table thead th {
  color: var(--color-text-secondary);
  backdrop-filter: blur(6px);
  background-color: var(--color-alpha-background);
+  z-index: 10;
 }

-table thead th[data-desc]::after {
+table thead th .header-container {
+  display: flex;
+  align-items: center;
+  gap: 0.125rem;
+}
+
+th.sortable {
+  cursor: pointer;
+  user-select: none;
+}
+
+.sort-indicator {
+  display: inline-block;
+  width: 1rem;
+  text-align: center;
+}
+
+table thead th .desc {
  color: var(--color-text-tertiary);
  margin-top: 0.5em;
-  content: attr(data-desc);
  display: block;
  font-size: 0.625rem;
  font-weight: normal;
@@ -239,15 +276,23 @@ tbody {
  }

  td:nth-child(1),
-  td:nth-child(2) {
+  td:nth-child(2),
+  td:nth-child(5),
+  td:nth-child(6),
+  td:nth-child(9),
+  td:nth-child(10),
+  td:nth-child(11),
+  td:nth-child(12),
+  td:nth-child(13),
+  td:nth-child(14),
+  td:nth-child(15),
+  td:nth-child(16) {
    color: var(--color-text);
  }

-  td:nth-child(5) {}
-
  td:nth-child(5),
  td:nth-child(6),
-  td:nth-child(7) {
+  td:nth-child(18) {
    font-size: 0.8125rem;
    font-family: var(--font-mono);
    text-transform: uppercase;
@@ -255,15 +300,122 @@ tbody {

  td:nth-child(3),
  td:nth-child(4),
-  td:nth-child(8),
  td:nth-child(9),
  td:nth-child(10),
  td:nth-child(11),
  td:nth-child(12),
-  td:nth-child(13) {
+  td:nth-child(13),
+  td:nth-child(14),
+  td:nth-child(15),
+  td:nth-child(16),
+  td:nth-child(17) {
    font-size: 0.8125rem;
    font-family: var(--font-mono);
  }
+
+  .provider-cell {
+    display: flex;
+    align-items: center;
+    gap: 0.375rem;
+  }
+
+  .provider-cell span:first-child {
+    flex: 0 0 auto;
+  }
+
+  .provider-cell svg {
+    display: block;
+    width: 1rem;
+    height: 1rem;
+    color: var(--color-text-secondary);
+  }
+
+  .model-id-cell {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 0.375rem;
+  }
+
+  .model-id-text {}
+
+  .copy-button {
+    flex: 0 0 auto;
+    background: none;
+    border: none;
+    cursor: pointer;
+    padding: 0.25rem;
+    border-radius: 0.25rem;
+    color: var(--color-text-tertiary);
+    opacity: 0;
+    transition: opacity 0.2s ease, color 0.2s ease;
+  }
+
+  .model-id-cell:hover .copy-button {
+    opacity: 1;
+  }
+
+  .model-id-cell .copy-button svg {
+    display: block;
+  }
+
+  .copy-button:hover {
+    color: var(--color-text);
+    background-color: var(--color-surface);
+  }
+
+  .copy-button:active {
+    transform: scale(0.95);
+  }
+
+  .copy-button.copied {
+    color: var(--color-brand) !important;
+  }
+
+  .modalities {
+    display: flex;
+    gap: 0.25rem;
+    align-items: center;
+  }
+
+  .modality-icon {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    width: 20px;
+    height: 20px;
+    border: 1px solid var(--color-border);
+    border-radius: 2px;
+    background-color: var(--color-background);
+    color: var(--color-text-secondary);
+    position: relative;
+  }
+
+  .modality-icon::after {
+    content: attr(data-tooltip);
+    position: absolute;
+    bottom: 100%;
+    left: 50%;
+    transform: translateX(-50%);
+    margin-bottom: 4px;
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+    line-height: 1;
+    padding: 0.375rem 0.375rem;
+    background-color: var(--color-text);
+    color: var(--color-background);
+    font-size: 0.625rem;
+    border-radius: 3px;
+    white-space: nowrap;
+    opacity: 0;
+    pointer-events: none;
+    transition: opacity 0.15s ease;
+    z-index: 100;
+  }
+
+  .modality-icon:hover::after {
+    opacity: 1;
+  }
 }

 dialog::backdrop {
@@ -394,4 +546,4 @@ dialog {
    }
  }

-}
+}
@@ -3,25 +3,47 @@ const modalClose = document.getElementById("close")!;
 const help = document.getElementById("help")!;
 const search = document.getElementById("search")! as HTMLInputElement;

-search.addEventListener("input", () => {
-  const value = search.value.toLowerCase();
-  const rows = document.querySelectorAll(
-    "table tbody tr",
-  ) as NodeListOf<HTMLTableRowElement>;
+/////////////////////////
+// URL State Management
+/////////////////////////
+function getQueryParams() {
+  return new URLSearchParams(window.location.search);
+}

-  rows.forEach((row) => {
-    const cellTexts = Array.from(row.cells).map((cell) =>
-      cell.textContent!.toLowerCase(),
-    );
-    const isVisible = cellTexts.some((text) => text.includes(value));
-    row.style.display = isVisible ? "" : "none";
-  });
-});
+function updateQueryParams(updates: Record<string, string | null>) {
+  const params = getQueryParams();
+  for (const [key, value] of Object.entries(updates)) {
+    if (value) {
+      params.set(key, value);
+    } else {
+      params.delete(key);
+    }
+  }
+  const newPath = params.toString()
+    ? `${window.location.pathname}?${params.toString()}`
+    : window.location.pathname;
+  window.history.pushState({}, "", newPath);
+}

+function getColumnNameForURL(headerEl: Element): string {
+  const text = headerEl.textContent?.trim().toLowerCase() || "";
+  return text.replace(/↑|↓/g, "").trim().split(/\s+/).slice(0, 2).join("-");
+}
+
+function getColumnIndexByUrlName(name: string): number {
+  const headers = document.querySelectorAll("th.sortable");
+  return Array.from(headers).findIndex(
+    (header) => getColumnNameForURL(header) === name
+  );
+}
+
+/////////////////////////
+// Handle "How to use"
+/////////////////////////
 let y = 0;

 help.addEventListener("click", () => {
-  scrollY = window.scrollY;
+  y = window.scrollY;
  document.body.style.position = "fixed";
  document.body.style.top = `-${y}px`;
  modal.showModal();
@@ -31,7 +53,7 @@ function closeDialog() {
  modal.close();
  document.body.style.position = "";
  document.body.style.top = "";
-  window.scrollTo(0, scrollY);
+  window.scrollTo(0, y);
 }

 modalClose.addEventListener("click", closeDialog);
@@ -39,3 +61,180 @@ modal.addEventListener("cancel", closeDialog);
 modal.addEventListener("click", (e) => {
  if (e.target === modal) closeDialog();
 });
+
+////////////////////
+// Handle Sorting
+////////////////////
+let currentSort = { column: -1, direction: "asc" };
+
+function sortTable(column: number, direction: "asc" | "desc") {
+  const header = document.querySelectorAll("th.sortable")[column];
+  const columnType = header.getAttribute("data-type");
+  if (!columnType) return;
+
+  // update state
+  currentSort = { column, direction };
+  updateQueryParams({
+    sort: getColumnNameForURL(header),
+    order: direction,
+  });
+
+  // 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);
+
+    // Handle undefined values - always sort to bottom
+    if (aValue === undefined && bValue === undefined) return 0;
+    if (aValue === undefined) return 1;
+    if (bValue === undefined) return -1;
+
+    let comparison = 0;
+    if (columnType === "number" || columnType === "modalities") {
+      comparison = (aValue as number) - (bValue as number);
+    } else if (columnType === "boolean") {
+      comparison = (aValue as string).localeCompare(bValue as string);
+    } else {
+      comparison = (aValue as string).localeCompare(bValue as string);
+    }
+
+    return direction === "asc" ? comparison : -comparison;
+  });
+  rows.forEach((row) => tbody.appendChild(row));
+
+  // update sort indicators
+  const headers = document.querySelectorAll("th.sortable");
+  headers.forEach((header, i) => {
+    const indicator = header.querySelector(".sort-indicator")!;
+
+    if (i === column) {
+      indicator.textContent = direction === "asc" ? "↑" : "↓";
+    } else {
+      indicator.textContent = "";
+    }
+  });
+}
+
+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) => {
+  header.addEventListener("click", () => {
+    const column = Array.from(header.parentElement!.children).indexOf(header);
+    const direction =
+      currentSort.column === column && currentSort.direction === "asc"
+        ? "desc"
+        : "asc";
+    sortTable(column, direction);
+  });
+});
+
+///////////////////
+// Handle 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);
+});
+
+document.addEventListener("keydown", (e) => {
+  if ((e.metaKey || e.ctrlKey) && e.key === "k") {
+    e.preventDefault();
+    search.focus();
+  }
+});
+
+search.addEventListener("keydown", (e) => {
+  if (e.key === "Escape") {
+    search.value = "";
+    search.dispatchEvent(new Event("input"));
+  }
+});
+
+///////////////////////////////////
+// Handle Copy model ID function
+///////////////////////////////////
+(window as any).copyModelId = async (
+  button: HTMLButtonElement,
+  modelId: string
+) => {
+  try {
+    if (navigator.clipboard) {
+      await navigator.clipboard.writeText(modelId);
+
+      // Switch to check icon
+      const copyIcon = button.querySelector(".copy-icon") as HTMLElement;
+      const checkIcon = button.querySelector(".check-icon") as HTMLElement;
+
+      copyIcon.style.display = "none";
+      checkIcon.style.display = "block";
+
+      // Switch back after 1 second
+      setTimeout(() => {
+        copyIcon.style.display = "block";
+        checkIcon.style.display = "none";
+      }, 1000);
+    }
+  } catch (err) {
+    console.error("Failed to copy text: ", err);
+  }
+};
+
+///////////////////////////////////
+// Initialize State from URL
+///////////////////////////////////
+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;
+
+    const columnIndex = getColumnIndexByUrlName(columnName);
+    if (columnIndex === -1) return;
+
+    const direction = (params.get("order") as "asc" | "desc") || "asc";
+    sortTable(columnIndex, direction);
+  })();
+}
+
+document.addEventListener("DOMContentLoaded", initializeFromURL);
+window.addEventListener("popstate", initializeFromURL);
@@ -1,15 +1,183 @@
 /** @jsx jsx */
 /** @jsxImportSource hono/jsx */

-import { generate } from "@models.dev/core"
-import { Fragment } from "hono/jsx"
-import { renderToString } from "hono/jsx/dom/server"
-import path from "path"
+import { generate } from "models.dev";
+import { Fragment } from "hono/jsx";
+import { renderToString } from "hono/jsx/dom/server";
+import { existsSync } from "fs";
+import path from "path";

 export const Providers = await generate(
  path.join(import.meta.dir, "..", "..", "..", "providers")
-)
+);

+// Function to load SVG content
+const loadProviderSvg = async (providerId: string): Promise<string | null> => {
+  const providerLogoPath = path.join(
+    import.meta.dir,
+    "..",
+    "..",
+    "..",
+    "providers",
+    providerId,
+    "logo.svg"
+  );
+
+  const defaultLogoPath = path.join(
+    import.meta.dir,
+    "..",
+    "..",
+    "..",
+    "providers",
+    "logo.svg"
+  );
+
+  try {
+    // Try provider-specific logo first
+    if (existsSync(providerLogoPath)) {
+      const file = Bun.file(providerLogoPath);
+      return await file.text();
+    }
+    //
+    // Fall back to default logo
+    if (existsSync(defaultLogoPath)) {
+      const file = Bun.file(defaultLogoPath);
+      return await file.text();
+    }
+    return null;
+  } catch (error) {
+    console.warn(`Failed to load logo for provider ${providerId}:`, error);
+    return null;
+  }
+};
+
+// Create a cache of loaded SVGs at build time
+const providerLogos = new Map<string, string>();
+
+// Pre-load all provider logos
+for (const [providerId] of Object.entries(Providers)) {
+  const svgContent = await loadProviderSvg(providerId);
+  if (svgContent) {
+    providerLogos.set(providerId, svgContent);
+  }
+}
+
+function renderProviderLogo(providerId: string) {
+  const svgContent = providerLogos.get(providerId) || "";
+
+  return <span dangerouslySetInnerHTML={{ __html: svgContent }} />;
+}
+
+const getModalityIcon = (modality: string) => {
+  switch (modality) {
+    case "text":
+      return (
+        <span class="modality-icon" data-tooltip="Text">
+          <svg
+            xmlns="http://www.w3.org/2000/svg"
+            width="16"
+            height="16"
+            viewBox="0 0 24 24"
+            fill="none"
+            stroke="currentColor"
+            stroke-width="2"
+            stroke-linecap="round"
+            stroke-linejoin="round"
+          >
+            <polyline points="4,7 4,4 20,4 20,7"></polyline>
+            <line x1="9" y1="20" x2="15" y2="20"></line>
+            <line x1="12" y1="4" x2="12" y2="20"></line>
+          </svg>
+        </span>
+      );
+    case "image":
+      return (
+        <span class="modality-icon" data-tooltip="Image">
+          <svg
+            xmlns="http://www.w3.org/2000/svg"
+            width="16"
+            height="16"
+            viewBox="0 0 24 24"
+            fill="none"
+            stroke="currentColor"
+            stroke-width="2"
+            stroke-linecap="round"
+            stroke-linejoin="round"
+          >
+            <rect width="18" height="18" x="3" y="3" rx="2" ry="2"></rect>
+            <circle cx="9" cy="9" r="2"></circle>
+            <path d="m21 15-3.086-3.086a2 2 0 0 0-2.828 0L6 21"></path>
+          </svg>
+        </span>
+      );
+    case "audio":
+      return (
+        <span class="modality-icon" data-tooltip="Audio">
+          <svg
+            xmlns="http://www.w3.org/2000/svg"
+            width="16"
+            height="16"
+            viewBox="0 0 24 24"
+            fill="none"
+            stroke="currentColor"
+            stroke-width="2"
+            stroke-linecap="round"
+            stroke-linejoin="round"
+          >
+            <polygon points="11 5 6 9 2 9 2 15 6 15 11 19 11 5"></polygon>
+            <path d="m19.07 4.93a10 10 0 0 1 0 14.14M15.54 8.46a5 5 0 0 1 0 7.07"></path>
+          </svg>
+        </span>
+      );
+    case "video":
+      return (
+        <span class="modality-icon" data-tooltip="Video">
+          <svg
+            xmlns="http://www.w3.org/2000/svg"
+            width="16"
+            height="16"
+            viewBox="0 0 24 24"
+            fill="none"
+            stroke="currentColor"
+            stroke-width="2"
+            stroke-linecap="round"
+            stroke-linejoin="round"
+          >
+            <path d="m22 8-6 4 6 4V8Z"></path>
+            <rect width="14" height="12" x="2" y="6" rx="2" ry="2"></rect>
+          </svg>
+        </span>
+      );
+    case "pdf":
+      return (
+        <span class="modality-icon" data-tooltip="PDF">
+          <svg
+            xmlns="http://www.w3.org/2000/svg"
+            width="16"
+            height="16"
+            viewBox="0 0 24 24"
+            fill="none"
+            stroke="currentColor"
+            stroke-width="2"
+            stroke-linecap="round"
+            stroke-linejoin="round"
+          >
+            <path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"></path>
+            <polyline points="14,2 14,8 20,8"></polyline>
+            <line x1="16" y1="13" x2="8" y2="13"></line>
+            <line x1="16" y1="17" x2="8" y2="17"></line>
+            <polyline points="10,9 9,9 8,9"></polyline>
+          </svg>
+        </span>
+      );
+    default:
+      return null;
+  }
+};
+
+const renderCost = (cost?: number) => {
+  return cost === undefined ? "-" : `$${cost.toFixed(2)}`;
+};

 export const Rendered = renderToString(
  <Fragment>
@@ -38,30 +206,140 @@ export const Rendered = renderToString(
            ></path>
          </svg>
        </a>
-        <input
-          type="text"
-          id="search"
-          placeholder="Filter by provider or model..."
-        />
+        <div class="search-container">
+          <input type="text" id="search" placeholder="Search models" />
+          <span class="search-shortcut">⌘K</span>
+        </div>
        <button id="help">How to use</button>
      </div>
    </header>
    <table>
      <thead>
        <tr>
-          <th>Provider</th>
-          <th>Model</th>
-          <th>Provider ID</th>
-          <th>Model ID</th>
-          <th>Attachment</th>
-          <th>Reasoning</th>
-          <th>Temperature</th>
-          <th data-desc="per 1M tokens">Input Cost</th>
-          <th data-desc="per 1M tokens">Output Cost</th>
-          <th data-desc="per 1M tokens">Cache Read Cost</th>
-          <th data-desc="per 1M tokens">Cache Write Cost</th>
-          <th>Context Limit</th>
-          <th>Output Limit</th>
+          <th class="sortable" data-type="text">
+            Provider <span class="sort-indicator"></span>
+          </th>
+          <th class="sortable" data-type="text">
+            Model <span class="sort-indicator"></span>
+          </th>
+          <th class="sortable" data-type="text">
+            Family <span class="sort-indicator"></span>
+          </th>
+          <th class="sortable" data-type="text">
+            Provider ID <span class="sort-indicator"></span>
+          </th>
+          <th class="sortable" data-type="text">
+            Model ID <span class="sort-indicator"></span>
+          </th>
+          <th class="sortable" data-type="boolean">
+            Tool Call <span class="sort-indicator"></span>
+          </th>
+          <th class="sortable" data-type="boolean">
+            Reasoning <span class="sort-indicator"></span>
+          </th>
+          <th class="sortable" data-type="modalities">
+            Input <span class="sort-indicator"></span>
+          </th>
+          <th class="sortable" data-type="modalities">
+            Output <span class="sort-indicator"></span>
+          </th>
+          <th class="sortable" data-type="number">
+            <div class="header-container">
+              <span class="header-text">
+                Input Cost
+                <br />
+                <span class="desc">per 1M tokens</span>
+              </span>
+              <span class="sort-indicator"></span>
+            </div>
+          </th>
+          <th class="sortable" data-type="number">
+            <div class="header-container">
+              <span class="header-text">
+                Output Cost
+                <br />
+                <span class="desc">per 1M tokens</span>
+              </span>
+              <span class="sort-indicator"></span>
+            </div>
+          </th>
+          <th class="sortable" data-type="number">
+            <div class="header-container">
+              <span class="header-text">
+                Reasoning Cost
+                <br />
+                <span class="desc">per 1M tokens</span>
+              </span>
+              <span class="sort-indicator"></span>
+            </div>
+          </th>
+          <th class="sortable" data-type="number">
+            <div class="header-container">
+              <span class="header-text">
+                Cache Read Cost
+                <br />
+                <span class="desc">per 1M tokens</span>
+              </span>
+              <span class="sort-indicator"></span>
+            </div>
+          </th>
+          <th class="sortable" data-type="number">
+            <div class="header-container">
+              <span class="header-text">
+                Cache Write Cost
+                <br />
+                <span class="desc">per 1M tokens</span>
+              </span>
+              <span class="sort-indicator"></span>
+            </div>
+          </th>
+          <th class="sortable" data-type="number">
+            <div class="header-container">
+              <span class="header-text">
+                Audio Input Cost
+                <br />
+                <span class="desc">per 1M tokens</span>
+              </span>
+              <span class="sort-indicator"></span>
+            </div>
+          </th>
+          <th class="sortable" data-type="number">
+            <div class="header-container">
+              <span class="header-text">
+                Audio Output Cost
+                <br />
+                <span class="desc">per 1M tokens</span>
+              </span>
+              <span class="sort-indicator"></span>
+            </div>
+          </th>
+          <th class="sortable" data-type="number">
+            Context Limit <span class="sort-indicator"></span>
+          </th>
+          <th class="sortable" data-type="number">
+            Input Limit <span class="sort-indicator"></span>
+          </th>
+          <th class="sortable" data-type="number">
+            Output Limit <span class="sort-indicator"></span>
+          </th>
+          <th class="sortable" data-type="boolean">
+            Structured Output <span class="sort-indicator"></span>
+          </th>
+          <th class="sortable" data-type="boolean">
+            Temperature <span class="sort-indicator"></span>
+          </th>
+          <th class="sortable" data-type="text">
+            Weights <span class="sort-indicator"></span>
+          </th>
+          <th class="sortable" data-type="text">
+            Knowledge <span class="sort-indicator"></span>
+          </th>
+          <th class="sortable" data-type="text">
+            Release Date <span class="sort-indicator"></span>
+          </th>
+          <th class="sortable" data-type="text">
+            Last Updated <span class="sort-indicator"></span>
+          </th>
        </tr>
      </thead>
      <tbody>
@@ -71,24 +349,108 @@ export const Rendered = renderToString(
          )
          .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>{provider.name}</td>
+                  <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>{modelId}</td>
-                  <td>{model.attachment ? "Yes" : "No"}</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.cost.input}</td>
-                  <td>${model.cost.output}</td>
-                  <td>{model.cost.cache_read ? `$${model.cost.cache_read}` : "-"}</td>
-                  <td>{model.cost.cache_write ? `$${model.cost.cache_write}` : "-"}</td>
-                  <td>{model.limit.context}</td>
-                  <td>{model.limit.output}</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>
              ))
          )}
@@ -122,14 +484,13 @@ export const Rendered = renderToString(
      </div>
      <div class="body">
        <p>
-          <a href="/">Models.dev</a> is a comprehensive open-source
-          database of AI model specifications, pricing, and features.
+          <a href="/">Models.dev</a> is a comprehensive open-source database of
+          AI model specifications, pricing, and features.
        </p>
        <p>
          There&apos;s no single database with information about all the
-          available AI models. We started Models.dev as a
-          community-contributed project to address this. We also use it
-          internally in{" "}
+          available AI models. We started Models.dev as a community-contributed
+          project to address this. We also use it internally in{" "}
          <a
            href="https://opencode.ai"
            target="_blank"
@@ -147,8 +508,8 @@ export const Rendered = renderToString(
          </code>
        </div>
        <p>
-          Use the <b>Model ID</b> field to do a lookup on any model;
-          it&apos;s the identifier used by{" "}
+          Use the <b>Model ID</b> field to do a lookup on any model; it&apos;s
+          the identifier used by{" "}
          <a
            href="https://ai-sdk.dev/"
            target="_blank"
@@ -158,6 +519,22 @@ export const Rendered = renderToString(
          </a>
          .
        </p>
+        <h2>Logos</h2>
+        <p>
+          Provider logos are available at <code>/logos/{`{provider}`}.svg</code>{" "}
+          where <code>{`{provider}`}</code> is the <b>Provider ID</b>.
+        </p>
+        <div class="code-block">
+          <code>
+            curl{" "}
+            <a href="/logos/anthropic.svg">
+              https://models.dev/logos/anthropic.svg
+            </a>
+          </code>
+        </div>
+        <p>
+          If we don't have a provider's logo, a default logo is served instead.
+        </p>
        <h2>Contribute</h2>
        <p>
          The data is stored in the{" "}
@@ -168,12 +545,12 @@ export const Rendered = renderToString(
          >
            GitHub repo
          </a>{" "}
-          as TOML files; organized by provider and model. This is used to
-          generate this page and power the API.
+          as TOML files; organized by provider and model. The logo is stored as
+          an SVG. This is used to generate this page and power the API.
        </p>
        <p>
-          We need your help keeping this up to date. Feel free to edit the
-          data and submit a pull request. Refer to the{" "}
+          We need your help keeping this up to date. Feel free to edit the data
+          and submit a pull request. Refer to the{" "}
          <a href="https://github.com/sst/models.dev/blob/dev/README.md">
            README
          </a>{" "}
@@ -188,15 +565,10 @@ export const Rendered = renderToString(
        >
          Edit on GitHub
        </a>
-        <a
-          href="https://sst.dev"
-          target="_blank"
-          rel="noopener noreferrer"
-        >
+        <a href="https://sst.dev" target="_blank" rel="noopener noreferrer">
          Created by SST
        </a>
      </div>
    </dialog>
  </Fragment>
-)
-
+);
@@ -8,10 +8,43 @@ Bun.serve({
    "/": Index,
    "/assets/*": (req) => {
      const file = Bun.file(
-        path.join(import.meta.dir, new URL(req.url).pathname),
+        path.join(import.meta.dir, new URL(req.url).pathname)
      );
      return new Response(file);
    },
+    "/logos/*": async (req) => {
+      const url = new URL(req.url);
+      const provider = url.pathname.split("/")[2].replace(".svg", "");
+      const logoPath = path.join(
+        import.meta.dir,
+        "..",
+        "..",
+        "..",
+        "providers",
+        provider,
+        "logo.svg"
+      );
+      const defaultLogoPath = path.join(
+        import.meta.dir,
+        "..",
+        "..",
+        "..",
+        "providers",
+        "logo.svg"
+      );
+
+      let file = Bun.file(logoPath);
+      if (!(await file.exists())) {
+        file = Bun.file(defaultLogoPath);
+      }
+
+      return new Response(file, {
+        headers: {
+          "Content-Type": "image/svg+xml",
+          "Cache-Control": "public, max-age=3600",
+        },
+      });
+    },
  },
 });

@@ -0,0 +1,3 @@
+<svg width="24" height="24" viewBox="0 0 40 40" xmlns="http://www.w3.org/2000/svg">
+  <path d="M10 6C11.1 6 12 6.9 12 8V32C12 33.1 11.1 34 10 34C8.9 34 8 33.1 8 32V8C8 6.9 8.9 6 10 6ZM20 6C21.1 6 22 6.9 22 8V32C22 33.1 21.1 34 20 34C18.9 34 18 33.1 18 32V8C18 6.9 18.9 6 20 6ZM30 6C31.1 6 32 6.9 32 8V32C32 33.1 31.1 34 30 34C28.9 34 28 33.1 28 32V8C28 6.9 28.9 6 30 6ZM10 12C11.65 12 13 13.35 13 15C13 16.65 11.65 18 10 18C8.35 18 7 16.65 7 15C7 13.35 8.35 12 10 12ZM20 20C21.65 20 23 21.35 23 23C23 24.65 21.65 26 20 26C18.35 26 17 24.65 17 23C17 21.35 18.35 20 20 20ZM30 16C31.65 16 33 17.35 33 19C33 20.65 31.65 22 30 22C28.35 22 27 20.65 27 19C27 17.35 28.35 16 30 16Z" fill="currentColor"/>
+</svg>
@@ -0,0 +1,21 @@
+name = "QwQ 32B"
+family = "qwq"
+release_date = "2024-11-28"
+last_updated = "2024-11-28"
+attachment = false
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = true
+
+[cost]
+input = 0.40
+output = 0.40
+
+[limit]
+context = 32_768
+output = 32_768
+
+[modalities]
+input = ["text"]
+output = ["text"]
@@ -0,0 +1,21 @@
+name = "Qwen 2.5 72B Instruct"
+family = "qwen-2.5"
+release_date = "2024-09-19"
+last_updated = "2024-09-19"
+attachment = false
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = true
+
+[cost]
+input = 0.11
+output = 0.38
+
+[limit]
+context = 128_000
+output = 8_192
+
+[modalities]
+input = ["text"]
+output = ["text"]
@@ -0,0 +1,21 @@
+name = "Qwen3 235B A22B Instruct"
+family = "qwen-3"
+release_date = "2025-07-01"
+last_updated = "2025-07-01"
+attachment = false
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = true
+
+[cost]
+input = 0.13
+output = 0.60
+
+[limit]
+context = 262_144
+output = 8_192
+
+[modalities]
+input = ["text"]
+output = ["text"]
@@ -0,0 +1,21 @@
+name = "Qwen3 32B"
+family = "qwen-3"
+release_date = "2025-04-29"
+last_updated = "2025-04-29"
+attachment = false
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = true
+
+[cost]
+input = 0.09
+output = 0.29
+
+[limit]
+context = 128_000
+output = 8_192
+
+[modalities]
+input = ["text"]
+output = ["text"]
@@ -0,0 +1,22 @@
+name = "Claude Sonnet 3.7"
+family = "claude-sonnet"
+release_date = "2025-02-19"
+last_updated = "2025-02-19"
+attachment = true
+reasoning = true
+temperature = true
+tool_call = true
+knowledge = "2024-10-31"
+open_weights = false
+
+[cost]
+input = 3.00
+output = 15.00
+
+[limit]
+context = 200_000
+output = 64_000
+
+[modalities]
+input = ["text", "image", "pdf"]
+output = ["text"]
@@ -0,0 +1,22 @@
+name = "Claude Haiku 4.5"
+family = "claude-haiku"
+release_date = "2025-10-15"
+last_updated = "2025-10-15"
+attachment = true
+reasoning = true
+temperature = true
+tool_call = true
+knowledge = "2025-02-28"
+open_weights = false
+
+[cost]
+input = 1.00
+output = 5.00
+
+[limit]
+context = 200_000
+output = 64_000
+
+[modalities]
+input = ["text", "image", "pdf"]
+output = ["text"]
@@ -0,0 +1,21 @@
+name = "Claude Opus 4.1"
+family = "claude-opus"
+release_date = "2025-08-05"
+last_updated = "2025-08-05"
+attachment = true
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = false
+
+[cost]
+input = 15.00
+output = 75.00
+
+[limit]
+context = 200_000
+output = 32_000
+
+[modalities]
+input = ["text", "image", "pdf"]
+output = ["text"]
@@ -0,0 +1,21 @@
+name = "Claude Opus 4"
+family = "claude-opus"
+release_date = "2025-05-14"
+last_updated = "2025-05-14"
+attachment = true
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = false
+
+[cost]
+input = 15.00
+output = 75.00
+
+[limit]
+context = 200_000
+output = 32_000
+
+[modalities]
+input = ["text", "image", "pdf"]
+output = ["text"]
@@ -0,0 +1,22 @@
+name = "Claude Opus 4.5"
+family = "claude-opus"
+release_date = "2025-11-01"
+last_updated = "2025-11-01"
+attachment = true
+reasoning = true
+temperature = true
+tool_call = true
+knowledge = "2025-03-31"
+open_weights = false
+
+[cost]
+input = 5.00
+output = 25.00
+
+[limit]
+context = 200_000
+output = 64_000
+
+[modalities]
+input = ["text", "image", "pdf"]
+output = ["text"]
@@ -0,0 +1,21 @@
+name = "Claude Sonnet 4"
+family = "claude-sonnet"
+release_date = "2025-05-14"
+last_updated = "2025-05-14"
+attachment = true
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = false
+
+[cost]
+input = 3.00
+output = 15.00
+
+[limit]
+context = 200_000
+output = 64_000
+
+[modalities]
+input = ["text", "image", "pdf"]
+output = ["text"]
@@ -0,0 +1,22 @@
+name = "Claude Sonnet 4.5"
+family = "claude-sonnet"
+release_date = "2025-09-29"
+last_updated = "2025-09-29"
+attachment = true
+reasoning = true
+temperature = true
+tool_call = true
+knowledge = "2025-07-31"
+open_weights = false
+
+[cost]
+input = 3.00
+output = 15.00
+
+[limit]
+context = 200_000
+output = 64_000
+
+[modalities]
+input = ["text", "image", "pdf"]
+output = ["text"]
@@ -0,0 +1,21 @@
+name = "DeepSeek R1"
+family = "deepseek-r1"
+release_date = "2025-01-20"
+last_updated = "2025-01-20"
+attachment = false
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = true
+
+[cost]
+input = 3.00
+output = 7.00
+
+[limit]
+context = 128_000
+output = 8_192
+
+[modalities]
+input = ["text"]
+output = ["text"]
@@ -0,0 +1,21 @@
+name = "DeepSeek V3.1 Terminus"
+family = "deepseek-v3"
+release_date = "2025-06-01"
+last_updated = "2025-06-01"
+attachment = false
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = true
+
+[cost]
+input = 0.27
+output = 1.00
+
+[limit]
+context = 128_000
+output = 8_192
+
+[modalities]
+input = ["text"]
+output = ["text"]
@@ -0,0 +1,21 @@
+name = "DeepSeek V3.2"
+family = "deepseek-v3"
+release_date = "2025-06-15"
+last_updated = "2025-06-15"
+attachment = false
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = true
+
+[cost]
+input = 0.27
+output = 0.40
+
+[limit]
+context = 128_000
+output = 8_192
+
+[modalities]
+input = ["text"]
+output = ["text"]
@@ -0,0 +1,21 @@
+name = "DeepSeek V3.1"
+family = "deepseek-v3"
+release_date = "2025-08-01"
+last_updated = "2025-08-01"
+attachment = false
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = true
+
+[cost]
+input = 0.55
+output = 1.66
+
+[limit]
+context = 128_000
+output = 8_192
+
+[modalities]
+input = ["text"]
+output = ["text"]
@@ -0,0 +1,21 @@
+name = "Gemini 2.0 Flash"
+family = "gemini-flash"
+release_date = "2025-02-05"
+last_updated = "2025-02-05"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+
+[cost]
+input = 0.10
+output = 0.40
+
+[limit]
+context = 1_000_000
+output = 8_192
+
+[modalities]
+input = ["text", "image", "audio", "video"]
+output = ["text"]
@@ -0,0 +1,17 @@
+name = "Gemini 2.0 Pro Exp"
+family = "gemini-pro"
+release_date = "2025-02-05"
+last_updated = "2025-02-05"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+
+[limit]
+context = 2_000_000
+output = 8_192
+
+[modalities]
+input = ["text", "image", "audio", "video"]
+output = ["text"]
@@ -0,0 +1,22 @@
+name = "Gemini 2.5 Flash"
+family = "gemini-flash"
+release_date = "2025-03-20"
+last_updated = "2025-06-05"
+attachment = true
+reasoning = true
+temperature = true
+tool_call = true
+knowledge = "2025-01"
+open_weights = false
+
+[cost]
+input = 0.30
+output = 2.50
+
+[limit]
+context = 1_048_576
+output = 65_536
+
+[modalities]
+input = ["text", "image", "audio", "video", "pdf"]
+output = ["text"]
@@ -0,0 +1,22 @@
+name = "Gemini 2.5 Pro"
+family = "gemini-pro"
+release_date = "2025-03-25"
+last_updated = "2025-03-25"
+attachment = true
+reasoning = true
+temperature = true
+tool_call = true
+knowledge = "2025-01"
+open_weights = false
+
+[cost]
+input = 1.25
+output = 10.00
+
+[limit]
+context = 1_048_576
+output = 65_536
+
+[modalities]
+input = ["text", "image", "audio", "video", "pdf"]
+output = ["text"]
@@ -0,0 +1,22 @@
+name = "Gemini 3 Flash Preview"
+family = "gemini-flash"
+release_date = "2025-12-17"
+last_updated = "2025-12-17"
+attachment = true
+reasoning = true
+temperature = true
+tool_call = true
+knowledge = "2025-01"
+open_weights = false
+
+[cost]
+input = 0.50
+output = 3.00
+
+[limit]
+context = 1_048_576
+output = 65_536
+
+[modalities]
+input = ["text", "image", "audio", "video", "pdf"]
+output = ["text"]
@@ -0,0 +1,21 @@
+name = "Gemini 3 Pro Preview"
+family = "gemini-pro"
+release_date = "2025-06-01"
+last_updated = "2025-06-01"
+attachment = true
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = false
+
+[cost]
+input = 2.00
+output = 12.00
+
+[limit]
+context = 1_000_000
+output = 65_000
+
+[modalities]
+input = ["text", "image", "audio", "video"]
+output = ["text"]
@@ -0,0 +1,22 @@
+name = "GPT-4.1 Mini"
+family = "gpt-4.1"
+release_date = "2025-04-14"
+last_updated = "2025-04-14"
+attachment = true
+reasoning = false
+temperature = true
+knowledge = "2024-04"
+tool_call = true
+open_weights = false
+
+[cost]
+input = 0.40
+output = 1.60
+
+[limit]
+context = 1_047_576
+output = 32_768
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]
@@ -0,0 +1,22 @@
+name = "GPT-4.1 Nano"
+family = "gpt-4.1"
+release_date = "2025-04-14"
+last_updated = "2025-04-14"
+attachment = true
+reasoning = false
+temperature = true
+knowledge = "2024-04"
+tool_call = true
+open_weights = false
+
+[cost]
+input = 0.10
+output = 0.40
+
+[limit]
+context = 1_047_576
+output = 32_768
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]
@@ -0,0 +1,22 @@
+name = "GPT-4.1"
+family = "gpt-4.1"
+release_date = "2025-04-14"
+last_updated = "2025-04-14"
+attachment = true
+reasoning = false
+temperature = true
+knowledge = "2024-04"
+tool_call = true
+open_weights = false
+
+[cost]
+input = 2.00
+output = 8.00
+
+[limit]
+context = 1_047_576
+output = 32_768
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]
@@ -0,0 +1,22 @@
+name = "GPT-4o (2024-11-20)"
+family = "gpt-4o"
+release_date = "2024-11-20"
+last_updated = "2024-11-20"
+attachment = true
+reasoning = false
+temperature = true
+knowledge = "2024-10"
+tool_call = true
+open_weights = false
+
+[cost]
+input = 2.50
+output = 10.00
+
+[limit]
+context = 128_000
+output = 16_384
+
+[modalities]
+input = ["text", "image", "audio"]
+output = ["text"]
@@ -0,0 +1,22 @@
+name = "GPT-4o Mini"
+family = "gpt-4o"
+release_date = "2024-07-18"
+last_updated = "2024-07-18"
+attachment = true
+reasoning = false
+temperature = true
+knowledge = "2024-04"
+tool_call = true
+open_weights = false
+
+[cost]
+input = 0.15
+output = 0.60
+
+[limit]
+context = 128_000
+output = 16_384
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]
@@ -0,0 +1,22 @@
+name = "GPT-5 Mini"
+family = "gpt-5-mini"
+release_date = "2025-08-07"
+last_updated = "2025-08-07"
+attachment = true
+reasoning = true
+temperature = false
+knowledge = "2024-05-30"
+tool_call = true
+open_weights = false
+
+[cost]
+input = 0.25
+output = 2.00
+
+[limit]
+context = 400_000
+output = 128_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]
@@ -0,0 +1,22 @@
+name = "GPT-5 Nano"
+family = "gpt-5-nano"
+release_date = "2025-08-07"
+last_updated = "2025-08-07"
+attachment = true
+reasoning = true
+temperature = false
+knowledge = "2024-05-30"
+tool_call = true
+open_weights = false
+
+[cost]
+input = 0.05
+output = 0.40
+
+[limit]
+context = 400_000
+output = 128_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]
@@ -0,0 +1,22 @@
+name = "GPT-5.1 Chat Latest"
+family = "gpt-5"
+release_date = "2025-11-13"
+last_updated = "2025-11-13"
+attachment = true
+reasoning = true
+temperature = false
+knowledge = "2024-09-30"
+tool_call = true
+open_weights = false
+
+[cost]
+input = 1.25
+output = 10.00
+
+[limit]
+context = 400_000
+output = 128_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]
@@ -0,0 +1,22 @@
+name = "GPT-5.1"
+family = "gpt-5"
+release_date = "2025-11-13"
+last_updated = "2025-11-13"
+attachment = true
+reasoning = true
+temperature = false
+knowledge = "2024-09-30"
+tool_call = true
+open_weights = false
+
+[cost]
+input = 1.25
+output = 10.00
+
+[limit]
+context = 400_000
+output = 128_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]
@@ -0,0 +1,22 @@
+name = "GPT-5.2"
+family = "gpt-5"
+release_date = "2025-12-11"
+last_updated = "2025-12-11"
+attachment = true
+reasoning = true
+temperature = false
+knowledge = "2025-08-31"
+tool_call = true
+open_weights = false
+
+[cost]
+input = 1.75
+output = 14.00
+
+[limit]
+context = 400_000
+output = 128_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]
@@ -0,0 +1,22 @@
+name = "GPT-5"
+family = "gpt-5"
+release_date = "2025-08-07"
+last_updated = "2025-08-07"
+attachment = true
+reasoning = true
+temperature = false
+knowledge = "2024-09-30"
+tool_call = true
+open_weights = false
+
+[cost]
+input = 1.25
+output = 10.00
+
+[limit]
+context = 400_000
+output = 128_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]
@@ -0,0 +1,21 @@
+name = "Grok 4"
+family = "grok-4"
+release_date = "2025-07-09"
+last_updated = "2025-07-09"
+attachment = true
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = false
+
+[cost]
+input = 3.00
+output = 15.00
+
+[limit]
+context = 256_000
+output = 16_384
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]
@@ -0,0 +1,21 @@
+name = "Grok 4.1 Fast (Non-Reasoning)"
+family = "grok-4.1"
+release_date = "2025-11-17"
+last_updated = "2025-11-17"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+
+[cost]
+input = 0.20
+output = 0.50
+
+[limit]
+context = 2_000_000
+output = 16_384
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]
@@ -0,0 +1,21 @@
+name = "Grok 4 Fast (Non-Reasoning)"
+family = "grok-4"
+release_date = "2025-07-09"
+last_updated = "2025-07-09"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+
+[cost]
+input = 0.20
+output = 0.50
+
+[limit]
+context = 2_000_000
+output = 16_384
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]
@@ -0,0 +1,21 @@
+name = "Grok Code Fast 1"
+family = "grok-code"
+release_date = "2025-09-01"
+last_updated = "2025-09-01"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+
+[cost]
+input = 0.20
+output = 1.50
+
+[limit]
+context = 256_000
+output = 16_384
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]
@@ -0,0 +1,21 @@
+name = "Kimi K2 Turbo Preview"
+family = "kimi-k2"
+release_date = "2025-07-08"
+last_updated = "2025-07-08"
+attachment = false
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = false
+
+[cost]
+input = 0.15
+output = 8.00
+
+[limit]
+context = 256_000
+output = 8_192
+
+[modalities]
+input = ["text"]
+output = ["text"]
@@ -0,0 +1,21 @@
+name = "Llama 3.3 70B Versatile"
+family = "llama-3.3"
+release_date = "2024-12-06"
+last_updated = "2024-12-06"
+attachment = false
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = true
+
+[cost]
+input = 0.59
+output = 0.79
+
+[limit]
+context = 128_000
+output = 32_768
+
+[modalities]
+input = ["text"]
+output = ["text"]
@@ -0,0 +1,22 @@
+name = "Llama 4 Maverick 17B 128E Instruct FP8"
+family = "llama-4"
+release_date = "2025-04-05"
+last_updated = "2025-04-05"
+attachment = true
+reasoning = false
+temperature = true
+tool_call = true
+knowledge = "2024-08"
+open_weights = true
+
+[cost]
+input = 0.14
+output = 0.59
+
+[limit]
+context = 1_000_000
+output = 32_768
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]
@@ -0,0 +1,21 @@
+name = "Llama 3.1 405B Instruct Turbo"
+family = "llama-3.1"
+release_date = "2024-07-23"
+last_updated = "2024-07-23"
+attachment = false
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = true
+
+[cost]
+input = 3.50
+output = 3.50
+
+[limit]
+context = 128_000
+output = 4_096
+
+[modalities]
+input = ["text"]
+output = ["text"]
@@ -0,0 +1,21 @@
+name = "Llama 3.1 70B Instruct"
+family = "llama-3.1"
+release_date = "2024-07-23"
+last_updated = "2024-07-23"
+attachment = false
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = true
+
+[cost]
+input = 0.40
+output = 0.40
+
+[limit]
+context = 128_000
+output = 4_096
+
+[modalities]
+input = ["text"]
+output = ["text"]
@@ -0,0 +1,21 @@
+name = "Llama 3.1 8B Instruct"
+family = "llama-3.1"
+release_date = "2024-07-23"
+last_updated = "2024-07-23"
+attachment = false
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = true
+
+[cost]
+input = 0.02
+output = 0.05
+
+[limit]
+context = 128_000
+output = 4_096
+
+[modalities]
+input = ["text"]
+output = ["text"]
@@ -0,0 +1,22 @@
+name = "o3-mini"
+family = "o3-mini"
+release_date = "2024-12-20"
+last_updated = "2025-01-29"
+attachment = false
+reasoning = true
+temperature = false
+knowledge = "2024-05"
+tool_call = true
+open_weights = false
+
+[cost]
+input = 1.10
+output = 4.40
+
+[limit]
+context = 200_000
+output = 100_000
+
+[modalities]
+input = ["text"]
+output = ["text"]
@@ -0,0 +1,22 @@
+name = "o3-pro"
+family = "o3-pro"
+release_date = "2025-06-10"
+last_updated = "2025-06-10"
+attachment = true
+reasoning = true
+temperature = false
+knowledge = "2024-05"
+tool_call = true
+open_weights = false
+
+[cost]
+input = 20.00
+output = 80.00
+
+[limit]
+context = 200_000
+output = 100_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]
@@ -0,0 +1,22 @@
+name = "o3"
+family = "o3"
+release_date = "2025-04-16"
+last_updated = "2025-04-16"
+attachment = true
+reasoning = true
+temperature = false
+knowledge = "2024-05"
+tool_call = true
+open_weights = false
+
+[cost]
+input = 2.00
+output = 8.00
+
+[limit]
+context = 200_000
+output = 100_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]
@@ -0,0 +1,22 @@
+name = "o4-mini"
+family = "o4-mini"
+release_date = "2025-04-16"
+last_updated = "2025-04-16"
+attachment = true
+reasoning = true
+temperature = false
+knowledge = "2024-05"
+tool_call = true
+open_weights = false
+
+[cost]
+input = 1.10
+output = 4.40
+
+[limit]
+context = 200_000
+output = 100_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]
@@ -0,0 +1,21 @@
+name = "GPT-OSS 120B"
+family = "gpt-oss"
+release_date = "2025-08-05"
+last_updated = "2025-08-05"
+attachment = true
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = true
+
+[cost]
+input = 0.08
+output = 0.44
+
+[limit]
+context = 128_000
+output = 32_768
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]
@@ -0,0 +1,21 @@
+name = "Qwen 2.5 Coder 32B"
+family = "qwen-2.5"
+release_date = "2024-11-11"
+last_updated = "2024-11-11"
+attachment = false
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = true
+
+[cost]
+input = 0.79
+output = 0.79
+
+[limit]
+context = 128_000
+output = 8_192
+
+[modalities]
+input = ["text"]
+output = ["text"]
@@ -0,0 +1,21 @@
+name = "Qwen3 Max"
+family = "qwen-3"
+release_date = "2025-05-28"
+last_updated = "2025-05-28"
+attachment = false
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = false
+
+[cost]
+input = 1.20
+output = 6.00
+
+[limit]
+context = 131_072
+output = 16_384
+
+[modalities]
+input = ["text"]
+output = ["text"]
@@ -0,0 +1,21 @@
+name = "Qwen3 Coder 480B A35B Instruct"
+family = "qwen-3-coder"
+release_date = "2025-07-22"
+last_updated = "2025-07-22"
+attachment = false
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = true
+
+[cost]
+input = 0.29
+output = 1.20
+
+[limit]
+context = 262_144
+output = 65_536
+
+[modalities]
+input = ["text"]
+output = ["text"]
@@ -0,0 +1,21 @@
+name = "GLM-4.5"
+family = "glm-4"
+release_date = "2025-07-28"
+last_updated = "2025-07-28"
+attachment = false
+reasoning = true
+temperature = true
+tool_call = true
+open_weights = true
+
+[cost]
+input = 0.60
+output = 2.20
+
+[limit]
+context = 128_000
+output = 8_192
+
+[modalities]
+input = ["text"]
+output = ["text"]
@@ -0,0 +1,21 @@
+name = "GLM-4.6"
+family = "glm-4"
+release_date = "2025-03-01"
+last_updated = "2025-03-01"
+attachment = false
+reasoning = false
+temperature = true
+tool_call = true
+open_weights = true
+
+[cost]
+input = 0.60
+output = 2.20
+
+[limit]
+context = 128_000
+output = 8_192
+
+[modalities]
+input = ["text"]
+output = ["text"]
@@ -0,0 +1,5 @@
+name = "Abacus"
+npm = "@ai-sdk/openai-compatible"
+env = ["ABACUS_API_KEY"]
+doc = "https://abacus.ai/help/api"
+api = "https://routellm.abacus.ai/v1/chat/completions"
@@ -0,0 +1,3 @@
+<svg width="24" height="24" viewBox="0 0 40 40" xmlns="http://www.w3.org/2000/svg">
+<path fill-rule="evenodd" clip-rule="evenodd" d="M18.7344 13.9883C18.8906 12.9154 19.237 11.5378 19.7734 9.85547L20 9.16016L20.2266 9.85547C20.763 11.5378 21.1094 12.9154 21.2656 13.9883C21.3854 14.7748 21.3854 15.7747 21.2656 16.9883C21.1458 18.207 21.1458 19.2148 21.2656 20.0117C21.4427 21.1784 21.9766 22.1471 22.8672 22.918C23.7734 23.7044 24.8229 24.0977 26.0156 24.0977C27.3385 24.0977 28.4688 23.6315 29.4062 22.6992C30.3385 21.7669 30.8099 20.6419 30.8203 19.3242C30.8255 18.1576 30.9453 16.8711 31.1797 15.4648C31.2944 14.7617 31.4116 14.1732 31.5313 13.6992L31.6875 13.0586L31.9688 13.6523C32.776 15.3607 33.1978 17.1628 33.2344 19.0586V19.3242C33.2344 21.1211 32.8882 22.8372 32.1953 24.4727C31.5235 26.0612 30.5781 27.4648 29.3594 28.6836C28.1354 29.9023 26.7318 30.8477 25.1484 31.5197C23.513 32.2122 21.7969 32.5588 20 32.5588C18.2031 32.5588 16.487 32.2122 14.8516 31.5197C13.2682 30.8477 11.8646 29.9023 10.6406 28.6836C9.42187 27.4648 8.47656 26.0612 7.80469 24.4727C7.11197 22.8372 6.76562 21.1211 6.76562 19.3242V19.0586C6.80209 17.1628 7.22397 15.3607 8.03125 13.6523L8.3125 13.0586L8.46875 13.6992C8.58853 14.1732 8.70572 14.7617 8.82031 15.4648C9.05469 16.8711 9.17447 18.1576 9.17969 19.3242C9.19009 20.6419 9.66147 21.7669 10.5937 22.6992C11.5312 23.6315 12.6615 24.0977 13.9844 24.0977C15.1771 24.0977 16.2266 23.7044 17.1328 22.918C18.0234 22.1471 18.5573 21.1784 18.7344 20.0117C18.8542 19.2148 18.8542 18.207 18.7344 16.9883C18.6146 15.7747 18.6146 14.7748 18.7344 13.9883ZM20 30.1445C21.8281 30.1445 23.5417 29.7122 25.1406 28.8477C26.2738 28.2378 27.2578 27.461 28.0927 26.5172C28.1969 26.3995 28.0742 26.2202 27.9224 26.2614C27.3073 26.4283 26.6717 26.5117 26.0156 26.5117C24.7135 26.5117 23.5026 26.1836 22.3828 25.5273C21.478 24.9999 20.7282 24.3152 20.1336 23.4732C20.0689 23.3815 19.9311 23.3815 19.8664 23.4732C19.2718 24.3152 18.522 24.9999 17.6172 25.5273C16.4974 26.1836 15.2865 26.5117 13.9844 26.5117C13.3283 26.5117 12.6927 26.4283 12.0776 26.2614C11.9258 26.2202 11.8031 26.3995 11.9072 26.5172C12.7422 27.461 13.7262 28.2378 14.8594 28.8477C16.4583 29.7122 18.1719 30.1445 20 30.1445Z" fill="currentColor"/>
+</svg>
@@ -0,0 +1,22 @@
+name = "Kimi K2 0905"
+family = "kimi-k2"
+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"]
@@ -0,0 +1,24 @@
+name = "Claude Haiku 4.5"
+family = "claude-haiku"
+release_date = "2025-09-29"
+last_updated = "2025-09-29"
+attachment = true
+reasoning = true
+temperature = true
+tool_call = true
+knowledge = "2025-07-31"
+open_weights = false
+
+[cost]
+input = 1.10
+output = 5.50
+cache_read = 0.11
+cache_write = 1.25
+
+[limit]
+context = 200_000
+output = 64_000
+
+[modalities]
+input = ["text", "image", "pdf"]
+output = ["text"]
@@ -0,0 +1,24 @@
+name = "Claude Opus 4.1"
+family = "claude-opus"
+release_date = "2025-08-05"
+last_updated = "2025-08-05"
+attachment = true
+reasoning = true
+temperature = true
+tool_call = true
+knowledge = "2025-03-31"
+open_weights = false
+
+[cost]
+input = 16.50
+output = 82.50
+cache_read = 1.50
+cache_write = 18.75
+
+[limit]
+context = 200_000
+output = 32_000
+
+[modalities]
+input = ["text", "image", "pdf"]
+output = ["text"]
@@ -0,0 +1,23 @@
+name = "Claude Opus 4.5"
+release_date = "2025-11-25"
+last_updated = "2025-11-25"
+attachment = true
+reasoning = true
+temperature = true
+tool_call = true
+knowledge = "2025-03"
+open_weights = false
+
+[cost]
+input = 5.00
+output = 25.00
+cache_read = 0.50
+cache_write = 6.25
+
+[limit]
+context = 200_000
+output = 32_000
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]
@@ -0,0 +1,24 @@
+name = "Claude Sonnet 4.5"
+family = "claude-sonnet"
+release_date = "2025-09-29"
+last_updated = "2025-09-29"
+attachment = true
+reasoning = true
+temperature = true
+tool_call = true
+knowledge = "2025-07-31"
+open_weights = false
+
+[cost]
+input = 3.30
+output = 16.50
+cache_read = 0.30
+cache_write = 3.75
+
+[limit]
+context = 200_000
+output = 64_000
+
+[modalities]
+input = ["text", "image", "pdf"]
+output = ["text"]
@@ -0,0 +1,27 @@
+name = "Coding GLM-4.7 Free"
+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"]
+
@@ -0,0 +1,22 @@
+name = "DeepSeek-V3.2-Think"
+family = "deepseek-v3"
+release_date = "2025-12-01"
+last_updated = "2025-12-01"
+attachment = false
+reasoning = true
+temperature = true
+knowledge = "2024-07"
+tool_call = true
+open_weights = true
+
+[cost]
+input = 0.30
+output = 0.45
+
+[limit]
+context = 131_000
+output = 64_000
+
+[modalities]
+input = ["text"]
+output = ["text"]
@@ -0,0 +1,22 @@
+name = "DeepSeek-V3.2"
+family = "deepseek-v3"
+release_date = "2025-12-01"
+last_updated = "2025-12-01"
+attachment = false
+reasoning = true
+temperature = true
+knowledge = "2024-07"
+tool_call = true
+open_weights = true
+
+[cost]
+input = 0.30
+output = 0.45
+
+[limit]
+context = 131_000
+output = 64_000
+
+[modalities]
+input = ["text"]
+output = ["text"]
@@ -0,0 +1,23 @@
+name = "Gemini 2.5 Flash"
+family = "gemini-flash"
+release_date = "2025-09-15"
+last_updated = "2025-09-15"
+attachment = true
+reasoning = false
+temperature = true
+knowledge = "2025-04"
+tool_call = true
+open_weights = false
+
+[cost]
+input = 0.075
+output = 0.30
+cache_read = 0.02
+
+[limit]
+context = 1_000_000
+output = 65_000
+
+[modalities]
+input = ["text", "image", "audio", "video"]
+output = ["text"]
@@ -0,0 +1,23 @@
+name = "Gemini 2.5 Pro"
+family = "gemini-pro"
+release_date = "2025-09-15"
+last_updated = "2025-09-15"
+attachment = true
+reasoning = true
+temperature = true
+knowledge = "2025-04"
+tool_call = true
+open_weights = false
+
+[cost]
+input = 1.25
+output = 5.00
+cache_read = 0.31
+
+[limit]
+context = 2_000_000
+output = 65_000
+
+[modalities]
+input = ["text", "image", "audio", "video"]
+output = ["text"]
@@ -0,0 +1,23 @@
+name = "Gemini 3 Pro Preview"
+family = "gemini-pro"
+release_date = "2025-11-19"
+last_updated = "2025-11-19"
+attachment = true
+reasoning = true
+temperature = true
+tool_call = true
+knowledge = "2025-11"
+open_weights = false
+
+[cost]
+input = 2.00
+output = 12.00
+cache_read = 0.50
+
+[limit]
+context = 1_000_000
+output = 65_000
+
+[modalities]
+input = ["text", "image", "audio", "video"]
+output = ["text"]
@@ -0,0 +1,27 @@
+name = "GLM-4.7"
+family = "glm-4.7"
+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.27
+output = 1.10
+cache_read = 0.548
+
+[limit]
+context = 204800
+output = 131072
+
+[modalities]
+input = ["text"]
+output = ["text"]
+
@@ -0,0 +1,23 @@
+name = "GPT-4.1 mini"
+family = "gpt-4.1-mini"
+release_date = "2025-04-14"
+last_updated = "2025-04-14"
+attachment = true
+reasoning = false
+temperature = true
+knowledge = "2024-04"
+tool_call = true
+open_weights = false
+
+[cost]
+input = 0.40
+output = 1.60
+cache_read = 0.10
+
+[limit]
+context = 1_047_576
+output = 32_768
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]
@@ -0,0 +1,23 @@
+name = "GPT-4.1 nano"
+family = "gpt-4.1-nano"
+release_date = "2025-04-14"
+last_updated = "2025-04-14"
+attachment = true
+reasoning = false
+temperature = true
+knowledge = "2024-04"
+tool_call = true
+open_weights = false
+
+[cost]
+input = 0.10
+output = 0.40
+cache_read = 0.03
+
+[limit]
+context = 1_047_576
+output = 32_768
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]
@@ -0,0 +1,23 @@
+name = "GPT-4.1"
+family = "gpt-4.1"
+release_date = "2025-04-14"
+last_updated = "2025-04-14"
+attachment = true
+reasoning = false
+temperature = true
+knowledge = "2024-04"
+tool_call = true
+open_weights = false
+
+[cost]
+input = 2.00
+output = 8.00
+cache_read = 0.50
+
+[limit]
+context = 1_047_576
+output = 32_768
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]
@@ -0,0 +1,23 @@
+name = "GPT-4o (2024-11-20)"
+family = "gpt-4o"
+release_date = "2024-11-20"
+last_updated = "2024-11-20"
+attachment = true
+reasoning = false
+temperature = true
+knowledge = "2023-09"
+tool_call = true
+open_weights = false
+
+[cost]
+input = 2.50
+output = 10.00
+cache_read = 1.25
+
+[limit]
+context = 128_000
+output = 16_384
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]
@@ -0,0 +1,23 @@
+name = "GPT-4o"
+family = "gpt-4o"
+release_date = "2024-05-13"
+last_updated = "2024-08-06"
+attachment = true
+reasoning = false
+temperature = true
+knowledge = "2023-09"
+tool_call = true
+open_weights = false
+
+[cost]
+input = 2.50
+output = 10.00
+cache_read = 1.25
+
+[limit]
+context = 128_000
+output = 16_384
+
+[modalities]
+input = ["text", "image"]
+output = ["text"]
--- a/Show More
+++ b/Show More