Claude Code. Any Model. The most powerful AI coding agent now speaks every language.
feat(catalog): read connection wires and the route registry
Jack Rudenko11d2ce2491e9
diff --git a/ai-docs/reports/wire-reader-plan-20261012.md b/ai-docs/reports/wire-reader-plan-20261012.mdnew file mode 100644index 00000000..a19b4e6f--- /dev/null+++ b/ai-docs/reports/wire-reader-plan-20261012.md@@ -0,0 +1,151 @@+# Wire reader: build every request from the connection's `wire`++Date: 2026-10-12. Branch `worktree-gpt-routing-fix`, rebased on v10.4.1 (`2e4ac246`).+Spec: Models Index `ai-docs/claudish-wire-requirements.md` (R1–R13, acceptance §4) and+`ai-docs/claudish-catalog-3.7.0.md`, both in the models-index repo. Live generation at writing:+`g-20261012101007285-7770c36e`.++## Why++v10.4.1 is the latest release and is broken against catalog 3.7.0, which has been live since+2026-10-08. `OpenAIAPIFormat.tokenParamName()` applies the model-level `tokenParam` to every chat+body. Since 3.7.0 that field describes the owner's direct connection only, so GPT and Grok chat+requests to gateways carry `max_output_tokens`.++- About 150 chat connections are affected.+- `[email protected]` answers 400 (reproduced).++There is no hotfix. Jack chose the full reader, with no backward compatibility.++## Where claudish departs from the backend spec (Jack's decisions)++| Topic | Backend spec | claudish |+|---|---|---|+| Effort not in `effort.values` | refuse (R3) | **clamp to the nearest published value** (C2) |+| `reasoning` / `tokenParam` `unknown` on a known wire | send nothing (R3) | **try in turn**: the owner's direct connection value when it is on the same `api`, then without it after a 400 that names the field. A different `api` has nothing to borrow, so send nothing. Every fallback is logged as a catalog gap. |+| `wire.status: unknown` | profile `apis` in fixed order, advance on protocol mismatch (R4) | same, any order is fine (3.2); remembered per connection until the next generation |+| No catalog | wait, or fail clearly (R4) | local providers only (C7), which already holds for bare names |+| `qtoken@` host | registry `qwencloud-token-plan` is "a different product" | same product, same key (C4): use the registry host; confirm live with Jack's key |+| Pro / speed syntax | `--mode pro`, `--speed fast` suggested (R13) | `model+pro`, `model#fast`, `model+pro#flex` |++Pro mode is kept. `proOnUltracode` still turns it on under ultracode, but only where the+connection's `wire.reasoning.mode` is `supported` with `pro`.++## Phases (one commit or more each, tests authored by Codex, run by a subagent)++### P1. Data: registry and connection wire (R1, R2, R6)++- **Types.** `ConnectionWire`, `WireControl`, `WireReasoningWarning` and the registry, in one+ module. `AggregatorEntry` / `SlimModelEntry` gain `wire`.+- **Fetch.** `catalog-client.ts` refreshCatalog fetches `catalog=routes&generationId=<same>` after the+ slim pages. If the `generationId` differs, refetch both. The registry is stored in the same cache+ file.+- **Validation.**+ - Reject a 3.7.0+ cache that has a mapped connection without `wire`.+ - Reject a `known` wire whose `api` is missing from its profile's `apis`.+- **Memoize** the cache read by mtime: the request path reads it on every request.+- **`resolveConnection(provider, modelName)`** returns `{route, externalModelId, wire, baseUrlFor(api)}`.+ - Uses exact route binding plus exact wire id; never family or sibling.+ - This is the only source of request decisions.+- **Model-level `tokenParam` / `endpoints` leave every request path.** Model-level `reasoning` stays+ for the effort vocabulary only.++### P2. Thread the connection through the pipeline++The connection travels `RouteCandidate` → `ProfileContext` → `ComposedHandlerOptions`. The+gatherer keeps the connection it already holds (`route-candidates.ts:204`) and skips `unsupported`+connections. An explicit `provider@model` resolves the connection the same way. Dynamic+subscriptions (`gk@`, `ag@`, `dv@`) keep their own discovery and are out of scope (R4).++### P3. Request building from `wire` (R3, R8, R9)++- **RFC 6901 pointer writer.** One helper, unit-tested with `~0` / `~1`.+- **Adapter by `wire.api`:**+ - chat → `OpenAIAPIFormat`;+ - responses → a new generic `ResponsesAPIFormat`, with the Codex extras only on+ `openai/codex-subscription`;+ - messages → Anthropic;+ - gemini → Gemini.+- **URL:** registry `baseUrl` plus the suffix. User env/config base-URL overrides stay, logged.+- **Token limit at `wire.tokenParam`.** Gemini keeps `generationConfig.maxOutputTokens`.+- **Reasoning:**+ - `enable` / `disable` / `effort` at their pointers;+ - effort clamped to the nearest published value;+ - `effort.default` when the user picked none;+ - `disable: not_applicable` means reasoning cannot be turned off, and the user is told.+- **`toolsWithReasoning`:**+ - `requires-responses`: drop reasoning when tools are present, and log it;+ - `requires-effort-none`: send `values.none` or no effort.+- **Warnings.** A `served_model_changes` part (Kimi Code `k3` disable → K2.8 Preview) is never sent+ silently.+- **Poe** keys go at the body root, never under `extra_body`.+- **OpenCode** requests send `x-opencode-session`; OpenCode Messages uses `x-api-key`.++### P4. `unknown` and `unsupported` (R4)++- `unsupported`: no request, and an error that names the connection and the protocol.+- `unknown` wire: try the profile's `apis` in turn, advancing only on 404, 405 or a 400 that names+ the protocol. Never advance on 401, 403, 429, 5xx or a network error. Remember what worked per+ connection until the next generation.+- `unknown` sub-fields: try in turn (table above), through a new arm of the parameter-recovery+ retry (`composed-handler.ts:1440`), which today can only drop `stop`/`top_p` or step Grok effort+ down.++### P5. Pro and speed (R13)++- **Parser.** `model-parser.ts` reads `+pro` and `#<speed>`; `:N` stays as concurrency for local+ providers. No catalog id contains `+` or `#`, but `-pro` (102 ids) and `-fast` (22) are real+ models, so a dash suffix can never be used.+- **Validation.** Each value is checked against the connection's control.+ - Unsupported: an error that lists what the connection offers.+ - `rejected`, `unknown`, `not_applicable`: never sent.+- **Sending.**+ - The native value goes at the control's `path`.+ - `headers` use append-comma, without duplicates.+ - Standard is `values.standard`, otherwise the field is omitted.+ - `access` `entitlement` or `usage-credits`: the 429 is surfaced and never retried in a loop.+- **Pro source.** `pro-injection.ts` moves its source to `wire.reasoning.mode`. That also+ removes its hardcoded `{reasoning:{mode:"pro"}}` pointer.++### P6. Delete the name rules (R5, R7, R10, R11, R12)++- **What goes.** Everything listed in R5:+ - `requiresResponsesApi`, the `openCodeZenProfile` family list, `includes("codex")` in+ `transport/openai.ts`;+ - `tokenParamName`'s fallback, `clampOpenAIEffortByName`, `isGpt51Plus` / `isOSeries`;+ - `clampCodexEffort` / `acceptsXhigh` / `acceptsMax`;+ - `SEED_REJECTS`;+ - each dialect's `shouldHandle` as a routing decision;+ - the name-picked thought-signature middleware and `isNativeAnthropic`, plus the other name rules+ in R5's list.+- **Dialects.** Any that survive are pure body transforms that the wire selects.+- **Hosts.** Hardcoded hosts for catalog-routed providers come from the registry.+- **`oc@`.** Moves to `https://ollama.com/v1` with plain ids and keeps its tools. The native+ `/api/chat` stays for local Ollama only.+- **Custom endpoints.** These use only what the user declares.+- **The advisor** resolves a connection like any request.+- **Grep test** (§4.1.5) pins the deletions.+- **Kept.** Local-only behaviour (`local-adapter.ts`, the MiniMax temperature clamp) stays.++### P7. Verify++- **Unit (§4.1).** The table is built from a real fixture: a trimmed subset of a sealed+ generation's models plus its registry, never hand-written rows.+- **Route-table gate.** `scripts/route-table-snapshot.ts capture` runs BEFORE P2 and+ `diff` runs after P6, on the same generation.+- **Live (§4.2).** One tool call per routable connection of the recommended models, using+ claudish's own credentials. The redacted exchanges go in the release PR.+- **Blocked.** OpenCode Zen and Go wait until the account is funded; both sides get 402 today.++## Recommended-model gaps at writing++13 of 17 recommended models have a gap on at least one connection. That is 36 of 85 connections:++| Cause | Connections | Fix |+|---|---|---|+| OpenCode, blocked on funding | 16 | Fund the OpenCode account. |+| Gateway probes | 13 | The backend's probes. |+| Vendors' own documented APIs (Gemini 2, Mistral, `grok-build-0.1`, MiniMax coding-plan effort) | 5 | Report to the backend. |+| Claude through native passthrough | 2 | Not used by claudish. |++Script: `ai-docs/sessions/gpt-grok-routing-20260926-231500-a1f3/recommended-gaps.ts`.diff --git a/packages/cli/src/model-loader.ts b/packages/cli/src/model-loader.tsindex 1e596541..65d124a7 100644--- a/packages/cli/src/model-loader.ts+++ b/packages/cli/src/model-loader.ts@@ -11,6 +11,7 @@ import {type CatalogV3Envelope,parseCatalogV3Envelope,} from "./providers/catalog-v3.js";+import type { ConnectionWire } from "./providers/connection-wire.js";import { compareByReleaseDateDesc } from "./providers/model-ordering.js";import type { OpenRouterModel } from "./types.js";@@ -164,6 +165,12 @@ export interface AggregatorEntry {contextWindow?: number;/** Reasoning behavior verified for this exact serving provider/model route. */reasoning?: RouteReasoningCapabilities;+ /**+ * How to call this exact connection (catalog 3.7.0): API, output-limit field,+ * reasoning encoding, mode and speed. Present on every mapped connection of a+ * 3.7.0 generation; the only source of request decisions.+ */+ wire?: ConnectionWire;}/**diff --git a/packages/cli/src/providers/all-models-cache.test.ts b/packages/cli/src/providers/all-models-cache.test.tsindex 754650a6..821dcf1c 100644--- a/packages/cli/src/providers/all-models-cache.test.ts+++ b/packages/cli/src/providers/all-models-cache.test.ts@@ -1,10 +1,11 @@-import { afterEach, describe, expect, test } from "bun:test";-import { existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";+import { afterEach, beforeEach, describe, expect, test } from "bun:test";+import { existsSync, mkdtempSync, readFileSync, rmSync, utimesSync, writeFileSync } from "node:fs";import { tmpdir } from "node:os";import { join } from "node:path";import {type DiskCacheV3,type SlimModelEntry,+ _clearAllModelsCacheMemo,readAllModelsCache,reasoningStatusOf,writeAllModelsCache,@@ -95,3 +96,119 @@ describe("reasoningStatusOf", () => {).toBe("unknown");});});++const wireFixture: DiskCacheV3 = JSON.parse(+ readFileSync(+ new URL("../test-fixtures/catalog-v3/wire-g-20261012101007285-7770c36e.json", import.meta.url),+ "utf8"+ )+);+beforeEach(() => _clearAllModelsCacheMemo());++function knownConnection(cache: DiskCacheV3) {+ return cache.entries+ .flatMap((entry) => entry.aggregators ?? [])+ .find(+ (connection) => connection.routeStatus === "mapped" && connection.wire?.status === "known"+ )!;+}++describe("wire registry cache validation", () => {+ test("loads the whole production fixture", () => {+ const path = cachePath();+ writeAllModelsCache(wireFixture, path);+ expect(readAllModelsCache(path)).toEqual(wireFixture);+ });+ const invalidCases: Array<[string, (cache: DiskCacheV3) => void]> = [+ [+ "mapped connection without wire",+ (cache) => {+ delete knownConnection(cache).wire;+ },+ ],+ [+ "malformed connection wire",+ (cache) => {+ Object.assign(knownConnection(cache).wire!, { api: "realtime" });+ },+ ],+ [+ "known API absent from its profile",+ (cache) => {+ const connection = knownConnection(cache);+ if (connection.wire?.status !== "known") throw new Error("Expected known fixture wire");+ delete cache.routeRegistry!.registry.routes[connection.route!.routeId]!.profiles[+ connection.route!.routeProfileId+ ]!.apis[connection.wire.api];+ },+ ],+ [+ "missing route profile",+ (cache) => {+ const route = knownConnection(cache).route!;+ delete cache.routeRegistry!.registry.routes[route.routeId]!.profiles[route.routeProfileId];+ },+ ],+ [+ "different registry generation",+ (cache) => {+ cache.routeRegistry!.generationId = "other-generation";+ },+ ],+ [+ "malformed registry",+ (cache) => {+ Reflect.deleteProperty(cache.routeRegistry!.registry, "routes");+ },+ ],+ ];+ for (const [name, mutate] of invalidCases) {+ test(`rejects ${name}`, () => {+ const path = cachePath();+ const cache = structuredClone(wireFixture);+ writeAllModelsCache(cache, path);+ expect(readAllModelsCache(path)).toEqual(cache);+ mutate(cache);+ writeFileSync(path, JSON.stringify(cache));+ expect(readAllModelsCache(path)).toBeNull();+ });+ }+ test("accepts a cache written before route registries", () => {+ const cache = structuredClone(wireFixture);+ delete cache.routeRegistry;+ const path = cachePath();+ writeAllModelsCache(cache, path);+ expect(readAllModelsCache(path)).toEqual(cache);+ });+ test("accepts a missing wire under registry 3.6.0", () => {+ const cache = structuredClone(wireFixture);+ cache.routeRegistry!.registry.registryVersion = "3.6.0";+ delete knownConnection(cache).wire;+ const path = cachePath();+ writeAllModelsCache(cache, path);+ expect(readAllModelsCache(path)).toEqual(cache);+ });+ test("memo observes writer updates, direct size-changing writes and deletion", () => {+ const path = cachePath();+ const cache = structuredClone(wireFixture);+ writeAllModelsCache(cache, path);+ const timestamp = new Date("2026-10-12T00:00:00Z");+ utimesSync(path, timestamp, timestamp);+ const firstRead = readAllModelsCache(path);+ expect(firstRead).toEqual(cache);+ expect(readAllModelsCache(path)).toBe(firstRead);+ // Same size and mtime: only writeAllModelsCache's invalidation sees this.+ cache.lastUpdated = "2026-10-13T00:00:00.000Z";+ expect(cache.lastUpdated.length).toBe(wireFixture.lastUpdated.length);+ writeAllModelsCache(cache, path);+ utimesSync(path, timestamp, timestamp);+ expect(readAllModelsCache(path)).toEqual(cache);+ // Same mtime, different size: out-of-band writes must also invalidate.+ cache.entries[0]!.displayName = "A different and longer value written directly to disk";+ writeFileSync(path, JSON.stringify(cache));+ utimesSync(path, timestamp, timestamp);+ expect(readAllModelsCache(path)).toEqual(cache);+ rmSync(path);+ expect(readAllModelsCache(path)).toBeNull();+ });+});diff --git a/packages/cli/src/providers/all-models-cache.ts b/packages/cli/src/providers/all-models-cache.tsindex fdb80825..6dfadbb9 100644--- a/packages/cli/src/providers/all-models-cache.ts+++ b/packages/cli/src/providers/all-models-cache.ts@@ -1,7 +1,15 @@-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";import { homedir } from "node:os";import { dirname, join } from "node:path";import type { AggregatorEntry } from "../model-loader.js";+import {+ type CachedRouteRegistry,+ WIRE_REGISTRY_VERSION,+ isConnectionWire,+ isRouteRegistry,+ registryVersionAtLeast,+ routeProfile,+} from "./connection-wire.js";export type ReasoningControl = "toggle" | "effort" | "adaptive" | "budget" | "none";@@ -91,6 +99,12 @@ export interface DiskCacheV3 {models: Array<{ id: string }>;plans: CachedSubscriptionPlan[];catalogGenerationId: string;+ /**+ * The route registry of the SAME generation (`catalog=routes&generationId=`).+ * Absent in a cache written before claudish read wires; the request path then+ * refreshes the catalog instead of building a request without one.+ */+ routeRegistry?: CachedRouteRegistry;}/**@@ -153,16 +167,33 @@ export function isCachedSubscriptionPlan(value: unknown): value is CachedSubscri);}-export function readAllModelsCache(path: string = ALL_MODELS_CACHE_PATH): DiskCacheV3 | null {- if (!existsSync(path)) return null;-- let raw: unknown;- try {- raw = JSON.parse(readFileSync(path, "utf-8"));- } catch {- return null;- }+/**+ * A cached registry must belong to the model list's generation, and from 3.7.0+ * every mapped connection must carry a `wire` whose route profile exists and,+ * when known, publishes a base URL for its `api`. One bad connection rejects the+ * whole cache: a partial wire table would send some requests from data and the+ * rest from nothing.+ */+export function wiresMatchRegistry(+ entries: SlimModelEntry[],+ routeRegistry: CachedRouteRegistry,+ catalogGenerationId: string+): boolean {+ if (routeRegistry.generationId !== catalogGenerationId) return false;+ const { registry } = routeRegistry;+ if (!registryVersionAtLeast(registry.registryVersion, WIRE_REGISTRY_VERSION)) return true;+ return entries.every((entry) =>+ (entry.aggregators ?? []).every((connection) => {+ if (connection.routeStatus !== "mapped") return true;+ if (!connection.route || !isConnectionWire(connection.wire)) return false;+ const profile = routeProfile(registry, connection.route);+ if (!profile) return false;+ return connection.wire.status !== "known" || !!profile.apis[connection.wire.api]?.baseUrl;+ })+ );+}+function parseAllModelsCache(raw: unknown): DiskCacheV3 | null {if (!raw || typeof raw !== "object") return null;const data = raw as Record<string, unknown>;if (@@ -178,11 +209,57 @@ export function readAllModelsCache(path: string = ALL_MODELS_CACHE_PATH): DiskCa) {return null;}-+ if (data.routeRegistry !== undefined) {+ const cached = data.routeRegistry as Record<string, unknown> | null;+ if (+ !cached ||+ typeof cached.generationId !== "string" ||+ !isRouteRegistry(cached.registry) ||+ !wiresMatchRegistry(+ data.entries as SlimModelEntry[],+ cached as unknown as CachedRouteRegistry,+ data.catalogGenerationId+ )+ ) {+ return null;+ }+ }return data as unknown as DiskCacheV3;}+// The request path reads the cache on every request, and the file is several+// MB. Parsed results are memoized per path, keyed by mtime and size, so a write+// by `refreshCatalog` or an out-of-band edit is seen on the next read.+const _readMemo = new Map<string, { mtimeMs: number; size: number; cache: DiskCacheV3 | null }>();++export function _clearAllModelsCacheMemo(): void {+ _readMemo.clear();+}++export function readAllModelsCache(path: string = ALL_MODELS_CACHE_PATH): DiskCacheV3 | null {+ if (!existsSync(path)) return null;++ let stat: { mtimeMs: number; size: number };+ try {+ stat = statSync(path);+ } catch {+ return null;+ }+ const memo = _readMemo.get(path);+ if (memo && memo.mtimeMs === stat.mtimeMs && memo.size === stat.size) return memo.cache;++ let cache: DiskCacheV3 | null;+ try {+ cache = parseAllModelsCache(JSON.parse(readFileSync(path, "utf-8")));+ } catch {+ cache = null;+ }+ _readMemo.set(path, { mtimeMs: stat.mtimeMs, size: stat.size, cache });+ return cache;+}+export function writeAllModelsCache(data: DiskCacheV3, path: string = ALL_MODELS_CACHE_PATH): void {mkdirSync(dirname(path), { recursive: true });writeFileSync(path, JSON.stringify(data), "utf-8");+ _readMemo.delete(path);}diff --git a/packages/cli/src/providers/catalog-client.test.ts b/packages/cli/src/providers/catalog-client.test.tsindex 653b5a8d..224bd2b7 100644--- a/packages/cli/src/providers/catalog-client.test.ts+++ b/packages/cli/src/providers/catalog-client.test.ts@@ -2,9 +2,16 @@ import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";import { mkdtempSync, readFileSync, rmSync } from "node:fs";import { tmpdir } from "node:os";import { join } from "node:path";-import { type SlimModelEntry, readAllModelsCache } from "./all-models-cache.js";+import {+ type DiskCacheV3,+ type SlimModelEntry,+ _clearAllModelsCacheMemo,+ readAllModelsCache,+ writeAllModelsCache,+} from "./all-models-cache.js";import {_resetCatalogClient,+ buildRoutesUrl,catalogWarmDisabledFor,getCatalogEntries,refreshCatalog,@@ -31,6 +38,7 @@ function restore(name: string, value: string | undefined): void {}beforeEach(() => {_resetCatalogClient();+ _clearAllModelsCacheMemo();delete process.env.CLAUDISH_DISABLE_CATALOG_WARM;process.env.CLAUDISH_CATALOG_URL = "https://catalog.test/queryModels?catalog=slim";process.env.CLAUDISH_PLANS_URL = "https://catalog.test/queryPlans";@@ -52,6 +60,24 @@ function envelope(data: unknown, generationId = "generation-a"): Response {data,});}+const wireFixture: DiskCacheV3 = JSON.parse(+ readFileSync(+ new URL("../test-fixtures/catalog-v3/wire-g-20261012101007285-7770c36e.json", import.meta.url),+ "utf8"+ )+);++function legacyRoutes(): Response {+ // These existing pagination tests predate wires. Keep their rows and assertions+ // meaningful with a 3.6.0 registry; the wire tests below use production 3.7.0.+ return envelope({+ mode: "routes",+ registry: {+ ...structuredClone(wireFixture.routeRegistry!.registry),+ registryVersion: "3.6.0",+ },+ });+}function entry(modelId: string, provider: string, externalModelId: string): SlimModelEntry {const routes: Record<string, { routeId: string; routeProfileId: string }> = {"qwen-coding": { routeId: "qwen", routeProfileId: "modelstudio-coding-plan" },@@ -111,6 +137,7 @@ describe("v3 catalog refresh", () => {generation: request.searchParams.get("generationId"),accept: new Headers(init?.headers).get("accept"),});+ if (request.searchParams.get("catalog") === "routes") return legacyRoutes();if (request.pathname === "/queryModels")return envelope({mode: "slim",@@ -141,6 +168,12 @@ describe("v3 catalog refresh", () => {generation: "generation-a",accept: CATALOG_V3_ACCEPT,},+ {+ pathname: "/queryModels",+ cursor: null,+ generation: "generation-a",+ accept: CATALOG_V3_ACCEPT,+ },]);expect(readAllModelsCache(cachePath)?.entries).toEqual([first, second]);expect(readAllModelsCache(cachePath)?.plans).toEqual([plan]);@@ -151,7 +184,9 @@ describe("v3 catalog refresh", () => {const cachePath = tempCachePath();let planGeneration = "generation-a";globalThis.fetch = mock(async (url: string | URL | Request) => {- const path = new URL(String(url)).pathname;+ const request = new URL(String(url));+ if (request.searchParams.get("catalog") === "routes") return legacyRoutes();+ const path = request.pathname;return path === "/queryPlans"? envelope({@@ -186,7 +221,9 @@ describe("v3 catalog refresh", () => {const cachePath = tempCachePath();let total = 1;globalThis.fetch = mock(async (url: string | URL | Request) => {- const path = new URL(String(url)).pathname;+ const request = new URL(String(url));+ if (request.searchParams.get("catalog") === "routes") return legacyRoutes();+ const path = request.pathname;return path === "/queryPlans"? envelope({plans: [@@ -312,3 +349,185 @@ describe("resolveTargetForCatalog", () => {});}});++describe("route registry refresh", () => {+ function serveFixture(+ options: {+ cache?: DiskCacheV3;+ routesGeneration?: (attempt: number) => string;+ registry?: unknown;+ } = {}+ ) {+ const cache = options.cache ?? wireFixture;+ const requests: Array<{ url: URL; accept: string | null }> = [];+ let attempts = 0;+ globalThis.fetch = mock(async (input: string | URL | Request, init?: RequestInit) => {+ const url = new URL(String(input));+ requests.push({ url, accept: new Headers(init?.headers).get("accept") });+ if (url.searchParams.get("catalog") === "routes") {+ return envelope(+ {+ mode: "routes",+ registry:+ options.registry === undefined ? cache.routeRegistry!.registry : options.registry,+ },+ options.routesGeneration?.(attempts) ?? cache.catalogGenerationId+ );+ }+ if (url.pathname === "/queryPlans") {+ return envelope(+ { plans: cache.plans, total: cache.plans.length },+ cache.catalogGenerationId+ );+ }+ // Two model pages make a full retry observable, including cursor reset.+ if (!url.searchParams.has("cursor")) attempts++;+ const second = url.searchParams.has("cursor");+ return envelope(+ {+ mode: "slim",+ models: second ? cache.entries.slice(8) : cache.entries.slice(0, 8),+ total: cache.entries.length,+ ...(second ? {} : { nextCursor: "fixture-page-two" }),+ },+ cache.catalogGenerationId+ );+ }) as unknown as typeof fetch;+ return requests;+ }++ function expectAttempt(requests: Array<{ url: URL; accept: string | null }>) {+ expect(+ requests.map(({ url, accept }) => ({+ path: url.pathname,+ mode: url.searchParams.get("catalog"),+ cursor: url.searchParams.get("cursor"),+ generation: url.searchParams.get("generationId"),+ accept,+ }))+ ).toEqual([+ {+ path: "/queryModels",+ mode: "slim",+ cursor: null,+ generation: null,+ accept: CATALOG_V3_ACCEPT,+ },+ {+ path: "/queryModels",+ mode: "slim",+ cursor: "fixture-page-two",+ generation: wireFixture.catalogGenerationId,+ accept: CATALOG_V3_ACCEPT,+ },+ {+ path: "/queryPlans",+ mode: null,+ cursor: null,+ generation: wireFixture.catalogGenerationId,+ accept: CATALOG_V3_ACCEPT,+ },+ {+ path: "/queryModels",+ mode: "routes",+ cursor: null,+ generation: wireFixture.catalogGenerationId,+ accept: CATALOG_V3_ACCEPT,+ },+ ]);+ }++ test("pins the routes URL to the model generation and writes its registry", async () => {+ const cachePath = tempCachePath();+ const requests = serveFixture();+ expect(await refreshCatalog(1000, { cachePath })).toEqual({+ kind: "refreshed",+ modelCount: 16,+ catalogGenerationId: wireFixture.catalogGenerationId,+ pages: 2,+ });+ expectAttempt(requests);+ const cache = readAllModelsCache(cachePath)!;+ expect(cache.entries).toEqual(wireFixture.entries);+ expect(cache.routeRegistry).toEqual(wireFixture.routeRegistry);+ expect(cache.routeRegistry!.generationId).toBe(cache.catalogGenerationId);+ });++ test.each([+ ["persistent mismatch", false],+ ["matching retry", true],+ ] as const)("retries the full refresh exactly once: %s", async (_name, recovers) => {+ const cachePath = tempCachePath();+ writeAllModelsCache(wireFixture, cachePath);+ const bytes = readFileSync(cachePath, "utf8");+ const requests = serveFixture({+ routesGeneration: (attempt) =>+ recovers && attempt === 2 ? wireFixture.catalogGenerationId : "different-generation",+ });+ expect(await refreshCatalog(1000, { cachePath })).toEqual(+ recovers+ ? {+ kind: "refreshed",+ modelCount: 16,+ catalogGenerationId: wireFixture.catalogGenerationId,+ pages: 2,+ }+ : { kind: "fetch_failed", reason: "generation_mismatch" }+ );+ expect(requests).toHaveLength(8);+ expectAttempt(requests.slice(0, 4));+ expectAttempt(requests.slice(4));+ if (recovers) {+ expect(readAllModelsCache(cachePath)!.routeRegistry).toEqual(wireFixture.routeRegistry);+ } else {+ expect(readFileSync(cachePath, "utf8")).toBe(bytes);+ }+ });++ test("malformed registry fails empty without replacing the existing file", async () => {+ const cachePath = tempCachePath();+ writeAllModelsCache(wireFixture, cachePath);+ const bytes = readFileSync(cachePath, "utf8");+ const registry = structuredClone(wireFixture.routeRegistry!.registry);+ Reflect.deleteProperty(registry, "routes");+ const requests = serveFixture({ registry });+ expect(await refreshCatalog(1000, { cachePath })).toEqual({+ kind: "fetch_failed",+ reason: "empty",+ });+ expect(requests).toHaveLength(4);+ expect(readFileSync(cachePath, "utf8")).toBe(bytes);+ });++ test("wires missing from a 3.7.0 connection fail incomplete without replacing the file", async () => {+ const cachePath = tempCachePath();+ writeAllModelsCache(wireFixture, cachePath);+ const bytes = readFileSync(cachePath, "utf8");+ const cache = structuredClone(wireFixture);+ const connection = cache.entries+ .flatMap((entry) => entry.aggregators ?? [])+ .find((connection) => connection.routeStatus === "mapped")!;+ delete connection.wire;+ const requests = serveFixture({ cache });+ expect(await refreshCatalog(1000, { cachePath })).toEqual({+ kind: "fetch_failed",+ reason: "incomplete",+ });+ expect(requests).toHaveLength(4);+ expect(readFileSync(cachePath, "utf8")).toBe(bytes);+ });++ test("buildRoutesUrl discards slim filters, pagination and stale generation", () => {+ const url = new URL(+ buildRoutesUrl(+ "https://catalog.test/queryModels?catalog=slim&cursor=old&limit=5&provider=openai&generationId=stale",+ "generation/with spaces+opaque"+ )+ );+ expect(url.origin + url.pathname).toBe("https://catalog.test/queryModels");+ expect(Object.fromEntries(url.searchParams)).toEqual({+ catalog: "routes",+ generationId: "generation/with spaces+opaque",+ });+ });+});diff --git a/packages/cli/src/providers/catalog-client.ts b/packages/cli/src/providers/catalog-client.tsindex 0d90e31f..d2ebdf4f 100644--- a/packages/cli/src/providers/catalog-client.ts+++ b/packages/cli/src/providers/catalog-client.ts@@ -5,10 +5,16 @@ import {isCachedSubscriptionPlan,isSlimModelEntry,readAllModelsCache,+ wiresMatchRegistry,writeAllModelsCache,} from "./all-models-cache.js";import { catalogRouteMatchesProvider } from "./catalog-route-bindings.js";import { CATALOG_V3_ACCEPT, type CatalogV3Envelope, parseCatalogV3Envelope } from "./catalog-v3.js";+import {+ type CachedRouteRegistry,+ type RouteRegistry,+ isRouteRegistry,+} from "./connection-wire.js";import { _clearChatCapabilityIndex } from "./transport/probe-discovery.js";const DEFAULT_CATALOG_URL =@@ -35,6 +41,15 @@ function plansUrl(): string {return process.env.CLAUDISH_PLANS_URL ?? derivePlansUrl(catalogUrl());}+/** `queryModels?catalog=routes&generationId=<id>` on the same host as the model list. */+export function buildRoutesUrl(modelsUrl: string, generationId: string): string {+ const url = new URL(modelsUrl);+ url.search = "";+ url.searchParams.set("catalog", "routes");+ url.searchParams.set("generationId", generationId);+ return url.toString();+}+export type DiskCache = DiskCacheV3;export type RefreshOutcome =@@ -335,7 +350,19 @@ export async function refreshCatalog(options: RefreshCatalogOptions = {}): Promise<RefreshOutcome> {if (catalogWarmDisabled()) return { kind: "fetch_failed", reason: "disabled" };+ // A generation can activate between the model pages and the registry read.+ // Never mix two: start over once, then report the mismatch.+ const first = await refreshCatalogOnce(timeoutMs, options);+ if (first.kind === "fetch_failed" && first.reason === "generation_mismatch") {+ return refreshCatalogOnce(timeoutMs, options);+ }+ return first;+}+async function refreshCatalogOnce(+ timeoutMs: number,+ options: RefreshCatalogOptions+): Promise<RefreshOutcome> {const entries: SlimModelEntry[] = [];let generationId: string | undefined;let generatedAt: string | undefined;@@ -407,6 +434,18 @@ export async function refreshCatalog(return { kind: "fetch_failed", reason: planResult.reason };}+ const registryResult = await fetchRouteRegistry(timeoutMs, generationId);+ if (!registryResult.ok) {+ if (registryResult.reason === "incompatible") {+ return { kind: "incompatible", serverContractVersion: registryResult.serverContractVersion };+ }+ return { kind: "fetch_failed", reason: registryResult.reason };+ }+ const routeRegistry: CachedRouteRegistry = { generationId, registry: registryResult.registry };+ if (!wiresMatchRegistry(entries, routeRegistry, generationId)) {+ return { kind: "fetch_failed", reason: "incomplete" };+ }+const models = entries.flatMap((entry) => {const id = externalIdFor(entry, "openrouter");return id ? [{ id }] : [];@@ -418,6 +457,7 @@ export async function refreshCatalog(models,plans: planResult.plans,catalogGenerationId: generationId,+ routeRegistry,};writeAllModelsCache(cache, options.cachePath);@@ -495,6 +535,29 @@ async function fetchSubscriptionPlans(return { ok: true, plans };}+async function fetchRouteRegistry(+ timeoutMs: number,+ generationId: string+): Promise<+ | { ok: true; registry: RouteRegistry }+ | FetchFailure+ | { ok: false; reason: "empty" | "generation_mismatch" }+> {+ const result = await fetchEnvelope<{ mode?: string; registry?: unknown }>(+ buildRoutesUrl(catalogUrl(), generationId),+ timeoutMs+ );+ if (!result.ok) return result;+ if (result.envelope.generationId !== generationId) {+ return { ok: false, reason: "generation_mismatch" };+ }+ const { registry } = result.envelope.data;+ if (result.envelope.data.mode !== "routes" || !isRouteRegistry(registry)) {+ return { ok: false, reason: "empty" };+ }+ return { ok: true, registry };+}+function startCatalogWarm(): Promise<void> {if (_warmPromise) return _warmPromise;const promise = refreshCatalog(8000).then((result) => {@@ -510,6 +573,20 @@ export async function warmCatalog(): Promise<void> {export async function ensureCatalogReady(timeoutMs = 5000): Promise<void> {if (isCatalogWarm() || (readAllModelsCache()?.entries.length ?? 0) > 0) return;+ await waitForCatalogWarm(timeoutMs);+}++/**+ * Like {@link ensureCatalogReady}, for the request path: a cache written before+ * claudish read wires has models but no route registry, and no request may be+ * built from it. Such a cache is refreshed rather than accepted.+ */+export async function ensureRouteRegistryReady(timeoutMs = 5000): Promise<void> {+ if (readAllModelsCache()?.routeRegistry) return;+ await waitForCatalogWarm(timeoutMs);+}++async function waitForCatalogWarm(timeoutMs: number): Promise<void> {await Promise.race([startCatalogWarm(),new Promise<void>((resolve) => setTimeout(resolve, timeoutMs)),diff --git a/packages/cli/src/providers/connection-resolver.test.ts b/packages/cli/src/providers/connection-resolver.test.tsnew file mode 100644index 00000000..23ee2bc0--- /dev/null+++ b/packages/cli/src/providers/connection-resolver.test.ts@@ -0,0 +1,330 @@+import { afterEach, beforeEach, describe, expect, test } from "bun:test";+import { mkdtempSync, readFileSync, rmSync } from "node:fs";+import { tmpdir } from "node:os";+import { join } from "node:path";+import {+ type DiskCacheV3,+ _clearAllModelsCacheMemo,+ writeAllModelsCache,+} from "./all-models-cache.js";+import {+ connectionBaseUrl,+ connectionRequestUrl,+ resolveConnection,+} from "./connection-resolver.js";+import type { KnownWire, WireApi } from "./connection-wire.js";++const fixture: DiskCacheV3 = JSON.parse(+ readFileSync(+ new URL("../test-fixtures/catalog-v3/wire-g-20261012101007285-7770c36e.json", import.meta.url),+ "utf8"+ )+);+let dir: string;+let cachePath: string;+beforeEach(() => {+ _clearAllModelsCacheMemo();+ dir = mkdtempSync(join(tmpdir(), "claudish-wire-resolver-"));+ cachePath = join(dir, "catalog.json");+ writeAllModelsCache(structuredClone(fixture), cachePath);+});+afterEach(() => {+ rmSync(dir, { recursive: true, force: true });+ _clearAllModelsCacheMemo();+});++type Case = [string, string, string, string, string, WireApi, KnownWire["tokenParam"], string];+const cases: Case[] = [+ [+ "openai",+ "gpt-6.1-sol",+ "gpt-6.1-sol",+ "openai/direct-api",+ "gpt-6.1-sol",+ "responses",+ "max_output_tokens",+ "https://api.openai.com/v1/responses",+ ],+ [+ "openai-codex",+ "gpt-6-sol",+ "gpt-6-sol",+ "openai/codex-subscription",+ "gpt-6-sol",+ "responses",+ "max_output_tokens",+ "https://chatgpt.com/backend-api/codex/responses",+ ],+ [+ "openrouter",+ "openai/gpt-6.1-sol",+ "gpt-6.1-sol",+ "openrouter/gateway",+ "openai/gpt-6.1-sol",+ "chat-completions",+ "max_tokens",+ "https://openrouter.ai/api/v1/chat/completions",+ ],+ [+ "openrouter",+ "gpt-6.1-sol",+ "gpt-6.1-sol",+ "openrouter/gateway",+ "openai/gpt-6.1-sol",+ "chat-completions",+ "max_tokens",+ "https://openrouter.ai/api/v1/chat/completions",+ ],+ [+ "opencode-zen-go",+ "grok-4.7",+ "grok-4.7",+ "opencode/go-subscription",+ "grok-4.7",+ "responses",+ "max_output_tokens",+ "https://opencode.ai/zen/go/v1/responses",+ ],+ [+ "opencode-zen-go",+ "minimax-m3",+ "minimax-m3",+ "opencode/go-subscription",+ "minimax-m3",+ "anthropic-messages",+ "max_tokens",+ "https://opencode.ai/zen/go/v1/messages",+ ],+ [+ "opencode-zen",+ "minimax-m3",+ "minimax-m3",+ "opencode/zen",+ "minimax-m3",+ "chat-completions",+ { status: "unknown" },+ "https://opencode.ai/zen/v1/chat/completions",+ ],+ [+ "x-ai",+ "grok-4.7",+ "grok-4.7",+ "x-ai/direct-api",+ "grok-4.7",+ "responses",+ "max_output_tokens",+ "https://api.x.ai/v1/responses",+ ],+ [+ "z-ai",+ "glm-5.3",+ "glm-5.3",+ "z-ai/direct-api",+ "glm-5.3",+ "chat-completions",+ "max_tokens",+ "https://api.z.ai/api/paas/v4/chat/completions",+ ],+ [+ "kimi-coding",+ "k3",+ "kimi-k3",+ "moonshotai/kimi-code-subscription",+ "k3",+ "chat-completions",+ "max_completion_tokens",+ "https://api.kimi.ai/coding/v1/chat/completions",+ ],+ [+ "kimi-coding",+ "kimi-k3",+ "kimi-k3",+ "moonshotai/kimi-code-subscription",+ "k3",+ "chat-completions",+ "max_completion_tokens",+ "https://api.kimi.ai/coding/v1/chat/completions",+ ],+ [+ "ollamacloud",+ "kimi-k3",+ "kimi-k3",+ "ollama/cloud",+ "kimi-k3",+ "chat-completions",+ "max_tokens",+ "https://ollama.com/v1/chat/completions",+ ],+ [+ "qwen-token-plan",+ "qwen3.7-plus",+ "qwen3.7-plus",+ "qwen/qwencloud-token-plan",+ "qwen3.7-plus",+ "chat-completions",+ "max_completion_tokens",+ "https://token-plan.maas.qwencloudapi.com/compatible-mode/v1/chat/completions",+ ],+ [+ "fireworks",+ "qwen3.8-max",+ "qwen3.8-max",+ "fireworks/gateway",+ "accounts/fireworks/models/qwen3p8-max",+ "chat-completions",+ "max_tokens",+ "https://api.fireworks.ai/inference/v1/chat/completions",+ ],+ [+ "google",+ "gemini-3.8-flash",+ "gemini-3.8-flash",+ "google/direct-api",+ "gemini-3.8-flash",+ "gemini",+ { status: "not_applicable" },+ "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.8-flash:streamGenerateContent?alt=sse",+ ],+ [+ "anthropic",+ "claude-opus-5-5",+ "claude-opus-5-5",+ "anthropic/direct-api",+ "claude-opus-5-5",+ "anthropic-messages",+ "max_tokens",+ "https://api.anthropic.com/v1/messages",+ ],+];++describe("production connection resolution", () => {+ for (const [provider, name, modelId, binding, externalModelId, api, tokenParam, url] of cases) {+ test(`${provider}@${name} retains its published wire and exact route binding`, () => {+ const [routeId, routeProfileId] = binding.split("/");+ const record = fixture.entries.find((entry) => entry.modelId === modelId)!;+ const published = record.aggregators!.find(+ (connection) =>+ connection.routeStatus === "mapped" &&+ connection.route?.routeId === routeId &&+ connection.route.routeProfileId === routeProfileId &&+ connection.externalModelId === externalModelId+ )!;+ expect(published.wire).toMatchObject({ status: "known", api, tokenParam });+ const result = resolveConnection(provider, name, cachePath);+ // Independently derive the owner's first direct connection from registry+ // ownership, excluding the selected connection itself.+ const owner = record.aggregators!.find((candidate) => {+ if (candidate === published || candidate.routeStatus !== "mapped" || !candidate.route)+ return false;+ const profile =+ fixture.routeRegistry!.registry.routes[candidate.route.routeId]?.profiles[+ candidate.route.routeProfileId+ ];+ return (+ profile?.kind === "direct" &&+ profile.nativeModelProviders?.includes(record.provider ?? "")+ );+ });+ expect(result).toEqual({+ ok: true,+ connection: {+ provider,+ modelId,+ route: { routeId, routeProfileId },+ externalModelId,+ wire: published.wire!,+ profile: fixture.routeRegistry!.registry.routes[routeId!]!.profiles[routeProfileId!],+ generationId: fixture.catalogGenerationId,+ ...(owner?.wire?.status === "known" ? { ownerWire: owner.wire } : {}),+ },+ });+ if (result.ok === false) throw new Error("Expected resolved fixture connection");+ expect(connectionRequestUrl(result.connection, api)).toBe(url);+ const base =+ api === "gemini"+ ? url.split("/models/")[0]+ : url.replace(/\/(responses|messages|chat\/completions)$/, "");+ expect(connectionBaseUrl(result.connection, api)).toBe(base);+ });+ }+ test.each([+ ["grok-subscription", "grok-4.7", "no-connection"],+ ["ollama", "llama3.2", "not-catalog-routed"],+ ["openai", "no-such-model", "no-connection"],+ ] as const)("%s@%s reports %s", (provider, model, reason) => {+ expect(resolveConnection(provider, model, cachePath)).toEqual({ ok: false, reason });+ });+ test("missing cache reports no-catalog", () => {+ expect(resolveConnection("openai", "gpt-6.1-sol", join(dir, "missing.json"))).toEqual({+ ok: false,+ reason: "no-catalog",+ });+ });+ test("legacy cache reports no-registry", () => {+ const cache = structuredClone(fixture);+ delete cache.routeRegistry;+ writeAllModelsCache(cache, cachePath);+ expect(resolveConnection("openai", "gpt-6.1-sol", cachePath)).toEqual({+ ok: false,+ reason: "no-registry",+ });+ });+ test.each(["GPT-6.1-SOL", "vendor/GPT-6.1-SOL", "OPENAI/GPT-6.1-SOL:BATCH"])(+ "resolves canonical ids and aliases case-insensitively: %s",+ (name) => {+ expect(resolveConnection("openai", name, cachePath)).toEqual(+ resolveConnection("openai", "gpt-6.1-sol", cachePath)+ );+ }+ );+ test("an exact wire id wins over an earlier canonical id match", () => {+ const cache = structuredClone(fixture);+ const first = cache.entries.find((entry) => entry.modelId === "gpt-6.1-sol")!;+ // This earlier record's canonical id collides with a later record's wire id.+ first.modelId = "gpt-6-sol";+ cache.entries.find((entry) => entry !== first && entry.modelId === "gpt-6-sol")!.modelId =+ "wire-match-record";+ writeAllModelsCache(cache, cachePath);+ const result = resolveConnection("openai", "gpt-6-sol", cachePath);+ expect(result).toMatchObject({+ ok: true,+ connection: {+ modelId: "wire-match-record",+ externalModelId: "gpt-6-sol",+ },+ });+ });+ test.each(["~vendor/x-latest", "x-latest"])(+ "skips leading moving pointer %s for canonical lookup",+ (pointer) => {+ const cache = structuredClone(fixture);+ const record = cache.entries.find((entry) => entry.modelId === "kimi-k3")!;+ const exact = record.aggregators!.find(+ (connection) => connection.route?.routeProfileId === "kimi-code-subscription"+ )!;+ record.aggregators!.unshift({ ...structuredClone(exact), externalModelId: pointer });+ writeAllModelsCache(cache, cachePath);+ expect(resolveConnection("kimi-coding", "kimi-k3", cachePath)).toMatchObject({+ ok: true,+ connection: { modelId: "kimi-k3", externalModelId: "k3" },+ });+ const requested = resolveConnection("kimi-coding", pointer, cachePath);+ expect(requested).toMatchObject({ ok: true, connection: { externalModelId: pointer } });+ record.modelId = "canonical-latest";+ writeAllModelsCache(cache, cachePath);+ expect(resolveConnection("kimi-coding", "canonical-latest", cachePath)).toMatchObject({+ ok: true,+ connection: { externalModelId: pointer },+ });+ }+ );+ test("URL helpers preserve non-streaming Gemini and absent APIs", () => {+ const result = resolveConnection("google", "gemini-3.8-flash", cachePath);+ if (result.ok === false) throw new Error("Expected Gemini fixture connection");+ expect(connectionRequestUrl(result.connection, "gemini", false)).toBe(+ "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.8-flash:generateContent"+ );+ expect(connectionBaseUrl(result.connection, "responses")).toBeUndefined();+ expect(connectionRequestUrl(result.connection, "responses")).toBeUndefined();+ });+});diff --git a/packages/cli/src/providers/connection-resolver.ts b/packages/cli/src/providers/connection-resolver.tsnew file mode 100644index 00000000..4d7503a5--- /dev/null+++ b/packages/cli/src/providers/connection-resolver.ts@@ -0,0 +1,196 @@+/**+ * Resolve the ONE catalog connection a request goes to, with its `wire` and its+ * route profile from the registry of the same generation.+ *+ * A connection is the claudish provider's exact route binding plus the exact+ * wire id. Nothing is matched by family, sibling id or model-level field: when+ * the catalog does not publish this provider for this model, the answer says so+ * and the caller decides, rather than borrowing another connection's wire.+ */+import type { AggregatorEntry } from "../model-loader.js";+import {+ ALL_MODELS_CACHE_PATH,+ type SlimModelEntry,+ readAllModelsCache,+} from "./all-models-cache.js";+import { isMovingPointer } from "./catalog-client.js";+import { type CatalogRouteBinding, catalogRouteForProvider } from "./catalog-route-bindings.js";+import {+ type ConnectionWire,+ type KnownWire,+ type RouteProfile,+ type RouteRegistry,+ type WireApi,+ routeProfile,+ wireRequestUrl,+} from "./connection-wire.js";++export interface ResolvedConnection {+ /** The claudish provider the request is for. */+ provider: string;+ /** The catalog record's canonical model id. */+ modelId: string;+ route: CatalogRouteBinding;+ /** The exact id sent to the provider. */+ externalModelId: string;+ wire: ConnectionWire;+ profile: RouteProfile;+ generationId: string;+ /**+ * The known wire of the model OWNER's own direct connection (the `direct`+ * profile whose `nativeModelProviders` names the model's vendor), when the+ * catalog publishes one and it is not this connection. Used only to TRY a+ * sub-field this connection publishes as `unknown`, on the same API.+ */+ ownerWire?: KnownWire;+}++export type ConnectionResolution =+ | { ok: true; connection: ResolvedConnection }+ | {+ ok: false;+ /**+ * - `not-catalog-routed`: the provider has no route binding (local, custom+ * endpoint, LiteLLM); its requests are not built from catalog wires.+ * - `no-catalog`: no readable cache.+ * - `no-registry`: a cache written before wires were read; refresh it.+ * - `no-connection`: the catalog does not map this model to this provider.+ */+ reason: "not-catalog-routed" | "no-catalog" | "no-registry" | "no-connection";+ };++function lower(value: string): string {+ return value.toLowerCase();+}++function stripVendorPrefix(id: string): string {+ return id.includes("/") ? id.substring(id.lastIndexOf("/") + 1) : id;+}++function mappedOnRoute(entry: SlimModelEntry, route: CatalogRouteBinding): AggregatorEntry[] {+ return (entry.aggregators ?? []).filter(+ (connection) =>+ connection.routeStatus === "mapped" &&+ connection.route?.routeId === route.routeId &&+ connection.route?.routeProfileId === route.routeProfileId &&+ typeof connection.externalModelId === "string"+ );+}++/**+ * The connection for `modelName` on `route`.+ *+ * 1. A connection whose wire id IS the name: an explicit spec is rewritten to+ * the provider's wire id before it gets here (`kc@k3`, `or@openai/gpt-6.1-sol`).+ * 2. The record whose canonical id or alias is the name (vendor prefix+ * dropped), then its exact wire id on that route — never a moving pointer+ * unless the model's own id is one (same rule as `externalIdFor`).+ */+function findConnection(+ entries: SlimModelEntry[],+ route: CatalogRouteBinding,+ modelName: string+): { entry: SlimModelEntry; connection: AggregatorEntry } | undefined {+ for (const entry of entries) {+ const connection = mappedOnRoute(entry, route).find((c) => c.externalModelId === modelName);+ if (connection) return { entry, connection };+ }++ const name = lower(modelName);+ const bare = stripVendorPrefix(name);+ const entry = entries.find(+ (candidate) =>+ lower(candidate.modelId) === name ||+ lower(candidate.modelId) === bare ||+ candidate.aliases.some((alias) => lower(alias) === name || lower(alias) === bare)+ );+ if (!entry) return undefined;+ const connections = mappedOnRoute(entry, route);+ const connection = isMovingPointer(entry.modelId)+ ? connections[0]+ : connections.find((c) => !isMovingPointer(c.externalModelId as string));+ return connection ? { entry, connection } : undefined;+}++export function resolveConnection(+ provider: string,+ modelName: string,+ cachePath: string = ALL_MODELS_CACHE_PATH+): ConnectionResolution {+ const route = catalogRouteForProvider(provider);+ if (!route) return { ok: false, reason: "not-catalog-routed" };++ const cache = readAllModelsCache(cachePath);+ if (!cache || cache.entries.length === 0) return { ok: false, reason: "no-catalog" };+ if (!cache.routeRegistry) return { ok: false, reason: "no-registry" };++ const found = findConnection(cache.entries, route, modelName);+ if (!found?.connection.wire) return { ok: false, reason: "no-connection" };+ const profile = routeProfile(cache.routeRegistry.registry, route);+ if (!profile) return { ok: false, reason: "no-connection" };++ const ownerWire = findOwnerWire(found.entry, cache.routeRegistry.registry, found.connection);+ return {+ ok: true,+ connection: {+ provider,+ modelId: found.entry.modelId,+ route,+ externalModelId: found.connection.externalModelId as string,+ wire: found.connection.wire,+ profile,+ generationId: cache.routeRegistry.generationId,+ ...(ownerWire ? { ownerWire } : {}),+ },+ };+}++function findOwnerWire(+ entry: SlimModelEntry,+ registry: RouteRegistry,+ self: AggregatorEntry+): KnownWire | undefined {+ const vendor = entry.provider;+ if (!vendor) return undefined;+ const owner = (entry.aggregators ?? []).find((connection) => {+ if (connection === self || connection.routeStatus !== "mapped" || !connection.route)+ return false;+ const profile = routeProfile(registry, connection.route);+ return profile?.kind === "direct" && (profile.nativeModelProviders ?? []).includes(vendor);+ });+ return owner?.wire?.status === "known" ? owner.wire : undefined;+}++/**+ * The route profile a provider is bound to, for a model the catalog does not+ * publish on it: which APIs the host serves, so they can be tried in turn.+ */+export function resolveRouteProfile(+ provider: string,+ cachePath: string = ALL_MODELS_CACHE_PATH+): { route: CatalogRouteBinding; profile: RouteProfile; generationId: string } | undefined {+ const route = catalogRouteForProvider(provider);+ if (!route) return undefined;+ const cache = readAllModelsCache(cachePath);+ if (!cache?.routeRegistry) return undefined;+ const profile = routeProfile(cache.routeRegistry.registry, route);+ return profile ? { route, profile, generationId: cache.routeRegistry.generationId } : undefined;+}++/** The registry base URL for `api` on this connection's profile, if published. */+export function connectionBaseUrl(+ connection: ResolvedConnection,+ api: WireApi+): string | undefined {+ return connection.profile.apis[api]?.baseUrl;+}++/** The full request URL for `api` on this connection, if its profile publishes a base URL. */+export function connectionRequestUrl(+ connection: ResolvedConnection,+ api: WireApi,+ stream = true+): string | undefined {+ const baseUrl = connectionBaseUrl(connection, api);+ return baseUrl ? wireRequestUrl(baseUrl, api, connection.externalModelId, stream) : undefined;+}diff --git a/packages/cli/src/providers/connection-wire.test.ts b/packages/cli/src/providers/connection-wire.test.tsnew file mode 100644index 00000000..697e04b4--- /dev/null+++ b/packages/cli/src/providers/connection-wire.test.ts@@ -0,0 +1,127 @@+import { describe, expect, test } from "bun:test";+import { readFileSync } from "node:fs";+import type { DiskCacheV3 } from "./all-models-cache.js";+import {+ WIRE_REGISTRY_VERSION,+ type WireApi,+ isConnectionWire,+ isRouteRegistry,+ registryVersionAtLeast,+ routeProfile,+ wireRequestUrl,+} from "./connection-wire.js";++const fixture: DiskCacheV3 = JSON.parse(+ readFileSync(+ new URL("../test-fixtures/catalog-v3/wire-g-20261012101007285-7770c36e.json", import.meta.url),+ "utf8"+ )+);+const registry = fixture.routeRegistry!.registry;+const connections = fixture.entries+ .flatMap((entry) => entry.aggregators ?? [])+ .filter((connection) => connection.routeStatus === "mapped");+const known = connections.find((connection) => connection.wire?.status === "known")!.wire!;++describe("isConnectionWire", () => {+ test("accepts every published wire, including known, unknown and unsupported", () => {+ expect(fixture.entries).toHaveLength(16);+ expect(new Set(connections.map((connection) => connection.wire?.status))).toEqual(+ new Set(["known", "unknown", "unsupported"])+ );+ for (const connection of connections) expect(isConnectionWire(connection.wire)).toBe(true);+ });+ test.each([+ ["null", null],+ ["missing api", { ...known, api: undefined }],+ ["unrecognized api", { ...known, api: "realtime" }],+ ["unrecognized status", { ...known, status: "future" }],+ ])("rejects %s", (_name, value) => expect(isConnectionWire(value)).toBe(false));+});++describe("isRouteRegistry", () => {+ test("accepts the production registry", () => expect(isRouteRegistry(registry)).toBe(true));+ test("rejects an unknown API key", () => {+ const copy = structuredClone(registry);+ const apis = copy.routes.openai!.profiles["direct-api"]!.apis;+ Object.assign(apis, { realtime: { baseUrl: "https://example.test" } });+ expect(isRouteRegistry(copy)).toBe(false);+ });+ test("rejects a missing baseUrl", () => {+ const copy = structuredClone(registry);+ Reflect.deleteProperty(copy.routes.openai!.profiles["direct-api"]!.apis.responses!, "baseUrl");+ expect(isRouteRegistry(copy)).toBe(false);+ });+ test.each([[null], ["registry"], [[]], [42]])("rejects non-object %j", (value) => {+ expect(isRouteRegistry(value)).toBe(false);+ });+ test("looks up the exact route profile", () => {+ expect(routeProfile(registry, { routeId: "openai", routeProfileId: "direct-api" })).toEqual(+ registry.routes.openai!.profiles["direct-api"]+ );+ expect(routeProfile(registry, { routeId: "openai", routeProfileId: "absent" })).toBeUndefined();+ expect(+ routeProfile(registry, { routeId: "absent", routeProfileId: "direct-api" })+ ).toBeUndefined();+ });+});++describe("registryVersionAtLeast", () => {+ test("wire enforcement starts at 3.7.0", () => expect(WIRE_REGISTRY_VERSION).toBe("3.7.0"));+ test.each([+ ["3.7.0", true],+ ["3.10.0", true],+ ["3.6.9", false],+ ["4.0", true],+ ] as const)("compares %s numerically", (version, expected) => {+ expect(registryVersionAtLeast(version, "3.7.0")).toBe(expected);+ });+});++describe("wireRequestUrl", () => {+ const cases: Array<[WireApi, string, string, string]> = [+ [+ "responses",+ "https://api.openai.com/v1",+ "gpt-6.1-sol",+ "https://api.openai.com/v1/responses",+ ],+ [+ "chat-completions",+ "https://openrouter.ai/api/v1",+ "openai/gpt-6.1-sol",+ "https://openrouter.ai/api/v1/chat/completions",+ ],+ [+ "anthropic-messages",+ "https://api.anthropic.com/v1",+ "claude-opus-5-5",+ "https://api.anthropic.com/v1/messages",+ ],+ [+ "gemini",+ "https://generativelanguage.googleapis.com/v1beta",+ "gemini-3.8-flash",+ "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.8-flash:streamGenerateContent?alt=sse",+ ],+ ];+ for (const [api, base, id, expected] of cases) {+ test(`${api} appends its path and strips trailing slashes`, () => {+ expect(wireRequestUrl(base, api, id)).toBe(expected);+ expect(wireRequestUrl(`${base}/`, api, id)).toBe(expected);+ expect(wireRequestUrl(`${base}///`, api, id)).toBe(expected);+ });+ }+ test("Gemini non-streaming uses generateContent without SSE query", () => {+ expect(+ wireRequestUrl(+ "https://generativelanguage.googleapis.com/v1beta/",+ "gemini",+ "gemini-3.8-flash",+ false+ )+ ).toBe(+ "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.8-flash:generateContent"+ );+ });+});diff --git a/packages/cli/src/providers/connection-wire.ts b/packages/cli/src/providers/connection-wire.tsnew file mode 100644index 00000000..2221ca50--- /dev/null+++ b/packages/cli/src/providers/connection-wire.ts@@ -0,0 +1,219 @@+/**+ * The catalog's per-connection `wire` and the route registry (contract 3.7.0).+ *+ * Every mapped connection publishes how to call it: the API, the output-limit+ * field, the reasoning encoding, the request mode and the speed tier. The route+ * registry publishes each route profile's base URL per API. Together they are+ * the ONLY source of request decisions for a catalog connection: no model name,+ * family or model-level field may decide any of these.+ *+ * Shapes are copied from Models Index `ai-docs/claudish-catalog-3.7.0.md` §3–4.+ */++export type WireApi = "chat-completions" | "responses" | "anthropic-messages" | "gemini";++export const WIRE_APIS: readonly WireApi[] = [+ "chat-completions",+ "responses",+ "anthropic-messages",+ "gemini",+];++export type WireUnknown = { status: "unknown" };+export type WireNotApplicable = { status: "not_applicable" };+export type WireStatusOnly = WireUnknown | WireNotApplicable;++export type WireValue = string | number | boolean;++export type TokenParam = "max_tokens" | "max_completion_tokens" | "max_output_tokens";++export interface WireAssignment {+ /** RFC 6901 JSON Pointer into the request body root. */+ path: string;+ value: WireValue;+}++export interface WireEffort {+ path: string;+ /** Catalog effort name → the exact native value on this connection. */+ values: Record<string, WireValue>;+ /** Catalog effort name in effect when the field is omitted. */+ default: string | WireUnknown;+}++export interface WireHeader {+ name: string;+ value: string;+ merge: "append-comma";+}++export type WireControl =+ | {+ status: "supported";+ path: string;+ values: Record<string, WireValue>;+ default: string | WireUnknown;+ headers: WireHeader[];+ echo: string | WireStatusOnly;+ access: "open" | "entitlement" | "usage-credits";+ }+ | { status: "rejected"; path: string }+ | WireStatusOnly;++export interface WireReasoningWarning {+ code: string;+ part: "enable" | "disable";+ servedModel: string;+}++export type WireReasoning =+ | {+ status: "supported";+ enable: WireAssignment[] | WireStatusOnly;+ disable: WireAssignment[] | WireStatusOnly;+ effort: WireEffort | WireStatusOnly;+ mode: WireControl;+ warnings?: WireReasoningWarning[];+ }+ | WireStatusOnly;++export interface WireEvidenceRef {+ evidenceId: string;+ method: string;+ sourceUrl?: string;+ observedAt: string;+}++export type KnownWire = {+ status: "known";+ api: WireApi;+ tokenParam: TokenParam | WireStatusOnly;+ toolsWithReasoning: "ok" | "requires-responses" | "requires-effort-none" | WireStatusOnly;+ reasoning: WireReasoning;+ speed: WireControl;+ evidence: WireEvidenceRef[];+};++export type ConnectionWire =+ | KnownWire+ | { status: "unknown"; evidence: WireEvidenceRef[] }+ | { status: "unsupported"; protocol: string; evidence: WireEvidenceRef[] };++export interface RouteProfile {+ kind: string;+ admission?: string;+ /** Vendors whose OWN models this profile serves natively (a `direct` profile is their native API). */+ nativeModelProviders?: string[];+ /** `{}` means no base URL is established for this profile. */+ apis: Partial<Record<WireApi, { baseUrl: string }>>;+}++export interface RouteRegistry {+ registryVersion: string;+ routes: Record<string, { routeId?: string; profiles: Record<string, RouteProfile> }>;+}++/** The registry as cached, pinned to the model list's generation. */+export interface CachedRouteRegistry {+ generationId: string;+ registry: RouteRegistry;+}++function isObject(value: unknown): value is Record<string, unknown> {+ return value !== null && typeof value === "object" && !Array.isArray(value);+}++function isWireApi(value: unknown): value is WireApi {+ return typeof value === "string" && (WIRE_APIS as readonly string[]).includes(value);+}++/**+ * Structural check of one connection's `wire`: the discriminator and the fields+ * a request reads. Sub-objects are checked only as far as `status` tells how to+ * read them; the request builder re-checks each value it uses.+ */+export function isConnectionWire(value: unknown): value is ConnectionWire {+ if (!isObject(value)) return false;+ switch (value.status) {+ case "unknown":+ return true;+ case "unsupported":+ return typeof value.protocol === "string";+ case "known":+ return (+ isWireApi(value.api) &&+ (typeof value.tokenParam === "string" || isObject(value.tokenParam)) &&+ isObject(value.reasoning) &&+ typeof value.reasoning.status === "string" &&+ isObject(value.speed) &&+ typeof value.speed.status === "string"+ );+ default:+ return false;+ }+}++export function isRouteRegistry(value: unknown): value is RouteRegistry {+ if (!isObject(value) || typeof value.registryVersion !== "string" || !isObject(value.routes)) {+ return false;+ }+ return Object.values(value.routes).every(+ (route) =>+ isObject(route) &&+ isObject(route.profiles) &&+ Object.values(route.profiles).every(+ (profile) =>+ isObject(profile) &&+ typeof profile.kind === "string" &&+ isObject(profile.apis) &&+ Object.entries(profile.apis).every(+ ([api, entry]) => isWireApi(api) && isObject(entry) && typeof entry.baseUrl === "string"+ )+ )+ );+}++/** `"3.7.0"` ≥ `"3.6.2"`, compared numerically per part. */+export function registryVersionAtLeast(version: string, minimum: string): boolean {+ const a = version.split(".").map((part) => Number.parseInt(part, 10) || 0);+ const b = minimum.split(".").map((part) => Number.parseInt(part, 10) || 0);+ for (let i = 0; i < Math.max(a.length, b.length); i++) {+ const diff = (a[i] ?? 0) - (b[i] ?? 0);+ if (diff !== 0) return diff > 0;+ }+ return true;+}++/** The first registry version whose connections all carry `wire`. */+export const WIRE_REGISTRY_VERSION = "3.7.0";++export function routeProfile(+ registry: RouteRegistry,+ route: { routeId: string; routeProfileId: string }+): RouteProfile | undefined {+ return registry.routes[route.routeId]?.profiles?.[route.routeProfileId];+}++/**+ * The request path for `api` under a registry base URL (catalog 3.7.0 §4).+ * `baseUrl` already ends in its version segment (`/v1`, `/v1beta`), so the+ * suffix is appended as is.+ */+export function wireRequestUrl(+ baseUrl: string,+ api: WireApi,+ externalModelId: string,+ stream = true+): string {+ const base = baseUrl.replace(/\/+$/, "");+ switch (api) {+ case "chat-completions":+ return `${base}/chat/completions`;+ case "responses":+ return `${base}/responses`;+ case "anthropic-messages":+ return `${base}/messages`;+ case "gemini":+ return `${base}/models/${externalModelId}:${stream ? "streamGenerateContent?alt=sse" : "generateContent"}`;+ }+}diff --git a/packages/cli/src/test-fixtures/catalog-v3/wire-g-20261012101007285-7770c36e.json b/packages/cli/src/test-fixtures/catalog-v3/wire-g-20261012101007285-7770c36e.jsonnew file mode 100644index 00000000..3d3c73bc--- /dev/null+++ b/packages/cli/src/test-fixtures/catalog-v3/wire-g-20261012101007285-7770c36e.json@@ -0,0 +1,13828 @@+{+ "version": 3,+ "lastUpdated": "2026-10-12T10:10:07.285Z",+ "entries": [+ {+ "contractVersion": 3,+ "modelId": "mai-voice-2.1",+ "displayName": "MAI-Voice-2.1",+ "provider": "microsoft",+ "aliases": [+ "microsoft/mai-voice-2.1",+ "MAI-Voice-2.1"+ ],+ "status": "active",+ "releaseDate": "2026-10-01",+ "inputModalities": [+ "text"+ ],+ "outputModalities": [+ "speech"+ ],+ "aggregators": [+ {+ "sourceProviderId": "openrouter",+ "sourceCollectorId": "openrouter-api",+ "confidence": "aggregator_reported",+ "routeStatus": "mapped",+ "route": {+ "routeId": "openrouter",+ "routeProfileId": "gateway"+ },+ "externalModelId": "microsoft/mai-voice-2.1",+ "pricing": {+ "type": "unavailable"+ },+ "reasoning": {+ "request": {+ "status": "unknown"+ }+ },+ "wire": {+ "status": "unknown",+ "evidence": []+ }+ }+ ],+ "supportsVision": false,+ "supportsTools": false,+ "videoInput": false,+ "videoOutput": false+ },+ {+ "contractVersion": 3,+ "modelId": "gpt-6.1-sol",+ "displayName": "GPT-6.1-Sol",+ "provider": "openai",+ "aliases": [+ "openai/gpt-6.1-sol",+ "openai/gpt-6.1-sol:batch"+ ],+ "status": "active",+ "releaseDate": "2026-09-29",+ "contextWindow": 1050000,+ "maxOutputTokens": 128000,+ "subscriptionPlanIds": [+ "openai-codex"+ ],+ "inputModalities": [+ "image",+ "text"+ ],+ "outputModalities": [+ "text"+ ],+ "aggregators": [+ {+ "sourceProviderId": "openai-codex",+ "sourceCollectorId": "openai-codex-models",+ "confidence": "scrape_verified",+ "routeStatus": "mapped",+ "route": {+ "routeId": "openai",+ "routeProfileId": "codex-subscription"+ },+ "externalModelId": "gpt-6.1-sol",+ "reasoning": {+ "mode": {+ "status": "rejected"+ },+ "request": {+ "status": "unknown"+ }+ },+ "wire": {+ "status": "known",+ "api": "responses",+ "tokenParam": "max_output_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": {+ "status": "unknown"+ },+ "disable": {+ "status": "unknown"+ },+ "effort": {+ "path": "/reasoning/effort",+ "values": {+ "max": "max",+ "xhigh": "xhigh",+ "high": "high",+ "medium": "medium",+ "low": "low"+ },+ "default": {+ "status": "unknown"+ }+ },+ "mode": {+ "status": "rejected",+ "path": "/reasoning/mode"+ }+ },+ "speed": {+ "status": "unknown"+ },+ "evidence": [+ {+ "evidenceId": "wev_994f26a74d9d2cb61fe8acf03a723d02",+ "method": "docs",+ "sourceUrl": "https://developers.openai.com/codex/config-reference.md",+ "observedAt": "2026-10-12T10:09:53.088Z"+ },+ {+ "evidenceId": "wev_aa5d3ec6840ff419a1eeb422030b817e",+ "method": "probe",+ "observedAt": "2026-10-11T22:06:12.429Z"+ },+ {+ "evidenceId": "wev_e1f5bd1741d1e1517d67f21ee811bf44",+ "method": "probe",+ "observedAt": "2026-10-11T22:06:14.933Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "openai",+ "sourceCollectorId": "openai-api",+ "confidence": "api_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "openai",+ "routeProfileId": "direct-api"+ },+ "externalModelId": "gpt-6.1-sol",+ "pricing": {+ "type": "flat",+ "input": 2,+ "output": 10,+ "cachedRead": 0.1,+ "cachedWrite": 2.5+ },+ "reasoning": {+ "mode": {+ "status": "supported",+ "values": [+ "standard",+ "pro"+ ],+ "default": "standard"+ },+ "request": {+ "status": "supported",+ "api": "responses",+ "evidenceSourceUrl": "https://developers.openai.com/api/reference/resources/responses.md",+ "effort": {+ "path": "/reasoning/effort",+ "values": {+ "max": "max",+ "xhigh": "xhigh",+ "high": "high",+ "medium": "medium",+ "low": "low"+ },+ "default": "medium"+ }+ }+ },+ "wire": {+ "status": "known",+ "api": "responses",+ "tokenParam": "max_output_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": {+ "status": "not_applicable"+ },+ "disable": {+ "status": "not_applicable"+ },+ "effort": {+ "path": "/reasoning/effort",+ "values": {+ "max": "max",+ "xhigh": "xhigh",+ "high": "high",+ "medium": "medium",+ "low": "low"+ },+ "default": "medium"+ },+ "mode": {+ "status": "supported",+ "path": "/reasoning/mode",+ "values": {+ "standard": "standard",+ "pro": "pro"+ },+ "default": "standard",+ "headers": [],+ "echo": "/reasoning/mode",+ "access": "open"+ }+ },+ "speed": {+ "status": "supported",+ "path": "/service_tier",+ "values": {+ "standard": "default",+ "fast": "priority",+ "flex": "flex"+ },+ "default": "standard",+ "headers": [],+ "echo": "/service_tier",+ "access": "open"+ },+ "evidence": [+ {+ "evidenceId": "wev_207065ba96c021e239582acdf43fe3b8",+ "method": "docs",+ "sourceUrl": "https://developers.openai.com/api/docs/pricing.md",+ "observedAt": "2026-10-12T10:09:52.384Z"+ },+ {+ "evidenceId": "wev_28213835df029786a7acf3d3c5a4f0a3",+ "method": "docs",+ "sourceUrl": "https://developers.openai.com/api/reference/resources/responses.md",+ "observedAt": "2026-10-12T10:09:54.840Z"+ },+ {+ "evidenceId": "wev_4101c69136a10bff8eca7359c08e7bb1",+ "method": "docs",+ "sourceUrl": "https://developers.openai.com/api/reference/resources/responses.md",+ "observedAt": "2026-10-12T10:09:54.840Z"+ },+ {+ "evidenceId": "wev_4bad7ed850f2400130b7045e55a5fa93",+ "method": "docs",+ "sourceUrl": "https://developers.openai.com/api/docs/models/gpt-6.1-sol.md",+ "observedAt": "2026-10-12T10:09:32.108Z"+ },+ {+ "evidenceId": "wev_83fb53b981a3db756880e57d4a7e99f7",+ "method": "docs",+ "sourceUrl": "https://developers.openai.com/api/docs/models/gpt-6.1-sol.md",+ "observedAt": "2026-10-12T10:09:32.108Z"+ },+ {+ "evidenceId": "wev_954b1ed079b430505f7cf28c7c25e29c",+ "method": "docs",+ "sourceUrl": "https://developers.openai.com/api/reference/resources/responses.md",+ "observedAt": "2026-10-12T10:09:54.840Z"+ },+ {+ "evidenceId": "wev_a798f203e8ede754f112df4553f27892",+ "method": "docs",+ "sourceUrl": "https://developers.openai.com/api/docs/models/gpt-6.1-sol.md",+ "observedAt": "2026-10-12T10:09:32.108Z"+ },+ {+ "evidenceId": "wev_d2a9bac1568fc5c7b388a9bfb5fd7e7a",+ "method": "docs",+ "sourceUrl": "https://developers.openai.com/api/docs/models/gpt-6.1-sol.md",+ "observedAt": "2026-10-12T10:09:32.108Z"+ },+ {+ "evidenceId": "wev_dce258dee33b533ac909f31ef9dd4585",+ "method": "docs",+ "sourceUrl": "https://developers.openai.com/api/reference/resources/responses.md",+ "observedAt": "2026-10-12T10:09:54.840Z"+ },+ {+ "evidenceId": "wev_e75762a92a1c984cf26db69de121ce60",+ "method": "docs",+ "sourceUrl": "https://developers.openai.com/api/docs/guides/reasoning",+ "observedAt": "2026-10-12T10:09:33.290Z"+ },+ {+ "evidenceId": "wev_ee7ea72f46461e5c7cc1d8b4fe11a84a",+ "method": "docs",+ "sourceUrl": "https://developers.openai.com/api/docs/models/gpt-6.1-sol.md",+ "observedAt": "2026-10-12T10:09:32.108Z"+ },+ {+ "evidenceId": "wev_b190dba97bc4a87f5e5fa313f3f963eb",+ "method": "probe",+ "observedAt": "2026-10-11T22:04:29.233Z"+ },+ {+ "evidenceId": "wev_cb99d41fca5b066e1802e3889e9f530d",+ "method": "probe",+ "observedAt": "2026-10-11T22:04:26.781Z"+ },+ {+ "evidenceId": "wev_ced0d554d1d34ecea8c6339f6d09eab2",+ "method": "probe",+ "observedAt": "2026-10-11T22:04:26.409Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "opencode-zen",+ "sourceCollectorId": "opencode-zen-api",+ "confidence": "gateway_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "opencode",+ "routeProfileId": "zen"+ },+ "externalModelId": "gpt-6.1-sol",+ "pricing": {+ "type": "flat",+ "input": 2,+ "output": 10,+ "cachedRead": 0.1,+ "cachedWrite": 2.5+ },+ "reasoning": {+ "mode": {+ "status": "supported",+ "values": [+ "standard",+ "pro"+ ],+ "default": "standard"+ },+ "request": {+ "status": "supported",+ "api": "responses",+ "evidenceSourceUrl": "https://developers.openai.com/api/reference/resources/responses.md",+ "effort": {+ "path": "/reasoning/effort",+ "values": {+ "max": "max",+ "xhigh": "xhigh",+ "high": "high",+ "medium": "medium",+ "low": "low"+ },+ "default": "medium"+ }+ }+ },+ "wire": {+ "status": "known",+ "api": "responses",+ "tokenParam": "max_output_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": {+ "status": "not_applicable"+ },+ "disable": {+ "status": "not_applicable"+ },+ "effort": {+ "path": "/reasoning/effort",+ "values": {+ "max": "max",+ "xhigh": "xhigh",+ "high": "high",+ "medium": "medium",+ "low": "low"+ },+ "default": "medium"+ },+ "mode": {+ "status": "supported",+ "path": "/reasoning/mode",+ "values": {+ "standard": "standard",+ "pro": "pro"+ },+ "default": "standard",+ "headers": [],+ "echo": {+ "status": "not_applicable"+ },+ "access": "open"+ }+ },+ "speed": {+ "status": "unknown"+ },+ "evidence": [+ {+ "evidenceId": "wev_107c948b92922c45a59b39b46298030a",+ "method": "docs",+ "sourceUrl": "https://developers.openai.com/api/docs/models/gpt-6.1-sol.md",+ "observedAt": "2026-10-12T10:09:32.108Z"+ },+ {+ "evidenceId": "wev_1b6d98b965847a82d7ef423e9d2e53a1",+ "method": "docs",+ "sourceUrl": "https://developers.openai.com/api/reference/resources/responses.md",+ "observedAt": "2026-10-12T10:09:54.840Z"+ },+ {+ "evidenceId": "wev_3790f25b1f95c64637b3174ec6624fdf",+ "method": "docs",+ "sourceUrl": "https://developers.openai.com/api/docs/models/gpt-6.1-sol.md",+ "observedAt": "2026-10-12T10:09:32.108Z"+ },+ {+ "evidenceId": "wev_71db54e4a739610b570eda10ef121df7",+ "method": "docs",+ "sourceUrl": "https://developers.openai.com/api/reference/resources/responses.md",+ "observedAt": "2026-10-12T10:09:54.840Z"+ },+ {+ "evidenceId": "wev_7fa823d5e7dc02a9dcd16cdabc2ad92f",+ "method": "docs",+ "sourceUrl": "https://developers.openai.com/api/docs/models/gpt-6.1-sol.md",+ "observedAt": "2026-10-12T10:09:32.108Z"+ },+ {+ "evidenceId": "wev_e18b242dd9f3942ef01c11d2b71bdb90",+ "method": "docs",+ "sourceUrl": "https://developers.openai.com/api/docs/guides/reasoning",+ "observedAt": "2026-10-12T10:09:33.290Z"+ },+ {+ "evidenceId": "wev_ffc68bfc7c40965dc1134631f07419a5",+ "method": "docs",+ "sourceUrl": "https://developers.openai.com/api/docs/models/gpt-6.1-sol.md",+ "observedAt": "2026-10-12T10:09:32.108Z"+ },+ {+ "evidenceId": "wev_d7069620c1bdc168d04e1486f96e71b6",+ "method": "endpoint-table",+ "sourceUrl": "https://opencode.ai/docs/en/zen/",+ "observedAt": "2026-10-12T10:09:23.090Z"+ },+ {+ "evidenceId": "wev_8b7b077ee27452971d60be9d01a6dc9a",+ "method": "probe",+ "observedAt": "2026-10-09T12:39:57.431Z"+ },+ {+ "evidenceId": "wev_aa9c48924c6dcb502ea14f1c959c8c2f",+ "method": "probe",+ "observedAt": "2026-10-09T12:40:07.300Z"+ },+ {+ "evidenceId": "wev_de88653e464217679bebde566075a8a8",+ "method": "probe",+ "observedAt": "2026-10-09T13:03:09.339Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "openrouter",+ "sourceCollectorId": "openrouter-api",+ "confidence": "aggregator_reported",+ "routeStatus": "mapped",+ "route": {+ "routeId": "openrouter",+ "routeProfileId": "gateway"+ },+ "externalModelId": "openai/gpt-6.1-sol",+ "pricing": {+ "type": "flat",+ "input": 2,+ "output": 10,+ "cachedRead": 0.1,+ "batchDiscountPct": 50+ },+ "reasoning": {+ "mode": {+ "status": "supported",+ "values": [+ "standard",+ "pro"+ ],+ "default": "standard"+ },+ "request": {+ "status": "supported",+ "api": "chat-completions",+ "evidenceSourceUrl": "https://openrouter.ai/api/v1/models",+ "enable": [+ {+ "path": "/reasoning/enabled",+ "value": true+ }+ ],+ "effort": {+ "path": "/reasoning/effort",+ "values": {+ "max": "max",+ "xhigh": "xhigh",+ "high": "high",+ "medium": "medium",+ "low": "low"+ },+ "default": "medium"+ }+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": {+ "status": "unknown"+ },+ "reasoning": {+ "status": "supported",+ "enable": [+ {+ "path": "/reasoning/enabled",+ "value": true+ }+ ],+ "disable": {+ "status": "not_applicable"+ },+ "effort": {+ "path": "/reasoning/effort",+ "values": {+ "max": "max",+ "xhigh": "xhigh",+ "high": "high",+ "medium": "medium",+ "low": "low"+ },+ "default": "medium"+ },+ "mode": {+ "status": "supported",+ "path": "/reasoning/mode",+ "values": {+ "standard": "standard",+ "pro": "pro"+ },+ "default": "standard",+ "headers": [],+ "echo": {+ "status": "not_applicable"+ },+ "access": "open"+ }+ },+ "speed": {+ "status": "supported",+ "path": "/service_tier",+ "values": {+ "fast": "priority",+ "flex": "flex",+ "ultrafast": "ultrafast"+ },+ "default": "standard",+ "headers": [],+ "echo": "/service_tier",+ "access": "open"+ },+ "evidence": [+ {+ "evidenceId": "wev_46f27a21cc6b633991632cf1a32066b0",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_6783589039d634d1a5072a6e2341446f",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_787d915717324dafa253ff2dfa3a3b99",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models/openai/gpt-6.1-sol/endpoints",+ "observedAt": "2026-10-12T10:09:32.503Z"+ },+ {+ "evidenceId": "wev_8bcdffce0978a14b038fe3e87e30ac24",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_98943b0860927f90c3a1455223e0412c",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_b13cdb5a7ff271fb0fdfcf5d9c16c03e",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_dbf5ab59182f1c8c007d2b9a726e8506",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_ef36cb983188c2bdca58911128e8f53a",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_4d2c897a9a6eedbf4dea4c4627f6e695",+ "method": "docs",+ "sourceUrl": "https://openrouter.ai/docs/guides/best-practices/reasoning-tokens",+ "observedAt": "2026-10-12T10:09:52.321Z"+ },+ {+ "evidenceId": "wev_acbc4b33cd595ec49ac0c5516eac2135",+ "method": "docs",+ "sourceUrl": "https://openrouter.ai/docs/guides/best-practices/reasoning-tokens",+ "observedAt": "2026-10-12T10:09:52.321Z"+ },+ {+ "evidenceId": "wev_4257b5a8693e0cfcc997a7be9746f3cf",+ "method": "probe",+ "observedAt": "2026-10-11T19:34:57.649Z"+ },+ {+ "evidenceId": "wev_62723b6c009fe8a2c1dea255f6c928a7",+ "method": "probe",+ "observedAt": "2026-10-11T19:35:02.463Z"+ },+ {+ "evidenceId": "wev_756e2df2f469c6623ec85b13ddf30227",+ "method": "probe",+ "observedAt": "2026-10-11T19:34:53.820Z"+ },+ {+ "evidenceId": "wev_e85ba394cd1a8d4084900708dcd30b24",+ "method": "probe",+ "observedAt": "2026-10-11T19:35:01.870Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "openrouter",+ "sourceCollectorId": "openrouter-api",+ "confidence": "aggregator_reported",+ "routeStatus": "unknown",+ "reason": "unverified_mapping",+ "observedExternalModelId": "openai/gpt-6.1-sol:batch"+ }+ ],+ "supportsVision": true,+ "supportsTools": true,+ "videoInput": false,+ "videoOutput": false,+ "reasoning": {+ "supported": true,+ "mandatory": true,+ "control": "effort",+ "efforts": [+ "max",+ "xhigh",+ "high",+ "medium",+ "low"+ ],+ "defaultEffort": "medium"+ },+ "endpoints": {+ "openai": {+ "api": "responses",+ "toolsWithReasoning": "ok"+ }+ },+ "tokenParam": "max_output_tokens"+ },+ {+ "contractVersion": 3,+ "modelId": "claude-sonnet-5-5",+ "displayName": "Claude Sonnet 5.5",+ "provider": "anthropic",+ "aliases": [+ "anthropic/claude-sonnet-5.5",+ "anthropic/claude-sonnet-5.5:batch",+ "claude-sonnet-5.5"+ ],+ "status": "active",+ "releaseDate": "2026-09-28",+ "contextWindow": 1000000,+ "maxOutputTokens": 128000,+ "subscriptionPlanIds": [+ "anthropic-claude-code"+ ],+ "inputModalities": [+ "image",+ "text"+ ],+ "outputModalities": [+ "text"+ ],+ "aggregators": [+ {+ "sourceProviderId": "anthropic",+ "sourceCollectorId": "anthropic-api",+ "confidence": "api_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "anthropic",+ "routeProfileId": "direct-api"+ },+ "externalModelId": "claude-sonnet-5-5",+ "pricing": {+ "type": "unavailable"+ },+ "reasoning": {+ "mode": {+ "status": "rejected"+ },+ "request": {+ "status": "supported",+ "api": "anthropic-messages",+ "evidenceSourceUrl": "https://platform.claude.com/docs/en/build-with-claude/effort",+ "enable": [+ {+ "path": "/thinking/type",+ "value": "adaptive"+ }+ ],+ "disable": [+ {+ "path": "/thinking/type",+ "value": "between_tools"+ }+ ],+ "effort": {+ "path": "/output_config/effort",+ "values": {+ "max": "max",+ "xhigh": "xhigh",+ "high": "high",+ "medium": "medium",+ "low": "low"+ },+ "default": "high"+ }+ }+ },+ "wire": {+ "status": "known",+ "api": "anthropic-messages",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": [+ {+ "path": "/thinking/type",+ "value": "adaptive"+ }+ ],+ "disable": [+ {+ "path": "/thinking/type",+ "value": "between_tools"+ }+ ],+ "effort": {+ "path": "/output_config/effort",+ "values": {+ "max": "max",+ "xhigh": "xhigh",+ "high": "high",+ "medium": "medium",+ "low": "low"+ },+ "default": "high"+ },+ "mode": {+ "status": "rejected",+ "path": "/reasoning/mode"+ }+ },+ "speed": {+ "status": "rejected",+ "path": "/speed"+ },+ "evidence": [+ {+ "evidenceId": "wev_014077ced08da3f5af1b0f30b95c3030",+ "method": "docs",+ "sourceUrl": "https://platform.claude.com/docs/en/build-with-claude/fast-mode.md",+ "observedAt": "2026-10-12T10:09:45.314Z"+ },+ {+ "evidenceId": "wev_12bcc787682028f62cb571cafc0aafc7",+ "method": "docs",+ "sourceUrl": "https://platform.claude.com/docs/en/api/messages.md",+ "observedAt": "2026-10-12T10:09:46.503Z"+ },+ {+ "evidenceId": "wev_156b3e0fc27ce523795ed9de36c82603",+ "method": "docs",+ "sourceUrl": "https://platform.claude.com/docs/en/models/sonnet-5-5/migration-guide.md",+ "observedAt": "2026-10-12T10:09:52.112Z"+ },+ {+ "evidenceId": "wev_2de2862adf774b0957f7eedaff4ee8fa",+ "method": "docs",+ "sourceUrl": "https://platform.claude.com/docs/en/cli-sdks-libraries/libraries/openai-sdk.md",+ "observedAt": "2026-10-12T10:09:51.974Z"+ },+ {+ "evidenceId": "wev_401568e8aa46937014780895d79f132e",+ "method": "docs",+ "sourceUrl": "https://platform.claude.com/docs/en/build-with-claude/effort",+ "observedAt": "2026-10-12T10:09:46.396Z"+ },+ {+ "evidenceId": "wev_5ef10c5a24955c01350be477d9a60441",+ "method": "docs",+ "sourceUrl": "https://platform.claude.com/docs/en/build-with-claude/effort",+ "observedAt": "2026-10-12T10:09:46.396Z"+ },+ {+ "evidenceId": "wev_6687a403b15893b99ceee50ae9f55223",+ "method": "docs",+ "sourceUrl": "https://platform.claude.com/docs/en/build-with-claude/effort",+ "observedAt": "2026-10-12T10:09:46.396Z"+ },+ {+ "evidenceId": "wev_6734511c560810832ef3b162aa315464",+ "method": "docs",+ "sourceUrl": "https://platform.claude.com/docs/en/build-with-claude/effort",+ "observedAt": "2026-10-12T10:09:46.396Z"+ },+ {+ "evidenceId": "wev_8e7482ba6c39faf0c35df26540b25784",+ "method": "docs",+ "sourceUrl": "https://platform.claude.com/docs/en/build-with-claude/effort",+ "observedAt": "2026-10-12T10:09:46.396Z"+ },+ {+ "evidenceId": "wev_c23c23f0afabca25839fc4c15597f6d8",+ "method": "docs",+ "sourceUrl": "https://platform.claude.com/docs/en/models/sonnet-5-5/migration-guide.md",+ "observedAt": "2026-10-12T10:09:52.112Z"+ },+ {+ "evidenceId": "wev_062142e7a5c4a4ec298151aea8c6f251",+ "method": "probe",+ "observedAt": "2026-10-11T22:07:58.018Z"+ },+ {+ "evidenceId": "wev_4cb0ae23568c8a9b33c7c33fb93044bd",+ "method": "probe",+ "observedAt": "2026-10-11T22:07:58.018Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "claude-code",+ "sourceCollectorId": "claude-code-models-docs",+ "confidence": "scrape_verified",+ "routeStatus": "mapped",+ "route": {+ "routeId": "anthropic",+ "routeProfileId": "claude-code-subscription"+ },+ "externalModelId": "claude-sonnet-5-5",+ "reasoning": {+ "mode": {+ "status": "unknown"+ },+ "request": {+ "status": "supported",+ "api": "anthropic-messages",+ "evidenceSourceUrl": "https://platform.claude.com/docs/en/build-with-claude/effort",+ "enable": [+ {+ "path": "/thinking/type",+ "value": "adaptive"+ }+ ],+ "disable": [+ {+ "path": "/thinking/type",+ "value": "between_tools"+ }+ ],+ "effort": {+ "path": "/output_config/effort",+ "values": {+ "max": "max",+ "xhigh": "xhigh",+ "high": "high",+ "medium": "medium",+ "low": "low"+ },+ "default": "high"+ }+ }+ },+ "wire": {+ "status": "known",+ "api": "anthropic-messages",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": [+ {+ "path": "/thinking/type",+ "value": "adaptive"+ }+ ],+ "disable": [+ {+ "path": "/thinking/type",+ "value": "between_tools"+ }+ ],+ "effort": {+ "path": "/output_config/effort",+ "values": {+ "max": "max",+ "xhigh": "xhigh",+ "high": "high",+ "medium": "medium",+ "low": "low"+ },+ "default": "high"+ },+ "mode": {+ "status": "unknown"+ }+ },+ "speed": {+ "status": "rejected",+ "path": "/speed"+ },+ "evidence": [+ {+ "evidenceId": "wev_07c27a8e778809a1e3f472e3820e1652",+ "method": "docs",+ "sourceUrl": "https://platform.claude.com/docs/en/build-with-claude/effort",+ "observedAt": "2026-10-12T10:09:46.396Z"+ },+ {+ "evidenceId": "wev_1c05b2963d2ec0507c5269ffa03ff195",+ "method": "docs",+ "sourceUrl": "https://platform.claude.com/docs/en/models/sonnet-5-5/migration-guide.md",+ "observedAt": "2026-10-12T10:09:52.112Z"+ },+ {+ "evidenceId": "wev_3c8ccd05992b57b3214261f3ffe9c9d9",+ "method": "docs",+ "sourceUrl": "https://code.claude.com/docs/en/llm-gateway-protocol.md",+ "observedAt": "2026-10-12T10:09:32.601Z"+ },+ {+ "evidenceId": "wev_8ab9783263f78ac21ee3fef37dc1acfe",+ "method": "docs",+ "sourceUrl": "https://platform.claude.com/docs/en/build-with-claude/fast-mode.md",+ "observedAt": "2026-10-12T10:09:45.314Z"+ },+ {+ "evidenceId": "wev_ade9942a6980f3e7e606511adb6501a9",+ "method": "docs",+ "sourceUrl": "https://platform.claude.com/docs/en/build-with-claude/effort",+ "observedAt": "2026-10-12T10:09:46.396Z"+ },+ {+ "evidenceId": "wev_b7747e0ddcc4d98be3eb5911a8086b7a",+ "method": "docs",+ "sourceUrl": "https://code.claude.com/docs/en/fast-mode",+ "observedAt": "2026-10-12T10:09:25.584Z"+ },+ {+ "evidenceId": "wev_bce74ae0fdc8ccbb95af49606093bd54",+ "method": "docs",+ "sourceUrl": "https://platform.claude.com/docs/en/api/messages.md",+ "observedAt": "2026-10-12T10:09:46.503Z"+ },+ {+ "evidenceId": "wev_d934570efd22a63d9369ca16bff8e135",+ "method": "docs",+ "sourceUrl": "https://platform.claude.com/docs/en/build-with-claude/effort",+ "observedAt": "2026-10-12T10:09:46.396Z"+ },+ {+ "evidenceId": "wev_ee0517dbf797065838eb5c8035a07df3",+ "method": "docs",+ "sourceUrl": "https://platform.claude.com/docs/en/build-with-claude/effort",+ "observedAt": "2026-10-12T10:09:46.396Z"+ },+ {+ "evidenceId": "wev_ef400d98b9ab5c5298e2dd69e1ed61fe",+ "method": "docs",+ "sourceUrl": "https://platform.claude.com/docs/en/build-with-claude/effort",+ "observedAt": "2026-10-12T10:09:46.396Z"+ },+ {+ "evidenceId": "wev_ffbcf4001f07fc74fe679004a6fcd78a",+ "method": "docs",+ "sourceUrl": "https://platform.claude.com/docs/en/models/sonnet-5-5/migration-guide.md",+ "observedAt": "2026-10-12T10:09:52.112Z"+ },+ {+ "evidenceId": "wev_c8c9ed7f7137d959e6e32cd389cd5eb3",+ "method": "probe",+ "observedAt": "2026-10-11T22:07:51.220Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "opencode-zen",+ "sourceCollectorId": "opencode-zen-api",+ "confidence": "gateway_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "opencode",+ "routeProfileId": "zen"+ },+ "externalModelId": "claude-sonnet-5-5",+ "pricing": {+ "type": "flat",+ "input": 2,+ "output": 10,+ "cachedRead": 0.2,+ "cachedWrite": 2.5+ },+ "reasoning": {+ "mode": {+ "status": "unknown"+ },+ "request": {+ "status": "supported",+ "api": "anthropic-messages",+ "evidenceSourceUrl": "https://platform.claude.com/docs/en/build-with-claude/effort",+ "enable": [+ {+ "path": "/thinking/type",+ "value": "adaptive"+ }+ ],+ "disable": [+ {+ "path": "/thinking/type",+ "value": "between_tools"+ }+ ],+ "effort": {+ "path": "/output_config/effort",+ "values": {+ "max": "max",+ "xhigh": "xhigh",+ "high": "high",+ "medium": "medium",+ "low": "low"+ },+ "default": "high"+ }+ }+ },+ "wire": {+ "status": "known",+ "api": "anthropic-messages",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": [+ {+ "path": "/thinking/type",+ "value": "adaptive"+ }+ ],+ "disable": [+ {+ "path": "/thinking/type",+ "value": "between_tools"+ }+ ],+ "effort": {+ "path": "/output_config/effort",+ "values": {+ "max": "max",+ "xhigh": "xhigh",+ "high": "high",+ "medium": "medium",+ "low": "low"+ },+ "default": "high"+ },+ "mode": {+ "status": "unknown"+ }+ },+ "speed": {+ "status": "unknown"+ },+ "evidence": [+ {+ "evidenceId": "wev_10c4f73d600b82d2eb98b831dcb24529",+ "method": "docs",+ "sourceUrl": "https://platform.claude.com/docs/en/build-with-claude/effort",+ "observedAt": "2026-10-12T10:09:46.396Z"+ },+ {+ "evidenceId": "wev_393a13fccd276354883234388321c876",+ "method": "docs",+ "sourceUrl": "https://platform.claude.com/docs/en/build-with-claude/effort",+ "observedAt": "2026-10-12T10:09:46.396Z"+ },+ {+ "evidenceId": "wev_b958b7646e7b65fcf3448bb338e3521c",+ "method": "docs",+ "sourceUrl": "https://platform.claude.com/docs/en/build-with-claude/effort",+ "observedAt": "2026-10-12T10:09:46.396Z"+ },+ {+ "evidenceId": "wev_e9f275bec60e0c9c2692e29a3933e70c",+ "method": "docs",+ "sourceUrl": "https://platform.claude.com/docs/en/build-with-claude/effort",+ "observedAt": "2026-10-12T10:09:46.396Z"+ },+ {+ "evidenceId": "wev_ec517ed8602adfb8848d7ec396ae5808",+ "method": "docs",+ "sourceUrl": "https://platform.claude.com/docs/en/build-with-claude/effort",+ "observedAt": "2026-10-12T10:09:46.396Z"+ },+ {+ "evidenceId": "wev_39970e4374188e70543dc9c5d9448cd8",+ "method": "endpoint-table",+ "sourceUrl": "https://opencode.ai/docs/en/zen/",+ "observedAt": "2026-10-12T10:09:23.090Z"+ },+ {+ "evidenceId": "wev_292e32152052363b04179eac86c14589",+ "method": "probe",+ "observedAt": "2026-10-09T12:40:38.011Z"+ },+ {+ "evidenceId": "wev_3ce226c8fe8fbe8cca60456d45c441d2",+ "method": "probe",+ "observedAt": "2026-10-09T12:40:41.572Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "openrouter",+ "sourceCollectorId": "openrouter-api",+ "confidence": "aggregator_reported",+ "routeStatus": "mapped",+ "route": {+ "routeId": "openrouter",+ "routeProfileId": "gateway"+ },+ "externalModelId": "anthropic/claude-sonnet-5.5",+ "pricing": {+ "type": "flat",+ "input": 2,+ "output": 10,+ "cachedRead": 0.1,+ "batchDiscountPct": 50+ },+ "reasoning": {+ "request": {+ "status": "supported",+ "api": "chat-completions",+ "evidenceSourceUrl": "https://openrouter.ai/api/v1/models",+ "enable": [+ {+ "path": "/reasoning/enabled",+ "value": true+ }+ ],+ "effort": {+ "path": "/reasoning/effort",+ "values": {+ "max": "max",+ "xhigh": "xhigh",+ "high": "high",+ "medium": "medium",+ "low": "low"+ },+ "default": "high"+ }+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": [+ {+ "path": "/reasoning/enabled",+ "value": true+ }+ ],+ "disable": {+ "status": "not_applicable"+ },+ "effort": {+ "path": "/reasoning/effort",+ "values": {+ "max": "max",+ "xhigh": "xhigh",+ "high": "high",+ "medium": "medium",+ "low": "low"+ },+ "default": "high"+ },+ "mode": {+ "status": "not_applicable"+ }+ },+ "speed": {+ "status": "not_applicable"+ },+ "evidence": [+ {+ "evidenceId": "wev_05fdaab6356e6a5649e01466a928f22b",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_36b495ed2660a6aa10e9bba461cba91c",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models/anthropic/claude-sonnet-5.5/endpoints",+ "observedAt": "2026-10-12T10:09:32.471Z"+ },+ {+ "evidenceId": "wev_89a975e3edd3e98f1ae0f87a53718c89",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_921d5cc91275e2e0712169a5c908b865",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_c3cc2fcb23731fd8b2dc7d2ef6d9ff40",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_d7ca9712f357674b528221adfebaa4e5",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_f59204a4814fb69084b7b29a95ba807d",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_0c3e3969fc0106186c680cf2f04ad893",+ "method": "docs",+ "sourceUrl": "https://openrouter.ai/docs/guides/best-practices/reasoning-tokens",+ "observedAt": "2026-10-12T10:09:52.321Z"+ },+ {+ "evidenceId": "wev_dabda36fb5590d13a8282b3a12579af7",+ "method": "docs",+ "sourceUrl": "https://openrouter.ai/docs/guides/best-practices/reasoning-tokens",+ "observedAt": "2026-10-12T10:09:52.321Z"+ },+ {+ "evidenceId": "wev_fe623944b4926073e33486aabc73bc59",+ "method": "docs",+ "sourceUrl": "https://openrouter.ai/docs/guides/best-practices/reasoning-tokens",+ "observedAt": "2026-10-12T10:09:52.321Z"+ },+ {+ "evidenceId": "wev_26be17872219c51f9752c611e38a246d",+ "method": "probe",+ "observedAt": "2026-10-11T20:34:24.493Z"+ },+ {+ "evidenceId": "wev_f71a901e9cc4fa555cd0afa183701f6e",+ "method": "probe",+ "observedAt": "2026-10-11T20:34:31.192Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "openrouter",+ "sourceCollectorId": "openrouter-api",+ "confidence": "aggregator_reported",+ "routeStatus": "unknown",+ "reason": "unverified_mapping",+ "observedExternalModelId": "anthropic/claude-sonnet-5.5:batch"+ },+ {+ "sourceProviderId": "poe",+ "sourceCollectorId": "poe-api",+ "confidence": "aggregator_reported",+ "routeStatus": "mapped",+ "route": {+ "routeId": "poe",+ "routeProfileId": "gateway"+ },+ "externalModelId": "claude-sonnet-5.5",+ "pricing": {+ "type": "flat",+ "input": 2.0202,+ "output": 10.101,+ "cachedRead": 0.202+ },+ "probeEligible": true,+ "reasoning": {+ "request": {+ "status": "supported",+ "api": "chat-completions",+ "evidenceSourceUrl": "https://api.poe.com/v1/models",+ "effort": {+ "path": "/effort",+ "values": {+ "max": "max",+ "xhigh": "xhigh",+ "high": "high",+ "medium": "medium",+ "low": "low"+ },+ "default": "high"+ }+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": {+ "status": "unknown"+ },+ "reasoning": {+ "status": "supported",+ "enable": {+ "status": "unknown"+ },+ "disable": {+ "status": "unknown"+ },+ "effort": {+ "path": "/effort",+ "values": {+ "max": "max",+ "xhigh": "xhigh",+ "high": "high",+ "medium": "medium",+ "low": "low"+ },+ "default": "high"+ },+ "mode": {+ "status": "not_applicable"+ }+ },+ "speed": {+ "status": "rejected",+ "path": "/service_tier"+ },+ "evidence": [+ {+ "evidenceId": "wev_2b5c8cce956b08ee052c3c3e2f869d12",+ "method": "api",+ "sourceUrl": "https://api.poe.com/v1/models",+ "observedAt": "2026-10-12T10:09:22.802Z"+ },+ {+ "evidenceId": "wev_7c0ddd33f191c8fbd440db2116c0f726",+ "method": "api",+ "sourceUrl": "https://api.poe.com/v1/models",+ "observedAt": "2026-10-12T10:09:22.802Z"+ },+ {+ "evidenceId": "wev_86cea8e72602b70fd089eb0819b9f1fd",+ "method": "api",+ "sourceUrl": "https://api.poe.com/v1/models",+ "observedAt": "2026-10-12T10:09:22.802Z"+ },+ {+ "evidenceId": "wev_b5747703ee0a2f015b8287a42675c407",+ "method": "api",+ "sourceUrl": "https://api.poe.com/v1/models",+ "observedAt": "2026-10-12T10:09:22.802Z"+ },+ {+ "evidenceId": "wev_b1feeaf09c0d7a30089f483d93342ae6",+ "method": "docs",+ "sourceUrl": "https://creator.poe.com/docs/external-applications/openai-compatible-api",+ "observedAt": "2026-10-12T10:09:33.306Z"+ },+ {+ "evidenceId": "wev_ef133e031dc26cfd019d7232a82dab69",+ "method": "docs",+ "sourceUrl": "https://creator.poe.com/docs/external-applications/openai-compatible-api",+ "observedAt": "2026-10-12T10:09:33.306Z"+ },+ {+ "evidenceId": "wev_12bb320e99c750e166fa786f321bd195",+ "method": "probe",+ "observedAt": "2026-10-11T19:47:23.016Z"+ },+ {+ "evidenceId": "wev_3957173b14684285d216ac1fdf19a900",+ "method": "probe",+ "observedAt": "2026-10-11T19:47:20.390Z"+ },+ {+ "evidenceId": "wev_8a220374596c1a64c3153c4b5cc174ce",+ "method": "probe",+ "observedAt": "2026-10-11T19:47:14.310Z"+ },+ {+ "evidenceId": "wev_c850fcd7efb471101bf0550db6905361",+ "method": "probe",+ "observedAt": "2026-10-11T19:47:23.016Z"+ }+ ]+ }+ }+ ],+ "supportsVision": true,+ "supportsTools": true,+ "videoInput": false,+ "videoOutput": false,+ "reasoning": {+ "supported": true,+ "mandatory": false,+ "control": "adaptive",+ "efforts": [+ "max",+ "xhigh",+ "high",+ "medium",+ "low"+ ],+ "defaultEffort": "high",+ "supportsBudgetTokens": false+ },+ "endpoints": {+ "anthropic": {+ "api": "anthropic-messages",+ "toolsWithReasoning": "ok"+ }+ },+ "tokenParam": "max_tokens"+ },+ {+ "contractVersion": 3,+ "modelId": "claude-opus-5-5",+ "displayName": "Claude Opus 5.5",+ "provider": "anthropic",+ "aliases": [+ "anthropic/claude-opus-5.5",+ "anthropic/claude-opus-5.5:batch"+ ],+ "status": "active",+ "releaseDate": "2026-09-22",+ "contextWindow": 1000000,+ "maxOutputTokens": 128000,+ "subscriptionPlanIds": [+ "anthropic-claude-code"+ ],+ "inputModalities": [+ "image",+ "text"+ ],+ "outputModalities": [+ "text"+ ],+ "aggregators": [+ {+ "sourceProviderId": "anthropic",+ "sourceCollectorId": "anthropic-api",+ "confidence": "api_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "anthropic",+ "routeProfileId": "direct-api"+ },+ "externalModelId": "claude-opus-5-5",+ "pricing": {+ "type": "unavailable"+ },+ "reasoning": {+ "mode": {+ "status": "rejected"+ },+ "request": {+ "status": "supported",+ "api": "anthropic-messages",+ "evidenceSourceUrl": "https://platform.claude.com/docs/en/build-with-claude/effort",+ "effort": {+ "path": "/output_config/effort",+ "values": {+ "max": "max",+ "xhigh": "xhigh",+ "high": "high",+ "medium": "medium",+ "low": "low"+ },+ "default": "medium"+ }+ }+ },+ "wire": {+ "status": "known",+ "api": "anthropic-messages",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": {+ "status": "not_applicable"+ },+ "disable": {+ "status": "not_applicable"+ },+ "effort": {+ "path": "/output_config/effort",+ "values": {+ "max": "max",+ "xhigh": "xhigh",+ "high": "high",+ "medium": "medium",+ "low": "low"+ },+ "default": "medium"+ },+ "mode": {+ "status": "rejected",+ "path": "/reasoning/mode"+ }+ },+ "speed": {+ "status": "supported",+ "path": "/speed",+ "values": {+ "standard": "standard",+ "fast": "fast"+ },+ "default": "standard",+ "headers": [+ {+ "name": "anthropic-beta",+ "value": "fast-mode-2026-02-01",+ "merge": "append-comma"+ }+ ],+ "echo": "/usage/speed",+ "access": "entitlement"+ },+ "evidence": [+ {+ "evidenceId": "wev_51fa50882fdc4285ba16674c0726c3a4",+ "method": "docs",+ "sourceUrl": "https://platform.claude.com/docs/en/cli-sdks-libraries/libraries/openai-sdk.md",+ "observedAt": "2026-10-12T10:09:51.974Z"+ },+ {+ "evidenceId": "wev_a11f5afb688026a057861c76b9223aed",+ "method": "docs",+ "sourceUrl": "https://platform.claude.com/docs/en/build-with-claude/effort",+ "observedAt": "2026-10-12T10:09:46.396Z"+ },+ {+ "evidenceId": "wev_ac9bff5ef25d4fda0fc4e3ecb1eb1faa",+ "method": "docs",+ "sourceUrl": "https://platform.claude.com/docs/en/build-with-claude/effort",+ "observedAt": "2026-10-12T10:09:46.396Z"+ },+ {+ "evidenceId": "wev_aed569accb9847693b4e0f7d502e6148",+ "method": "docs",+ "sourceUrl": "https://platform.claude.com/docs/en/api/beta/messages/create.md",+ "observedAt": "2026-10-12T10:09:45.666Z"+ },+ {+ "evidenceId": "wev_b4a2340d5b435ab1c9333eeb26658355",+ "method": "docs",+ "sourceUrl": "https://platform.claude.com/docs/en/build-with-claude/effort",+ "observedAt": "2026-10-12T10:09:46.396Z"+ },+ {+ "evidenceId": "wev_be0a1e69e98b419cdb0ed57614342cf8",+ "method": "docs",+ "sourceUrl": "https://platform.claude.com/docs/en/build-with-claude/fast-mode.md",+ "observedAt": "2026-10-12T10:09:45.314Z"+ },+ {+ "evidenceId": "wev_e6a00d62561146dbf05cca91a87d4db3",+ "method": "docs",+ "sourceUrl": "https://platform.claude.com/docs/en/build-with-claude/effort",+ "observedAt": "2026-10-12T10:09:46.396Z"+ },+ {+ "evidenceId": "wev_ee3e82a1f7339afeda2c718604192fa8",+ "method": "docs",+ "sourceUrl": "https://platform.claude.com/docs/en/build-with-claude/effort",+ "observedAt": "2026-10-12T10:09:46.396Z"+ },+ {+ "evidenceId": "wev_f0bad8a579207a1b0528360519ec4189",+ "method": "docs",+ "sourceUrl": "https://platform.claude.com/docs/en/api/messages.md",+ "observedAt": "2026-10-12T10:09:46.503Z"+ },+ {+ "evidenceId": "wev_1d13378f879aa7514f157b844191ae79",+ "method": "probe",+ "observedAt": "2026-10-11T22:06:45.221Z"+ },+ {+ "evidenceId": "wev_7229af1869fb8c5a3673d69fb1886fcc",+ "method": "probe",+ "observedAt": "2026-10-11T22:06:45.221Z"+ },+ {+ "evidenceId": "wev_a074a2e72e2af3237751ca850c841994",+ "method": "probe",+ "observedAt": "2026-10-11T22:06:39.950Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "claude-code",+ "sourceCollectorId": "claude-code-models-docs",+ "confidence": "scrape_verified",+ "routeStatus": "mapped",+ "route": {+ "routeId": "anthropic",+ "routeProfileId": "claude-code-subscription"+ },+ "externalModelId": "claude-opus-5-5",+ "reasoning": {+ "mode": {+ "status": "unknown"+ },+ "request": {+ "status": "supported",+ "api": "anthropic-messages",+ "evidenceSourceUrl": "https://platform.claude.com/docs/en/build-with-claude/effort",+ "effort": {+ "path": "/output_config/effort",+ "values": {+ "max": "max",+ "xhigh": "xhigh",+ "high": "high",+ "medium": "medium",+ "low": "low"+ },+ "default": "medium"+ }+ }+ },+ "wire": {+ "status": "known",+ "api": "anthropic-messages",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": {+ "status": "not_applicable"+ },+ "disable": {+ "status": "not_applicable"+ },+ "effort": {+ "path": "/output_config/effort",+ "values": {+ "max": "max",+ "xhigh": "xhigh",+ "high": "high",+ "medium": "medium",+ "low": "low"+ },+ "default": "medium"+ },+ "mode": {+ "status": "unknown"+ }+ },+ "speed": {+ "status": "unknown"+ },+ "evidence": [+ {+ "evidenceId": "wev_04873ae8126a73abbe714b3156205e16",+ "method": "docs",+ "sourceUrl": "https://platform.claude.com/docs/en/build-with-claude/effort",+ "observedAt": "2026-10-12T10:09:46.396Z"+ },+ {+ "evidenceId": "wev_0936e0c54ef017fc10897e77f6852f9d",+ "method": "docs",+ "sourceUrl": "https://platform.claude.com/docs/en/build-with-claude/effort",+ "observedAt": "2026-10-12T10:09:46.396Z"+ },+ {+ "evidenceId": "wev_139102a2decc091c0956f48109bda0ed",+ "method": "docs",+ "sourceUrl": "https://platform.claude.com/docs/en/build-with-claude/effort",+ "observedAt": "2026-10-12T10:09:46.396Z"+ },+ {+ "evidenceId": "wev_706c1310fa40d9493ce26309c1b63d85",+ "method": "docs",+ "sourceUrl": "https://platform.claude.com/docs/en/build-with-claude/effort",+ "observedAt": "2026-10-12T10:09:46.396Z"+ },+ {+ "evidenceId": "wev_92d1f90e014894cbb8d29445a0b184e2",+ "method": "docs",+ "sourceUrl": "https://platform.claude.com/docs/en/build-with-claude/effort",+ "observedAt": "2026-10-12T10:09:46.396Z"+ },+ {+ "evidenceId": "wev_baa1a54e383304f28bf798cf82dccbb9",+ "method": "docs",+ "sourceUrl": "https://platform.claude.com/docs/en/api/messages.md",+ "observedAt": "2026-10-12T10:09:46.503Z"+ },+ {+ "evidenceId": "wev_f38f0f125ca7089d573c44e228ce8970",+ "method": "docs",+ "sourceUrl": "https://code.claude.com/docs/en/llm-gateway-protocol.md",+ "observedAt": "2026-10-12T10:09:32.601Z"+ },+ {+ "evidenceId": "wev_ee864cb065952bf6a9efe8f08cb089d6",+ "method": "probe",+ "observedAt": "2026-10-11T22:04:36.871Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "opencode-zen",+ "sourceCollectorId": "opencode-zen-api",+ "confidence": "gateway_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "opencode",+ "routeProfileId": "zen"+ },+ "externalModelId": "claude-opus-5-5",+ "pricing": {+ "type": "flat",+ "input": 4,+ "output": 20,+ "cachedRead": 0.2,+ "cachedWrite": 5+ },+ "reasoning": {+ "request": {+ "status": "unknown"+ }+ },+ "wire": {+ "status": "known",+ "api": "anthropic-messages",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": {+ "status": "unknown"+ },+ "reasoning": {+ "status": "unknown"+ },+ "speed": {+ "status": "unknown"+ },+ "evidence": [+ {+ "evidenceId": "wev_c3f211eefe58a5ca0d2e7f79210d7f5e",+ "method": "endpoint-table",+ "sourceUrl": "https://opencode.ai/docs/en/zen/",+ "observedAt": "2026-10-12T10:09:23.090Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "openrouter",+ "sourceCollectorId": "openrouter-api",+ "confidence": "aggregator_reported",+ "routeStatus": "mapped",+ "route": {+ "routeId": "openrouter",+ "routeProfileId": "gateway"+ },+ "externalModelId": "anthropic/claude-opus-5.5",+ "pricing": {+ "type": "flat",+ "input": 4,+ "output": 20,+ "cachedRead": 0.2,+ "batchDiscountPct": 50+ },+ "reasoning": {+ "request": {+ "status": "supported",+ "api": "chat-completions",+ "evidenceSourceUrl": "https://openrouter.ai/api/v1/models",+ "enable": [+ {+ "path": "/reasoning/enabled",+ "value": true+ }+ ],+ "effort": {+ "path": "/reasoning/effort",+ "values": {+ "max": "max",+ "xhigh": "xhigh",+ "high": "high",+ "medium": "medium",+ "low": "low"+ },+ "default": "high"+ }+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": [+ {+ "path": "/reasoning/enabled",+ "value": true+ }+ ],+ "disable": {+ "status": "not_applicable"+ },+ "effort": {+ "path": "/reasoning/effort",+ "values": {+ "max": "max",+ "xhigh": "xhigh",+ "high": "high",+ "medium": "medium",+ "low": "low"+ },+ "default": "high"+ },+ "mode": {+ "status": "not_applicable"+ }+ },+ "speed": {+ "status": "supported",+ "path": "/service_tier",+ "values": {+ "fast": "priority"+ },+ "default": "standard",+ "headers": [],+ "echo": "/service_tier",+ "access": "open"+ },+ "evidence": [+ {+ "evidenceId": "wev_05caad13d5ba08d16529cea49023df7a",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models/anthropic/claude-opus-5.5/endpoints",+ "observedAt": "2026-10-12T10:09:35.712Z"+ },+ {+ "evidenceId": "wev_18480fdd60d11a843fdd96732e69b692",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_497abff360ec3cc0dcb49eeca2fc5918",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_6c6d5dc07a5f5e4a284aa2779800f702",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_6ddfa100bc01437a73537aa4bd9f9914",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_83839123a7a107758488aaeb3e5181e8",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_bfe5d37cb0e8e17a4034ea2d6c928ac7",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_49402fe032800bcda74b9ed81a150542",+ "method": "docs",+ "sourceUrl": "https://openrouter.ai/docs/guides/best-practices/reasoning-tokens",+ "observedAt": "2026-10-12T10:09:52.321Z"+ },+ {+ "evidenceId": "wev_b3025627b73c1150596e94625693c068",+ "method": "docs",+ "sourceUrl": "https://openrouter.ai/docs/guides/best-practices/reasoning-tokens",+ "observedAt": "2026-10-12T10:09:52.321Z"+ },+ {+ "evidenceId": "wev_ba4ad8702c07c0b3c2a458bc0f6b595b",+ "method": "docs",+ "sourceUrl": "https://openrouter.ai/docs/guides/best-practices/reasoning-tokens",+ "observedAt": "2026-10-12T10:09:52.321Z"+ },+ {+ "evidenceId": "wev_97acf9b5352538f30b78966cd05e17cb",+ "method": "probe",+ "observedAt": "2026-10-11T19:59:11.268Z"+ },+ {+ "evidenceId": "wev_aebf89346041ca49af8bd2a8d95d5d6a",+ "method": "probe",+ "observedAt": "2026-10-11T19:59:26.456Z"+ },+ {+ "evidenceId": "wev_f99cc71a10927fa9183c59603b34d8f6",+ "method": "probe",+ "observedAt": "2026-10-11T19:59:24.171Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "openrouter",+ "sourceCollectorId": "openrouter-api",+ "confidence": "aggregator_reported",+ "routeStatus": "unknown",+ "reason": "unverified_mapping",+ "observedExternalModelId": "anthropic/claude-opus-5.5:batch"+ }+ ],+ "supportsVision": true,+ "supportsTools": true,+ "videoInput": false,+ "videoOutput": false,+ "reasoning": {+ "supported": true,+ "mandatory": true,+ "control": "adaptive",+ "efforts": [+ "max",+ "xhigh",+ "high",+ "medium",+ "low"+ ],+ "defaultEffort": "medium",+ "supportsBudgetTokens": false+ },+ "endpoints": {+ "anthropic": {+ "api": "anthropic-messages",+ "toolsWithReasoning": "ok"+ }+ },+ "tokenParam": "max_tokens"+ },+ {+ "contractVersion": 3,+ "modelId": "gpt-6-sol",+ "displayName": "GPT-6-Sol",+ "provider": "openai",+ "aliases": [+ "openai/gpt-6-sol",+ "openai/gpt-6-sol:batch"+ ],+ "status": "active",+ "releaseDate": "2026-09-22",+ "contextWindow": 1050000,+ "maxOutputTokens": 128000,+ "subscriptionPlanIds": [+ "openai-codex"+ ],+ "inputModalities": [+ "image",+ "text"+ ],+ "outputModalities": [+ "text"+ ],+ "aggregators": [+ {+ "sourceProviderId": "openai-codex",+ "sourceCollectorId": "openai-codex-models",+ "confidence": "scrape_verified",+ "routeStatus": "mapped",+ "route": {+ "routeId": "openai",+ "routeProfileId": "codex-subscription"+ },+ "externalModelId": "gpt-6-sol",+ "reasoning": {+ "mode": {+ "status": "rejected"+ },+ "request": {+ "status": "unknown"+ }+ },+ "wire": {+ "status": "known",+ "api": "responses",+ "tokenParam": "max_output_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": {+ "status": "unknown"+ },+ "disable": {+ "status": "unknown"+ },+ "effort": {+ "path": "/reasoning/effort",+ "values": {+ "max": "max",+ "xhigh": "xhigh",+ "high": "high",+ "medium": "medium",+ "low": "low",+ "none": "none"+ },+ "default": {+ "status": "unknown"+ }+ },+ "mode": {+ "status": "rejected",+ "path": "/reasoning/mode"+ }+ },+ "speed": {+ "status": "unknown"+ },+ "evidence": [+ {+ "evidenceId": "wev_fc1ec3f5857fc51097713aeee7eb0408",+ "method": "docs",+ "sourceUrl": "https://developers.openai.com/codex/config-reference.md",+ "observedAt": "2026-10-12T10:09:53.088Z"+ },+ {+ "evidenceId": "wev_6a5a73b2c40b72ac43dac8e7b65f84a1",+ "method": "probe",+ "observedAt": "2026-10-11T22:04:36.680Z"+ },+ {+ "evidenceId": "wev_7c09e581680584d52eb34d2967dd89f3",+ "method": "probe",+ "observedAt": "2026-10-11T22:04:35.105Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "openai",+ "sourceCollectorId": "openai-api",+ "confidence": "api_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "openai",+ "routeProfileId": "direct-api"+ },+ "externalModelId": "gpt-6-sol",+ "pricing": {+ "type": "flat",+ "input": 2,+ "output": 10,+ "cachedRead": 0.2,+ "cachedWrite": 2.5+ },+ "reasoning": {+ "mode": {+ "status": "supported",+ "values": [+ "standard",+ "pro"+ ],+ "default": "standard"+ },+ "request": {+ "status": "supported",+ "api": "responses",+ "evidenceSourceUrl": "https://developers.openai.com/api/reference/resources/responses.md",+ "effort": {+ "path": "/reasoning/effort",+ "values": {+ "max": "max",+ "xhigh": "xhigh",+ "high": "high",+ "medium": "medium",+ "low": "low",+ "none": "none"+ },+ "default": "medium"+ }+ }+ },+ "wire": {+ "status": "known",+ "api": "responses",+ "tokenParam": "max_output_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": {+ "status": "unknown"+ },+ "disable": {+ "status": "unknown"+ },+ "effort": {+ "path": "/reasoning/effort",+ "values": {+ "max": "max",+ "xhigh": "xhigh",+ "high": "high",+ "medium": "medium",+ "low": "low",+ "none": "none"+ },+ "default": "medium"+ },+ "mode": {+ "status": "supported",+ "path": "/reasoning/mode",+ "values": {+ "standard": "standard",+ "pro": "pro"+ },+ "default": "standard",+ "headers": [],+ "echo": "/reasoning/mode",+ "access": "open"+ }+ },+ "speed": {+ "status": "supported",+ "path": "/service_tier",+ "values": {+ "standard": "default",+ "fast": "priority",+ "flex": "flex"+ },+ "default": "standard",+ "headers": [],+ "echo": "/service_tier",+ "access": "open"+ },+ "evidence": [+ {+ "evidenceId": "wev_1d4e02868f12b5ee182ebbd0935cecbd",+ "method": "docs",+ "sourceUrl": "https://developers.openai.com/api/reference/resources/responses.md",+ "observedAt": "2026-10-12T10:09:54.840Z"+ },+ {+ "evidenceId": "wev_2f6e964cc2a43f6fc7045e5649058e72",+ "method": "docs",+ "sourceUrl": "https://developers.openai.com/api/reference/resources/responses.md",+ "observedAt": "2026-10-12T10:09:54.840Z"+ },+ {+ "evidenceId": "wev_8afd0c9795c786b5e49cde2eced7088d",+ "method": "docs",+ "sourceUrl": "https://developers.openai.com/api/reference/resources/responses.md",+ "observedAt": "2026-10-12T10:09:54.840Z"+ },+ {+ "evidenceId": "wev_a2ddc8b8406c566108e822376e7c3311",+ "method": "docs",+ "sourceUrl": "https://developers.openai.com/api/docs/models/gpt-6-sol.md",+ "observedAt": "2026-10-12T10:09:46.224Z"+ },+ {+ "evidenceId": "wev_c27b62a88f5c05739ed4524ca64a3023",+ "method": "docs",+ "sourceUrl": "https://developers.openai.com/api/docs/guides/reasoning",+ "observedAt": "2026-10-12T10:09:33.290Z"+ },+ {+ "evidenceId": "wev_c6c3d9261948df75ce35943aff3ad7f7",+ "method": "docs",+ "sourceUrl": "https://developers.openai.com/api/docs/models/gpt-6-sol.md",+ "observedAt": "2026-10-12T10:09:46.224Z"+ },+ {+ "evidenceId": "wev_c8655fb9671437e3d583ce12ccccdd64",+ "method": "docs",+ "sourceUrl": "https://developers.openai.com/api/docs/pricing.md",+ "observedAt": "2026-10-12T10:09:52.384Z"+ },+ {+ "evidenceId": "wev_d6b215709ae1286419f8a1753b00d4c7",+ "method": "docs",+ "sourceUrl": "https://developers.openai.com/api/docs/models/gpt-6-sol.md",+ "observedAt": "2026-10-12T10:09:46.224Z"+ },+ {+ "evidenceId": "wev_e9f01bfa9cfa84f1a1d55ac303306fef",+ "method": "docs",+ "sourceUrl": "https://developers.openai.com/api/reference/resources/responses.md",+ "observedAt": "2026-10-12T10:09:54.840Z"+ },+ {+ "evidenceId": "wev_4642980d99f37ac2bd06680fdfb52095",+ "method": "probe",+ "observedAt": "2026-10-11T22:03:55.452Z"+ },+ {+ "evidenceId": "wev_87d3580c2edd1b8df27d3d9a57caca41",+ "method": "probe",+ "observedAt": "2026-10-11T22:03:57.705Z"+ },+ {+ "evidenceId": "wev_fac8e5f5417e347626d4ed55af14c1f0",+ "method": "probe",+ "observedAt": "2026-10-11T22:03:55.147Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "opencode-zen",+ "sourceCollectorId": "opencode-zen-api",+ "confidence": "gateway_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "opencode",+ "routeProfileId": "zen"+ },+ "externalModelId": "gpt-6-sol",+ "pricing": {+ "type": "flat",+ "input": 2,+ "output": 10,+ "cachedRead": 0.2,+ "cachedWrite": 2.5+ },+ "reasoning": {+ "mode": {+ "status": "supported",+ "values": [+ "standard",+ "pro"+ ],+ "default": "standard"+ },+ "request": {+ "status": "supported",+ "api": "responses",+ "evidenceSourceUrl": "https://developers.openai.com/api/reference/resources/responses.md",+ "effort": {+ "path": "/reasoning/effort",+ "values": {+ "max": "max",+ "xhigh": "xhigh",+ "high": "high",+ "medium": "medium",+ "low": "low",+ "none": "none"+ },+ "default": "medium"+ }+ }+ },+ "wire": {+ "status": "known",+ "api": "responses",+ "tokenParam": "max_output_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": {+ "status": "unknown"+ },+ "disable": {+ "status": "unknown"+ },+ "effort": {+ "path": "/reasoning/effort",+ "values": {+ "max": "max",+ "xhigh": "xhigh",+ "high": "high",+ "medium": "medium",+ "low": "low",+ "none": "none"+ },+ "default": "medium"+ },+ "mode": {+ "status": "supported",+ "path": "/reasoning/mode",+ "values": {+ "standard": "standard",+ "pro": "pro"+ },+ "default": "standard",+ "headers": [],+ "echo": {+ "status": "not_applicable"+ },+ "access": "open"+ }+ },+ "speed": {+ "status": "unknown"+ },+ "evidence": [+ {+ "evidenceId": "wev_03a883ed84b3b48befd98470bba32271",+ "method": "docs",+ "sourceUrl": "https://developers.openai.com/api/docs/models/gpt-6-sol.md",+ "observedAt": "2026-10-12T10:09:46.224Z"+ },+ {+ "evidenceId": "wev_76dce9bb29e4487d176569baeb2ea0d7",+ "method": "docs",+ "sourceUrl": "https://developers.openai.com/api/reference/resources/responses.md",+ "observedAt": "2026-10-12T10:09:54.840Z"+ },+ {+ "evidenceId": "wev_83ca2615ffaa8cb9217625ecc2e02cba",+ "method": "docs",+ "sourceUrl": "https://developers.openai.com/api/docs/guides/reasoning",+ "observedAt": "2026-10-12T10:09:33.290Z"+ },+ {+ "evidenceId": "wev_9fb80bfca41d249fa2a0a29a0ba9d554",+ "method": "docs",+ "sourceUrl": "https://developers.openai.com/api/reference/resources/responses.md",+ "observedAt": "2026-10-12T10:09:54.840Z"+ },+ {+ "evidenceId": "wev_dc48d8523029cf8f3c0702efd7f892be",+ "method": "docs",+ "sourceUrl": "https://developers.openai.com/api/docs/models/gpt-6-sol.md",+ "observedAt": "2026-10-12T10:09:46.224Z"+ },+ {+ "evidenceId": "wev_7f0fb628df073c978e828a706c67376f",+ "method": "endpoint-table",+ "sourceUrl": "https://opencode.ai/docs/en/zen/",+ "observedAt": "2026-10-12T10:09:23.090Z"+ },+ {+ "evidenceId": "wev_80ce131a019ba39dd1d0bfd6089ea07b",+ "method": "probe",+ "observedAt": "2026-10-09T13:03:08.722Z"+ },+ {+ "evidenceId": "wev_a1c92000822985b42fbf5fc064940498",+ "method": "probe",+ "observedAt": "2026-10-09T12:39:46.744Z"+ },+ {+ "evidenceId": "wev_e35ae4d52bd09129c91213da764f63c7",+ "method": "probe",+ "observedAt": "2026-10-09T12:39:39.639Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "openrouter",+ "sourceCollectorId": "openrouter-api",+ "confidence": "aggregator_reported",+ "routeStatus": "mapped",+ "route": {+ "routeId": "openrouter",+ "routeProfileId": "gateway"+ },+ "externalModelId": "openai/gpt-6-sol",+ "pricing": {+ "type": "flat",+ "input": 2,+ "output": 10,+ "cachedRead": 0.2,+ "batchDiscountPct": 50+ },+ "reasoning": {+ "mode": {+ "status": "supported",+ "values": [+ "standard",+ "pro"+ ],+ "default": "standard"+ },+ "request": {+ "status": "supported",+ "api": "chat-completions",+ "evidenceSourceUrl": "https://openrouter.ai/api/v1/models",+ "enable": [+ {+ "path": "/reasoning/enabled",+ "value": true+ }+ ],+ "disable": [+ {+ "path": "/reasoning/effort",+ "value": "none"+ }+ ],+ "effort": {+ "path": "/reasoning/effort",+ "values": {+ "max": "max",+ "xhigh": "xhigh",+ "high": "high",+ "medium": "medium",+ "low": "low",+ "none": "none"+ },+ "default": "medium"+ }+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": [+ {+ "path": "/reasoning/enabled",+ "value": true+ }+ ],+ "disable": [+ {+ "path": "/reasoning/effort",+ "value": "none"+ }+ ],+ "effort": {+ "path": "/reasoning/effort",+ "values": {+ "max": "max",+ "xhigh": "xhigh",+ "high": "high",+ "medium": "medium",+ "low": "low",+ "none": "none"+ },+ "default": "medium"+ },+ "mode": {+ "status": "supported",+ "path": "/reasoning/mode",+ "values": {+ "standard": "standard",+ "pro": "pro"+ },+ "default": "standard",+ "headers": [],+ "echo": {+ "status": "not_applicable"+ },+ "access": "open"+ }+ },+ "speed": {+ "status": "supported",+ "path": "/service_tier",+ "values": {+ "fast": "priority",+ "flex": "flex"+ },+ "default": "standard",+ "headers": [],+ "echo": "/service_tier",+ "access": "open"+ },+ "evidence": [+ {+ "evidenceId": "wev_04009ebfb5489a82215d666b9e08ecf0",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_4c6572d298d491c92588f3d32bbbdece",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_7ea19f152037dcaa581ddf795d970730",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_7f0f54054f906a0724d33d5a39660d2f",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_a38f268894117461e2d63502fc769b63",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_adea36f6e19552e6f29be22d11b18c8a",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models/openai/gpt-6-sol/endpoints",+ "observedAt": "2026-10-12T10:09:35.697Z"+ },+ {+ "evidenceId": "wev_ccd473d3a5516848397d302b107cb9f7",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_fc315244f801790b29f2c5e32e5304bb",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_416254a17934f1586d22adf390d472f8",+ "method": "docs",+ "sourceUrl": "https://openrouter.ai/docs/guides/best-practices/reasoning-tokens",+ "observedAt": "2026-10-12T10:09:52.321Z"+ },+ {+ "evidenceId": "wev_8b225f4e096afa4bd1d205b08d9e7bf0",+ "method": "docs",+ "sourceUrl": "https://openrouter.ai/docs/guides/best-practices/reasoning-tokens",+ "observedAt": "2026-10-12T10:09:52.321Z"+ },+ {+ "evidenceId": "wev_183e92cf5672d6287af715144e09a719",+ "method": "probe",+ "observedAt": "2026-10-11T19:15:58.886Z"+ },+ {+ "evidenceId": "wev_7e0ba307d821c3c736453deedd0b2bee",+ "method": "probe",+ "observedAt": "2026-10-11T19:15:57.727Z"+ },+ {+ "evidenceId": "wev_d09b578cf486af89e99eab36357e6688",+ "method": "probe",+ "observedAt": "2026-10-11T19:15:59.329Z"+ },+ {+ "evidenceId": "wev_f587a1260a08ba1d7fa64ad817c03623",+ "method": "probe",+ "observedAt": "2026-10-11T19:15:56.162Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "openrouter",+ "sourceCollectorId": "openrouter-api",+ "confidence": "aggregator_reported",+ "routeStatus": "unknown",+ "reason": "unverified_mapping",+ "observedExternalModelId": "openai/gpt-6-sol:batch"+ }+ ],+ "supportsVision": true,+ "supportsTools": true,+ "videoInput": false,+ "videoOutput": false,+ "reasoning": {+ "supported": true,+ "mandatory": false,+ "control": "effort",+ "efforts": [+ "max",+ "xhigh",+ "high",+ "medium",+ "low",+ "none"+ ],+ "defaultEffort": "medium"+ },+ "endpoints": {+ "openai": {+ "api": "responses",+ "toolsWithReasoning": "ok"+ }+ },+ "tokenParam": "max_output_tokens"+ },+ {+ "contractVersion": 3,+ "modelId": "grok-4.7",+ "displayName": "Grok 4.7",+ "provider": "x-ai",+ "aliases": [+ "x-ai/grok-4.7"+ ],+ "status": "active",+ "releaseDate": "2026-09-21",+ "contextWindow": 500000,+ "subscriptionPlanIds": [+ "opencode-go",+ "opencode-go-plus"+ ],+ "inputModalities": [+ "image",+ "text"+ ],+ "outputModalities": [+ "text"+ ],+ "aggregators": [+ {+ "sourceProviderId": "opencode-go",+ "sourceCollectorId": "popular-coding-subscriptions",+ "confidence": "gateway_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "opencode",+ "routeProfileId": "go-subscription"+ },+ "externalModelId": "grok-4.7",+ "reasoning": {+ "mode": {+ "status": "unknown"+ },+ "request": {+ "status": "supported",+ "api": "responses",+ "evidenceSourceUrl": "https://docs.x.ai/developers/model-capabilities/text/reasoning",+ "effort": {+ "path": "/reasoning/effort",+ "values": {+ "low": "low",+ "medium": "medium",+ "high": "high",+ "xhigh": "xhigh"+ },+ "default": "high"+ }+ }+ },+ "wire": {+ "status": "known",+ "api": "responses",+ "tokenParam": "max_output_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": {+ "status": "not_applicable"+ },+ "disable": {+ "status": "not_applicable"+ },+ "effort": {+ "path": "/reasoning/effort",+ "values": {+ "low": "low",+ "medium": "medium",+ "high": "high",+ "xhigh": "xhigh"+ },+ "default": "high"+ },+ "mode": {+ "status": "unknown"+ }+ },+ "speed": {+ "status": "unknown"+ },+ "evidence": [+ {+ "evidenceId": "wev_0b108d2f700554d550ace8c904c1f889",+ "method": "docs",+ "sourceUrl": "https://docs.x.ai/developers/model-capabilities/text/reasoning",+ "observedAt": "2026-10-12T10:09:42.371Z"+ },+ {+ "evidenceId": "wev_5a77d5500543754ddc7192b7d694ba40",+ "method": "docs",+ "sourceUrl": "https://docs.x.ai/developers/model-capabilities/text/reasoning",+ "observedAt": "2026-10-12T10:09:42.371Z"+ },+ {+ "evidenceId": "wev_8e647468b63a880540d312cf1ba67b15",+ "method": "docs",+ "sourceUrl": "https://docs.x.ai/developers/model-capabilities/text/reasoning",+ "observedAt": "2026-10-12T10:09:42.371Z"+ },+ {+ "evidenceId": "wev_bdee3689d67a5a29de6306bc6c8f0684",+ "method": "docs",+ "sourceUrl": "https://docs.x.ai/developers/model-capabilities/text/reasoning",+ "observedAt": "2026-10-12T10:09:42.371Z"+ },+ {+ "evidenceId": "wev_c681afe9648840076d7ec68e2fc70783",+ "method": "docs",+ "sourceUrl": "https://docs.x.ai/developers/model-capabilities/text/reasoning",+ "observedAt": "2026-10-12T10:09:42.371Z"+ },+ {+ "evidenceId": "wev_805c0627fbe793941c5b028b43d3ac12",+ "method": "endpoint-table",+ "sourceUrl": "https://opencode.ai/v2/docs/console/go",+ "observedAt": "2026-10-12T10:09:25.039Z"+ },+ {+ "evidenceId": "wev_806cdc286ff34aaebe4f5a3f1d11fe20",+ "method": "probe",+ "observedAt": "2026-10-09T13:03:16.397Z"+ },+ {+ "evidenceId": "wev_fc98f9d4388b8d788587db54ae6f50cf",+ "method": "probe",+ "observedAt": "2026-10-09T12:49:21.452Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "opencode-zen",+ "sourceCollectorId": "opencode-zen-api",+ "confidence": "gateway_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "opencode",+ "routeProfileId": "zen"+ },+ "externalModelId": "grok-4.7",+ "pricing": {+ "type": "flat",+ "input": 2,+ "output": 6,+ "cachedRead": 0.5+ },+ "reasoning": {+ "mode": {+ "status": "unknown"+ },+ "request": {+ "status": "supported",+ "api": "responses",+ "evidenceSourceUrl": "https://docs.x.ai/developers/model-capabilities/text/reasoning",+ "effort": {+ "path": "/reasoning/effort",+ "values": {+ "low": "low",+ "medium": "medium",+ "high": "high",+ "xhigh": "xhigh"+ },+ "default": "high"+ }+ }+ },+ "wire": {+ "status": "known",+ "api": "responses",+ "tokenParam": "max_output_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": {+ "status": "not_applicable"+ },+ "disable": {+ "status": "not_applicable"+ },+ "effort": {+ "path": "/reasoning/effort",+ "values": {+ "low": "low",+ "medium": "medium",+ "high": "high",+ "xhigh": "xhigh"+ },+ "default": "high"+ },+ "mode": {+ "status": "unknown"+ }+ },+ "speed": {+ "status": "unknown"+ },+ "evidence": [+ {+ "evidenceId": "wev_701d52ecfc412a62553ab8c153278be9",+ "method": "docs",+ "sourceUrl": "https://docs.x.ai/developers/model-capabilities/text/reasoning",+ "observedAt": "2026-10-12T10:09:42.371Z"+ },+ {+ "evidenceId": "wev_818c2f50c6a3cf618cbb32ffc2f73902",+ "method": "docs",+ "sourceUrl": "https://docs.x.ai/developers/model-capabilities/text/reasoning",+ "observedAt": "2026-10-12T10:09:42.371Z"+ },+ {+ "evidenceId": "wev_90bb91a41af150a6770639e632522d4f",+ "method": "docs",+ "sourceUrl": "https://docs.x.ai/developers/model-capabilities/text/reasoning",+ "observedAt": "2026-10-12T10:09:42.371Z"+ },+ {+ "evidenceId": "wev_c2e84c543e9758756ca441d2f365bf11",+ "method": "docs",+ "sourceUrl": "https://docs.x.ai/developers/model-capabilities/text/reasoning",+ "observedAt": "2026-10-12T10:09:42.371Z"+ },+ {+ "evidenceId": "wev_c61f71f9582be47040b954fea83cada3",+ "method": "docs",+ "sourceUrl": "https://docs.x.ai/developers/model-capabilities/text/reasoning",+ "observedAt": "2026-10-12T10:09:42.371Z"+ },+ {+ "evidenceId": "wev_f0290cc31c4a85a014a8ed83591315f9",+ "method": "endpoint-table",+ "sourceUrl": "https://opencode.ai/docs/en/zen/",+ "observedAt": "2026-10-12T10:09:23.090Z"+ },+ {+ "evidenceId": "wev_c1ed08d62e18326e0468d0e0905b7250",+ "method": "probe",+ "observedAt": "2026-10-09T13:03:16.804Z"+ },+ {+ "evidenceId": "wev_c52a3f9f95847cccaebdfad8493dd8ba",+ "method": "probe",+ "observedAt": "2026-10-09T12:52:26.857Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "openrouter",+ "sourceCollectorId": "openrouter-api",+ "confidence": "aggregator_reported",+ "routeStatus": "mapped",+ "route": {+ "routeId": "openrouter",+ "routeProfileId": "gateway"+ },+ "externalModelId": "x-ai/grok-4.7",+ "pricing": {+ "type": "flat",+ "input": 2,+ "output": 6,+ "cachedRead": 0.5+ },+ "reasoning": {+ "request": {+ "status": "supported",+ "api": "chat-completions",+ "evidenceSourceUrl": "https://openrouter.ai/api/v1/models",+ "enable": [+ {+ "path": "/reasoning/enabled",+ "value": true+ }+ ],+ "effort": {+ "path": "/reasoning/effort",+ "values": {+ "low": "low",+ "medium": "medium",+ "high": "high",+ "xhigh": "xhigh"+ },+ "default": "high"+ }+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": [+ {+ "path": "/reasoning/enabled",+ "value": true+ }+ ],+ "disable": {+ "status": "not_applicable"+ },+ "effort": {+ "path": "/reasoning/effort",+ "values": {+ "low": "low",+ "medium": "medium",+ "high": "high",+ "xhigh": "xhigh"+ },+ "default": "high"+ },+ "mode": {+ "status": "not_applicable"+ }+ },+ "speed": {+ "status": "supported",+ "path": "/service_tier",+ "values": {+ "priority": "priority"+ },+ "default": "standard",+ "headers": [],+ "echo": "/service_tier",+ "access": "open"+ },+ "evidence": [+ {+ "evidenceId": "wev_2c37227bc11c4102fc7132005e8c491b",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_30c0264c14f5b9d1a7f76b429099057f",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_45bb83c66f0aafccd73348777b225a8d",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_681801aa0832bd2f3c1c46298ad65187",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models/x-ai/grok-4.7/endpoints",+ "observedAt": "2026-10-12T10:09:39.330Z"+ },+ {+ "evidenceId": "wev_91643e1a735cfeb4d5d90d8c7823ed5b",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_b2e4bd9fba149b485bb9e76f64b4b7e5",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_d8e480b99f36678685ce129245d31c39",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_62c56d937f6334d37ed88b13140237ca",+ "method": "docs",+ "sourceUrl": "https://openrouter.ai/docs/guides/best-practices/reasoning-tokens",+ "observedAt": "2026-10-12T10:09:52.321Z"+ },+ {+ "evidenceId": "wev_679636e3f106b7e0adf052c4ed764f5d",+ "method": "docs",+ "sourceUrl": "https://openrouter.ai/docs/guides/best-practices/reasoning-tokens",+ "observedAt": "2026-10-12T10:09:52.321Z"+ },+ {+ "evidenceId": "wev_e8ebcae38bd71e04abc1a1141aadb7d6",+ "method": "docs",+ "sourceUrl": "https://openrouter.ai/docs/guides/best-practices/reasoning-tokens",+ "observedAt": "2026-10-12T10:09:52.321Z"+ },+ {+ "evidenceId": "wev_20f847e9a58d834358530689929fa78c",+ "method": "probe",+ "observedAt": "2026-10-11T20:19:03.424Z"+ },+ {+ "evidenceId": "wev_4d2f4ef61d54807a30e4cd40105ff898",+ "method": "probe",+ "observedAt": "2026-10-11T20:34:49.239Z"+ },+ {+ "evidenceId": "wev_a852a9bd20b14ba2df7e564ad084ab51",+ "method": "probe",+ "observedAt": "2026-10-11T20:34:49.239Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "poe",+ "sourceCollectorId": "poe-api",+ "confidence": "aggregator_reported",+ "routeStatus": "mapped",+ "route": {+ "routeId": "poe",+ "routeProfileId": "gateway"+ },+ "externalModelId": "grok-4.7",+ "pricing": {+ "type": "flat",+ "input": 2.0202,+ "output": 6.0606,+ "cachedRead": 0.5051+ },+ "probeEligible": true,+ "reasoning": {+ "request": {+ "status": "unknown"+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "unknown"+ },+ "speed": {+ "status": "rejected",+ "path": "/service_tier"+ },+ "evidence": [+ {+ "evidenceId": "wev_f8ce50c637308c03c1e00c3b3c9d0ffb",+ "method": "api",+ "sourceUrl": "https://api.poe.com/v1/models",+ "observedAt": "2026-10-12T10:09:22.802Z"+ },+ {+ "evidenceId": "wev_38c837be2ee8cd6982f11f02543284f5",+ "method": "docs",+ "sourceUrl": "https://creator.poe.com/docs/external-applications/openai-compatible-api",+ "observedAt": "2026-10-12T10:09:33.306Z"+ },+ {+ "evidenceId": "wev_b1686d9945319db2d39793eb317563cc",+ "method": "docs",+ "sourceUrl": "https://creator.poe.com/docs/external-applications/openai-compatible-api",+ "observedAt": "2026-10-12T10:09:33.306Z"+ },+ {+ "evidenceId": "wev_d4da7afd79771b721454bc8e4984a38e",+ "method": "docs",+ "sourceUrl": "https://docs.x.ai/developers/advanced-api-usage/priority-processing",+ "observedAt": "2026-10-12T10:09:42.197Z"+ },+ {+ "evidenceId": "wev_d39181e837bf1f2e592ff7ac3737f20c",+ "method": "probe",+ "observedAt": "2026-10-11T20:34:15.386Z"+ },+ {+ "evidenceId": "wev_dbe1abefd41fa44f59a3dc658de456a4",+ "method": "probe",+ "observedAt": "2026-10-11T20:34:15.386Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "x-ai",+ "sourceCollectorId": "xai-api",+ "confidence": "api_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "x-ai",+ "routeProfileId": "direct-api"+ },+ "externalModelId": "grok-4.7",+ "pricing": {+ "type": "flat",+ "input": 2,+ "output": 6,+ "cachedRead": 0.5+ },+ "reasoning": {+ "request": {+ "status": "supported",+ "api": "responses",+ "evidenceSourceUrl": "https://docs.x.ai/developers/model-capabilities/text/reasoning",+ "effort": {+ "path": "/reasoning/effort",+ "values": {+ "low": "low",+ "medium": "medium",+ "high": "high",+ "xhigh": "xhigh"+ },+ "default": "high"+ }+ }+ },+ "wire": {+ "status": "known",+ "api": "responses",+ "tokenParam": "max_output_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": {+ "status": "not_applicable"+ },+ "disable": {+ "status": "not_applicable"+ },+ "effort": {+ "path": "/reasoning/effort",+ "values": {+ "low": "low",+ "medium": "medium",+ "high": "high",+ "xhigh": "xhigh"+ },+ "default": "high"+ },+ "mode": {+ "status": "not_applicable"+ }+ },+ "speed": {+ "status": "supported",+ "path": "/service_tier",+ "values": {+ "standard": "default",+ "priority": "priority"+ },+ "default": "standard",+ "headers": [],+ "echo": "/service_tier",+ "access": "open"+ },+ "evidence": [+ {+ "evidenceId": "wev_11e79d19d3f257d4f74411a0a79c7318",+ "method": "docs",+ "sourceUrl": "https://docs.x.ai/developers/model-capabilities/text/reasoning",+ "observedAt": "2026-10-12T10:09:42.371Z"+ },+ {+ "evidenceId": "wev_4de7e7e9d8a857bab7e965ae1bd80c53",+ "method": "docs",+ "sourceUrl": "https://docs.x.ai/developers/model-capabilities/text/reasoning",+ "observedAt": "2026-10-12T10:09:42.371Z"+ },+ {+ "evidenceId": "wev_686f832e0ee98e2111edef258229a8d5",+ "method": "docs",+ "sourceUrl": "https://docs.x.ai/developers/model-capabilities/text/reasoning",+ "observedAt": "2026-10-12T10:09:42.371Z"+ },+ {+ "evidenceId": "wev_6b6671ac327bd0b5ede72d4ab7f6001e",+ "method": "docs",+ "sourceUrl": "https://docs.x.ai/developers/model-capabilities/text/reasoning",+ "observedAt": "2026-10-12T10:09:42.371Z"+ },+ {+ "evidenceId": "wev_c080c692d0135c5cfe652dcb6ae7def5",+ "method": "docs",+ "sourceUrl": "https://docs.x.ai/developers/rest-api-reference/inference/responses.md",+ "observedAt": "2026-10-12T10:09:43.120Z"+ },+ {+ "evidenceId": "wev_d4ec72343a85513411c3b20a56f1b08f",+ "method": "docs",+ "sourceUrl": "https://docs.x.ai/developers/advanced-api-usage/priority-processing",+ "observedAt": "2026-10-12T10:09:42.197Z"+ },+ {+ "evidenceId": "wev_e69f4cb71c8739e97540c6742ea20bbe",+ "method": "docs",+ "sourceUrl": "https://docs.x.ai/developers/model-capabilities/text/reasoning",+ "observedAt": "2026-10-12T10:09:42.371Z"+ },+ {+ "evidenceId": "wev_ee08a17d9ed6ee2c97f41f48f70f1e88",+ "method": "docs",+ "sourceUrl": "https://docs.x.ai/developers/model-capabilities/text/reasoning",+ "observedAt": "2026-10-12T10:09:42.371Z"+ },+ {+ "evidenceId": "wev_2c4edb429f28a5b414fcdd2cfd74b932",+ "method": "probe",+ "observedAt": "2026-10-11T22:07:21.835Z"+ },+ {+ "evidenceId": "wev_2cb93251a308373460facd9778629404",+ "method": "probe",+ "observedAt": "2026-10-11T22:07:21.835Z"+ },+ {+ "evidenceId": "wev_e49935be0b095fedc77598f2836bc9e8",+ "method": "probe",+ "observedAt": "2026-10-11T22:07:18.081Z"+ }+ ]+ }+ }+ ],+ "supportsVision": true,+ "supportsTools": true,+ "videoInput": false,+ "videoOutput": false,+ "reasoning": {+ "supported": true,+ "mandatory": true,+ "control": "effort",+ "efforts": [+ "low",+ "medium",+ "high",+ "xhigh"+ ],+ "defaultEffort": "high"+ },+ "endpoints": {+ "openai": {+ "api": "responses",+ "toolsWithReasoning": "ok"+ }+ },+ "tokenParam": "max_output_tokens"+ },+ {+ "contractVersion": 3,+ "modelId": "qwen3.8-omni-flash-realtime",+ "displayName": "Qwen3.8-Omni-Flash-Realtime",+ "provider": "qwen",+ "aliases": [],+ "status": "active",+ "releaseDate": "2026-09-21",+ "inputModalities": [+ "audio",+ "image",+ "text",+ "video"+ ],+ "outputModalities": [+ "audio",+ "text"+ ],+ "aggregators": [+ {+ "sourceProviderId": "qwen",+ "sourceCollectorId": "dashscope-api",+ "confidence": "api_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "qwen",+ "routeProfileId": "realtime-websocket"+ },+ "externalModelId": "qwen3.8-omni-flash-realtime",+ "pricing": {+ "type": "unavailable"+ },+ "probeEligible": false,+ "reasoning": {+ "request": {+ "status": "unknown"+ }+ },+ "wire": {+ "status": "unsupported",+ "protocol": "dashscope-realtime-websocket",+ "evidence": [+ {+ "evidenceId": "wev_be3f984384810c8385d9eee28f5d6524",+ "method": "docs",+ "sourceUrl": "https://www.alibabacloud.com/help/en/model-studio/realtime",+ "observedAt": "2026-10-12T10:09:54.183Z"+ }+ ]+ }+ }+ ],+ "supportsVision": true,+ "supportsTools": true,+ "videoInput": true,+ "videoOutput": false+ },+ {+ "contractVersion": 3,+ "modelId": "deepseek-v4.1-flash",+ "displayName": "DeepSeek-V4.1-Flash",+ "provider": "deepseek",+ "aliases": [+ "deepseek/deepseek-v4.1-flash",+ "deepseek/deepseek-v4.1-flash:batch",+ "deepseek-ai/DeepSeek-V4.1-Flash",+ "deepseek-flash",+ "accounts/fireworks/models/deepseek-v4p1-flash"+ ],+ "status": "active",+ "releaseDate": "2026-09-10",+ "contextWindow": 1048576,+ "maxOutputTokens": 393216,+ "subscriptionPlanIds": [+ "alibaba-token-plan-individual",+ "alibaba-token-plan-team-edition",+ "ollama-cloud",+ "opencode-go",+ "opencode-go-plus"+ ],+ "inputModalities": [+ "image",+ "text"+ ],+ "outputModalities": [+ "text"+ ],+ "aggregators": [+ {+ "sourceProviderId": "deepseek",+ "sourceCollectorId": "deepseek-api",+ "confidence": "api_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "deepseek",+ "routeProfileId": "direct-api"+ },+ "externalModelId": "deepseek-flash",+ "pricing": {+ "type": "unavailable"+ },+ "reasoning": {+ "request": {+ "status": "unknown"+ }+ },+ "wire": {+ "status": "known",+ "api": "responses",+ "tokenParam": "max_output_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": {+ "status": "unknown"+ },+ "disable": {+ "status": "unknown"+ },+ "effort": {+ "path": "/reasoning/effort",+ "values": {+ "max": "max",+ "high": "high",+ "low": "low"+ },+ "default": {+ "status": "unknown"+ }+ },+ "mode": {+ "status": "not_applicable"+ }+ },+ "speed": {+ "status": "not_applicable"+ },+ "evidence": [+ {+ "evidenceId": "wev_0aa1ddc2b64331ddb6ef99eadeeb0395",+ "method": "docs",+ "sourceUrl": "https://api-docs.deepseek.com/quick_start/pricing/",+ "observedAt": "2026-10-12T10:09:23.499Z"+ },+ {+ "evidenceId": "wev_cac076da8755d56c25ad038390c93a74",+ "method": "docs",+ "sourceUrl": "https://api-docs.deepseek.com/guides/responses_api",+ "observedAt": "2026-10-12T10:09:26.088Z"+ },+ {+ "evidenceId": "wev_2438932d177390ab789d053e6172e11a",+ "method": "probe",+ "observedAt": "2026-10-11T22:07:37.461Z"+ },+ {+ "evidenceId": "wev_27a4e17d345ac5e8715995839d2af5c2",+ "method": "probe",+ "observedAt": "2026-10-11T22:07:37.608Z"+ },+ {+ "evidenceId": "wev_d492232b81acbe6ab4892d6406aeff45",+ "method": "probe",+ "observedAt": "2026-10-11T22:07:37.608Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "fireworks",+ "sourceCollectorId": "fireworks-api",+ "confidence": "aggregator_reported",+ "routeStatus": "mapped",+ "route": {+ "routeId": "fireworks",+ "routeProfileId": "gateway"+ },+ "externalModelId": "accounts/fireworks/models/deepseek-v4p1-flash",+ "pricing": {+ "type": "unavailable"+ },+ "reasoning": {+ "request": {+ "status": "unknown"+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "unknown"+ },+ "speed": {+ "status": "supported",+ "path": "/service_tier",+ "values": {+ "priority": "priority"+ },+ "default": "standard",+ "headers": [],+ "echo": {+ "status": "not_applicable"+ },+ "access": "open"+ },+ "evidence": [+ {+ "evidenceId": "wev_feb4d179a4d10072e0af9e6317ca4749",+ "method": "api",+ "sourceUrl": "https://api.fireworks.ai/inference/v1/models",+ "observedAt": "2026-10-12T10:09:22.214Z"+ },+ {+ "evidenceId": "wev_218ef581607e131f84542be7bacdb54a",+ "method": "docs",+ "sourceUrl": "https://docs.fireworks.ai/serverless/serverless-modes.md",+ "observedAt": "2026-10-12T10:09:37.403Z"+ },+ {+ "evidenceId": "wev_3a8bd0c45060b98a33be7bb3368aa61d",+ "method": "docs",+ "sourceUrl": "https://docs.fireworks.ai/tools-sdks/openai-compatibility.md",+ "observedAt": "2026-10-12T10:09:50.512Z"+ },+ {+ "evidenceId": "wev_ef64f0da51105457a0c37aa165155276",+ "method": "docs",+ "sourceUrl": "https://docs.fireworks.ai/serverless/pricing.md",+ "observedAt": "2026-10-12T10:09:35.878Z"+ },+ {+ "evidenceId": "wev_69457ce95ae3516f9095b4e482221b9a",+ "method": "probe",+ "observedAt": "2026-10-11T22:07:38.288Z"+ },+ {+ "evidenceId": "wev_fa94ce880dc58a2b44522f972ff0b747",+ "method": "probe",+ "observedAt": "2026-10-11T22:07:39.507Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "ollamacloud",+ "sourceCollectorId": "ollama-cloud-api",+ "confidence": "gateway_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "ollama",+ "routeProfileId": "cloud"+ },+ "externalModelId": "deepseek-v4.1-flash",+ "pricing": {+ "type": "flat",+ "input": 0.3,+ "output": 1.2,+ "cachedRead": 0.006+ },+ "reasoning": {+ "request": {+ "status": "supported",+ "api": "chat-completions",+ "evidenceSourceUrl": "https://ollama.com/api/show",+ "effort": {+ "path": "/reasoning_effort",+ "values": {+ "max": "max",+ "high": "high",+ "low": "low"+ },+ "default": "high"+ }+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": {+ "status": "unknown"+ },+ "disable": {+ "status": "unknown"+ },+ "effort": {+ "path": "/reasoning_effort",+ "values": {+ "max": "max",+ "high": "high",+ "low": "low"+ },+ "default": "high"+ },+ "mode": {+ "status": "not_applicable"+ }+ },+ "speed": {+ "status": "not_applicable"+ },+ "evidence": [+ {+ "evidenceId": "wev_0ee49a2afae64c115e18239f2a086fb0",+ "method": "api",+ "sourceUrl": "https://ollama.com/api/show",+ "observedAt": "2026-10-12T10:09:22.262Z"+ },+ {+ "evidenceId": "wev_43983bfeddc9c478fcf7fa062169ea70",+ "method": "api",+ "sourceUrl": "https://ollama.com/api/show",+ "observedAt": "2026-10-12T10:09:22.262Z"+ },+ {+ "evidenceId": "wev_e1000e0e3a9ed64b3f79dfe1f461cef7",+ "method": "api",+ "sourceUrl": "https://ollama.com/api/show",+ "observedAt": "2026-10-12T10:09:22.262Z"+ },+ {+ "evidenceId": "wev_1677e1797f582d17ee41822cf58f5528",+ "method": "docs",+ "sourceUrl": "https://ollama.com/pricing",+ "observedAt": "2026-10-12T10:09:43.892Z"+ },+ {+ "evidenceId": "wev_3cd067fd251668fe5b6db73c7dfc753b",+ "method": "probe",+ "observedAt": "2026-10-11T20:32:13.166Z"+ },+ {+ "evidenceId": "wev_a53ac0033b0755ff4f7fecc63f4604fa",+ "method": "probe",+ "observedAt": "2026-10-11T20:32:08.335Z"+ },+ {+ "evidenceId": "wev_f2d6a6faed2158e2b07bc73575b2a644",+ "method": "probe",+ "observedAt": "2026-10-11T20:32:13.166Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "opencode-go",+ "sourceCollectorId": "popular-coding-subscriptions",+ "confidence": "gateway_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "opencode",+ "routeProfileId": "go-subscription"+ },+ "externalModelId": "deepseek-flash",+ "reasoning": {+ "request": {+ "status": "unknown"+ }+ },+ "wire": {+ "status": "unknown",+ "evidence": []+ }+ },+ {+ "sourceProviderId": "opencode-go",+ "sourceCollectorId": "popular-coding-subscriptions",+ "confidence": "gateway_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "opencode",+ "routeProfileId": "go-subscription"+ },+ "externalModelId": "deepseek-v4.1-flash",+ "reasoning": {+ "request": {+ "status": "unknown"+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": {+ "status": "unknown"+ },+ "toolsWithReasoning": {+ "status": "unknown"+ },+ "reasoning": {+ "status": "unknown"+ },+ "speed": {+ "status": "unknown"+ },+ "evidence": [+ {+ "evidenceId": "wev_bcb619bac8594f2b68408ddb65b3e7b1",+ "method": "endpoint-table",+ "sourceUrl": "https://opencode.ai/v2/docs/console/go",+ "observedAt": "2026-10-12T10:09:25.039Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "opencode-zen",+ "sourceCollectorId": "opencode-zen-api",+ "confidence": "gateway_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "opencode",+ "routeProfileId": "zen"+ },+ "externalModelId": "deepseek-v4.1-flash",+ "pricing": {+ "type": "flat",+ "input": 0.3,+ "output": 1.2,+ "cachedRead": 0.006+ },+ "reasoning": {+ "request": {+ "status": "unknown"+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": {+ "status": "unknown"+ },+ "toolsWithReasoning": {+ "status": "unknown"+ },+ "reasoning": {+ "status": "unknown"+ },+ "speed": {+ "status": "unknown"+ },+ "evidence": [+ {+ "evidenceId": "wev_93320a4e622d127772bbb83aa8296176",+ "method": "endpoint-table",+ "sourceUrl": "https://opencode.ai/docs/en/zen/",+ "observedAt": "2026-10-12T10:09:23.090Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "openrouter",+ "sourceCollectorId": "openrouter-api",+ "confidence": "aggregator_reported",+ "routeStatus": "mapped",+ "route": {+ "routeId": "openrouter",+ "routeProfileId": "gateway"+ },+ "externalModelId": "deepseek/deepseek-v4.1-flash",+ "pricing": {+ "type": "flat",+ "input": 0.15,+ "output": 0.6,+ "cachedRead": 0.003+ },+ "reasoning": {+ "request": {+ "status": "supported",+ "api": "chat-completions",+ "evidenceSourceUrl": "https://openrouter.ai/api/v1/models",+ "enable": [+ {+ "path": "/reasoning/enabled",+ "value": true+ }+ ],+ "disable": [+ {+ "path": "/reasoning/effort",+ "value": "none"+ }+ ],+ "effort": {+ "path": "/reasoning/effort",+ "values": {+ "max": "max",+ "high": "high",+ "low": "low"+ },+ "default": "high"+ }+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": [+ {+ "path": "/reasoning/enabled",+ "value": true+ }+ ],+ "disable": [+ {+ "path": "/reasoning/effort",+ "value": "none"+ }+ ],+ "effort": {+ "path": "/reasoning/effort",+ "values": {+ "max": "max",+ "high": "high",+ "low": "low"+ },+ "default": "high"+ },+ "mode": {+ "status": "not_applicable"+ }+ },+ "speed": {+ "status": "unknown"+ },+ "evidence": [+ {+ "evidenceId": "wev_1f59cbe86a5d78273291a6378b14459d",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_42ed9ef7fa6f8b17bbf078cfd8578531",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_7aef5bf1a2d6c37d73558a32d978969f",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_cf39464053af7919369dc36f3e7dbed0",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_f43733e35a2f4107eb830d28d11e944b",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_f4753b6fdfe0a5caec8522d49fb8bba8",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_6441e329656b2a74bbda7a1b3e05df8d",+ "method": "docs",+ "sourceUrl": "https://openrouter.ai/docs/guides/best-practices/reasoning-tokens",+ "observedAt": "2026-10-12T10:09:52.321Z"+ },+ {+ "evidenceId": "wev_cb80daee081875b6dee3c9043524a17a",+ "method": "docs",+ "sourceUrl": "https://openrouter.ai/docs/guides/best-practices/reasoning-tokens",+ "observedAt": "2026-10-12T10:09:52.321Z"+ },+ {+ "evidenceId": "wev_d46eaaa0d0a1a7fa44516f5e249e536f",+ "method": "docs",+ "sourceUrl": "https://openrouter.ai/docs/guides/best-practices/reasoning-tokens",+ "observedAt": "2026-10-12T10:09:52.321Z"+ },+ {+ "evidenceId": "wev_0a1652beec70d0151be7e082fb2577be",+ "method": "probe",+ "observedAt": "2026-10-11T19:42:43.889Z"+ },+ {+ "evidenceId": "wev_3c1f92278b11889d32066d449b7acc33",+ "method": "probe",+ "observedAt": "2026-10-11T19:42:43.889Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "openrouter",+ "sourceCollectorId": "openrouter-api",+ "confidence": "aggregator_reported",+ "routeStatus": "unknown",+ "reason": "unverified_mapping",+ "observedExternalModelId": "deepseek/deepseek-v4.1-flash:batch"+ },+ {+ "sourceProviderId": "poe",+ "sourceCollectorId": "poe-api",+ "confidence": "aggregator_reported",+ "routeStatus": "mapped",+ "route": {+ "routeId": "poe",+ "routeProfileId": "gateway"+ },+ "externalModelId": "deepseek-v4.1-flash",+ "pricing": {+ "type": "flat",+ "input": 0.303,+ "output": 1.2121,+ "cachedRead": 0.0061+ },+ "probeEligible": true,+ "reasoning": {+ "request": {+ "status": "supported",+ "api": "chat-completions",+ "evidenceSourceUrl": "https://api.poe.com/v1/models",+ "enable": [+ {+ "path": "/enable_thinking",+ "value": true+ }+ ],+ "disable": [+ {+ "path": "/enable_thinking",+ "value": false+ }+ ]+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": [+ {+ "path": "/enable_thinking",+ "value": true+ }+ ],+ "disable": [+ {+ "path": "/enable_thinking",+ "value": false+ }+ ],+ "effort": {+ "status": "unknown"+ },+ "mode": {+ "status": "not_applicable"+ }+ },+ "speed": {+ "status": "rejected",+ "path": "/service_tier"+ },+ "evidence": [+ {+ "evidenceId": "wev_3d23e6b5808f8a7ce2d6c8e39fe3ef9d",+ "method": "api",+ "sourceUrl": "https://api.poe.com/v1/models",+ "observedAt": "2026-10-12T10:09:22.802Z"+ },+ {+ "evidenceId": "wev_7327e1c7f8ad4e3d6e17bb8ecbc47e5a",+ "method": "api",+ "sourceUrl": "https://api.poe.com/v1/models",+ "observedAt": "2026-10-12T10:09:22.802Z"+ },+ {+ "evidenceId": "wev_b17e22a5eb628544cb38e205386de3b1",+ "method": "docs",+ "sourceUrl": "https://creator.poe.com/docs/external-applications/openai-compatible-api",+ "observedAt": "2026-10-12T10:09:33.306Z"+ },+ {+ "evidenceId": "wev_c2b466e384e282b252a1366611722e99",+ "method": "docs",+ "sourceUrl": "https://creator.poe.com/docs/external-applications/openai-compatible-api",+ "observedAt": "2026-10-12T10:09:33.306Z"+ },+ {+ "evidenceId": "wev_18ab023d95dd6f1f72dae6499e6a1b12",+ "method": "probe",+ "observedAt": "2026-10-11T21:53:18.261Z"+ },+ {+ "evidenceId": "wev_1a389ac327d4e52fb8cae2861daf8ad5",+ "method": "probe",+ "observedAt": "2026-10-11T21:53:21.770Z"+ },+ {+ "evidenceId": "wev_427e5d7791d7301d70c0498281664f0a",+ "method": "probe",+ "observedAt": "2026-10-11T21:53:23.327Z"+ },+ {+ "evidenceId": "wev_76400325f1f36f46f8d0943444cb7d22",+ "method": "probe",+ "observedAt": "2026-10-11T21:53:23.327Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "qwen-cloud",+ "sourceCollectorId": "qwen-cloud-token-plan-scrape",+ "confidence": "scrape_verified",+ "routeStatus": "mapped",+ "route": {+ "routeId": "qwen",+ "routeProfileId": "qwencloud-token-plan"+ },+ "externalModelId": "deepseek-v4.1-flash",+ "reasoning": {+ "request": {+ "status": "supported",+ "api": "chat-completions",+ "evidenceSourceUrl": "https://docs.qwencloud.com/api-reference/chat/openai-chat.md",+ "enable": [+ {+ "path": "/enable_thinking",+ "value": true+ }+ ],+ "disable": [+ {+ "path": "/enable_thinking",+ "value": false+ }+ ],+ "effort": {+ "path": "/reasoning_effort",+ "values": {+ "max": "max",+ "high": "high",+ "low": "low"+ },+ "default": "high"+ }+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": "max_completion_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": [+ {+ "path": "/enable_thinking",+ "value": true+ }+ ],+ "disable": [+ {+ "path": "/enable_thinking",+ "value": false+ }+ ],+ "effort": {+ "path": "/reasoning_effort",+ "values": {+ "max": "max",+ "high": "high",+ "low": "low"+ },+ "default": "high"+ },+ "mode": {+ "status": "not_applicable"+ }+ },+ "speed": {+ "status": "not_applicable"+ },+ "evidence": [+ {+ "evidenceId": "wev_02021060e282e52fd3363aadd24cea90",+ "method": "docs",+ "sourceUrl": "https://docs.qwencloud.com/developer-guides/text-generation/thinking.md",+ "observedAt": "2026-10-12T10:09:42.815Z"+ },+ {+ "evidenceId": "wev_0247e54651cf14b976cc1dc7572a6101",+ "method": "docs",+ "sourceUrl": "https://docs.qwencloud.com/api-reference/chat/openai-chat.md",+ "observedAt": "2026-10-12T10:09:42.397Z"+ },+ {+ "evidenceId": "wev_14661f07366bba3b0fe344fa6571773c",+ "method": "docs",+ "sourceUrl": "https://docs.qwencloud.com/token-plan/team/token-plan-team-overview.md",+ "observedAt": "2026-10-12T10:09:51.277Z"+ },+ {+ "evidenceId": "wev_2672f7f227daa0b4737432c52d4ee867",+ "method": "docs",+ "sourceUrl": "https://docs.qwencloud.com/api-reference/chat/openai-chat.md",+ "observedAt": "2026-10-12T10:09:42.397Z"+ },+ {+ "evidenceId": "wev_513882c5cc3a5570eae6214b8e7bce5d",+ "method": "docs",+ "sourceUrl": "https://docs.qwencloud.com/api-reference/chat/openai-chat.md",+ "observedAt": "2026-10-12T10:09:42.397Z"+ },+ {+ "evidenceId": "wev_5a933aaf1835fea3f82a73b4bf3f4171",+ "method": "docs",+ "sourceUrl": "https://docs.qwencloud.com/developer-guides/text-generation/thinking.md",+ "observedAt": "2026-10-12T10:09:42.815Z"+ },+ {+ "evidenceId": "wev_774ccac4b9fc0b8005d0b4889e2170cd",+ "method": "docs",+ "sourceUrl": "https://docs.qwencloud.com/token-plan/personal/token-plan-personal-quickstart.md",+ "observedAt": "2026-10-12T10:09:40.705Z"+ },+ {+ "evidenceId": "wev_8cea955b3f9c819f4a1178c686c400c7",+ "method": "docs",+ "sourceUrl": "https://docs.qwencloud.com/token-plan/personal/token-plan-personal-quickstart.md",+ "observedAt": "2026-10-12T10:09:40.705Z"+ },+ {+ "evidenceId": "wev_b539926bc4e76a7587f40114d7b6a07a",+ "method": "docs",+ "sourceUrl": "https://docs.qwencloud.com/api-reference/chat/openai-chat.md",+ "observedAt": "2026-10-12T10:09:42.397Z"+ },+ {+ "evidenceId": "wev_ddfdf19ac3804610008f2037124817f9",+ "method": "docs",+ "sourceUrl": "https://docs.qwencloud.com/api-reference/chat/openai-chat.md",+ "observedAt": "2026-10-12T10:09:42.397Z"+ },+ {+ "evidenceId": "wev_e9321bac9e08e05e0b1b47c236a1007e",+ "method": "docs",+ "sourceUrl": "https://docs.qwencloud.com/api-reference/chat/openai-chat",+ "observedAt": "2026-10-12T10:09:40.412Z"+ },+ {+ "evidenceId": "wev_f2fb416e511e4aab08eb3510082c10a0",+ "method": "docs",+ "sourceUrl": "https://docs.qwencloud.com/api-reference/chat/openai-chat.md",+ "observedAt": "2026-10-12T10:09:42.397Z"+ },+ {+ "evidenceId": "wev_fb898c8024208622557fe6abebdb9ab9",+ "method": "docs",+ "sourceUrl": "https://docs.qwencloud.com/api-reference/chat/openai-chat.md",+ "observedAt": "2026-10-12T10:09:42.397Z"+ },+ {+ "evidenceId": "wev_383b7a4bf6b0d361dac9a73b7eb394f4",+ "method": "probe",+ "observedAt": "2026-10-11T19:22:58.218Z"+ },+ {+ "evidenceId": "wev_7f132ce2cd2e0348d0fa6a1c2bdaed0d",+ "method": "probe",+ "observedAt": "2026-10-11T19:22:58.218Z"+ },+ {+ "evidenceId": "wev_e330e4a1e0492189004b87a3106c9600",+ "method": "probe",+ "observedAt": "2026-10-11T19:19:24.828Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "together-ai",+ "sourceCollectorId": "together-ai-api",+ "confidence": "gateway_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "together-ai",+ "routeProfileId": "gateway"+ },+ "externalModelId": "deepseek-ai/DeepSeek-V4.1-Flash",+ "pricing": {+ "type": "flat",+ "input": 0.3,+ "output": 1.2+ },+ "probeEligible": true,+ "reasoning": {+ "request": {+ "status": "unknown"+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": {+ "status": "unknown"+ },+ "reasoning": {+ "status": "unknown"+ },+ "speed": {+ "status": "not_applicable"+ },+ "evidence": [+ {+ "evidenceId": "wev_58f096d632300f8187606bedc1a078dc",+ "method": "docs",+ "sourceUrl": "https://docs.together.ai/reference/chat-completions.md",+ "observedAt": "2026-10-12T10:09:50.817Z"+ },+ {+ "evidenceId": "wev_6de2de4f141e611e65e10f04353af01f",+ "method": "docs",+ "sourceUrl": "https://docs.together.ai/docs/inference/openai-compatibility.md",+ "observedAt": "2026-10-12T10:09:42.290Z"+ },+ {+ "evidenceId": "wev_d2e318d6110d1f4103c6953beaead438",+ "method": "docs",+ "sourceUrl": "https://docs.together.ai/docs/inference/openai-compatibility.md",+ "observedAt": "2026-10-12T10:09:42.290Z"+ },+ {+ "evidenceId": "wev_eb3adb8fa231ef31f4698622fd913915",+ "method": "docs",+ "sourceUrl": "https://docs.together.ai/docs/inference/chat/parameters.md",+ "observedAt": "2026-10-12T10:09:42.288Z"+ },+ {+ "evidenceId": "wev_03243b5141777c80b7a5e6fca12b17dd",+ "method": "probe",+ "observedAt": "2026-10-09T16:01:23.382Z"+ }+ ]+ }+ }+ ],+ "supportsVision": true,+ "supportsTools": true,+ "supportsThinking": true,+ "videoInput": false,+ "videoOutput": false,+ "reasoning": {+ "supported": true,+ "mandatory": false,+ "control": "effort",+ "efforts": [+ "max",+ "high",+ "low"+ ],+ "defaultEffort": "high"+ },+ "endpoints": {+ "openai": {+ "api": "responses",+ "toolsWithReasoning": "ok"+ }+ },+ "tokenParam": "max_output_tokens"+ },+ {+ "contractVersion": 3,+ "modelId": "gemini-3.8-flash",+ "displayName": "Gemini 3.8 Flash",+ "provider": "google",+ "aliases": [+ "google/gemini-3.8-flash",+ "google/gemini-3.8-flash:batch"+ ],+ "status": "active",+ "releaseDate": "2026-09-02",+ "contextWindow": 1048576,+ "maxOutputTokens": 65536,+ "inputModalities": [+ "audio",+ "image",+ "text",+ "video"+ ],+ "outputModalities": [+ "text"+ ],+ "aggregators": [+ {+ "sourceProviderId": "google",+ "sourceCollectorId": "google-api",+ "confidence": "api_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "google",+ "routeProfileId": "direct-api"+ },+ "externalModelId": "gemini-3.8-flash",+ "pricing": {+ "type": "flat",+ "input": 0.75,+ "output": 3.75+ },+ "reasoning": {+ "request": {+ "status": "unknown"+ }+ },+ "wire": {+ "status": "known",+ "api": "gemini",+ "tokenParam": {+ "status": "not_applicable"+ },+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "unknown"+ },+ "speed": {+ "status": "unknown"+ },+ "evidence": [+ {+ "evidenceId": "wev_dcc54a85c1331c897174f99a36487f6d",+ "method": "api",+ "sourceUrl": "https://generativelanguage.googleapis.com/v1beta/models",+ "observedAt": "2026-10-12T10:10:01.861Z"+ },+ {+ "evidenceId": "wev_369f8f4a85b5461804d8c4052d2871e6",+ "method": "probe",+ "observedAt": "2026-10-11T22:10:51.077Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "opencode-zen",+ "sourceCollectorId": "opencode-zen-api",+ "confidence": "gateway_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "opencode",+ "routeProfileId": "zen"+ },+ "externalModelId": "gemini-3.8-flash",+ "pricing": {+ "type": "flat",+ "input": 1.5,+ "output": 7.5,+ "cachedRead": 0.15+ },+ "reasoning": {+ "request": {+ "status": "unknown"+ }+ },+ "wire": {+ "status": "known",+ "api": "gemini",+ "tokenParam": {+ "status": "not_applicable"+ },+ "toolsWithReasoning": {+ "status": "unknown"+ },+ "reasoning": {+ "status": "unknown"+ },+ "speed": {+ "status": "unknown"+ },+ "evidence": [+ {+ "evidenceId": "wev_68da2cf7ef3a1f5ce6c7ed9d5ee13312",+ "method": "endpoint-table",+ "sourceUrl": "https://opencode.ai/docs/en/zen/",+ "observedAt": "2026-10-12T10:09:23.090Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "openrouter",+ "sourceCollectorId": "openrouter-api",+ "confidence": "aggregator_reported",+ "routeStatus": "mapped",+ "route": {+ "routeId": "openrouter",+ "routeProfileId": "gateway"+ },+ "externalModelId": "google/gemini-3.8-flash",+ "pricing": {+ "type": "flat",+ "input": 0.75,+ "output": 3.75,+ "cachedRead": 0.075,+ "batchDiscountPct": 50+ },+ "reasoning": {+ "request": {+ "status": "supported",+ "api": "chat-completions",+ "evidenceSourceUrl": "https://openrouter.ai/api/v1/models",+ "enable": [+ {+ "path": "/reasoning/enabled",+ "value": true+ }+ ],+ "effort": {+ "path": "/reasoning/effort",+ "values": {+ "high": "high",+ "medium": "medium",+ "low": "low"+ },+ "default": "medium"+ }+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": [+ {+ "path": "/reasoning/enabled",+ "value": true+ }+ ],+ "disable": {+ "status": "not_applicable"+ },+ "effort": {+ "path": "/reasoning/effort",+ "values": {+ "high": "high",+ "medium": "medium",+ "low": "low"+ },+ "default": "medium"+ },+ "mode": {+ "status": "not_applicable"+ }+ },+ "speed": {+ "status": "supported",+ "path": "/service_tier",+ "values": {+ "priority": "priority",+ "flex": "flex"+ },+ "default": "standard",+ "headers": [],+ "echo": "/service_tier",+ "access": "open"+ },+ "evidence": [+ {+ "evidenceId": "wev_393b0e2e7aca31300bbfdc0a9a466d06",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_508a8e954cb4513969145e1983b4ad87",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models/google/gemini-3.8-flash/endpoints",+ "observedAt": "2026-10-12T10:09:43.113Z"+ },+ {+ "evidenceId": "wev_5913d6efd218d7d0259fc95a1b9fcb69",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_9f659cc55d9f4e458300193126c6043c",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_a58a332fe35adf5c084e8e7a3a55a70d",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_d044e1e682f7984317ca0479bb8cd624",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_fe0dfdecc12cd5b58c1aad79ab63463b",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_485f7c7eff0a082a550807dd0317c78d",+ "method": "docs",+ "sourceUrl": "https://openrouter.ai/docs/guides/best-practices/reasoning-tokens",+ "observedAt": "2026-10-12T10:09:52.321Z"+ },+ {+ "evidenceId": "wev_5e8bdef4e15d9a63ea4e1b781bb987ab",+ "method": "docs",+ "sourceUrl": "https://openrouter.ai/docs/guides/best-practices/reasoning-tokens",+ "observedAt": "2026-10-12T10:09:52.321Z"+ },+ {+ "evidenceId": "wev_9648640fd30d9b70bdfd3ef19cee5515",+ "method": "docs",+ "sourceUrl": "https://openrouter.ai/docs/guides/best-practices/reasoning-tokens",+ "observedAt": "2026-10-12T10:09:52.321Z"+ },+ {+ "evidenceId": "wev_1589a1cadf56228d93e2884f65d429a0",+ "method": "probe",+ "observedAt": "2026-10-11T21:59:40.563Z"+ },+ {+ "evidenceId": "wev_9efa640e568a0d61bc850f7823841d61",+ "method": "probe",+ "observedAt": "2026-10-11T21:59:51.722Z"+ },+ {+ "evidenceId": "wev_e6e5a61f28dc5e83effaa4bcf0d527ae",+ "method": "probe",+ "observedAt": "2026-10-11T21:59:51.026Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "openrouter",+ "sourceCollectorId": "openrouter-api",+ "confidence": "aggregator_reported",+ "routeStatus": "unknown",+ "reason": "unverified_mapping",+ "observedExternalModelId": "google/gemini-3.8-flash:batch"+ },+ {+ "sourceProviderId": "poe",+ "sourceCollectorId": "poe-api",+ "confidence": "aggregator_reported",+ "routeStatus": "mapped",+ "route": {+ "routeId": "poe",+ "routeProfileId": "gateway"+ },+ "externalModelId": "gemini-3.8-flash",+ "pricing": {+ "type": "flat",+ "input": 0.7575999999999999,+ "output": 3.7879,+ "cachedRead": 0.0758+ },+ "probeEligible": true,+ "reasoning": {+ "request": {+ "status": "unknown"+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": {+ "status": "unknown"+ },+ "reasoning": {+ "status": "unknown"+ },+ "speed": {+ "status": "rejected",+ "path": "/service_tier"+ },+ "evidence": [+ {+ "evidenceId": "wev_e90688077b80e763e20192c81311d97a",+ "method": "api",+ "sourceUrl": "https://api.poe.com/v1/models",+ "observedAt": "2026-10-12T10:09:22.802Z"+ },+ {+ "evidenceId": "wev_7cd91244f23a48ea645359bac7e91fb9",+ "method": "docs",+ "sourceUrl": "https://creator.poe.com/docs/external-applications/openai-compatible-api",+ "observedAt": "2026-10-12T10:09:33.306Z"+ },+ {+ "evidenceId": "wev_95e5a5e70138e35eda932b4c1d0ba81e",+ "method": "docs",+ "sourceUrl": "https://creator.poe.com/docs/external-applications/openai-compatible-api",+ "observedAt": "2026-10-12T10:09:33.306Z"+ },+ {+ "evidenceId": "wev_b7a1a4d5b835dde5ef9e35716b57fb02",+ "method": "probe",+ "observedAt": "2026-10-11T22:10:09.647Z"+ }+ ]+ }+ }+ ],+ "supportsVision": true,+ "supportsTools": true,+ "videoInput": true,+ "videoOutput": false,+ "reasoning": {+ "supported": true,+ "mandatory": true,+ "control": "effort",+ "efforts": [+ "high",+ "medium",+ "low"+ ],+ "defaultEffort": "medium"+ },+ "endpoints": {+ "gemini": {+ "api": "gemini",+ "toolsWithReasoning": "ok"+ }+ }+ },+ {+ "contractVersion": 3,+ "modelId": "glm-5.3",+ "displayName": "GLM-5.3",+ "provider": "z-ai",+ "aliases": [+ "z-ai/glm-5.3",+ "z-ai/glm-5.3:batch",+ "zai-org/GLM-5.3",+ "accounts/fireworks/models/glm-5p3",+ "GLM-5.3"+ ],+ "status": "active",+ "releaseDate": "2026-08-14",+ "contextWindow": 1000000,+ "maxOutputTokens": 128000,+ "subscriptionPlanIds": [+ "alibaba-token-plan-individual",+ "alibaba-token-plan-team-edition",+ "ollama-cloud",+ "opencode-go",+ "opencode-go-plus",+ "z-ai-glm-coding-plan"+ ],+ "inputModalities": [+ "text"+ ],+ "outputModalities": [+ "text"+ ],+ "aggregators": [+ {+ "sourceProviderId": "fireworks",+ "sourceCollectorId": "fireworks-api",+ "confidence": "aggregator_reported",+ "routeStatus": "mapped",+ "route": {+ "routeId": "fireworks",+ "routeProfileId": "gateway"+ },+ "externalModelId": "accounts/fireworks/models/glm-5p3",+ "pricing": {+ "type": "unavailable"+ },+ "reasoning": {+ "mode": {+ "status": "unknown"+ },+ "request": {+ "status": "supported",+ "api": "chat-completions",+ "evidenceSourceUrl": "https://docs.z.ai/guides/llm/glm-5.3",+ "enable": [+ {+ "path": "/thinking/type",+ "value": "enabled"+ }+ ],+ "effort": {+ "path": "/reasoning_effort",+ "values": {+ "max": "max",+ "high": "high",+ "low": "low"+ },+ "default": "max"+ }+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": [+ {+ "path": "/thinking/type",+ "value": "enabled"+ }+ ],+ "disable": {+ "status": "not_applicable"+ },+ "effort": {+ "path": "/reasoning_effort",+ "values": {+ "max": "max",+ "high": "high",+ "low": "low"+ },+ "default": "max"+ },+ "mode": {+ "status": "unknown"+ }+ },+ "speed": {+ "status": "supported",+ "path": "/service_tier",+ "values": {+ "priority": "priority"+ },+ "default": "standard",+ "headers": [],+ "echo": {+ "status": "not_applicable"+ },+ "access": "open"+ },+ "evidence": [+ {+ "evidenceId": "wev_610c3888a1f4a9bd6e64e83da0a3d17e",+ "method": "api",+ "sourceUrl": "https://api.fireworks.ai/inference/v1/models",+ "observedAt": "2026-10-12T10:09:22.214Z"+ },+ {+ "evidenceId": "wev_1002b3700513e12a5381dec50886d278",+ "method": "docs",+ "sourceUrl": "https://docs.z.ai/guides/llm/glm-5.3",+ "observedAt": "2026-10-12T10:09:43.797Z"+ },+ {+ "evidenceId": "wev_2dfb1e726696b0fbd7e2498e063123a9",+ "method": "docs",+ "sourceUrl": "https://docs.fireworks.ai/tools-sdks/openai-compatibility.md",+ "observedAt": "2026-10-12T10:09:50.512Z"+ },+ {+ "evidenceId": "wev_33f4fc0ac8c18d31707fb7f8ba87ace4",+ "method": "docs",+ "sourceUrl": "https://docs.z.ai/guides/llm/glm-5.3",+ "observedAt": "2026-10-12T10:09:43.797Z"+ },+ {+ "evidenceId": "wev_4b09ed0b8622683292242d6bcea29661",+ "method": "docs",+ "sourceUrl": "https://docs.z.ai/guides/llm/glm-5.3",+ "observedAt": "2026-10-12T10:09:43.797Z"+ },+ {+ "evidenceId": "wev_92252816636dbc617864d4411aa91e63",+ "method": "docs",+ "sourceUrl": "https://docs.fireworks.ai/serverless/pricing.md",+ "observedAt": "2026-10-12T10:09:35.878Z"+ },+ {+ "evidenceId": "wev_9fa864f143a027ce953258cd5e41b5e5",+ "method": "docs",+ "sourceUrl": "https://docs.fireworks.ai/serverless/serverless-modes.md",+ "observedAt": "2026-10-12T10:09:37.403Z"+ },+ {+ "evidenceId": "wev_bd15401e57869f5df9364723fa21fd9e",+ "method": "docs",+ "sourceUrl": "https://docs.z.ai/guides/llm/glm-5.3",+ "observedAt": "2026-10-12T10:09:43.797Z"+ },+ {+ "evidenceId": "wev_e910be9fe07437f1753bb82753a43a4c",+ "method": "docs",+ "sourceUrl": "https://docs.z.ai/guides/llm/glm-5.3",+ "observedAt": "2026-10-12T10:09:43.797Z"+ },+ {+ "evidenceId": "wev_099bfd2cdb8fa848f6ac2602d9afa7ac",+ "method": "probe",+ "observedAt": "2026-10-11T19:40:00.599Z"+ },+ {+ "evidenceId": "wev_4dc6b39cda2eb0dd8f05534cb88fc678",+ "method": "probe",+ "observedAt": "2026-10-11T19:40:17.320Z"+ },+ {+ "evidenceId": "wev_b70fc09af1e2fb3bc9216f510e6b49d8",+ "method": "probe",+ "observedAt": "2026-10-11T19:40:15.113Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "ollamacloud",+ "sourceCollectorId": "ollama-cloud-api",+ "confidence": "gateway_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "ollama",+ "routeProfileId": "cloud"+ },+ "externalModelId": "glm-5.3",+ "pricing": {+ "type": "flat",+ "input": 1.4,+ "output": 4.4,+ "cachedRead": 0.26+ },+ "reasoning": {+ "request": {+ "status": "supported",+ "api": "chat-completions",+ "evidenceSourceUrl": "https://ollama.com/api/show",+ "effort": {+ "path": "/reasoning_effort",+ "values": {+ "max": "max",+ "high": "high",+ "low": "low"+ },+ "default": "max"+ }+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": {+ "status": "not_applicable"+ },+ "disable": {+ "status": "not_applicable"+ },+ "effort": {+ "path": "/reasoning_effort",+ "values": {+ "max": "max",+ "high": "high",+ "low": "low"+ },+ "default": "max"+ },+ "mode": {+ "status": "not_applicable"+ }+ },+ "speed": {+ "status": "not_applicable"+ },+ "evidence": [+ {+ "evidenceId": "wev_5e5182de6041c46ebe6b39a406a640fa",+ "method": "api",+ "sourceUrl": "https://ollama.com/api/show",+ "observedAt": "2026-10-12T10:09:22.262Z"+ },+ {+ "evidenceId": "wev_9b48632db9c8b64707f59b943028fa1d",+ "method": "api",+ "sourceUrl": "https://ollama.com/api/show",+ "observedAt": "2026-10-12T10:09:22.262Z"+ },+ {+ "evidenceId": "wev_c5e4cdf9a9872c3f326f413d8de92e11",+ "method": "api",+ "sourceUrl": "https://ollama.com/api/show",+ "observedAt": "2026-10-12T10:09:22.262Z"+ },+ {+ "evidenceId": "wev_1b9edad9246a356567ccf2f818b02d02",+ "method": "docs",+ "sourceUrl": "https://docs.z.ai/guides/llm/glm-5.3",+ "observedAt": "2026-10-12T10:09:43.797Z"+ },+ {+ "evidenceId": "wev_3a18db4f678fa6d6f5b97d05cdcab756",+ "method": "docs",+ "sourceUrl": "https://docs.z.ai/guides/llm/glm-5.3",+ "observedAt": "2026-10-12T10:09:43.797Z"+ },+ {+ "evidenceId": "wev_5628cb7a8cc868b27ffb9e5a7a2fa928",+ "method": "docs",+ "sourceUrl": "https://docs.z.ai/guides/llm/glm-5.3",+ "observedAt": "2026-10-12T10:09:43.797Z"+ },+ {+ "evidenceId": "wev_8c6be59c88179212481878d0663a62aa",+ "method": "docs",+ "sourceUrl": "https://docs.z.ai/guides/llm/glm-5.3",+ "observedAt": "2026-10-12T10:09:43.797Z"+ },+ {+ "evidenceId": "wev_90cdae3e0068262e151f2cdfaf38bbb6",+ "method": "docs",+ "sourceUrl": "https://ollama.com/library/glm-5.3",+ "observedAt": "2026-10-12T10:09:31.920Z"+ },+ {+ "evidenceId": "wev_c4ef5de668141c6479681231bdf2867c",+ "method": "docs",+ "sourceUrl": "https://ollama.com/library/glm-5.3",+ "observedAt": "2026-10-12T10:09:31.920Z"+ },+ {+ "evidenceId": "wev_eb9d69084278c29250cf7f67bbdcda32",+ "method": "docs",+ "sourceUrl": "https://ollama.com/pricing",+ "observedAt": "2026-10-12T10:09:43.892Z"+ },+ {+ "evidenceId": "wev_f854904293b746650da332319652fdd2",+ "method": "docs",+ "sourceUrl": "https://ollama.com/library/glm-5.3",+ "observedAt": "2026-10-12T10:09:31.920Z"+ },+ {+ "evidenceId": "wev_65563eef6291cd1f584776485a6a83c2",+ "method": "probe",+ "observedAt": "2026-10-11T19:53:12.849Z"+ },+ {+ "evidenceId": "wev_92d415421f36c2888bef8dc93363f637",+ "method": "probe",+ "observedAt": "2026-10-11T19:52:58.052Z"+ },+ {+ "evidenceId": "wev_cd8a80df4883a4f4d188f8f18d61ed75",+ "method": "probe",+ "observedAt": "2026-10-11T19:53:12.849Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "opencode-go",+ "sourceCollectorId": "popular-coding-subscriptions",+ "confidence": "gateway_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "opencode",+ "routeProfileId": "go-subscription"+ },+ "externalModelId": "glm-5.3",+ "reasoning": {+ "mode": {+ "status": "unknown"+ },+ "request": {+ "status": "supported",+ "api": "chat-completions",+ "evidenceSourceUrl": "https://docs.z.ai/guides/llm/glm-5.3",+ "enable": [+ {+ "path": "/thinking/type",+ "value": "enabled"+ }+ ],+ "effort": {+ "path": "/reasoning_effort",+ "values": {+ "max": "max",+ "high": "high",+ "low": "low"+ },+ "default": "max"+ }+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": [+ {+ "path": "/thinking/type",+ "value": "enabled"+ }+ ],+ "disable": {+ "status": "not_applicable"+ },+ "effort": {+ "path": "/reasoning_effort",+ "values": {+ "max": "max",+ "high": "high",+ "low": "low"+ },+ "default": "max"+ },+ "mode": {+ "status": "unknown"+ }+ },+ "speed": {+ "status": "unknown"+ },+ "evidence": [+ {+ "evidenceId": "wev_2121d240fb53e4246a88fb69f6646646",+ "method": "docs",+ "sourceUrl": "https://docs.z.ai/guides/llm/glm-5.3",+ "observedAt": "2026-10-12T10:09:43.797Z"+ },+ {+ "evidenceId": "wev_349b27e8d04a4a10e59d84a5ffadda8c",+ "method": "docs",+ "sourceUrl": "https://docs.z.ai/guides/llm/glm-5.3",+ "observedAt": "2026-10-12T10:09:43.797Z"+ },+ {+ "evidenceId": "wev_9e1ed7454571f14f278d1cd418f6efa1",+ "method": "docs",+ "sourceUrl": "https://docs.z.ai/guides/llm/glm-5.3",+ "observedAt": "2026-10-12T10:09:43.797Z"+ },+ {+ "evidenceId": "wev_bd5983827839cfd7017f1318d1bbdf43",+ "method": "docs",+ "sourceUrl": "https://docs.z.ai/guides/llm/glm-5.3",+ "observedAt": "2026-10-12T10:09:43.797Z"+ },+ {+ "evidenceId": "wev_c1abf6249cde1ea613ddd620c6e18138",+ "method": "docs",+ "sourceUrl": "https://docs.z.ai/guides/llm/glm-5.3",+ "observedAt": "2026-10-12T10:09:43.797Z"+ },+ {+ "evidenceId": "wev_f4b629d45ffcc222756ab7a60d18c7d7",+ "method": "docs",+ "sourceUrl": "https://docs.z.ai/guides/llm/glm-5.3",+ "observedAt": "2026-10-12T10:09:43.797Z"+ },+ {+ "evidenceId": "wev_953b9374d3fb14e8d19b1a54792359ab",+ "method": "endpoint-table",+ "sourceUrl": "https://opencode.ai/v2/docs/console/go",+ "observedAt": "2026-10-12T10:09:25.039Z"+ },+ {+ "evidenceId": "wev_cec8297541b86a327e8e6b2084c2a47b",+ "method": "probe",+ "observedAt": "2026-10-09T13:02:39.564Z"+ },+ {+ "evidenceId": "wev_eeeb3ccaaa24d522579925a10903c562",+ "method": "probe",+ "observedAt": "2026-10-09T13:02:47.658Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "opencode-zen",+ "sourceCollectorId": "opencode-zen-api",+ "confidence": "gateway_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "opencode",+ "routeProfileId": "zen"+ },+ "externalModelId": "glm-5.3",+ "pricing": {+ "type": "flat",+ "input": 1.4,+ "output": 4.4,+ "cachedRead": 0.26+ },+ "reasoning": {+ "request": {+ "status": "unknown"+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": {+ "status": "unknown"+ },+ "toolsWithReasoning": {+ "status": "unknown"+ },+ "reasoning": {+ "status": "unknown"+ },+ "speed": {+ "status": "unknown"+ },+ "evidence": [+ {+ "evidenceId": "wev_a84d947a63ae690c78cff1db01784099",+ "method": "endpoint-table",+ "sourceUrl": "https://opencode.ai/docs/en/zen/",+ "observedAt": "2026-10-12T10:09:23.090Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "openrouter",+ "sourceCollectorId": "openrouter-api",+ "confidence": "aggregator_reported",+ "routeStatus": "mapped",+ "route": {+ "routeId": "openrouter",+ "routeProfileId": "gateway"+ },+ "externalModelId": "z-ai/glm-5.3",+ "pricing": {+ "type": "flat",+ "input": 0.079,+ "output": 4.8,+ "cachedRead": 0.059+ },+ "reasoning": {+ "request": {+ "status": "supported",+ "api": "chat-completions",+ "evidenceSourceUrl": "https://openrouter.ai/api/v1/models",+ "enable": [+ {+ "path": "/reasoning/enabled",+ "value": true+ }+ ],+ "effort": {+ "path": "/reasoning/effort",+ "values": {+ "max": "max",+ "high": "high",+ "low": "low"+ },+ "default": "max"+ }+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": [+ {+ "path": "/reasoning/enabled",+ "value": true+ }+ ],+ "disable": {+ "status": "not_applicable"+ },+ "effort": {+ "path": "/reasoning/effort",+ "values": {+ "max": "max",+ "high": "high",+ "low": "low"+ },+ "default": "max"+ },+ "mode": {+ "status": "not_applicable"+ }+ },+ "speed": {+ "status": "unknown"+ },+ "evidence": [+ {+ "evidenceId": "wev_0e75b6ef07fa5f58534c3f9b306205b6",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_242fe295ee005d4dabb816044a0f993b",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_5632aba3779866734c27d9e97a18a562",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_578e27bd50a7fab86d2996ac90d0b21a",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_858f787f0a2d3adfd26a70dc3baf94d3",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_aa70f8833c3b7ec2306b20b91959f124",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_0ff10ad1a361c85dab4c05523a571c72",+ "method": "docs",+ "sourceUrl": "https://openrouter.ai/docs/guides/best-practices/reasoning-tokens",+ "observedAt": "2026-10-12T10:09:52.321Z"+ },+ {+ "evidenceId": "wev_139ab35ae83b146b7e50443413369e44",+ "method": "docs",+ "sourceUrl": "https://docs.z.ai/guides/llm/glm-5.3",+ "observedAt": "2026-10-12T10:09:43.797Z"+ },+ {+ "evidenceId": "wev_46a3813ee2da338752c4b5ff0668d39a",+ "method": "docs",+ "sourceUrl": "https://openrouter.ai/docs/guides/best-practices/reasoning-tokens",+ "observedAt": "2026-10-12T10:09:52.321Z"+ },+ {+ "evidenceId": "wev_74fce557da48565ca35a54a735041e07",+ "method": "docs",+ "sourceUrl": "https://docs.z.ai/guides/llm/glm-5.3",+ "observedAt": "2026-10-12T10:09:43.797Z"+ },+ {+ "evidenceId": "wev_9cedb5d8e72de731d84cc9860d48a47f",+ "method": "docs",+ "sourceUrl": "https://openrouter.ai/docs/guides/best-practices/reasoning-tokens",+ "observedAt": "2026-10-12T10:09:52.321Z"+ },+ {+ "evidenceId": "wev_b58531b5c0763823d1443bf7d1b3e8d3",+ "method": "docs",+ "sourceUrl": "https://docs.z.ai/guides/llm/glm-5.3",+ "observedAt": "2026-10-12T10:09:43.797Z"+ },+ {+ "evidenceId": "wev_654d7d8e8cfc0e4d36e255f07559f955",+ "method": "probe",+ "observedAt": "2026-10-11T20:30:26.938Z"+ },+ {+ "evidenceId": "wev_e0b58ac7280bea71fd2bca990b8c6600",+ "method": "probe",+ "observedAt": "2026-10-11T20:30:18.794Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "openrouter",+ "sourceCollectorId": "openrouter-api",+ "confidence": "aggregator_reported",+ "routeStatus": "unknown",+ "reason": "unverified_mapping",+ "observedExternalModelId": "z-ai/glm-5.3:batch"+ },+ {+ "sourceProviderId": "poe",+ "sourceCollectorId": "poe-api",+ "confidence": "aggregator_reported",+ "routeStatus": "mapped",+ "route": {+ "routeId": "poe",+ "routeProfileId": "gateway"+ },+ "externalModelId": "glm-5.3",+ "pricing": {+ "type": "flat",+ "input": 1.4141,+ "output": 4.4444,+ "cachedRead": 0.2626+ },+ "probeEligible": true,+ "reasoning": {+ "request": {+ "status": "supported",+ "api": "chat-completions",+ "evidenceSourceUrl": "https://docs.z.ai/guides/llm/glm-5.3",+ "enable": [+ {+ "path": "/enable_thinking",+ "value": true+ }+ ],+ "effort": {+ "path": "/reasoning_effort",+ "values": {+ "max": "max",+ "high": "high",+ "low": "low"+ },+ "default": "max"+ }+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": [+ {+ "path": "/enable_thinking",+ "value": true+ }+ ],+ "disable": {+ "status": "not_applicable"+ },+ "effort": {+ "path": "/reasoning_effort",+ "values": {+ "max": "max",+ "high": "high",+ "low": "low"+ },+ "default": "max"+ },+ "mode": {+ "status": "not_applicable"+ }+ },+ "speed": {+ "status": "rejected",+ "path": "/service_tier"+ },+ "evidence": [+ {+ "evidenceId": "wev_2b2acfe00cdbd9d9c1f9148dc2e618dc",+ "method": "api",+ "sourceUrl": "https://api.poe.com/v1/models",+ "observedAt": "2026-10-12T10:09:22.802Z"+ },+ {+ "evidenceId": "wev_6761107b6f7c4df302941a073a19189f",+ "method": "docs",+ "sourceUrl": "https://creator.poe.com/docs/external-applications/openai-compatible-api",+ "observedAt": "2026-10-12T10:09:33.306Z"+ },+ {+ "evidenceId": "wev_ac069b4a0b55decdf38b13f12a26d954",+ "method": "docs",+ "sourceUrl": "https://docs.z.ai/guides/llm/glm-5.3",+ "observedAt": "2026-10-12T10:09:43.797Z"+ },+ {+ "evidenceId": "wev_c47ec70f08a0c4bbb067cfec1ee9f6f5",+ "method": "docs",+ "sourceUrl": "https://docs.z.ai/guides/llm/glm-5.3",+ "observedAt": "2026-10-12T10:09:43.797Z"+ },+ {+ "evidenceId": "wev_d7f392cdbba74208f07ce3d3419b5003",+ "method": "docs",+ "sourceUrl": "https://creator.poe.com/docs/external-applications/openai-compatible-api",+ "observedAt": "2026-10-12T10:09:33.306Z"+ },+ {+ "evidenceId": "wev_f1bbb87371a380ce18ae68472058464d",+ "method": "docs",+ "sourceUrl": "https://docs.z.ai/guides/llm/glm-5.3",+ "observedAt": "2026-10-12T10:09:43.797Z"+ },+ {+ "evidenceId": "wev_1fbe1d1a886da7012dd0bf704d93da6e",+ "method": "probe",+ "observedAt": "2026-10-11T19:52:26.742Z"+ },+ {+ "evidenceId": "wev_296352f33c936ad4974de0ff763d240e",+ "method": "probe",+ "observedAt": "2026-10-11T19:52:26.742Z"+ },+ {+ "evidenceId": "wev_5ea8c8884c7c0265d042c65c2dc283ab",+ "method": "probe",+ "observedAt": "2026-10-11T19:47:01.124Z"+ },+ {+ "evidenceId": "wev_6e3b4356f2010b595f4f389ca634e557",+ "method": "probe",+ "observedAt": "2026-10-11T19:46:58.233Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "qwen-cloud",+ "sourceCollectorId": "qwen-cloud-token-plan-scrape",+ "confidence": "scrape_verified",+ "routeStatus": "mapped",+ "route": {+ "routeId": "qwen",+ "routeProfileId": "qwencloud-token-plan"+ },+ "externalModelId": "glm-5.3",+ "reasoning": {+ "request": {+ "status": "supported",+ "api": "chat-completions",+ "evidenceSourceUrl": "https://docs.z.ai/guides/llm/glm-5.3",+ "enable": [+ {+ "path": "/thinking/type",+ "value": "enabled"+ }+ ],+ "effort": {+ "path": "/reasoning_effort",+ "values": {+ "max": "max",+ "high": "high",+ "low": "low"+ },+ "default": "max"+ }+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": "max_completion_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": [+ {+ "path": "/thinking/type",+ "value": "enabled"+ }+ ],+ "disable": {+ "status": "not_applicable"+ },+ "effort": {+ "path": "/reasoning_effort",+ "values": {+ "max": "max",+ "high": "high",+ "low": "low"+ },+ "default": "max"+ },+ "mode": {+ "status": "not_applicable"+ }+ },+ "speed": {+ "status": "not_applicable"+ },+ "evidence": [+ {+ "evidenceId": "wev_07ca1ca95bf82aae851390af48728f56",+ "method": "docs",+ "sourceUrl": "https://docs.z.ai/guides/llm/glm-5.3",+ "observedAt": "2026-10-12T10:09:43.797Z"+ },+ {+ "evidenceId": "wev_32e145c6b1ecae38bf95a0c9c889d8cd",+ "method": "docs",+ "sourceUrl": "https://docs.z.ai/guides/llm/glm-5.3",+ "observedAt": "2026-10-12T10:09:43.797Z"+ },+ {+ "evidenceId": "wev_4806fd591799914139105eba7e8409ae",+ "method": "docs",+ "sourceUrl": "https://docs.qwencloud.com/api-reference/chat/openai-chat.md",+ "observedAt": "2026-10-12T10:09:42.397Z"+ },+ {+ "evidenceId": "wev_690355a82cdeb5c4538432d6bd95f40a",+ "method": "docs",+ "sourceUrl": "https://docs.qwencloud.com/api-reference/chat/openai-chat",+ "observedAt": "2026-10-12T10:09:40.412Z"+ },+ {+ "evidenceId": "wev_72120a8b2414d1ff4f90179f2922c477",+ "method": "docs",+ "sourceUrl": "https://docs.qwencloud.com/token-plan/personal/token-plan-personal-quickstart.md",+ "observedAt": "2026-10-12T10:09:39.169Z"+ },+ {+ "evidenceId": "wev_74477bf3595f09b8c7054e2b33edbd64",+ "method": "docs",+ "sourceUrl": "https://docs.qwencloud.com/token-plan/personal/token-plan-personal-quickstart.md",+ "observedAt": "2026-10-12T10:09:40.705Z"+ },+ {+ "evidenceId": "wev_813d578748c7048901f6636553134289",+ "method": "docs",+ "sourceUrl": "https://docs.z.ai/guides/llm/glm-5.3",+ "observedAt": "2026-10-12T10:09:43.797Z"+ },+ {+ "evidenceId": "wev_8bb641256cce68e7e59487a151b890bc",+ "method": "docs",+ "sourceUrl": "https://docs.z.ai/guides/llm/glm-5.3",+ "observedAt": "2026-10-12T10:09:43.797Z"+ },+ {+ "evidenceId": "wev_92b66f4705437dce1f4b584a5259cbba",+ "method": "docs",+ "sourceUrl": "https://docs.z.ai/guides/llm/glm-5.3",+ "observedAt": "2026-10-12T10:09:43.797Z"+ },+ {+ "evidenceId": "wev_967d9860adcc6499c87a9eef71bb140a",+ "method": "probe",+ "observedAt": "2026-10-11T20:00:49.005Z"+ },+ {+ "evidenceId": "wev_b4c3d9d28e5b7a344d3528f3d02bea97",+ "method": "probe",+ "observedAt": "2026-10-11T20:00:55.923Z"+ },+ {+ "evidenceId": "wev_d32f1e67db7f0d8db86da61c8c068639",+ "method": "probe",+ "observedAt": "2026-10-11T20:00:55.923Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "together-ai",+ "sourceCollectorId": "together-ai-api",+ "confidence": "gateway_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "together-ai",+ "routeProfileId": "gateway"+ },+ "externalModelId": "zai-org/GLM-5.3",+ "pricing": {+ "type": "flat",+ "input": 1.4,+ "output": 4.4+ },+ "probeEligible": true,+ "reasoning": {+ "request": {+ "status": "unknown"+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": {+ "status": "unknown"+ },+ "reasoning": {+ "status": "unknown"+ },+ "speed": {+ "status": "not_applicable"+ },+ "evidence": [+ {+ "evidenceId": "wev_90a0d101ba76fc751fc92f41ace0c290",+ "method": "docs",+ "sourceUrl": "https://docs.together.ai/reference/chat-completions.md",+ "observedAt": "2026-10-12T10:09:50.817Z"+ },+ {+ "evidenceId": "wev_c2e92ab661e9f3de19dcbfa33121b342",+ "method": "docs",+ "sourceUrl": "https://docs.together.ai/docs/inference/chat/parameters.md",+ "observedAt": "2026-10-12T10:09:42.288Z"+ },+ {+ "evidenceId": "wev_e56c1b105b44ea140c7f6446839f1afe",+ "method": "docs",+ "sourceUrl": "https://docs.together.ai/docs/inference/openai-compatibility.md",+ "observedAt": "2026-10-12T10:09:42.290Z"+ },+ {+ "evidenceId": "wev_e73361c1c3515c184ef7eca735175605",+ "method": "docs",+ "sourceUrl": "https://docs.together.ai/docs/inference/openai-compatibility.md",+ "observedAt": "2026-10-12T10:09:42.290Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "z-ai",+ "sourceCollectorId": "zhipu-api",+ "confidence": "api_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "z-ai",+ "routeProfileId": "direct-api"+ },+ "externalModelId": "glm-5.3",+ "pricing": {+ "type": "unavailable"+ },+ "reasoning": {+ "request": {+ "status": "supported",+ "api": "chat-completions",+ "evidenceSourceUrl": "https://docs.z.ai/guides/llm/glm-5.3",+ "enable": [+ {+ "path": "/thinking/type",+ "value": "enabled"+ }+ ],+ "effort": {+ "path": "/reasoning_effort",+ "values": {+ "max": "max",+ "high": "high",+ "low": "low"+ },+ "default": "max"+ }+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": [+ {+ "path": "/thinking/type",+ "value": "enabled"+ }+ ],+ "disable": {+ "status": "not_applicable"+ },+ "effort": {+ "path": "/reasoning_effort",+ "values": {+ "max": "max",+ "high": "high",+ "low": "low"+ },+ "default": "max"+ },+ "mode": {+ "status": "not_applicable"+ }+ },+ "speed": {+ "status": "not_applicable"+ },+ "evidence": [+ {+ "evidenceId": "wev_2c4312bad23339e54f46f9f49afab161",+ "method": "docs",+ "sourceUrl": "https://docs.z.ai/guides/overview/quick-start",+ "observedAt": "2026-10-12T10:09:50.915Z"+ },+ {+ "evidenceId": "wev_3dbba0d71b39042bcb75ba51ece72532",+ "method": "docs",+ "sourceUrl": "https://docs.z.ai/guides/llm/glm-5.3",+ "observedAt": "2026-10-12T10:09:43.797Z"+ },+ {+ "evidenceId": "wev_46382c1f11865a19d151565396bb1786",+ "method": "docs",+ "sourceUrl": "https://docs.z.ai/guides/llm/glm-5.3",+ "observedAt": "2026-10-12T10:09:43.797Z"+ },+ {+ "evidenceId": "wev_4b7ed2da9c50647f7e61a8f3f4b73ca0",+ "method": "docs",+ "sourceUrl": "https://docs.z.ai/guides/llm/glm-5.3",+ "observedAt": "2026-10-12T10:09:43.797Z"+ },+ {+ "evidenceId": "wev_6823574e8a69bd71afb2b4ba426a8204",+ "method": "docs",+ "sourceUrl": "https://docs.z.ai/api-reference/llm/chat-completion.md",+ "observedAt": "2026-10-12T10:09:43.283Z"+ },+ {+ "evidenceId": "wev_7a08c8edef022462ba74f0bf590d6cfd",+ "method": "docs",+ "sourceUrl": "https://docs.z.ai/guides/llm/glm-5.3",+ "observedAt": "2026-10-12T10:09:43.797Z"+ },+ {+ "evidenceId": "wev_d424147a11da550b4326111f24f3c93f",+ "method": "docs",+ "sourceUrl": "https://docs.z.ai/guides/llm/glm-5.3",+ "observedAt": "2026-10-12T10:09:43.797Z"+ },+ {+ "evidenceId": "wev_d8f48d1c616193c4dec92ba57b2bda8d",+ "method": "docs",+ "sourceUrl": "https://docs.z.ai/guides/llm/glm-5.3",+ "observedAt": "2026-10-12T10:09:43.797Z"+ },+ {+ "evidenceId": "wev_e7fa6104b8490d9ac6122fca46d171a8",+ "method": "docs",+ "sourceUrl": "https://docs.z.ai/guides/llm/glm-5.3",+ "observedAt": "2026-10-12T10:09:43.797Z"+ },+ {+ "evidenceId": "wev_8ad51ef6dd4119452ef799e0a8396da8",+ "method": "probe",+ "observedAt": "2026-10-11T22:08:00.643Z"+ },+ {+ "evidenceId": "wev_90c1b2da43567bda32f451e319d66cdb",+ "method": "probe",+ "observedAt": "2026-10-11T22:08:00.643Z"+ },+ {+ "evidenceId": "wev_b19dbcd433d545109e39a30f743a5907",+ "method": "probe",+ "observedAt": "2026-10-11T22:07:58.733Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "zai-glm-coding",+ "sourceCollectorId": "zai-glm-coding-plan-docs",+ "confidence": "scrape_verified",+ "routeStatus": "mapped",+ "route": {+ "routeId": "z-ai",+ "routeProfileId": "glm-coding-subscription"+ },+ "externalModelId": "GLM-5.3",+ "reasoning": {+ "request": {+ "status": "supported",+ "api": "chat-completions",+ "evidenceSourceUrl": "https://docs.z.ai/devpack/latest-model.md",+ "enable": [+ {+ "path": "/thinking/type",+ "value": "enabled"+ }+ ],+ "effort": {+ "path": "/reasoning_effort",+ "values": {+ "max": "max",+ "high": "high",+ "low": "low"+ },+ "default": "max"+ }+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": [+ {+ "path": "/thinking/type",+ "value": "enabled"+ }+ ],+ "disable": {+ "status": "not_applicable"+ },+ "effort": {+ "path": "/reasoning_effort",+ "values": {+ "max": "max",+ "high": "high",+ "low": "low"+ },+ "default": "max"+ },+ "mode": {+ "status": "not_applicable"+ }+ },+ "speed": {+ "status": "not_applicable"+ },+ "evidence": [+ {+ "evidenceId": "wev_0180befbc436b9e90f9de8663ec9a5a0",+ "method": "docs",+ "sourceUrl": "https://docs.z.ai/devpack/latest-model.md",+ "observedAt": "2026-10-12T10:09:43.410Z"+ },+ {+ "evidenceId": "wev_3785a4b50b18c47aa2f17f4c21c1750f",+ "method": "docs",+ "sourceUrl": "https://docs.z.ai/devpack/latest-model.md",+ "observedAt": "2026-10-12T10:09:43.410Z"+ },+ {+ "evidenceId": "wev_3d68b864d8c69a74c4d85153447a9a1e",+ "method": "docs",+ "sourceUrl": "https://docs.z.ai/devpack/latest-model.md",+ "observedAt": "2026-10-12T10:09:43.410Z"+ },+ {+ "evidenceId": "wev_5fca3dda573cee379e947acd8b2d4e91",+ "method": "docs",+ "sourceUrl": "https://docs.z.ai/devpack/quick-start.md",+ "observedAt": "2026-10-12T10:09:43.392Z"+ },+ {+ "evidenceId": "wev_aa486df67af8571dfaff77c22a62fd1c",+ "method": "docs",+ "sourceUrl": "https://docs.z.ai/devpack/latest-model.md",+ "observedAt": "2026-10-12T10:09:43.410Z"+ },+ {+ "evidenceId": "wev_e4d42ec5e13baf7f9cdfde1dc86a092d",+ "method": "docs",+ "sourceUrl": "https://docs.z.ai/devpack/latest-model.md",+ "observedAt": "2026-10-12T10:09:43.410Z"+ },+ {+ "evidenceId": "wev_edb4836c2117143a119951969f177796",+ "method": "docs",+ "sourceUrl": "https://docs.z.ai/devpack/latest-model.md",+ "observedAt": "2026-10-12T10:09:43.410Z"+ },+ {+ "evidenceId": "wev_7c0d48c68f0e063ecd49163286ada430",+ "method": "probe",+ "observedAt": "2026-10-11T22:08:14.789Z"+ },+ {+ "evidenceId": "wev_9159d01af05958d40aeb852944978d5e",+ "method": "probe",+ "observedAt": "2026-10-11T22:08:14.789Z"+ },+ {+ "evidenceId": "wev_bb0857fcee4ccfd7362c36b8489cd780",+ "method": "probe",+ "observedAt": "2026-10-11T22:08:11.497Z"+ }+ ]+ }+ }+ ],+ "supportsVision": false,+ "supportsTools": true,+ "supportsThinking": true,+ "videoInput": false,+ "videoOutput": false,+ "reasoning": {+ "supported": true,+ "mandatory": true,+ "control": "effort",+ "efforts": [+ "max",+ "high",+ "low"+ ],+ "defaultEffort": "max"+ },+ "endpoints": {+ "openai": {+ "api": "chat-completions",+ "toolsWithReasoning": "ok"+ }+ },+ "tokenParam": "max_tokens"+ },+ {+ "contractVersion": 3,+ "modelId": "qwen3.8-max",+ "displayName": "Qwen3.8-Max",+ "provider": "qwen",+ "aliases": [+ "accounts/fireworks/models/qwen3p8-max"+ ],+ "status": "active",+ "releaseDate": "2026-08-02",+ "contextWindow": 1000000,+ "maxOutputTokens": 131072,+ "subscriptionPlanIds": [+ "alibaba-token-plan-individual",+ "alibaba-token-plan-team-edition",+ "opencode-go",+ "opencode-go-plus"+ ],+ "inputModalities": [+ "image",+ "text",+ "video"+ ],+ "outputModalities": [+ "text"+ ],+ "aggregators": [+ {+ "sourceProviderId": "fireworks",+ "sourceCollectorId": "fireworks-api",+ "confidence": "aggregator_reported",+ "routeStatus": "mapped",+ "route": {+ "routeId": "fireworks",+ "routeProfileId": "gateway"+ },+ "externalModelId": "accounts/fireworks/models/qwen3p8-max",+ "pricing": {+ "type": "unavailable"+ },+ "reasoning": {+ "request": {+ "status": "unknown"+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "unknown"+ },+ "speed": {+ "status": "unknown"+ },+ "evidence": [+ {+ "evidenceId": "wev_0286d97afaa1741f7377c135ad21f188",+ "method": "api",+ "sourceUrl": "https://api.fireworks.ai/inference/v1/models",+ "observedAt": "2026-10-12T10:09:22.214Z"+ },+ {+ "evidenceId": "wev_6e4cbc02263dee693315f9bb1097ece8",+ "method": "docs",+ "sourceUrl": "https://docs.fireworks.ai/tools-sdks/openai-compatibility.md",+ "observedAt": "2026-10-12T10:09:50.512Z"+ },+ {+ "evidenceId": "wev_ae9473ecd22295158dcfa7f00fddb891",+ "method": "probe",+ "observedAt": "2026-10-11T22:08:43.100Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "opencode-go",+ "sourceCollectorId": "popular-coding-subscriptions",+ "confidence": "gateway_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "opencode",+ "routeProfileId": "go-subscription"+ },+ "externalModelId": "qwen3.8-max",+ "reasoning": {+ "request": {+ "status": "unknown"+ }+ },+ "wire": {+ "status": "known",+ "api": "anthropic-messages",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": {+ "status": "unknown"+ },+ "reasoning": {+ "status": "unknown"+ },+ "speed": {+ "status": "unknown"+ },+ "evidence": [+ {+ "evidenceId": "wev_1a0042c916f6775059c28dbdfd211f3f",+ "method": "endpoint-table",+ "sourceUrl": "https://opencode.ai/v2/docs/console/go",+ "observedAt": "2026-10-12T10:09:25.039Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "opencode-zen",+ "sourceCollectorId": "opencode-zen-api",+ "confidence": "gateway_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "opencode",+ "routeProfileId": "zen"+ },+ "externalModelId": "qwen3.8-max",+ "pricing": {+ "type": "flat",+ "input": 2,+ "output": 6,+ "cachedRead": 0.25,+ "cachedWrite": 2.5+ },+ "reasoning": {+ "request": {+ "status": "unknown"+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": {+ "status": "unknown"+ },+ "toolsWithReasoning": {+ "status": "unknown"+ },+ "reasoning": {+ "status": "unknown"+ },+ "speed": {+ "status": "unknown"+ },+ "evidence": [+ {+ "evidenceId": "wev_60630e82fe0021ddbce3521ae90990b3",+ "method": "endpoint-table",+ "sourceUrl": "https://opencode.ai/docs/en/zen/",+ "observedAt": "2026-10-12T10:09:23.090Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "qwen-cloud",+ "sourceCollectorId": "qwen-cloud-token-plan-scrape",+ "confidence": "scrape_verified",+ "routeStatus": "mapped",+ "route": {+ "routeId": "qwen",+ "routeProfileId": "qwencloud-token-plan"+ },+ "externalModelId": "qwen3.8-max",+ "reasoning": {+ "request": {+ "status": "unknown"+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": "max_completion_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "unknown"+ },+ "speed": {+ "status": "not_applicable"+ },+ "evidence": [+ {+ "evidenceId": "wev_0b6fb78accbe34acd8c0bc889ae091d4",+ "method": "docs",+ "sourceUrl": "https://docs.qwencloud.com/api-reference/chat/openai-chat.md",+ "observedAt": "2026-10-12T10:09:42.397Z"+ },+ {+ "evidenceId": "wev_3352f1d106ef07a82ca2f2b4c1f7df08",+ "method": "docs",+ "sourceUrl": "https://docs.qwencloud.com/token-plan/personal/token-plan-personal-quickstart.md",+ "observedAt": "2026-10-12T10:09:40.705Z"+ },+ {+ "evidenceId": "wev_d150271a5a1adce20a915d2d7ce26d95",+ "method": "docs",+ "sourceUrl": "https://docs.qwencloud.com/api-reference/chat/openai-chat",+ "observedAt": "2026-10-12T10:09:40.412Z"+ },+ {+ "evidenceId": "wev_f10541c25c330f59646410480a7e1c96",+ "method": "docs",+ "sourceUrl": "https://docs.qwencloud.com/token-plan/personal/token-plan-personal-quickstart.md",+ "observedAt": "2026-10-12T10:09:39.169Z"+ },+ {+ "evidenceId": "wev_8a7485f7bfd66052ebff4f4a6c2a52f7",+ "method": "probe",+ "observedAt": "2026-10-11T22:10:01.153Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "qwen",+ "sourceCollectorId": "dashscope-api",+ "confidence": "api_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "qwen",+ "routeProfileId": "dashscope-direct"+ },+ "externalModelId": "qwen3.8-max",+ "pricing": {+ "type": "unavailable"+ },+ "reasoning": {+ "request": {+ "status": "supported",+ "api": "responses",+ "evidenceSourceUrl": "https://www.alibabacloud.com/help/en/model-studio/qwen-api-via-openai-responses.md",+ "effort": {+ "path": "/reasoning/effort",+ "values": {+ "xhigh": "xhigh",+ "medium": "medium",+ "low": "low"+ },+ "default": "xhigh"+ }+ }+ },+ "wire": {+ "status": "known",+ "api": "responses",+ "tokenParam": "max_output_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": {+ "status": "unknown"+ },+ "disable": {+ "status": "unknown"+ },+ "effort": {+ "path": "/reasoning/effort",+ "values": {+ "xhigh": "xhigh",+ "medium": "medium",+ "low": "low"+ },+ "default": "xhigh"+ },+ "mode": {+ "status": "not_applicable"+ }+ },+ "speed": {+ "status": "not_applicable"+ },+ "evidence": [+ {+ "evidenceId": "wev_25c0ca5ccc3c339d8727c29fae38e9a7",+ "method": "docs",+ "sourceUrl": "https://www.alibabacloud.com/help/en/model-studio/qwen-api-via-openai-responses.md",+ "observedAt": "2026-10-12T10:09:21.560Z"+ },+ {+ "evidenceId": "wev_427fc5663cc7507780d559298af14ba1",+ "method": "docs",+ "sourceUrl": "https://www.alibabacloud.com/help/en/model-studio/qwen-api-via-openai-responses.md",+ "observedAt": "2026-10-12T10:09:21.560Z"+ },+ {+ "evidenceId": "wev_8ac4b2b49a87a5290a379f0dc5bb5ec3",+ "method": "docs",+ "sourceUrl": "https://www.alibabacloud.com/help/en/model-studio/qwen-api-via-openai-responses.md",+ "observedAt": "2026-10-12T10:09:21.560Z"+ },+ {+ "evidenceId": "wev_96e244cc8e3a801651b3a72206650903",+ "method": "docs",+ "sourceUrl": "https://www.alibabacloud.com/help/en/model-studio/qwen-api-via-openai-responses.md",+ "observedAt": "2026-10-12T10:09:21.560Z"+ },+ {+ "evidenceId": "wev_b18d5de39ca997418cec6fe4ddd55664",+ "method": "docs",+ "sourceUrl": "https://www.alibabacloud.com/help/en/model-studio/qwen-api-via-openai-responses",+ "observedAt": "2026-10-12T10:09:53.969Z"+ },+ {+ "evidenceId": "wev_12469f39cececab36f8529d1a5e1ea66",+ "method": "probe",+ "observedAt": "2026-10-11T22:08:52.210Z"+ },+ {+ "evidenceId": "wev_d932261b4ffeaf44248502b187378b91",+ "method": "probe",+ "observedAt": "2026-10-11T22:08:52.210Z"+ },+ {+ "evidenceId": "wev_dd84c9e233d325ae8e7bb71dace68b19",+ "method": "probe",+ "observedAt": "2026-10-11T22:08:51.209Z"+ }+ ]+ }+ }+ ],+ "supportsVision": true,+ "supportsTools": true,+ "supportsThinking": true,+ "videoInput": true,+ "videoOutput": false,+ "reasoning": {+ "supported": true,+ "mandatory": false,+ "control": "effort",+ "efforts": [+ "xhigh",+ "medium",+ "low"+ ],+ "defaultEffort": "xhigh"+ },+ "endpoints": {+ "openai": {+ "api": "responses",+ "toolsWithReasoning": "ok"+ }+ },+ "tokenParam": "max_output_tokens"+ },+ {+ "contractVersion": 3,+ "modelId": "kimi-k3",+ "displayName": "Kimi K3",+ "provider": "moonshotai",+ "aliases": [+ "moonshotai/kimi-k3",+ "moonshotai/kimi-k3:batch",+ "moonshotai/Kimi-K3",+ "accounts/fireworks/models/kimi-k3",+ "k3"+ ],+ "status": "active",+ "releaseDate": "2026-07-16",+ "contextWindow": 1048576,+ "subscriptionPlanIds": [+ "kimi-code",+ "ollama-cloud",+ "opencode-go",+ "opencode-go-plus"+ ],+ "inputModalities": [+ "video"+ ],+ "outputModalities": [+ "text"+ ],+ "aggregators": [+ {+ "sourceProviderId": "fireworks",+ "sourceCollectorId": "fireworks-api",+ "confidence": "aggregator_reported",+ "routeStatus": "mapped",+ "route": {+ "routeId": "fireworks",+ "routeProfileId": "gateway"+ },+ "externalModelId": "accounts/fireworks/models/kimi-k3",+ "pricing": {+ "type": "unavailable"+ },+ "reasoning": {+ "mode": {+ "status": "rejected"+ },+ "request": {+ "status": "supported",+ "api": "chat-completions",+ "evidenceSourceUrl": "https://docs.fireworks.ai/api-reference/post-chatcompletions.md",+ "effort": {+ "path": "/reasoning_effort",+ "values": {+ "max": "max",+ "high": "high",+ "low": "low"+ },+ "default": "max"+ }+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": {+ "status": "not_applicable"+ },+ "disable": {+ "status": "not_applicable"+ },+ "effort": {+ "path": "/reasoning_effort",+ "values": {+ "max": "max",+ "high": "high",+ "low": "low"+ },+ "default": "max"+ },+ "mode": {+ "status": "rejected",+ "path": "/reasoning/mode"+ }+ },+ "speed": {+ "status": "supported",+ "path": "/service_tier",+ "values": {+ "priority": "priority"+ },+ "default": "standard",+ "headers": [],+ "echo": {+ "status": "not_applicable"+ },+ "access": "open"+ },+ "evidence": [+ {+ "evidenceId": "wev_1839019a7da1a7499627c0b16dac7237",+ "method": "api",+ "sourceUrl": "https://api.fireworks.ai/inference/v1/models",+ "observedAt": "2026-10-12T10:09:22.214Z"+ },+ {+ "evidenceId": "wev_499e08d004bf254386ad88fd1069c756",+ "method": "api",+ "sourceUrl": "https://api.moonshot.ai/v1/models",+ "observedAt": "2026-10-12T10:09:22.368Z"+ },+ {+ "evidenceId": "wev_0e5d92cc2578bde4a965bf92e3b2c1f4",+ "method": "docs",+ "sourceUrl": "https://platform.kimi.ai/docs/guide/kimi-k3-quickstart.md",+ "observedAt": "2026-10-12T10:09:46.379Z"+ },+ {+ "evidenceId": "wev_3de4e092299b3198bcefd398a79d7928",+ "method": "docs",+ "sourceUrl": "https://docs.fireworks.ai/api-reference/post-chatcompletions.md",+ "observedAt": "2026-10-12T10:09:25.340Z"+ },+ {+ "evidenceId": "wev_96faed81a0e5cddfa70603040be95c37",+ "method": "docs",+ "sourceUrl": "https://docs.fireworks.ai/api-reference/post-chatcompletions.md",+ "observedAt": "2026-10-12T10:09:25.340Z"+ },+ {+ "evidenceId": "wev_a7dba9263a387cdb22816aab40e5c217",+ "method": "docs",+ "sourceUrl": "https://platform.kimi.ai/docs/guide/kimi-k3-quickstart.md",+ "observedAt": "2026-10-12T10:09:46.379Z"+ },+ {+ "evidenceId": "wev_aa52a85b40e027f84055a1df2f475ebd",+ "method": "docs",+ "sourceUrl": "https://docs.fireworks.ai/serverless/serverless-modes.md",+ "observedAt": "2026-10-12T10:09:37.403Z"+ },+ {+ "evidenceId": "wev_ad6789e872865960897cbc751e0eb9b2",+ "method": "docs",+ "sourceUrl": "https://docs.fireworks.ai/tools-sdks/openai-compatibility.md",+ "observedAt": "2026-10-12T10:09:50.512Z"+ },+ {+ "evidenceId": "wev_ef6950bb3b5e7a8ff7777b2141465b4f",+ "method": "docs",+ "sourceUrl": "https://docs.fireworks.ai/serverless/pricing.md",+ "observedAt": "2026-10-12T10:09:35.878Z"+ },+ {+ "evidenceId": "wev_f27c0e598aaaf60100041c3b84f68c0a",+ "method": "docs",+ "sourceUrl": "https://docs.fireworks.ai/api-reference/post-chatcompletions.md",+ "observedAt": "2026-10-12T10:09:25.340Z"+ },+ {+ "evidenceId": "wev_3918ae665d7f97d06e39bd46c97c639d",+ "method": "probe",+ "observedAt": "2026-10-11T19:44:32.521Z"+ },+ {+ "evidenceId": "wev_84590856181637bbe0324fb7163ecb24",+ "method": "probe",+ "observedAt": "2026-10-11T19:45:03.981Z"+ },+ {+ "evidenceId": "wev_96588014b20c1de2f4b04db95b5bd6f4",+ "method": "probe",+ "observedAt": "2026-10-11T19:45:01.358Z"+ },+ {+ "evidenceId": "wev_f1ca26181a086cf336495036f5658a0c",+ "method": "probe",+ "observedAt": "2026-10-11T19:45:03.981Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "kimi-code",+ "sourceCollectorId": "kimi-code-models",+ "confidence": "gateway_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "moonshotai",+ "routeProfileId": "kimi-code-subscription"+ },+ "externalModelId": "k3",+ "reasoning": {+ "request": {+ "status": "supported",+ "api": "chat-completions",+ "evidenceSourceUrl": "https://www.kimi.com/code/docs/en/kimi-code/models.html",+ "effort": {+ "path": "/reasoning_effort",+ "values": {+ "max": "max",+ "high": "high",+ "low": "low"+ },+ "default": "high"+ }+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": "max_completion_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": {+ "status": "unknown"+ },+ "disable": [+ {+ "path": "/reasoning_effort",+ "value": "none"+ }+ ],+ "effort": {+ "path": "/reasoning_effort",+ "values": {+ "max": "max",+ "high": "high",+ "low": "low"+ },+ "default": "high"+ },+ "mode": {+ "status": "not_applicable"+ },+ "warnings": [+ {+ "code": "served_model_changes",+ "part": "disable",+ "servedModel": "K2.8 Preview",+ "evidence": [+ {+ "evidenceId": "wev_d47364e2f32d6d849775521ef3b18329",+ "method": "docs",+ "sourceUrl": "https://www.kimi.com/code/docs/en/kimi-code/models.html",+ "observedAt": "2026-10-12T10:09:49.166Z"+ },+ {+ "evidenceId": "wev_d68dd1d98ae6dee8dfa71ca57c453a36",+ "method": "probe",+ "observedAt": "2026-10-11T22:07:42.654Z"+ }+ ]+ }+ ]+ },+ "speed": {+ "status": "unknown"+ },+ "evidence": [+ {+ "evidenceId": "wev_07b993cc1976ff89bde2ad9975968383",+ "method": "docs",+ "sourceUrl": "https://www.kimi.com/code/docs/en/kimi-code/models.html",+ "observedAt": "2026-10-12T10:09:49.166Z"+ },+ {+ "evidenceId": "wev_20d7c2bd1df3bb17df5df4bc9a9ac6c9",+ "method": "docs",+ "sourceUrl": "https://www.kimi.com/code/docs/en/kimi-code/models.html",+ "observedAt": "2026-10-12T10:09:49.166Z"+ },+ {+ "evidenceId": "wev_6c35b172e1d5abed2a49f40e65259107",+ "method": "docs",+ "sourceUrl": "https://www.kimi.com/code/docs/en/kimi-code/models.html",+ "observedAt": "2026-10-12T10:09:49.166Z"+ },+ {+ "evidenceId": "wev_7e20f7f733024b64ea4c8ad152a236c5",+ "method": "docs",+ "sourceUrl": "https://www.kimi.com/code/docs/en/kimi-code/models.html",+ "observedAt": "2026-10-12T10:09:49.166Z"+ },+ {+ "evidenceId": "wev_83ab7d61d4d41609092cc3f750afbca8",+ "method": "docs",+ "sourceUrl": "https://www.kimi.com/code/docs/en/kimi-code/models.html",+ "observedAt": "2026-10-12T10:09:49.166Z"+ },+ {+ "evidenceId": "wev_d47364e2f32d6d849775521ef3b18329",+ "method": "docs",+ "sourceUrl": "https://www.kimi.com/code/docs/en/kimi-code/models.html",+ "observedAt": "2026-10-12T10:09:49.166Z"+ },+ {+ "evidenceId": "wev_85805a51e04abe0e02e21626fd9d97a2",+ "method": "probe",+ "observedAt": "2026-10-11T22:07:38.519Z"+ },+ {+ "evidenceId": "wev_d68dd1d98ae6dee8dfa71ca57c453a36",+ "method": "probe",+ "observedAt": "2026-10-11T22:07:42.654Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "moonshotai",+ "sourceCollectorId": "moonshot-api",+ "confidence": "api_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "moonshotai",+ "routeProfileId": "direct-api"+ },+ "externalModelId": "kimi-k3",+ "pricing": {+ "type": "unavailable"+ },+ "reasoning": {+ "request": {+ "status": "supported",+ "api": "chat-completions",+ "evidenceSourceUrl": "https://platform.kimi.ai/docs/guide/kimi-k3-quickstart.md",+ "effort": {+ "path": "/reasoning_effort",+ "values": {+ "max": "max",+ "high": "high",+ "low": "low"+ },+ "default": "max"+ }+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": "max_completion_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": {+ "status": "not_applicable"+ },+ "disable": {+ "status": "not_applicable"+ },+ "effort": {+ "path": "/reasoning_effort",+ "values": {+ "max": "max",+ "high": "high",+ "low": "low"+ },+ "default": "max"+ },+ "mode": {+ "status": "not_applicable"+ }+ },+ "speed": {+ "status": "unknown"+ },+ "evidence": [+ {+ "evidenceId": "wev_2635b1e1285f3930ed228e1a8fc3cd7e",+ "method": "api",+ "sourceUrl": "https://api.moonshot.ai/v1/models",+ "observedAt": "2026-10-12T10:09:22.368Z"+ },+ {+ "evidenceId": "wev_958d67adef66789e568bc6d17823b7c3",+ "method": "api",+ "sourceUrl": "https://api.moonshot.ai/v1/models",+ "observedAt": "2026-10-12T10:09:22.368Z"+ },+ {+ "evidenceId": "wev_b3c8da97f4416d78ae39c90dd424d101",+ "method": "api",+ "sourceUrl": "https://api.moonshot.ai/v1/models",+ "observedAt": "2026-10-12T10:09:22.368Z"+ },+ {+ "evidenceId": "wev_1b1eb232866836788091508db3d6ef1b",+ "method": "docs",+ "sourceUrl": "https://platform.kimi.ai/docs/guide/kimi-k3-quickstart.md",+ "observedAt": "2026-10-12T10:09:46.379Z"+ },+ {+ "evidenceId": "wev_5d9d832f784dff3105a6ede12ce1a18e",+ "method": "docs",+ "sourceUrl": "https://platform.kimi.ai/docs/guide/kimi-k3-quickstart.md",+ "observedAt": "2026-10-12T10:09:46.379Z"+ },+ {+ "evidenceId": "wev_a06262889db87006f755bfcbbc5c7c48",+ "method": "docs",+ "sourceUrl": "https://platform.kimi.ai/docs/guide/kimi-k3-quickstart.md",+ "observedAt": "2026-10-12T10:09:46.379Z"+ },+ {+ "evidenceId": "wev_b26f07d6e89857cbbe3c74f8861fd0a2",+ "method": "docs",+ "sourceUrl": "https://platform.kimi.ai/docs/guide/kimi-k3-quickstart.md",+ "observedAt": "2026-10-12T10:09:46.379Z"+ },+ {+ "evidenceId": "wev_b74bb66ed67a7e4b2e4dadfc887cbaff",+ "method": "docs",+ "sourceUrl": "https://platform.kimi.ai/docs/guide/kimi-k3-quickstart.md",+ "observedAt": "2026-10-12T10:09:46.379Z"+ },+ {+ "evidenceId": "wev_d2c1042c860d4acb8ad19f2147722c83",+ "method": "docs",+ "sourceUrl": "https://platform.kimi.ai/docs/guide/kimi-k3-quickstart.md",+ "observedAt": "2026-10-12T10:09:46.379Z"+ },+ {+ "evidenceId": "wev_fd948f88b9681843035b8d485154c545",+ "method": "docs",+ "sourceUrl": "https://platform.kimi.ai/docs/guide/kimi-k3-quickstart.md",+ "observedAt": "2026-10-12T10:09:46.379Z"+ },+ {+ "evidenceId": "wev_3dd589d95db0d5e6b15ac8d2a9a6a50a",+ "method": "probe",+ "observedAt": "2026-10-11T22:07:46.560Z"+ },+ {+ "evidenceId": "wev_c128619f1b947bb8aa6b36c4f1eff2fc",+ "method": "probe",+ "observedAt": "2026-10-11T22:07:48.249Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "ollamacloud",+ "sourceCollectorId": "ollama-cloud-api",+ "confidence": "gateway_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "ollama",+ "routeProfileId": "cloud"+ },+ "externalModelId": "kimi-k3",+ "pricing": {+ "type": "flat",+ "input": 3,+ "output": 15,+ "cachedRead": 0.3+ },+ "reasoning": {+ "request": {+ "status": "supported",+ "api": "chat-completions",+ "evidenceSourceUrl": "https://ollama.com/api/show",+ "effort": {+ "path": "/reasoning_effort",+ "values": {+ "max": "max",+ "high": "high",+ "low": "low"+ },+ "default": "max"+ }+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": {+ "status": "not_applicable"+ },+ "disable": {+ "status": "not_applicable"+ },+ "effort": {+ "path": "/reasoning_effort",+ "values": {+ "max": "max",+ "high": "high",+ "low": "low"+ },+ "default": "max"+ },+ "mode": {+ "status": "not_applicable"+ }+ },+ "speed": {+ "status": "not_applicable"+ },+ "evidence": [+ {+ "evidenceId": "wev_22434ae809230da4aefe572f276cb3a5",+ "method": "api",+ "sourceUrl": "https://api.moonshot.ai/v1/models",+ "observedAt": "2026-10-12T10:09:22.368Z"+ },+ {+ "evidenceId": "wev_68e2167b0fbf1cd2a1d3ebd0cb558c3a",+ "method": "api",+ "sourceUrl": "https://api.moonshot.ai/v1/models",+ "observedAt": "2026-10-12T10:09:22.368Z"+ },+ {+ "evidenceId": "wev_7d5f782b83c2215ac4cb608e3c90989d",+ "method": "api",+ "sourceUrl": "https://ollama.com/api/show",+ "observedAt": "2026-10-12T10:09:22.262Z"+ },+ {+ "evidenceId": "wev_963c7eee354dd1b352800f70c1ff890a",+ "method": "api",+ "sourceUrl": "https://ollama.com/api/show",+ "observedAt": "2026-10-12T10:09:22.262Z"+ },+ {+ "evidenceId": "wev_a25d18b3e4d7b50e2c285da65b6e637c",+ "method": "api",+ "sourceUrl": "https://ollama.com/api/show",+ "observedAt": "2026-10-12T10:09:22.262Z"+ },+ {+ "evidenceId": "wev_252e71f9344d986e0b076d6d54e9b03f",+ "method": "docs",+ "sourceUrl": "https://ollama.com/pricing",+ "observedAt": "2026-10-12T10:09:43.892Z"+ },+ {+ "evidenceId": "wev_2c24344b66cd539a4b702dc9db614e7f",+ "method": "docs",+ "sourceUrl": "https://platform.kimi.ai/docs/guide/kimi-k3-quickstart.md",+ "observedAt": "2026-10-12T10:09:46.379Z"+ },+ {+ "evidenceId": "wev_86d45eb7e51cbf77aed54f5a86eba94f",+ "method": "docs",+ "sourceUrl": "https://platform.kimi.ai/docs/guide/kimi-k3-quickstart.md",+ "observedAt": "2026-10-12T10:09:46.379Z"+ },+ {+ "evidenceId": "wev_4d815e62e9e3bc16437ae51b2e3dded0",+ "method": "probe",+ "observedAt": "2026-10-11T20:38:10.033Z"+ },+ {+ "evidenceId": "wev_86cf4b3058d5ed8bf6bb595a1557580d",+ "method": "probe",+ "observedAt": "2026-10-11T20:38:10.033Z"+ },+ {+ "evidenceId": "wev_98095d0bc77fd42c0aea361efd40ada1",+ "method": "probe",+ "observedAt": "2026-10-11T20:33:27.093Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "opencode-go",+ "sourceCollectorId": "popular-coding-subscriptions",+ "confidence": "gateway_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "opencode",+ "routeProfileId": "go-subscription"+ },+ "externalModelId": "kimi-k3",+ "reasoning": {+ "request": {+ "status": "unknown"+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": {+ "status": "unknown"+ },+ "toolsWithReasoning": {+ "status": "unknown"+ },+ "reasoning": {+ "status": "unknown"+ },+ "speed": {+ "status": "unknown"+ },+ "evidence": [+ {+ "evidenceId": "wev_f8713cc00bc5ce7797fb73d12b34a8d0",+ "method": "endpoint-table",+ "sourceUrl": "https://opencode.ai/v2/docs/console/go",+ "observedAt": "2026-10-12T10:09:25.039Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "opencode-zen",+ "sourceCollectorId": "opencode-zen-api",+ "confidence": "gateway_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "opencode",+ "routeProfileId": "zen"+ },+ "externalModelId": "kimi-k3",+ "pricing": {+ "type": "flat",+ "input": 3,+ "output": 15,+ "cachedRead": 0.3+ },+ "reasoning": {+ "request": {+ "status": "unknown"+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": {+ "status": "unknown"+ },+ "toolsWithReasoning": {+ "status": "unknown"+ },+ "reasoning": {+ "status": "unknown"+ },+ "speed": {+ "status": "unknown"+ },+ "evidence": [+ {+ "evidenceId": "wev_f91a647425200947eefed234e5c03bdc",+ "method": "endpoint-table",+ "sourceUrl": "https://opencode.ai/docs/en/zen/",+ "observedAt": "2026-10-12T10:09:23.090Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "openrouter",+ "sourceCollectorId": "openrouter-api",+ "confidence": "aggregator_reported",+ "routeStatus": "mapped",+ "route": {+ "routeId": "openrouter",+ "routeProfileId": "gateway"+ },+ "externalModelId": "moonshotai/kimi-k3",+ "pricing": {+ "type": "flat",+ "input": 0.73,+ "output": 10,+ "cachedRead": 0.55+ },+ "reasoning": {+ "request": {+ "status": "supported",+ "api": "chat-completions",+ "evidenceSourceUrl": "https://openrouter.ai/api/v1/models",+ "enable": [+ {+ "path": "/reasoning/enabled",+ "value": true+ }+ ],+ "effort": {+ "path": "/reasoning/effort",+ "values": {+ "max": "max",+ "high": "high",+ "low": "low"+ },+ "default": "max"+ }+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": [+ {+ "path": "/reasoning/enabled",+ "value": true+ }+ ],+ "disable": {+ "status": "not_applicable"+ },+ "effort": {+ "path": "/reasoning/effort",+ "values": {+ "max": "max",+ "high": "high",+ "low": "low"+ },+ "default": "max"+ },+ "mode": {+ "status": "not_applicable"+ }+ },+ "speed": {+ "status": "unknown"+ },+ "evidence": [+ {+ "evidenceId": "wev_0cecee4ea00c6af2f2c564299ccad550",+ "method": "api",+ "sourceUrl": "https://api.moonshot.ai/v1/models",+ "observedAt": "2026-10-12T10:09:22.368Z"+ },+ {+ "evidenceId": "wev_2ed9b2873d078dd0c838af545dced469",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_aa90c012207ebd2977eb16593e233521",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_bb294abf2ea846787514ee3362be80ee",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_d204130af3154afe01c716485f5d51a4",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_ea2922e7835c3953b2aa0ede09c4ae1b",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_2149f63531d6335ed22c3e464839ebd4",+ "method": "docs",+ "sourceUrl": "https://openrouter.ai/docs/guides/best-practices/reasoning-tokens",+ "observedAt": "2026-10-12T10:09:52.321Z"+ },+ {+ "evidenceId": "wev_e7b54d8ffe93af19df8d470c5f92835f",+ "method": "docs",+ "sourceUrl": "https://openrouter.ai/docs/guides/best-practices/reasoning-tokens",+ "observedAt": "2026-10-12T10:09:52.321Z"+ },+ {+ "evidenceId": "wev_eadade75dce86cba94b895d51c03dc8d",+ "method": "docs",+ "sourceUrl": "https://openrouter.ai/docs/guides/best-practices/reasoning-tokens",+ "observedAt": "2026-10-12T10:09:52.321Z"+ },+ {+ "evidenceId": "wev_894a62ce53455bf252a520958fcb4517",+ "method": "probe",+ "observedAt": "2026-10-11T20:46:40.192Z"+ },+ {+ "evidenceId": "wev_a71c0c3658428c2c778e0f3d458235d8",+ "method": "probe",+ "observedAt": "2026-10-11T20:46:40.192Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "openrouter",+ "sourceCollectorId": "openrouter-api",+ "confidence": "aggregator_reported",+ "routeStatus": "unknown",+ "reason": "unverified_mapping",+ "observedExternalModelId": "moonshotai/kimi-k3:batch"+ },+ {+ "sourceProviderId": "poe",+ "sourceCollectorId": "poe-api",+ "confidence": "aggregator_reported",+ "routeStatus": "mapped",+ "route": {+ "routeId": "poe",+ "routeProfileId": "gateway"+ },+ "externalModelId": "kimi-k3",+ "pricing": {+ "type": "flat",+ "input": 3.0303,+ "output": 15.1515,+ "cachedRead": 0.303+ },+ "probeEligible": true,+ "reasoning": {+ "request": {+ "status": "supported",+ "api": "chat-completions",+ "evidenceSourceUrl": "https://platform.kimi.ai/docs/guide/kimi-k3-quickstart.md",+ "effort": {+ "path": "/reasoning_effort",+ "values": {+ "max": "max",+ "high": "high",+ "low": "low"+ }+ }+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": {+ "status": "not_applicable"+ },+ "disable": {+ "status": "not_applicable"+ },+ "effort": {+ "path": "/reasoning_effort",+ "values": {+ "max": "max",+ "high": "high",+ "low": "low"+ },+ "default": {+ "status": "unknown"+ }+ },+ "mode": {+ "status": "not_applicable"+ }+ },+ "speed": {+ "status": "rejected",+ "path": "/service_tier"+ },+ "evidence": [+ {+ "evidenceId": "wev_0c1de5adcb25eefa1c84a839ca65c968",+ "method": "api",+ "sourceUrl": "https://api.moonshot.ai/v1/models",+ "observedAt": "2026-10-12T10:09:22.368Z"+ },+ {+ "evidenceId": "wev_894973bbe1f93d56432b94d06ba4d1fe",+ "method": "api",+ "sourceUrl": "https://api.moonshot.ai/v1/models",+ "observedAt": "2026-10-12T10:09:22.368Z"+ },+ {+ "evidenceId": "wev_36cd640eb8722fb3d6d9cbd8caff4b26",+ "method": "docs",+ "sourceUrl": "https://creator.poe.com/docs/external-applications/openai-compatible-api",+ "observedAt": "2026-10-12T10:09:33.306Z"+ },+ {+ "evidenceId": "wev_426daf24b7e4b6fa94d4999c6ceb8d77",+ "method": "docs",+ "sourceUrl": "https://creator.poe.com/docs/external-applications/openai-compatible-api",+ "observedAt": "2026-10-12T10:09:33.306Z"+ },+ {+ "evidenceId": "wev_669fa46d69aeda9963b3b21de68fdb5d",+ "method": "docs",+ "sourceUrl": "https://platform.kimi.ai/docs/guide/kimi-k3-quickstart.md",+ "observedAt": "2026-10-12T10:09:46.379Z"+ },+ {+ "evidenceId": "wev_6f12556a980c33677ddabc03629123f3",+ "method": "docs",+ "sourceUrl": "https://platform.kimi.ai/docs/guide/kimi-k3-quickstart.md",+ "observedAt": "2026-10-12T10:09:46.379Z"+ },+ {+ "evidenceId": "wev_23887d051a43dd1746ea635e29bff888",+ "method": "probe",+ "observedAt": "2026-10-11T20:16:57.106Z"+ },+ {+ "evidenceId": "wev_3b717e1939de1ddc83b5013ea59483a2",+ "method": "probe",+ "observedAt": "2026-10-11T20:06:28.740Z"+ },+ {+ "evidenceId": "wev_b495aaf65fce5eb80f7265def87a7642",+ "method": "probe",+ "observedAt": "2026-10-11T20:16:57.106Z"+ },+ {+ "evidenceId": "wev_cf8a412dc09b30415cc2c3040a5e7916",+ "method": "probe",+ "observedAt": "2026-10-11T20:06:30.196Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "together-ai",+ "sourceCollectorId": "together-ai-api",+ "confidence": "gateway_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "together-ai",+ "routeProfileId": "gateway"+ },+ "externalModelId": "moonshotai/Kimi-K3",+ "pricing": {+ "type": "flat",+ "input": 2.7,+ "output": 13.5+ },+ "probeEligible": true,+ "reasoning": {+ "request": {+ "status": "unknown"+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": {+ "status": "unknown"+ },+ "reasoning": {+ "status": "unknown"+ },+ "speed": {+ "status": "not_applicable"+ },+ "evidence": [+ {+ "evidenceId": "wev_30fc206804bc9a0f7450f03eeb6263fb",+ "method": "docs",+ "sourceUrl": "https://docs.together.ai/docs/inference/openai-compatibility.md",+ "observedAt": "2026-10-12T10:09:42.290Z"+ },+ {+ "evidenceId": "wev_40c32dcb90823a39338ebdc888a26efb",+ "method": "docs",+ "sourceUrl": "https://docs.together.ai/docs/inference/openai-compatibility.md",+ "observedAt": "2026-10-12T10:09:42.290Z"+ },+ {+ "evidenceId": "wev_721e68d23458d1b30dd2351e98c97b47",+ "method": "docs",+ "sourceUrl": "https://docs.together.ai/docs/inference/chat/parameters.md",+ "observedAt": "2026-10-12T10:09:42.288Z"+ },+ {+ "evidenceId": "wev_e4821c2c52cfeba604f7ed64fa35d9eb",+ "method": "docs",+ "sourceUrl": "https://docs.together.ai/reference/chat-completions.md",+ "observedAt": "2026-10-12T10:09:50.817Z"+ }+ ]+ }+ }+ ],+ "supportsVision": true,+ "supportsTools": true,+ "supportsThinking": true,+ "videoInput": true,+ "videoOutput": false,+ "reasoning": {+ "supported": true,+ "mandatory": true,+ "control": "effort",+ "efforts": [+ "max",+ "high",+ "low"+ ],+ "defaultEffort": "max"+ },+ "endpoints": {+ "openai": {+ "api": "chat-completions",+ "toolsWithReasoning": "ok"+ }+ },+ "tokenParam": "max_completion_tokens"+ },+ {+ "contractVersion": 3,+ "modelId": "minimax-m3",+ "displayName": "MiniMax-M3",+ "provider": "minimax",+ "aliases": [+ "minimax/minimax-m3",+ "MiniMaxAI/MiniMax-M3",+ "accounts/fireworks/models/minimax-m3",+ "MiniMax-M3"+ ],+ "status": "active",+ "releaseDate": "2026-06-01",+ "contextWindow": 1000000,+ "subscriptionPlanIds": [+ "minimax-token-plan",+ "ollama-cloud",+ "opencode-go",+ "opencode-go-plus"+ ],+ "outputModalities": [+ "text"+ ],+ "aggregators": [+ {+ "sourceProviderId": "fireworks",+ "sourceCollectorId": "fireworks-api",+ "confidence": "aggregator_reported",+ "routeStatus": "mapped",+ "route": {+ "routeId": "fireworks",+ "routeProfileId": "gateway"+ },+ "externalModelId": "accounts/fireworks/models/minimax-m3",+ "pricing": {+ "type": "unavailable"+ },+ "reasoning": {+ "mode": {+ "status": "rejected"+ },+ "request": {+ "status": "supported",+ "api": "chat-completions",+ "evidenceSourceUrl": "https://platform.minimax.io/docs/api-reference/text-openai-api.md",+ "enable": [+ {+ "path": "/thinking/type",+ "value": "adaptive"+ }+ ],+ "disable": [+ {+ "path": "/thinking/type",+ "value": "disabled"+ }+ ]+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": [+ {+ "path": "/thinking/type",+ "value": "adaptive"+ }+ ],+ "disable": [+ {+ "path": "/thinking/type",+ "value": "disabled"+ }+ ],+ "effort": {+ "status": "not_applicable"+ },+ "mode": {+ "status": "rejected",+ "path": "/reasoning/mode"+ }+ },+ "speed": {+ "status": "supported",+ "path": "/service_tier",+ "values": {+ "priority": "priority"+ },+ "default": "standard",+ "headers": [],+ "echo": {+ "status": "not_applicable"+ },+ "access": "open"+ },+ "evidence": [+ {+ "evidenceId": "wev_e9f1a0b9f9f434a90b06e1bd2b11af44",+ "method": "api",+ "sourceUrl": "https://api.fireworks.ai/inference/v1/models",+ "observedAt": "2026-10-12T10:09:22.214Z"+ },+ {+ "evidenceId": "wev_49f068b6c12d449dfd344c18f0b1f8e9",+ "method": "docs",+ "sourceUrl": "https://platform.minimax.io/docs/api-reference/text-openai-api.md",+ "observedAt": "2026-10-12T10:09:25.354Z"+ },+ {+ "evidenceId": "wev_70324853e6feb1778beffae263d12883",+ "method": "docs",+ "sourceUrl": "https://platform.minimax.io/docs/api-reference/text-openai-api.md",+ "observedAt": "2026-10-12T10:09:25.354Z"+ },+ {+ "evidenceId": "wev_b8175495469f74abc4115e32d90068a2",+ "method": "docs",+ "sourceUrl": "https://docs.fireworks.ai/tools-sdks/openai-compatibility.md",+ "observedAt": "2026-10-12T10:09:50.512Z"+ },+ {+ "evidenceId": "wev_c19ad939838b3918a70d1f6f38f28184",+ "method": "docs",+ "sourceUrl": "https://platform.minimax.io/docs/api-reference/text-openai-api.md",+ "observedAt": "2026-10-12T10:09:25.354Z"+ },+ {+ "evidenceId": "wev_d22404b1e8f03e79def0c4a783e526f7",+ "method": "docs",+ "sourceUrl": "https://docs.fireworks.ai/serverless/pricing.md",+ "observedAt": "2026-10-12T10:09:35.878Z"+ },+ {+ "evidenceId": "wev_de89ca4ac3b2d4d89b0019ee4e492e98",+ "method": "docs",+ "sourceUrl": "https://docs.fireworks.ai/serverless/serverless-modes.md",+ "observedAt": "2026-10-12T10:09:37.403Z"+ },+ {+ "evidenceId": "wev_03388f3d4c0ebf7108565d8a2b77009c",+ "method": "probe",+ "observedAt": "2026-10-11T21:55:10.745Z"+ },+ {+ "evidenceId": "wev_118d97cc18cf6d4f556dd754b3744bdd",+ "method": "probe",+ "observedAt": "2026-10-11T21:55:13.545Z"+ },+ {+ "evidenceId": "wev_4bd6116fc8f85175ff064551c0c49a96",+ "method": "probe",+ "observedAt": "2026-10-11T21:55:11.392Z"+ },+ {+ "evidenceId": "wev_e01a83d7b5b811067f6b4337e86850ca",+ "method": "probe",+ "observedAt": "2026-10-11T21:55:13.545Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "minimax-token-plan",+ "sourceCollectorId": "minimax-token-plan-membership",+ "confidence": "scrape_verified",+ "routeStatus": "mapped",+ "route": {+ "routeId": "minimax",+ "routeProfileId": "coding-plan-subscription"+ },+ "externalModelId": "MiniMax-M3",+ "reasoning": {+ "request": {+ "status": "unknown"+ }+ },+ "wire": {+ "status": "known",+ "api": "anthropic-messages",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": [+ {+ "path": "/thinking/type",+ "value": "enabled"+ },+ {+ "path": "/thinking/budget_tokens",+ "value": 1024+ }+ ],+ "disable": [+ {+ "path": "/thinking/type",+ "value": "disabled"+ }+ ],+ "effort": {+ "status": "unknown"+ },+ "mode": {+ "status": "not_applicable"+ }+ },+ "speed": {+ "status": "unknown"+ },+ "evidence": [+ {+ "evidenceId": "wev_52e6450772d230088a7de7ef3db66529",+ "method": "docs",+ "sourceUrl": "https://platform.minimax.io/docs/m-plan/other-tools.md",+ "observedAt": "2026-10-12T10:09:46.802Z"+ },+ {+ "evidenceId": "wev_b06edbf499b7ae9d48ede9f9de950a36",+ "method": "probe",+ "observedAt": "2026-10-11T22:11:12.372Z"+ },+ {+ "evidenceId": "wev_cd1c7819d32dea4e4cec344c1ea7255d",+ "method": "probe",+ "observedAt": "2026-10-11T22:11:12.372Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "minimax",+ "sourceCollectorId": "minimax-api",+ "confidence": "api_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "minimax",+ "routeProfileId": "direct-api"+ },+ "externalModelId": "MiniMax-M3",+ "pricing": {+ "type": "unavailable"+ },+ "reasoning": {+ "request": {+ "status": "supported",+ "api": "chat-completions",+ "evidenceSourceUrl": "https://platform.minimax.io/docs/api-reference/text-openai-api.md",+ "enable": [+ {+ "path": "/thinking/type",+ "value": "adaptive"+ }+ ],+ "disable": [+ {+ "path": "/thinking/type",+ "value": "disabled"+ }+ ]+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": "max_completion_tokens",+ "toolsWithReasoning": {+ "status": "unknown"+ },+ "reasoning": {+ "status": "supported",+ "enable": [+ {+ "path": "/thinking/type",+ "value": "adaptive"+ }+ ],+ "disable": [+ {+ "path": "/thinking/type",+ "value": "disabled"+ }+ ],+ "effort": {+ "status": "not_applicable"+ },+ "mode": {+ "status": "not_applicable"+ }+ },+ "speed": {+ "status": "unknown"+ },+ "evidence": [+ {+ "evidenceId": "wev_55a34488df310b226bc20bf85d576fb8",+ "method": "docs",+ "sourceUrl": "https://platform.minimax.io/docs/api-reference/text-openai-api.md",+ "observedAt": "2026-10-12T10:09:25.354Z"+ },+ {+ "evidenceId": "wev_5635607cd6dc7ea3a7edb6257b835912",+ "method": "docs",+ "sourceUrl": "https://platform.minimax.io/docs/api-reference/text-openai-api.md",+ "observedAt": "2026-10-12T10:09:25.354Z"+ },+ {+ "evidenceId": "wev_b1228a06a9b3a3267a27674bf02571e6",+ "method": "docs",+ "sourceUrl": "https://platform.minimax.io/docs/api-reference/text-openai-api.md",+ "observedAt": "2026-10-12T10:09:25.354Z"+ },+ {+ "evidenceId": "wev_cb2d8c544057fe9dbfa76f562aa58fa1",+ "method": "docs",+ "sourceUrl": "https://platform.minimax.io/docs/api-reference/text-openai-api.md",+ "observedAt": "2026-10-12T10:09:25.354Z"+ },+ {+ "evidenceId": "wev_da793544081bcd394392c5615e686b42",+ "method": "docs",+ "sourceUrl": "https://platform.minimax.io/docs/api-reference/text-openai-api.md",+ "observedAt": "2026-10-12T10:09:25.354Z"+ },+ {+ "evidenceId": "wev_6d95bf5eb9c07e65fbabf122b021ef77",+ "method": "probe",+ "observedAt": "2026-10-11T22:11:18.654Z"+ },+ {+ "evidenceId": "wev_731683835f9ffb807b8251d04533e7a5",+ "method": "probe",+ "observedAt": "2026-10-11T22:11:18.654Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "ollamacloud",+ "sourceCollectorId": "ollama-cloud-api",+ "confidence": "gateway_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "ollama",+ "routeProfileId": "cloud"+ },+ "externalModelId": "minimax-m3",+ "pricing": {+ "type": "flat",+ "input": 0.6,+ "output": 2.4,+ "cachedRead": 0.12+ },+ "reasoning": {+ "request": {+ "status": "unknown"+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "unknown"+ },+ "speed": {+ "status": "not_applicable"+ },+ "evidence": [+ {+ "evidenceId": "wev_75495d9451cac80122c5a67bc723c226",+ "method": "docs",+ "sourceUrl": "https://ollama.com/pricing",+ "observedAt": "2026-10-12T10:09:43.892Z"+ },+ {+ "evidenceId": "wev_3255e7747fa0a7aabcfbaa6369f43924",+ "method": "probe",+ "observedAt": "2026-10-11T22:03:52.552Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "opencode-go",+ "sourceCollectorId": "popular-coding-subscriptions",+ "confidence": "gateway_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "opencode",+ "routeProfileId": "go-subscription"+ },+ "externalModelId": "minimax-m3",+ "reasoning": {+ "request": {+ "status": "unknown"+ }+ },+ "wire": {+ "status": "known",+ "api": "anthropic-messages",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": {+ "status": "unknown"+ },+ "reasoning": {+ "status": "unknown"+ },+ "speed": {+ "status": "unknown"+ },+ "evidence": [+ {+ "evidenceId": "wev_0ccf5d28a210c893036c06dbce4ede00",+ "method": "endpoint-table",+ "sourceUrl": "https://opencode.ai/v2/docs/console/go",+ "observedAt": "2026-10-12T10:09:25.039Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "opencode-zen",+ "sourceCollectorId": "opencode-zen-api",+ "confidence": "gateway_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "opencode",+ "routeProfileId": "zen"+ },+ "externalModelId": "minimax-m3",+ "pricing": {+ "type": "flat",+ "input": 0.3,+ "output": 1.2,+ "cachedRead": 0.06+ },+ "reasoning": {+ "request": {+ "status": "unknown"+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": {+ "status": "unknown"+ },+ "toolsWithReasoning": {+ "status": "unknown"+ },+ "reasoning": {+ "status": "unknown"+ },+ "speed": {+ "status": "unknown"+ },+ "evidence": [+ {+ "evidenceId": "wev_520a5a26d6458880d7cc6bfa7be2bbe2",+ "method": "endpoint-table",+ "sourceUrl": "https://opencode.ai/docs/en/zen/",+ "observedAt": "2026-10-12T10:09:23.090Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "openrouter",+ "sourceCollectorId": "openrouter-api",+ "confidence": "aggregator_reported",+ "routeStatus": "mapped",+ "route": {+ "routeId": "openrouter",+ "routeProfileId": "gateway"+ },+ "externalModelId": "minimax/minimax-m3",+ "pricing": {+ "type": "flat",+ "input": 0.3,+ "output": 1.2,+ "cachedRead": 0.06+ },+ "reasoning": {+ "request": {+ "status": "supported",+ "api": "chat-completions",+ "evidenceSourceUrl": "https://openrouter.ai/api/v1/models",+ "enable": [+ {+ "path": "/reasoning/enabled",+ "value": true+ }+ ]+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": [+ {+ "path": "/reasoning/enabled",+ "value": true+ }+ ],+ "disable": {+ "status": "unknown"+ },+ "effort": {+ "status": "not_applicable"+ },+ "mode": {+ "status": "not_applicable"+ }+ },+ "speed": {+ "status": "not_applicable"+ },+ "evidence": [+ {+ "evidenceId": "wev_1f4cdf7369aa632bf076e4f70e5faa93",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_541f6ab68b1888ebb60c2613fba23a91",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_66e382334490ca30fa8102fbcb425181",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_7cb9aded5b57c3c6eed788c7070af7f7",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models/minimax/minimax-m3/endpoints",+ "observedAt": "2026-10-12T10:09:48.912Z"+ },+ {+ "evidenceId": "wev_f700d86945c03caa3be4325fdfede53d",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_1b483f4fd62677287135d21dcf90aded",+ "method": "docs",+ "sourceUrl": "https://platform.minimax.io/docs/api-reference/text-openai-api.md",+ "observedAt": "2026-10-12T10:09:25.354Z"+ },+ {+ "evidenceId": "wev_4c84a09b8e24b96563e9810f3d2245b6",+ "method": "docs",+ "sourceUrl": "https://openrouter.ai/docs/guides/best-practices/reasoning-tokens",+ "observedAt": "2026-10-12T10:09:52.321Z"+ },+ {+ "evidenceId": "wev_5d5e13da37b56f69eeb92e7522eee839",+ "method": "docs",+ "sourceUrl": "https://openrouter.ai/docs/guides/best-practices/reasoning-tokens",+ "observedAt": "2026-10-12T10:09:52.321Z"+ },+ {+ "evidenceId": "wev_3a6101e051aedf6d83418de6107a6681",+ "method": "probe",+ "observedAt": "2026-10-11T22:23:36.489Z"+ },+ {+ "evidenceId": "wev_6bf79e17365773851c5b3ea0a6bb5899",+ "method": "probe",+ "observedAt": "2026-10-11T22:23:32.453Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "poe",+ "sourceCollectorId": "poe-api",+ "confidence": "aggregator_reported",+ "routeStatus": "mapped",+ "route": {+ "routeId": "poe",+ "routeProfileId": "gateway"+ },+ "externalModelId": "minimax-m3",+ "pricing": {+ "type": "flat",+ "input": 0.303,+ "output": 1.2121,+ "cachedRead": 0.0606+ },+ "probeEligible": true,+ "reasoning": {+ "request": {+ "status": "supported",+ "api": "chat-completions",+ "evidenceSourceUrl": "https://api.poe.com/v1/models",+ "enable": [+ {+ "path": "/enable_thinking",+ "value": true+ }+ ],+ "disable": [+ {+ "path": "/enable_thinking",+ "value": false+ }+ ]+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": [+ {+ "path": "/enable_thinking",+ "value": true+ }+ ],+ "disable": [+ {+ "path": "/enable_thinking",+ "value": false+ }+ ],+ "effort": {+ "status": "not_applicable"+ },+ "mode": {+ "status": "not_applicable"+ }+ },+ "speed": {+ "status": "rejected",+ "path": "/service_tier"+ },+ "evidence": [+ {+ "evidenceId": "wev_4ff86a0d2c7813e1f93f945788b5e9a4",+ "method": "api",+ "sourceUrl": "https://api.poe.com/v1/models",+ "observedAt": "2026-10-12T10:09:22.802Z"+ },+ {+ "evidenceId": "wev_9b0441d27f38d64a6c3fb9058d8970a6",+ "method": "api",+ "sourceUrl": "https://api.poe.com/v1/models",+ "observedAt": "2026-10-12T10:09:22.802Z"+ },+ {+ "evidenceId": "wev_0b6a903914a0572ac64fe5578395b72a",+ "method": "docs",+ "sourceUrl": "https://creator.poe.com/docs/external-applications/openai-compatible-api",+ "observedAt": "2026-10-12T10:09:33.306Z"+ },+ {+ "evidenceId": "wev_1309c51b87141f2e7aeb19116a111a1a",+ "method": "docs",+ "sourceUrl": "https://creator.poe.com/docs/external-applications/openai-compatible-api",+ "observedAt": "2026-10-12T10:09:33.306Z"+ },+ {+ "evidenceId": "wev_c0bd2e4a4cc3164f542595778a2d9bd7",+ "method": "docs",+ "sourceUrl": "https://platform.minimax.io/docs/api-reference/text-openai-api.md",+ "observedAt": "2026-10-12T10:09:25.354Z"+ },+ {+ "evidenceId": "wev_ca95e86e85b3307ca795081807a00646",+ "method": "docs",+ "sourceUrl": "https://platform.minimax.io/docs/api-reference/text-openai-api.md",+ "observedAt": "2026-10-12T10:09:46.726Z"+ },+ {+ "evidenceId": "wev_165b1523bea017271ec93840a9c9b039",+ "method": "probe",+ "observedAt": "2026-10-11T21:55:22.289Z"+ },+ {+ "evidenceId": "wev_500a993d87f001da3d4a06297509c68b",+ "method": "probe",+ "observedAt": "2026-10-11T21:55:24.930Z"+ },+ {+ "evidenceId": "wev_7320fc0904e05fea4b83ceffca9d5320",+ "method": "probe",+ "observedAt": "2026-10-11T21:55:23.177Z"+ },+ {+ "evidenceId": "wev_ea9122bb0153c4fb8c062fbd5366163a",+ "method": "probe",+ "observedAt": "2026-10-11T21:55:24.930Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "together-ai",+ "sourceCollectorId": "together-ai-api",+ "confidence": "gateway_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "together-ai",+ "routeProfileId": "gateway"+ },+ "externalModelId": "MiniMaxAI/MiniMax-M3",+ "pricing": {+ "type": "flat",+ "input": 0.3,+ "output": 1.2+ },+ "probeEligible": true,+ "reasoning": {+ "request": {+ "status": "unknown"+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": {+ "status": "unknown"+ },+ "reasoning": {+ "status": "unknown"+ },+ "speed": {+ "status": "not_applicable"+ },+ "evidence": [+ {+ "evidenceId": "wev_0d6f8f6531c4b6534d6b01146853ccb2",+ "method": "docs",+ "sourceUrl": "https://docs.together.ai/docs/inference/openai-compatibility.md",+ "observedAt": "2026-10-12T10:09:42.290Z"+ },+ {+ "evidenceId": "wev_16808a53d786a70caa8f8c131df4166b",+ "method": "docs",+ "sourceUrl": "https://docs.together.ai/docs/inference/openai-compatibility.md",+ "observedAt": "2026-10-12T10:09:42.290Z"+ },+ {+ "evidenceId": "wev_6b7af6c011567372b5c44e68def2d34e",+ "method": "docs",+ "sourceUrl": "https://docs.together.ai/reference/chat-completions.md",+ "observedAt": "2026-10-12T10:09:50.817Z"+ },+ {+ "evidenceId": "wev_9de866bf1705e42fb650022390c03d09",+ "method": "docs",+ "sourceUrl": "https://docs.together.ai/docs/inference/chat/parameters.md",+ "observedAt": "2026-10-12T10:09:42.288Z"+ }+ ]+ }+ }+ ],+ "supportsTools": true,+ "videoInput": true,+ "videoOutput": false,+ "reasoning": {+ "supported": true,+ "mandatory": false,+ "control": "toggle"+ },+ "endpoints": {+ "openai": {+ "api": "chat-completions"+ }+ },+ "tokenParam": "max_completion_tokens"+ },+ {+ "contractVersion": 3,+ "modelId": "qwen3.7-plus",+ "displayName": "Qwen3.7-Plus",+ "provider": "qwen",+ "aliases": [+ "qwen/qwen3.7-plus",+ "Qwen/Qwen3.7-Plus"+ ],+ "status": "active",+ "releaseDate": "2026-06-01",+ "contextWindow": 1000000,+ "maxOutputTokens": 131072,+ "subscriptionPlanIds": [+ "alibaba-ai-coding-plan",+ "alibaba-token-plan-individual",+ "alibaba-token-plan-team-edition",+ "opencode-go",+ "opencode-go-plus"+ ],+ "inputModalities": [+ "image",+ "text",+ "video"+ ],+ "outputModalities": [+ "text"+ ],+ "aggregators": [+ {+ "sourceProviderId": "fireworks",+ "sourceCollectorId": "fireworks-api",+ "confidence": "aggregator_reported",+ "routeStatus": "mapped",+ "route": {+ "routeId": "fireworks",+ "routeProfileId": "gateway"+ },+ "externalModelId": "accounts/fireworks/models/qwen3p7-plus",+ "pricing": {+ "type": "unavailable"+ },+ "reasoning": {+ "request": {+ "status": "unknown"+ }+ },+ "wire": {+ "status": "unknown",+ "evidence": []+ }+ },+ {+ "sourceProviderId": "opencode-go",+ "sourceCollectorId": "popular-coding-subscriptions",+ "confidence": "gateway_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "opencode",+ "routeProfileId": "go-subscription"+ },+ "externalModelId": "qwen3.7-plus",+ "reasoning": {+ "request": {+ "status": "unknown"+ }+ },+ "wire": {+ "status": "known",+ "api": "anthropic-messages",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": {+ "status": "unknown"+ },+ "reasoning": {+ "status": "unknown"+ },+ "speed": {+ "status": "unknown"+ },+ "evidence": [+ {+ "evidenceId": "wev_fd3425e784964965db7c29fa064885b0",+ "method": "endpoint-table",+ "sourceUrl": "https://opencode.ai/v2/docs/console/go",+ "observedAt": "2026-10-12T10:09:25.039Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "openrouter",+ "sourceCollectorId": "openrouter-api",+ "confidence": "aggregator_reported",+ "routeStatus": "mapped",+ "route": {+ "routeId": "openrouter",+ "routeProfileId": "gateway"+ },+ "externalModelId": "qwen/qwen3.7-plus",+ "pricing": {+ "type": "flat",+ "input": 0.32,+ "output": 1.28,+ "cachedRead": 0.064+ },+ "reasoning": {+ "request": {+ "status": "supported",+ "api": "chat-completions",+ "evidenceSourceUrl": "https://openrouter.ai/api/v1/models",+ "enable": [+ {+ "path": "/reasoning/enabled",+ "value": true+ }+ ]+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": [+ {+ "path": "/reasoning/enabled",+ "value": true+ }+ ],+ "disable": {+ "status": "unknown"+ },+ "effort": {+ "status": "not_applicable"+ },+ "mode": {+ "status": "not_applicable"+ }+ },+ "speed": {+ "status": "not_applicable"+ },+ "evidence": [+ {+ "evidenceId": "wev_016b35443ce1bceff8dd11dc33327eb0",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_5595e0aee41807178f80b492de72f4f4",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models/qwen/qwen3.7-plus/endpoints",+ "observedAt": "2026-10-12T10:09:48.891Z"+ },+ {+ "evidenceId": "wev_58cf31f2ff740197b8df5e039d2638a2",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_69cc5e1a82f2f13421f9f7562214f4e6",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_784bf99280f29d827aea1fe4337a47e9",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_d42cd803735b521e9fd27f928d0f6376",+ "method": "docs",+ "sourceUrl": "https://openrouter.ai/docs/guides/best-practices/reasoning-tokens",+ "observedAt": "2026-10-12T10:09:52.321Z"+ },+ {+ "evidenceId": "wev_d76f82f23c7a852a050d8825bb63cdf7",+ "method": "docs",+ "sourceUrl": "https://openrouter.ai/docs/guides/best-practices/reasoning-tokens",+ "observedAt": "2026-10-12T10:09:52.321Z"+ },+ {+ "evidenceId": "wev_1cd1a39c5cdac4b74adc90d9b3ff9924",+ "method": "probe",+ "observedAt": "2026-10-11T22:23:57.362Z"+ },+ {+ "evidenceId": "wev_b8f19c3ebd3ddcd4789e93667a8aab2c",+ "method": "probe",+ "observedAt": "2026-10-11T22:23:54.403Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "qwen-cloud",+ "sourceCollectorId": "qwen-cloud-token-plan-scrape",+ "confidence": "scrape_verified",+ "routeStatus": "mapped",+ "route": {+ "routeId": "qwen",+ "routeProfileId": "qwencloud-token-plan"+ },+ "externalModelId": "qwen3.7-plus",+ "reasoning": {+ "request": {+ "status": "supported",+ "api": "chat-completions",+ "evidenceSourceUrl": "https://docs.qwencloud.com/developer-guides/text-generation/thinking.md",+ "enable": [+ {+ "path": "/enable_thinking",+ "value": true+ }+ ],+ "disable": [+ {+ "path": "/enable_thinking",+ "value": false+ }+ ]+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": "max_completion_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": [+ {+ "path": "/enable_thinking",+ "value": true+ }+ ],+ "disable": [+ {+ "path": "/enable_thinking",+ "value": false+ }+ ],+ "effort": {+ "status": "unknown"+ },+ "mode": {+ "status": "not_applicable"+ }+ },+ "speed": {+ "status": "not_applicable"+ },+ "evidence": [+ {+ "evidenceId": "wev_062ea267c0cdacdfacec673eb6f5d17d",+ "method": "docs",+ "sourceUrl": "https://docs.qwencloud.com/api-reference/chat/openai-chat",+ "observedAt": "2026-10-12T10:09:40.412Z"+ },+ {+ "evidenceId": "wev_3551680caba207367c6e7b73822b8a63",+ "method": "docs",+ "sourceUrl": "https://docs.qwencloud.com/api-reference/chat/openai-chat.md",+ "observedAt": "2026-10-12T10:09:42.397Z"+ },+ {+ "evidenceId": "wev_4ce5990b0da091f1f935b4843584ec44",+ "method": "docs",+ "sourceUrl": "https://docs.qwencloud.com/token-plan/team/token-plan-team-overview.md",+ "observedAt": "2026-10-12T10:09:51.277Z"+ },+ {+ "evidenceId": "wev_53cb0703a3eb6c2260f806fc86e64390",+ "method": "docs",+ "sourceUrl": "https://docs.qwencloud.com/developer-guides/text-generation/thinking.md",+ "observedAt": "2026-10-12T10:09:42.815Z"+ },+ {+ "evidenceId": "wev_61099b4fa6e535542f5ef61582fff4f1",+ "method": "docs",+ "sourceUrl": "https://docs.qwencloud.com/developer-guides/text-generation/thinking.md",+ "observedAt": "2026-10-12T10:09:42.815Z"+ },+ {+ "evidenceId": "wev_7ca5fc8a9fb7e57fc16fddc60f6d3995",+ "method": "docs",+ "sourceUrl": "https://docs.qwencloud.com/api-reference/chat/openai-chat.md",+ "observedAt": "2026-10-12T10:09:42.397Z"+ },+ {+ "evidenceId": "wev_cb352aa9ff82868e22f95943188b5feb",+ "method": "docs",+ "sourceUrl": "https://docs.qwencloud.com/token-plan/personal/token-plan-personal-quickstart.md",+ "observedAt": "2026-10-12T10:09:40.705Z"+ },+ {+ "evidenceId": "wev_d0d133252b0018d99f36921240fc35ac",+ "method": "docs",+ "sourceUrl": "https://docs.qwencloud.com/token-plan/personal/token-plan-personal-quickstart.md",+ "observedAt": "2026-10-12T10:09:40.705Z"+ },+ {+ "evidenceId": "wev_0430a9df207a9f067c66d63f4a87107a",+ "method": "probe",+ "observedAt": "2026-10-11T22:33:16.650Z"+ },+ {+ "evidenceId": "wev_28241378a7e32ad002a229ce23c690bb",+ "method": "probe",+ "observedAt": "2026-10-11T22:33:16.650Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "qwen-coding",+ "sourceCollectorId": "alibaba-coding-plan-scrape",+ "confidence": "gateway_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "qwen",+ "routeProfileId": "modelstudio-coding-plan"+ },+ "externalModelId": "qwen3.7-plus",+ "reasoning": {+ "mode": {+ "status": "unknown"+ },+ "request": {+ "status": "supported",+ "api": "chat-completions",+ "evidenceSourceUrl": "https://www.alibabacloud.com/help/en/model-studio/coding-plan",+ "enable": [+ {+ "path": "/enable_thinking",+ "value": true+ }+ ]+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": {+ "status": "unknown"+ },+ "toolsWithReasoning": {+ "status": "unknown"+ },+ "reasoning": {+ "status": "supported",+ "enable": [+ {+ "path": "/enable_thinking",+ "value": true+ }+ ],+ "disable": {+ "status": "unknown"+ },+ "effort": {+ "status": "unknown"+ },+ "mode": {+ "status": "unknown"+ }+ },+ "speed": {+ "status": "unknown"+ },+ "evidence": [+ {+ "evidenceId": "wev_3abe38c2d65c23a0b6566727f0f17971",+ "method": "docs",+ "sourceUrl": "https://www.alibabacloud.com/help/en/model-studio/coding-plan",+ "observedAt": "2026-10-12T10:09:48.402Z"+ },+ {+ "evidenceId": "wev_3b243c0438a9bcaeb7f39508677a2f56",+ "method": "docs",+ "sourceUrl": "https://www.alibabacloud.com/help/en/model-studio/coding-plan",+ "observedAt": "2026-10-12T10:09:48.402Z"+ },+ {+ "evidenceId": "wev_3e9ab280c8fd00708a7bf6e4e7ca422d",+ "method": "docs",+ "sourceUrl": "https://www.alibabacloud.com/help/en/model-studio/coding-plan-faq",+ "observedAt": "2026-10-12T10:09:48.822Z"+ },+ {+ "evidenceId": "wev_6215c770d8115a8ddbc22562ff56fc46",+ "method": "docs",+ "sourceUrl": "https://www.alibabacloud.com/help/en/model-studio/codex",+ "observedAt": "2026-10-12T10:09:48.469Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "qwen",+ "sourceCollectorId": "dashscope-api",+ "confidence": "api_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "qwen",+ "routeProfileId": "dashscope-direct"+ },+ "externalModelId": "qwen3.7-plus",+ "pricing": {+ "type": "unavailable"+ },+ "reasoning": {+ "request": {+ "status": "unknown"+ }+ },+ "wire": {+ "status": "known",+ "api": "responses",+ "tokenParam": "max_output_tokens",+ "toolsWithReasoning": {+ "status": "unknown"+ },+ "reasoning": {+ "status": "unknown"+ },+ "speed": {+ "status": "not_applicable"+ },+ "evidence": [+ {+ "evidenceId": "wev_7dc62bb1fd12834a7f475fefc1c3bfce",+ "method": "docs",+ "sourceUrl": "https://www.alibabacloud.com/help/en/model-studio/qwen-api-via-openai-responses",+ "observedAt": "2026-10-12T10:09:53.969Z"+ },+ {+ "evidenceId": "wev_a6c98847a6309cc64f9a952af01f9565",+ "method": "docs",+ "sourceUrl": "https://www.alibabacloud.com/help/en/model-studio/qwen-api-via-openai-responses.md",+ "observedAt": "2026-10-12T10:09:21.560Z"+ },+ {+ "evidenceId": "wev_122705e51a0f784369bbc4b0d31d4581",+ "method": "probe",+ "observedAt": "2026-10-11T22:33:53.879Z"+ },+ {+ "evidenceId": "wev_b9ae6f5829d5ce31f18ef1864a182686",+ "method": "probe",+ "observedAt": "2026-10-11T22:33:53.879Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "together-ai",+ "sourceCollectorId": "together-ai-api",+ "confidence": "gateway_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "together-ai",+ "routeProfileId": "gateway"+ },+ "externalModelId": "Qwen/Qwen3.7-Plus",+ "pricing": {+ "type": "flat",+ "input": 0.32,+ "output": 1.28+ },+ "probeEligible": true,+ "reasoning": {+ "request": {+ "status": "unknown"+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": {+ "status": "unknown"+ },+ "reasoning": {+ "status": "unknown"+ },+ "speed": {+ "status": "not_applicable"+ },+ "evidence": [+ {+ "evidenceId": "wev_14e4116c7b04f4dcf819263bc45158e4",+ "method": "docs",+ "sourceUrl": "https://docs.together.ai/docs/inference/openai-compatibility.md",+ "observedAt": "2026-10-12T10:09:42.290Z"+ },+ {+ "evidenceId": "wev_412a08f901a3337bae490ebd4cfa3de8",+ "method": "docs",+ "sourceUrl": "https://docs.together.ai/reference/chat-completions.md",+ "observedAt": "2026-10-12T10:09:50.817Z"+ },+ {+ "evidenceId": "wev_725d0294633d1cb49eb808b0230f6a2f",+ "method": "docs",+ "sourceUrl": "https://docs.together.ai/docs/inference/chat/parameters.md",+ "observedAt": "2026-10-12T10:09:42.288Z"+ },+ {+ "evidenceId": "wev_d252205a5c67cf95a28b99770cfa0d13",+ "method": "docs",+ "sourceUrl": "https://docs.together.ai/docs/inference/openai-compatibility.md",+ "observedAt": "2026-10-12T10:09:42.290Z"+ }+ ]+ }+ }+ ],+ "supportsVision": true,+ "supportsTools": true,+ "supportsThinking": true,+ "videoInput": true,+ "videoOutput": false,+ "reasoning": {+ "supported": true,+ "mandatory": false,+ "control": "toggle"+ },+ "endpoints": {+ "openai": {+ "api": "responses"+ }+ },+ "tokenParam": "max_output_tokens"+ },+ {+ "contractVersion": 3,+ "modelId": "grok-build-0.1",+ "displayName": "Grok Build 0.1",+ "provider": "x-ai",+ "aliases": [+ "x-ai/grok-build-0.1",+ "grok-code-fast-1",+ "grok-code-fast",+ "grok-code-fast-1-0825"+ ],+ "status": "active",+ "releaseDate": "2026-05-19",+ "contextWindow": 256000,+ "maxOutputTokens": 10000,+ "inputModalities": [+ "image",+ "text"+ ],+ "outputModalities": [+ "text"+ ],+ "aggregators": [+ {+ "sourceProviderId": "opencode-zen",+ "sourceCollectorId": "opencode-zen-api",+ "confidence": "gateway_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "opencode",+ "routeProfileId": "zen"+ },+ "externalModelId": "grok-build-0.1",+ "pricing": {+ "type": "flat",+ "input": 1,+ "output": 2,+ "cachedRead": 0.2+ },+ "reasoning": {+ "request": {+ "status": "unknown"+ }+ },+ "wire": {+ "status": "known",+ "api": "responses",+ "tokenParam": {+ "status": "unknown"+ },+ "toolsWithReasoning": {+ "status": "unknown"+ },+ "reasoning": {+ "status": "unknown"+ },+ "speed": {+ "status": "unknown"+ },+ "evidence": [+ {+ "evidenceId": "wev_bd9772057e46907077104ca5c1e33b36",+ "method": "endpoint-table",+ "sourceUrl": "https://opencode.ai/docs/en/zen/",+ "observedAt": "2026-10-12T10:09:23.090Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "openrouter",+ "sourceCollectorId": "openrouter-api",+ "confidence": "aggregator_reported",+ "routeStatus": "mapped",+ "route": {+ "routeId": "openrouter",+ "routeProfileId": "gateway"+ },+ "externalModelId": "x-ai/grok-build-0.1",+ "pricing": {+ "type": "flat",+ "input": 1,+ "output": 2,+ "cachedRead": 0.2+ },+ "reasoning": {+ "request": {+ "status": "supported",+ "api": "chat-completions",+ "evidenceSourceUrl": "https://openrouter.ai/api/v1/models",+ "enable": [+ {+ "path": "/reasoning/enabled",+ "value": true+ }+ ]+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": [+ {+ "path": "/reasoning/enabled",+ "value": true+ }+ ],+ "disable": {+ "status": "not_applicable"+ },+ "effort": {+ "status": "not_applicable"+ },+ "mode": {+ "status": "not_applicable"+ }+ },+ "speed": {+ "status": "supported",+ "path": "/service_tier",+ "values": {+ "priority": "priority"+ },+ "default": "standard",+ "headers": [],+ "echo": "/service_tier",+ "access": "open"+ },+ "evidence": [+ {+ "evidenceId": "wev_10e4afa8e03338ad063ca3aed3e99bc0",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_543f8783079e2effe4c206913f41c175",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_8035fa0060b7304f0d6fb5e8d7548cad",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models/x-ai/grok-build-0.1/endpoints",+ "observedAt": "2026-10-12T10:09:48.998Z"+ },+ {+ "evidenceId": "wev_914e96932c1d0731a96b0ce6b1d0a736",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_b91da5b3031d35978c939662d087f02b",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_e105a4dffa6457f9abd56f8ed08a83d4",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_2e7fdfad209bcdf40437de47f5ff783e",+ "method": "docs",+ "sourceUrl": "https://openrouter.ai/docs/guides/best-practices/reasoning-tokens",+ "observedAt": "2026-10-12T10:09:52.321Z"+ },+ {+ "evidenceId": "wev_9c6222032532c301d9391640c5a22ee7",+ "method": "docs",+ "sourceUrl": "https://openrouter.ai/docs/guides/best-practices/reasoning-tokens",+ "observedAt": "2026-10-12T10:09:52.321Z"+ },+ {+ "evidenceId": "wev_0e4f266ba57ac6654f35e6efc095bd3c",+ "method": "probe",+ "observedAt": "2026-10-11T22:32:36.260Z"+ },+ {+ "evidenceId": "wev_39a46fd4338af73d7dac9bdf1ace5a50",+ "method": "probe",+ "observedAt": "2026-10-11T22:32:36.279Z"+ },+ {+ "evidenceId": "wev_c9751f21ac5092b784fa00512698af20",+ "method": "probe",+ "observedAt": "2026-10-11T22:32:36.260Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "x-ai",+ "sourceCollectorId": "xai-api",+ "confidence": "api_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "x-ai",+ "routeProfileId": "direct-api"+ },+ "externalModelId": "grok-build-0.1",+ "pricing": {+ "type": "flat",+ "input": 1,+ "output": 2,+ "cachedRead": 0.2+ },+ "reasoning": {+ "request": {+ "status": "unknown"+ }+ },+ "wire": {+ "status": "known",+ "api": "responses",+ "tokenParam": "max_output_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "unknown"+ },+ "speed": {+ "status": "supported",+ "path": "/service_tier",+ "values": {+ "standard": "default",+ "priority": "priority"+ },+ "default": "standard",+ "headers": [],+ "echo": "/service_tier",+ "access": "open"+ },+ "evidence": [+ {+ "evidenceId": "wev_5974b11544a26cad8a8fec7f99e6a217",+ "method": "docs",+ "sourceUrl": "https://docs.x.ai/developers/rest-api-reference/inference/responses.md",+ "observedAt": "2026-10-12T10:09:43.120Z"+ },+ {+ "evidenceId": "wev_6b489a01a88829e5f2cdb0164c568b30",+ "method": "docs",+ "sourceUrl": "https://docs.x.ai/developers/advanced-api-usage/priority-processing",+ "observedAt": "2026-10-12T10:09:42.197Z"+ },+ {+ "evidenceId": "wev_4719ed0a0944b31f1faa9059a33c1fbb",+ "method": "probe",+ "observedAt": "2026-10-11T22:22:05.600Z"+ },+ {+ "evidenceId": "wev_e96af41170d3baf141661f16d07ae1f1",+ "method": "probe",+ "observedAt": "2026-10-11T22:22:05.773Z"+ }+ ]+ }+ }+ ],+ "supportsVision": true,+ "supportsTools": true,+ "videoInput": false,+ "videoOutput": false,+ "reasoning": {+ "supported": true,+ "mandatory": true,+ "control": "unknown"+ },+ "endpoints": {+ "openai": {+ "api": "responses",+ "toolsWithReasoning": "ok"+ }+ },+ "tokenParam": "max_output_tokens"+ },+ {+ "contractVersion": 3,+ "modelId": "gpt-5.5",+ "displayName": "GPT-5.5",+ "provider": "openai",+ "aliases": [+ "openai/gpt-5.5",+ "openai/gpt-5.5:batch"+ ],+ "status": "active",+ "releaseDate": "2026-04-23",+ "contextWindow": 1050000,+ "maxOutputTokens": 128000,+ "subscriptionPlanIds": [+ "openai-codex"+ ],+ "inputModalities": [+ "image",+ "text"+ ],+ "outputModalities": [+ "text"+ ],+ "aggregators": [+ {+ "sourceProviderId": "openai-codex",+ "sourceCollectorId": "openai-codex-models",+ "confidence": "scrape_verified",+ "routeStatus": "mapped",+ "route": {+ "routeId": "openai",+ "routeProfileId": "codex-subscription"+ },+ "externalModelId": "gpt-5.5",+ "reasoning": {+ "mode": {+ "status": "rejected"+ },+ "request": {+ "status": "unknown"+ }+ },+ "wire": {+ "status": "known",+ "api": "responses",+ "tokenParam": "max_output_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": {+ "status": "unknown"+ },+ "disable": {+ "status": "unknown"+ },+ "effort": {+ "path": "/reasoning/effort",+ "values": {+ "xhigh": "xhigh",+ "high": "high",+ "medium": "medium",+ "low": "low",+ "none": "none"+ },+ "default": {+ "status": "unknown"+ }+ },+ "mode": {+ "status": "rejected",+ "path": "/reasoning/mode"+ }+ },+ "speed": {+ "status": "unknown"+ },+ "evidence": [+ {+ "evidenceId": "wev_71b42ee919e4f3a612020d7f4ed7b3c8",+ "method": "docs",+ "sourceUrl": "https://developers.openai.com/codex/config-reference.md",+ "observedAt": "2026-10-12T10:09:53.088Z"+ },+ {+ "evidenceId": "wev_1b4e36096195b37be907442db8503417",+ "method": "probe",+ "observedAt": "2026-10-11T22:05:48.525Z"+ },+ {+ "evidenceId": "wev_45bc6156532c2a5535b71a87263fc2d2",+ "method": "probe",+ "observedAt": "2026-10-11T22:05:46.938Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "openai",+ "sourceCollectorId": "openai-api",+ "confidence": "api_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "openai",+ "routeProfileId": "direct-api"+ },+ "externalModelId": "gpt-5.5",+ "pricing": {+ "type": "flat",+ "input": 5,+ "output": 30,+ "cachedRead": 0.5+ },+ "reasoning": {+ "mode": {+ "status": "rejected"+ },+ "request": {+ "status": "supported",+ "api": "responses",+ "evidenceSourceUrl": "https://developers.openai.com/api/reference/resources/responses.md",+ "effort": {+ "path": "/reasoning/effort",+ "values": {+ "xhigh": "xhigh",+ "high": "high",+ "medium": "medium",+ "low": "low",+ "none": "none"+ },+ "default": "medium"+ }+ }+ },+ "wire": {+ "status": "known",+ "api": "responses",+ "tokenParam": "max_output_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": {+ "status": "unknown"+ },+ "disable": {+ "status": "unknown"+ },+ "effort": {+ "path": "/reasoning/effort",+ "values": {+ "xhigh": "xhigh",+ "high": "high",+ "medium": "medium",+ "low": "low",+ "none": "none"+ },+ "default": "medium"+ },+ "mode": {+ "status": "rejected",+ "path": "/reasoning/mode"+ }+ },+ "speed": {+ "status": "unknown"+ },+ "evidence": [+ {+ "evidenceId": "wev_0a3a4b29e20934eaa8d361987102b277",+ "method": "docs",+ "sourceUrl": "https://developers.openai.com/api/reference/resources/responses.md",+ "observedAt": "2026-10-12T10:09:54.840Z"+ },+ {+ "evidenceId": "wev_633b0ea58ae71b1223083418671aedce",+ "method": "docs",+ "sourceUrl": "https://developers.openai.com/api/docs/models/gpt-5.5.md",+ "observedAt": "2026-10-12T10:09:44.895Z"+ },+ {+ "evidenceId": "wev_a968bf78e09a793334eee14834788bb3",+ "method": "docs",+ "sourceUrl": "https://developers.openai.com/api/docs/models/gpt-5.5.md",+ "observedAt": "2026-10-12T10:09:44.895Z"+ },+ {+ "evidenceId": "wev_e5b93bd1b62be3da2c57564458992895",+ "method": "docs",+ "sourceUrl": "https://developers.openai.com/api/docs/models/gpt-5.5.md",+ "observedAt": "2026-10-12T10:09:44.895Z"+ },+ {+ "evidenceId": "wev_f53bfcd7cb04aa877b80b4fa0695aa13",+ "method": "docs",+ "sourceUrl": "https://developers.openai.com/api/reference/resources/responses.md",+ "observedAt": "2026-10-12T10:09:54.840Z"+ },+ {+ "evidenceId": "wev_47d50b54f7abbbdbffc839a33c248ed3",+ "method": "probe",+ "observedAt": "2026-10-11T22:07:12.773Z"+ },+ {+ "evidenceId": "wev_6f1e41f3f459661f028fdc86c06081ad",+ "method": "probe",+ "observedAt": "2026-10-11T22:07:13.350Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "opencode-zen",+ "sourceCollectorId": "opencode-zen-api",+ "confidence": "gateway_official",+ "routeStatus": "mapped",+ "route": {+ "routeId": "opencode",+ "routeProfileId": "zen"+ },+ "externalModelId": "gpt-5.5",+ "pricing": {+ "type": "flat",+ "input": 5,+ "output": 30,+ "cachedRead": 0.5+ },+ "reasoning": {+ "request": {+ "status": "unknown"+ }+ },+ "wire": {+ "status": "known",+ "api": "responses",+ "tokenParam": {+ "status": "unknown"+ },+ "toolsWithReasoning": {+ "status": "unknown"+ },+ "reasoning": {+ "status": "unknown"+ },+ "speed": {+ "status": "unknown"+ },+ "evidence": [+ {+ "evidenceId": "wev_9ecd5948fe9e771024cd66577b1fe3f1",+ "method": "endpoint-table",+ "sourceUrl": "https://opencode.ai/docs/en/zen/",+ "observedAt": "2026-10-12T10:09:23.090Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "openrouter",+ "sourceCollectorId": "openrouter-api",+ "confidence": "aggregator_reported",+ "routeStatus": "mapped",+ "route": {+ "routeId": "openrouter",+ "routeProfileId": "gateway"+ },+ "externalModelId": "openai/gpt-5.5",+ "pricing": {+ "type": "flat",+ "input": 5,+ "output": 30,+ "cachedRead": 0.5,+ "batchDiscountPct": 50+ },+ "reasoning": {+ "mode": {+ "status": "rejected"+ },+ "request": {+ "status": "supported",+ "api": "chat-completions",+ "evidenceSourceUrl": "https://openrouter.ai/api/v1/models",+ "enable": [+ {+ "path": "/reasoning/enabled",+ "value": true+ }+ ],+ "disable": [+ {+ "path": "/reasoning/effort",+ "value": "none"+ }+ ],+ "effort": {+ "path": "/reasoning/effort",+ "values": {+ "xhigh": "xhigh",+ "high": "high",+ "medium": "medium",+ "low": "low",+ "none": "none"+ },+ "default": "medium"+ }+ }+ },+ "wire": {+ "status": "known",+ "api": "chat-completions",+ "tokenParam": "max_tokens",+ "toolsWithReasoning": "ok",+ "reasoning": {+ "status": "supported",+ "enable": [+ {+ "path": "/reasoning/enabled",+ "value": true+ }+ ],+ "disable": [+ {+ "path": "/reasoning/effort",+ "value": "none"+ }+ ],+ "effort": {+ "path": "/reasoning/effort",+ "values": {+ "xhigh": "xhigh",+ "high": "high",+ "medium": "medium",+ "low": "low",+ "none": "none"+ },+ "default": "medium"+ },+ "mode": {+ "status": "rejected",+ "path": "/reasoning/mode"+ }+ },+ "speed": {+ "status": "supported",+ "path": "/service_tier",+ "values": {+ "fast": "priority",+ "flex": "flex"+ },+ "default": "standard",+ "headers": [],+ "echo": "/service_tier",+ "access": "open"+ },+ "evidence": [+ {+ "evidenceId": "wev_0580eca6580a166351c0e938baa5c6ed",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_080169197b66605e880da5e12b84c880",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_1b0478e3e4d85ee75a9ce065c3ecfef1",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_2967f269c22aa8bf1a921da540983dd5",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_5f9ae4156f524410676023d6e7d538ab",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models/openai/gpt-5.5/endpoints",+ "observedAt": "2026-10-12T10:09:49.572Z"+ },+ {+ "evidenceId": "wev_a2bed3e3a712b440bbf10336d618091c",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_a8731c18e56d2ec5ae1cfe904b14d70c",+ "method": "api",+ "sourceUrl": "https://openrouter.ai/api/v1/models",+ "observedAt": "2026-10-12T10:09:21.826Z"+ },+ {+ "evidenceId": "wev_c49d27474f0a3a8f1b9870fdc0854ed7",+ "method": "docs",+ "sourceUrl": "https://openrouter.ai/docs/guides/best-practices/reasoning-tokens",+ "observedAt": "2026-10-12T10:09:52.321Z"+ },+ {+ "evidenceId": "wev_cac35101d5f534f50dd3081b49110770",+ "method": "docs",+ "sourceUrl": "https://openrouter.ai/docs/guides/best-practices/reasoning-tokens",+ "observedAt": "2026-10-12T10:09:52.321Z"+ },+ {+ "evidenceId": "wev_5d453a8fade8fed5f07bc82df64d4f46",+ "method": "probe",+ "observedAt": "2026-10-11T19:15:39.114Z"+ },+ {+ "evidenceId": "wev_85ee13b073611882ea86bb77dda469db",+ "method": "probe",+ "observedAt": "2026-10-11T19:15:42.216Z"+ },+ {+ "evidenceId": "wev_d8aace2da232cc0bff9c23f0d164f45e",+ "method": "probe",+ "observedAt": "2026-10-11T19:15:42.216Z"+ },+ {+ "evidenceId": "wev_fa0590a7def63e1ba62059f084e26e24",+ "method": "probe",+ "observedAt": "2026-10-11T19:15:36.241Z"+ }+ ]+ }+ },+ {+ "sourceProviderId": "openrouter",+ "sourceCollectorId": "openrouter-api",+ "confidence": "aggregator_reported",+ "routeStatus": "unknown",+ "reason": "unverified_mapping",+ "observedExternalModelId": "openai/gpt-5.5:batch"+ }+ ],+ "supportsVision": true,+ "supportsTools": true,+ "videoInput": false,+ "videoOutput": false,+ "reasoning": {+ "supported": true,+ "mandatory": false,+ "control": "effort",+ "efforts": [+ "xhigh",+ "high",+ "medium",+ "low",+ "none"+ ],+ "defaultEffort": "medium"+ },+ "endpoints": {+ "openai": {+ "api": "responses",+ "toolsWithReasoning": "ok"+ }+ },+ "tokenParam": "max_output_tokens"+ }+ ],+ "models": [+ {+ "id": "microsoft/mai-voice-2.1"+ },+ {+ "id": "openai/gpt-6.1-sol"+ },+ {+ "id": "anthropic/claude-sonnet-5.5"+ },+ {+ "id": "anthropic/claude-opus-5.5"+ },+ {+ "id": "openai/gpt-6-sol"+ },+ {+ "id": "x-ai/grok-4.7"+ },+ {+ "id": "deepseek/deepseek-v4.1-flash"+ },+ {+ "id": "google/gemini-3.8-flash"+ },+ {+ "id": "z-ai/glm-5.3"+ },+ {+ "id": "moonshotai/kimi-k3"+ },+ {+ "id": "minimax/minimax-m3"+ },+ {+ "id": "qwen/qwen3.7-plus"+ },+ {+ "id": "x-ai/grok-build-0.1"+ },+ {+ "id": "openai/gpt-5.5"+ }+ ],+ "plans": [+ {+ "contractVersion": 3,+ "id": "alibaba-ai-coding-plan",+ "displayName": "Alibaba Cloud Model Studio Coding Plan",+ "provider": "alibaba",+ "pricing": [+ {+ "period": "monthly",+ "price": 50,+ "currency": "USD",+ "description": "Pro"+ }+ ],+ "modelDiscovery": "catalog",+ "inclusions": [+ {+ "kind": "provider_model",+ "sourceText": "qwen3.7-plus",+ "provider": "alibaba",+ "externalModelId": "qwen3.7-plus",+ "resolution": {+ "status": "mapped",+ "modelId": "qwen3.7-plus"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "qwen3.6-plus",+ "provider": "alibaba",+ "externalModelId": "qwen3.6-plus",+ "resolution": {+ "status": "mapped",+ "modelId": "qwen3.6-plus"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "kimi-k2.5",+ "provider": "alibaba",+ "externalModelId": "kimi-k2.5",+ "resolution": {+ "status": "mapped",+ "modelId": "kimi-k2.5"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "glm-5",+ "provider": "alibaba",+ "externalModelId": "glm-5",+ "resolution": {+ "status": "mapped",+ "modelId": "glm-5"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "MiniMax-M2.5",+ "provider": "alibaba",+ "externalModelId": "MiniMax-M2.5",+ "resolution": {+ "status": "mapped",+ "modelId": "minimax-m2.5"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "qwen3.5-plus",+ "provider": "alibaba",+ "externalModelId": "qwen3.5-plus",+ "resolution": {+ "status": "mapped",+ "modelId": "qwen3.5-plus"+ }+ }+ ],+ "features": [+ "Alibaba Cloud Model Studio and QwenCloud are shared service branding; Coding Plan, Token Plan, and pay-as-you-go are separate billing products",+ "Fixed-price monthly subscription for AI coding tools, billed by model calls rather than Token Plan Credits",+ "Pro has limited purchase slots, restocked daily at 00:00 UTC+08:00; temporary stock shortages do not retire the plan or its supported models",+ "All three request caps apply simultaneously; calls pause when any cap is reached",+ "Requires Coding Plan credentials and coding-intl.dashscope.aliyuncs.com endpoints; Token Plan and pay-as-you-go credentials and endpoints are not interchangeable",+ "Claudish uses the dedicated qwen-coding provider, Coding Plan credential, and Coding Plan endpoint",+ "Coding Plan, Token Plan, and pay-as-you-go credentials and endpoints remain isolated products",+ "Pro quota includes 6,000 requests per five hours, 45,000 per week, and 90,000 per month",+ "Lite stopped accepting new subscriptions on March 20, 2026; renewals and upgrades stopped on April 13, 2026, and existing access lasts only until expiry",+ "Compatible with Codex, Claude Code, OpenCode, Qwen Code, Cline, Cursor, and Kilo tools"+ ],+ "lastUpdated": "2026-10-12T10:09:25.715Z",+ "routeStatus": "supported",+ "route": {+ "routeId": "qwen",+ "routeProfileId": "modelstudio-coding-plan"+ },+ "membershipRequirements": [+ {+ "membershipId": "alibaba-ai-coding-plan-live",+ "authority": "authoritative",+ "requiredForActivation": true,+ "maxAgeHours": 24+ }+ ],+ "membershipCoverage": {+ "status": "complete",+ "observedAt": "2026-10-12T10:09:25.715Z",+ "expiresAt": "2026-10-13T10:09:25.715Z"+ }+ },+ {+ "contractVersion": 3,+ "id": "alibaba-token-plan-individual",+ "displayName": "QwenCloud Token Plan Individual",+ "provider": "alibaba",+ "pricing": [+ {+ "period": "monthly",+ "price": 6,+ "currency": "USD",+ "description": "Lite promotional price (regular $8): 11,500 Credits/month"+ },+ {+ "period": "monthly",+ "price": 10,+ "currency": "USD",+ "description": "Essential promotional price (regular $16): 25,500 Credits/month"+ },+ {+ "period": "monthly",+ "price": 18,+ "currency": "USD",+ "description": "Standard promotional price (regular $25): 45,000 Credits/month"+ },+ {+ "period": "monthly",+ "price": 68,+ "currency": "USD",+ "description": "Pro promotional price (regular $80): 180,000 Credits/month"+ },+ {+ "period": "one-time",+ "price": 15,+ "currency": "USD",+ "description": "Credit Pack: 20,000 Credits; requires an active subscription; expires after one month"+ }+ ],+ "modelDiscovery": "catalog",+ "inclusions": [+ {+ "kind": "provider_model",+ "sourceText": "auto",+ "provider": "qwencloud",+ "externalModelId": "auto",+ "resolution": {+ "status": "mapped",+ "modelId": "qwencloud-auto"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "qwen3.8-max",+ "provider": "qwencloud",+ "externalModelId": "qwen3.8-max",+ "resolution": {+ "status": "mapped",+ "modelId": "qwen3.8-max"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "qwen3.8-flash",+ "provider": "qwencloud",+ "externalModelId": "qwen3.8-flash",+ "resolution": {+ "status": "mapped",+ "modelId": "qwen3.8-flash"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "qwen3.7-max",+ "provider": "qwencloud",+ "externalModelId": "qwen3.7-max",+ "resolution": {+ "status": "mapped",+ "modelId": "qwen3.7-max"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "qwen3.7-plus",+ "provider": "qwencloud",+ "externalModelId": "qwen3.7-plus",+ "resolution": {+ "status": "mapped",+ "modelId": "qwen3.7-plus"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "qwen3.6-flash",+ "provider": "qwencloud",+ "externalModelId": "qwen3.6-flash",+ "resolution": {+ "status": "mapped",+ "modelId": "qwen3.6-flash"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "qwen-image-3.0-pro",+ "provider": "qwencloud",+ "externalModelId": "qwen-image-3.0-pro",+ "resolution": {+ "status": "mapped",+ "modelId": "qwen-image-3.0-pro"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "qwen-audio-3.0-tts-plus",+ "provider": "qwencloud",+ "externalModelId": "qwen-audio-3.0-tts-plus",+ "resolution": {+ "status": "mapped",+ "modelId": "qwen-audio-3.0-tts-plus"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "qwen-audio-3.0-realtime-plus",+ "provider": "qwencloud",+ "externalModelId": "qwen-audio-3.0-realtime-plus",+ "resolution": {+ "status": "mapped",+ "modelId": "qwen-audio-3.0-realtime-plus"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "qwen-audio-3.0-asr-flash",+ "provider": "qwencloud",+ "externalModelId": "qwen-audio-3.0-asr-flash",+ "resolution": {+ "status": "mapped",+ "modelId": "qwen-audio-3.0-asr-flash"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "glm-5.3",+ "provider": "qwencloud",+ "externalModelId": "glm-5.3",+ "resolution": {+ "status": "mapped",+ "modelId": "glm-5.3"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "glm-5.2",+ "provider": "qwencloud",+ "externalModelId": "glm-5.2",+ "resolution": {+ "status": "mapped",+ "modelId": "glm-5.2"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "deepseek-v4-pro",+ "provider": "qwencloud",+ "externalModelId": "deepseek-v4-pro",+ "resolution": {+ "status": "mapped",+ "modelId": "deepseek-v4-pro"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "deepseek-v4-pro-0813",+ "provider": "qwencloud",+ "externalModelId": "deepseek-v4-pro-0813",+ "resolution": {+ "status": "mapped",+ "modelId": "deepseek-v4-pro-0813"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "deepseek-v4-flash-0731",+ "provider": "qwencloud",+ "externalModelId": "deepseek-v4-flash-0731",+ "resolution": {+ "status": "mapped",+ "modelId": "deepseek-v4-flash-0731"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "deepseek-v4.1-flash",+ "provider": "qwencloud",+ "externalModelId": "deepseek-v4.1-flash",+ "resolution": {+ "status": "mapped",+ "modelId": "deepseek-v4.1-flash"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "wan2.7-image",+ "provider": "qwencloud",+ "externalModelId": "wan2.7-image",+ "resolution": {+ "status": "mapped",+ "modelId": "wan2.7-image"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "wan2.7-image-pro",+ "provider": "qwencloud",+ "externalModelId": "wan2.7-image-pro",+ "resolution": {+ "status": "mapped",+ "modelId": "wan2.7-image-pro"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "happyhorse-1.1-i2v",+ "provider": "qwencloud",+ "externalModelId": "happyhorse-1.1-i2v",+ "resolution": {+ "status": "mapped",+ "modelId": "happyhorse-1.1-i2v"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "happyhorse-1.1-t2v",+ "provider": "qwencloud",+ "externalModelId": "happyhorse-1.1-t2v",+ "resolution": {+ "status": "mapped",+ "modelId": "happyhorse-1.1-t2v"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "happyhorse-1.1-r2v",+ "provider": "qwencloud",+ "externalModelId": "happyhorse-1.1-r2v",+ "resolution": {+ "status": "mapped",+ "modelId": "happyhorse-1.1-r2v"+ }+ }+ ],+ "features": [+ "Alibaba Cloud Model Studio and QwenCloud are shared service branding; Coding Plan, Token Plan, and pay-as-you-go are separate billing products",+ "Individual developer plan with unified Credits across text, image, audio, video, and Harness tools",+ "Published models describe the public product allowlist; actual access can vary by account and must be discovered with the account's Token Plan credential",+ "Requires Token Plan credentials and token-plan.ap-southeast-1.maas.aliyuncs.com; Coding Plan and pay-as-you-go keys are not interchangeable",+ "Credits consumption depends on model, token usage, thinking mode, and tool calls; this is not a fixed prepaid token count",+ "Monthly quota resets on the subscription billing cycle; unused quota does not carry over",+ "Credit Packs require an active subscription, expire after one month, and are limited to five at a time",+ "qwen3.8-max-preview is retired and requests are routed to qwen3.8-max",+ "Singapore-only plan with OpenAI-compatible and Anthropic-compatible base URLs",+ "Interactive AI-tool use only; automated scripts, application backends, and non-interactive batch processing are prohibited"+ ],+ "lastUpdated": "2026-10-12T10:09:21.538Z",+ "routeStatus": "supported",+ "route": {+ "routeId": "qwen",+ "routeProfileId": "qwencloud-token-plan"+ },+ "membershipRequirements": [+ {+ "membershipId": "qwencloud-token-plan-personal-live",+ "authority": "authoritative",+ "requiredForActivation": true,+ "maxAgeHours": 24+ }+ ],+ "membershipCoverage": {+ "status": "complete",+ "observedAt": "2026-10-12T10:09:21.538Z",+ "expiresAt": "2026-10-13T10:09:21.538Z"+ }+ },+ {+ "contractVersion": 3,+ "id": "alibaba-token-plan-team-edition",+ "displayName": "QwenCloud Token Plan Team Edition",+ "provider": "alibaba",+ "pricing": [+ {+ "period": "monthly",+ "price": 20,+ "currency": "USD",+ "description": "Standard Seat promotional price (regular $30): 25,000 Credits per seat"+ },+ {+ "period": "monthly",+ "price": 75,+ "currency": "USD",+ "description": "Pro Seat promotional price (regular $100): 100,000 Credits per seat"+ },+ {+ "period": "monthly",+ "price": 200,+ "currency": "USD",+ "description": "Max Seat: 250,000 Credits per seat"+ },+ {+ "period": "one-time",+ "price": 700,+ "currency": "USD",+ "description": "Shared Credit Pack: 625,000 Credits; expires after one month"+ }+ ],+ "modelDiscovery": "catalog",+ "inclusions": [+ {+ "kind": "provider_model",+ "sourceText": "auto",+ "provider": "qwencloud",+ "externalModelId": "auto",+ "resolution": {+ "status": "mapped",+ "modelId": "qwencloud-auto"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "qwen3.8-max",+ "provider": "qwencloud",+ "externalModelId": "qwen3.8-max",+ "resolution": {+ "status": "mapped",+ "modelId": "qwen3.8-max"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "qwen3.8-flash",+ "provider": "qwencloud",+ "externalModelId": "qwen3.8-flash",+ "resolution": {+ "status": "mapped",+ "modelId": "qwen3.8-flash"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "qwen3.7-max",+ "provider": "qwencloud",+ "externalModelId": "qwen3.7-max",+ "resolution": {+ "status": "mapped",+ "modelId": "qwen3.7-max"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "qwen3.7-plus",+ "provider": "qwencloud",+ "externalModelId": "qwen3.7-plus",+ "resolution": {+ "status": "mapped",+ "modelId": "qwen3.7-plus"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "qwen3.6-plus",+ "provider": "qwencloud",+ "externalModelId": "qwen3.6-plus",+ "resolution": {+ "status": "mapped",+ "modelId": "qwen3.6-plus"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "qwen3.6-flash",+ "provider": "qwencloud",+ "externalModelId": "qwen3.6-flash",+ "resolution": {+ "status": "mapped",+ "modelId": "qwen3.6-flash"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "qwen-image-2.0",+ "provider": "qwencloud",+ "externalModelId": "qwen-image-2.0",+ "resolution": {+ "status": "mapped",+ "modelId": "qwen-image-2.0"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "qwen-image-2.0-pro",+ "provider": "qwencloud",+ "externalModelId": "qwen-image-2.0-pro",+ "resolution": {+ "status": "mapped",+ "modelId": "qwen-image-2.0-pro"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "qwen-image-3.0-pro",+ "provider": "qwencloud",+ "externalModelId": "qwen-image-3.0-pro",+ "resolution": {+ "status": "mapped",+ "modelId": "qwen-image-3.0-pro"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "qwen-audio-3.0-tts-plus",+ "provider": "qwencloud",+ "externalModelId": "qwen-audio-3.0-tts-plus",+ "resolution": {+ "status": "mapped",+ "modelId": "qwen-audio-3.0-tts-plus"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "qwen-audio-3.0-realtime-plus",+ "provider": "qwencloud",+ "externalModelId": "qwen-audio-3.0-realtime-plus",+ "resolution": {+ "status": "mapped",+ "modelId": "qwen-audio-3.0-realtime-plus"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "qwen-audio-3.0-asr-flash",+ "provider": "qwencloud",+ "externalModelId": "qwen-audio-3.0-asr-flash",+ "resolution": {+ "status": "mapped",+ "modelId": "qwen-audio-3.0-asr-flash"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "wan2.7-image",+ "provider": "qwencloud",+ "externalModelId": "wan2.7-image",+ "resolution": {+ "status": "mapped",+ "modelId": "wan2.7-image"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "wan2.7-image-pro",+ "provider": "qwencloud",+ "externalModelId": "wan2.7-image-pro",+ "resolution": {+ "status": "mapped",+ "modelId": "wan2.7-image-pro"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "deepseek-v4-pro",+ "provider": "qwencloud",+ "externalModelId": "deepseek-v4-pro",+ "resolution": {+ "status": "mapped",+ "modelId": "deepseek-v4-pro"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "deepseek-v4-pro-0813",+ "provider": "qwencloud",+ "externalModelId": "deepseek-v4-pro-0813",+ "resolution": {+ "status": "mapped",+ "modelId": "deepseek-v4-pro-0813"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "deepseek-v4-flash-0731",+ "provider": "qwencloud",+ "externalModelId": "deepseek-v4-flash-0731",+ "resolution": {+ "status": "mapped",+ "modelId": "deepseek-v4-flash-0731"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "deepseek-v4.1-flash",+ "provider": "qwencloud",+ "externalModelId": "deepseek-v4.1-flash",+ "resolution": {+ "status": "mapped",+ "modelId": "deepseek-v4.1-flash"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "kimi-k2.7-code",+ "provider": "qwencloud",+ "externalModelId": "kimi-k2.7-code",+ "resolution": {+ "status": "mapped",+ "modelId": "kimi-k2.7-code"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "kimi-k2.6",+ "provider": "qwencloud",+ "externalModelId": "kimi-k2.6",+ "resolution": {+ "status": "mapped",+ "modelId": "kimi-k2.6"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "kimi-k2.5",+ "provider": "qwencloud",+ "externalModelId": "kimi-k2.5",+ "resolution": {+ "status": "mapped",+ "modelId": "kimi-k2.5"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "glm-5.3",+ "provider": "qwencloud",+ "externalModelId": "glm-5.3",+ "resolution": {+ "status": "mapped",+ "modelId": "glm-5.3"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "glm-5.2",+ "provider": "qwencloud",+ "externalModelId": "glm-5.2",+ "resolution": {+ "status": "mapped",+ "modelId": "glm-5.2"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "glm-5.1",+ "provider": "qwencloud",+ "externalModelId": "glm-5.1",+ "resolution": {+ "status": "mapped",+ "modelId": "glm-5.1"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "glm-5",+ "provider": "qwencloud",+ "externalModelId": "glm-5",+ "resolution": {+ "status": "mapped",+ "modelId": "glm-5"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "MiniMax-M2.5",+ "provider": "qwencloud",+ "externalModelId": "MiniMax-M2.5",+ "resolution": {+ "status": "mapped",+ "modelId": "minimax-m2.5"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "happyhorse-1.1-t2v",+ "provider": "qwencloud",+ "externalModelId": "happyhorse-1.1-t2v",+ "resolution": {+ "status": "mapped",+ "modelId": "happyhorse-1.1-t2v"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "happyhorse-1.1-i2v",+ "provider": "qwencloud",+ "externalModelId": "happyhorse-1.1-i2v",+ "resolution": {+ "status": "mapped",+ "modelId": "happyhorse-1.1-i2v"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "happyhorse-1.1-r2v",+ "provider": "qwencloud",+ "externalModelId": "happyhorse-1.1-r2v",+ "resolution": {+ "status": "mapped",+ "modelId": "happyhorse-1.1-r2v"+ }+ }+ ],+ "features": [+ "Alibaba Cloud Model Studio and QwenCloud are shared service branding; Coding Plan, Token Plan, and pay-as-you-go are separate billing products",+ "Team-oriented subscription using Credits as a unified billing unit across text, image, audio, and video models",+ "Published models describe the public product allowlist; actual access can vary by member and must be discovered with that member's Token Plan credential",+ "Credits consumption depends on model, token usage, thinking mode, and tool calls; this is not a fixed prepaid token count",+ "Monthly seat Credits are consumed first, then shared Credit Packs; calls pause when all Credits are exhausted",+ "Shared Credit Packs expire after one month; Individual and Team subscriptions can be held simultaneously with independent billing",+ "No five-hour or seven-day frequency windows while monthly seat Credits remain",+ "Singapore-region plan with dedicated per-member API keys and OpenAI-compatible and Anthropic-compatible base URLs",+ "qwen3.8-max-preview is retired and requests are routed to qwen3.8-max",+ "Interactive AI-tool use only; automated scripts and application backends are prohibited"+ ],+ "lastUpdated": "2026-10-12T10:09:21.538Z",+ "routeStatus": "supported",+ "route": {+ "routeId": "qwen",+ "routeProfileId": "qwencloud-token-plan"+ },+ "membershipRequirements": [+ {+ "membershipId": "qwencloud-token-plan-team-live",+ "authority": "authoritative",+ "requiredForActivation": true,+ "maxAgeHours": 24+ }+ ],+ "membershipCoverage": {+ "status": "complete",+ "observedAt": "2026-10-12T10:09:21.538Z",+ "expiresAt": "2026-10-13T10:09:21.538Z"+ }+ },+ {+ "contractVersion": 3,+ "id": "anthropic-claude-code",+ "displayName": "Claude Code",+ "provider": "anthropic",+ "pricing": [+ {+ "period": "monthly",+ "price": 20,+ "currency": "USD",+ "description": "Pro monthly"+ },+ {+ "period": "yearly",+ "price": 200,+ "currency": "USD",+ "description": "Pro annual"+ },+ {+ "period": "monthly",+ "price": 100,+ "currency": "USD",+ "description": "Max 5x"+ },+ {+ "period": "monthly",+ "price": 200,+ "currency": "USD",+ "description": "Max 20x"+ },+ {+ "period": "monthly",+ "price": 20,+ "currency": "USD",+ "description": "Team standard seat, annual billing"+ }+ ],+ "modelDiscovery": "catalog",+ "inclusions": [+ {+ "kind": "provider_model",+ "sourceText": "claude-haiku-5-5",+ "provider": "anthropic",+ "externalModelId": "claude-haiku-5-5",+ "resolution": {+ "status": "mapped",+ "modelId": "claude-haiku-5-5"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "claude-sonnet-5-5",+ "provider": "anthropic",+ "externalModelId": "claude-sonnet-5-5",+ "resolution": {+ "status": "mapped",+ "modelId": "claude-sonnet-5-5"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "claude-opus-5-5",+ "provider": "anthropic",+ "externalModelId": "claude-opus-5-5",+ "resolution": {+ "status": "mapped",+ "modelId": "claude-opus-5-5"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "claude-fable-5-1",+ "provider": "anthropic",+ "externalModelId": "claude-fable-5-1",+ "resolution": {+ "status": "mapped",+ "modelId": "claude-fable-5-1"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "claude-opus-5",+ "provider": "anthropic",+ "externalModelId": "claude-opus-5",+ "resolution": {+ "status": "mapped",+ "modelId": "claude-opus-5"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "claude-sonnet-5",+ "provider": "anthropic",+ "externalModelId": "claude-sonnet-5",+ "resolution": {+ "status": "mapped",+ "modelId": "claude-sonnet-5"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "claude-fable-5",+ "provider": "anthropic",+ "externalModelId": "claude-fable-5",+ "resolution": {+ "status": "mapped",+ "modelId": "claude-fable-5"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "claude-opus-4-8",+ "provider": "anthropic",+ "externalModelId": "claude-opus-4-8",+ "resolution": {+ "status": "mapped",+ "modelId": "claude-opus-4-8"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "claude-opus-4-7",+ "provider": "anthropic",+ "externalModelId": "claude-opus-4-7",+ "resolution": {+ "status": "mapped",+ "modelId": "claude-opus-4-7"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "claude-sonnet-4-6",+ "provider": "anthropic",+ "externalModelId": "claude-sonnet-4-6",+ "resolution": {+ "status": "mapped",+ "modelId": "claude-sonnet-4-6"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "claude-opus-4-6",+ "provider": "anthropic",+ "externalModelId": "claude-opus-4-6",+ "resolution": {+ "status": "mapped",+ "modelId": "claude-opus-4-6"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "claude-opus-4-5-20251101",+ "provider": "anthropic",+ "externalModelId": "claude-opus-4-5-20251101",+ "resolution": {+ "status": "mapped",+ "modelId": "claude-opus-4-5"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "claude-haiku-4-5-20251001",+ "provider": "anthropic",+ "externalModelId": "claude-haiku-4-5-20251001",+ "resolution": {+ "status": "mapped",+ "modelId": "claude-haiku-4-5"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "claude-sonnet-4-5-20250929",+ "provider": "anthropic",+ "externalModelId": "claude-sonnet-4-5-20250929",+ "resolution": {+ "status": "mapped",+ "modelId": "claude-sonnet-4-5"+ }+ }+ ],+ "features": [+ "Terminal-based Claude Code access through Claude subscriptions",+ "Shared Claude and Claude Code usage limits on Pro and Max",+ "Team and Enterprise subscription login supported"+ ],+ "lastUpdated": "2026-10-12T10:09:24.533Z",+ "routeStatus": "supported",+ "route": {+ "routeId": "anthropic",+ "routeProfileId": "claude-code-subscription"+ },+ "membershipRequirements": [+ {+ "membershipId": "anthropic-claude-code-live",+ "authority": "authoritative",+ "requiredForActivation": true,+ "maxAgeHours": 24+ }+ ],+ "membershipCoverage": {+ "status": "complete",+ "observedAt": "2026-10-12T10:09:24.533Z",+ "expiresAt": "2026-10-13T10:09:24.533Z"+ }+ },+ {+ "contractVersion": 3,+ "id": "byteplus-modelark-coding-plan",+ "displayName": "BytePlus ModelArk Coding Plan",+ "provider": "bytedance",+ "pricing": [+ {+ "period": "monthly",+ "price": 10,+ "currency": "USD",+ "description": "Lite"+ },+ {+ "period": "quarterly",+ "price": 30,+ "currency": "USD",+ "description": "Lite quarterly"+ },+ {+ "period": "monthly",+ "price": 50,+ "currency": "USD",+ "description": "Pro"+ },+ {+ "period": "quarterly",+ "price": 150,+ "currency": "USD",+ "description": "Pro quarterly"+ }+ ],+ "modelDiscovery": "client",+ "inclusions": [+ {+ "kind": "display_label",+ "sourceText": "Dola-Seed-2.0-pro",+ "resolution": {+ "status": "unknown",+ "reason": "dynamic_models_catalog_required"+ }+ },+ {+ "kind": "display_label",+ "sourceText": "GLM-5.2",+ "resolution": {+ "status": "unknown",+ "reason": "dynamic_models_catalog_required"+ }+ },+ {+ "kind": "family_label",+ "sourceText": "DeepSeek-V4 Series",+ "resolution": {+ "status": "unknown",+ "reason": "dynamic_models_catalog_required"+ }+ },+ {+ "kind": "display_label",+ "sourceText": "Kimi-K2.5",+ "resolution": {+ "status": "unknown",+ "reason": "dynamic_models_catalog_required"+ }+ },+ {+ "kind": "display_label",+ "sourceText": "GPT-OSS",+ "resolution": {+ "status": "unknown",+ "reason": "dynamic_models_catalog_required"+ }+ }+ ],+ "features": [+ "Flat coding plan for Claude Code, Cursor, Cline, Kilo Code, Roo Code, OpenCode, OpenClaw, and Hermes Agent integrations",+ "Lite and Pro tiers with monthly package quota that does not fall back to other balances after exhaustion",+ "Pro unlocks ArkClaw, a hosted personal AI assistant build platform, during the subscription period",+ "Model availability can vary by region"+ ],+ "lastUpdated": "2026-09-29T21:17:24.000Z",+ "routeStatus": "unsupported",+ "routeReason": "no_reviewed_consumer_route",+ "membershipRequirements": [],+ "membershipCoverage": {+ "status": "unknown",+ "reason": "unavailable"+ }+ },+ {+ "contractVersion": 3,+ "id": "cognition-devin",+ "displayName": "Devin",+ "provider": "cognition",+ "pricing": [+ {+ "period": "monthly",+ "price": 0,+ "currency": "USD",+ "description": "Free: light coding-agent quota with limited model availability"+ },+ {+ "period": "monthly",+ "price": 20,+ "currency": "USD",+ "description": "Pro: full model availability and increased quotas"+ },+ {+ "period": "monthly",+ "price": 200,+ "currency": "USD",+ "description": "Max: significantly higher quotas"+ },+ {+ "period": "monthly",+ "price": 80,+ "currency": "USD",+ "description": "Teams: $80 monthly minimum; $40 full seats count toward the minimum"+ }+ ],+ "modelDiscovery": "client",+ "inclusions": [+ {+ "kind": "display_label",+ "sourceText": "SWE-2",+ "resolution": {+ "status": "unknown",+ "reason": "dynamic_models_catalog_required"+ }+ },+ {+ "kind": "display_label",+ "sourceText": "SWE-1.7",+ "resolution": {+ "status": "unknown",+ "reason": "dynamic_models_catalog_required"+ }+ },+ {+ "kind": "prose_placeholder",+ "sourceText": "account-specific Devin models catalog",+ "resolution": {+ "status": "unknown",+ "reason": "dynamic_models_catalog_required"+ }+ }+ ],+ "features": [+ "Paid-plan quotas cover Devin sessions, Devin CLI, and Devin Desktop",+ "Pro includes full model availability and named SWE models within the plan quota",+ "Callable model variants and their pricing are account-specific and must be discovered from the signed-in Devin client",+ "Extra usage beyond a paid-plan quota is available at API pricing"+ ],+ "lastUpdated": "2026-09-29T21:17:24.000Z",+ "routeStatus": "supported",+ "route": {+ "routeId": "cognition",+ "routeProfileId": "devin-subscription"+ },+ "membershipRequirements": [],+ "membershipCoverage": {+ "status": "unknown",+ "reason": "unavailable"+ }+ },+ {+ "contractVersion": 3,+ "id": "github-copilot",+ "displayName": "GitHub Copilot",+ "provider": "github",+ "pricing": [+ {+ "period": "monthly",+ "price": 0,+ "currency": "USD",+ "description": "Free"+ },+ {+ "period": "monthly",+ "price": 10,+ "currency": "USD",+ "description": "Pro"+ },+ {+ "period": "monthly",+ "price": 39,+ "currency": "USD",+ "description": "Pro+"+ },+ {+ "period": "monthly",+ "price": 100,+ "currency": "USD",+ "description": "Max"+ },+ {+ "period": "monthly",+ "price": 19,+ "currency": "USD",+ "description": "Business, per user"+ },+ {+ "period": "monthly",+ "price": 39,+ "currency": "USD",+ "description": "Enterprise, per user"+ }+ ],+ "modelDiscovery": "client",+ "inclusions": [+ {+ "kind": "display_label",+ "sourceText": "GPT-5 mini",+ "resolution": {+ "status": "unknown",+ "reason": "official_display_label_without_callable_wire_id"+ }+ },+ {+ "kind": "display_label",+ "sourceText": "GPT-5.3-Codex",+ "resolution": {+ "status": "unknown",+ "reason": "official_display_label_without_callable_wire_id"+ }+ },+ {+ "kind": "display_label",+ "sourceText": "GPT-5.4",+ "resolution": {+ "status": "unknown",+ "reason": "official_display_label_without_callable_wire_id"+ }+ },+ {+ "kind": "display_label",+ "sourceText": "GPT-5.4 mini",+ "resolution": {+ "status": "unknown",+ "reason": "official_display_label_without_callable_wire_id"+ }+ },+ {+ "kind": "display_label",+ "sourceText": "GPT-5.4 nano",+ "resolution": {+ "status": "unknown",+ "reason": "official_display_label_without_callable_wire_id"+ }+ },+ {+ "kind": "display_label",+ "sourceText": "GPT-5.5",+ "resolution": {+ "status": "unknown",+ "reason": "official_display_label_without_callable_wire_id"+ }+ },+ {+ "kind": "display_label",+ "sourceText": "GPT-5.6 Luna",+ "resolution": {+ "status": "unknown",+ "reason": "official_display_label_without_callable_wire_id"+ }+ },+ {+ "kind": "display_label",+ "sourceText": "GPT-5.6 Sol",+ "resolution": {+ "status": "unknown",+ "reason": "official_display_label_without_callable_wire_id"+ }+ },+ {+ "kind": "display_label",+ "sourceText": "GPT-5.6 Terra",+ "resolution": {+ "status": "unknown",+ "reason": "official_display_label_without_callable_wire_id"+ }+ },+ {+ "kind": "display_label",+ "sourceText": "GPT-6 Astra",+ "resolution": {+ "status": "unknown",+ "reason": "official_display_label_without_callable_wire_id"+ }+ },+ {+ "kind": "display_label",+ "sourceText": "GPT-6 Luna",+ "resolution": {+ "status": "unknown",+ "reason": "official_display_label_without_callable_wire_id"+ }+ },+ {+ "kind": "display_label",+ "sourceText": "GPT-6 Sol",+ "resolution": {+ "status": "unknown",+ "reason": "official_display_label_without_callable_wire_id"+ }+ },+ {+ "kind": "display_label",+ "sourceText": "GPT-6.1 Sol",+ "resolution": {+ "status": "unknown",+ "reason": "official_display_label_without_callable_wire_id"+ }+ },+ {+ "kind": "display_label",+ "sourceText": "Claude Fable 5",+ "resolution": {+ "status": "unknown",+ "reason": "official_display_label_without_callable_wire_id"+ }+ },+ {+ "kind": "display_label",+ "sourceText": "Claude Fable 5.1",+ "resolution": {+ "status": "unknown",+ "reason": "official_display_label_without_callable_wire_id"+ }+ },+ {+ "kind": "display_label",+ "sourceText": "Claude Haiku 4.5",+ "resolution": {+ "status": "unknown",+ "reason": "official_display_label_without_callable_wire_id"+ }+ },+ {+ "kind": "display_label",+ "sourceText": "Claude Haiku 5.5",+ "resolution": {+ "status": "unknown",+ "reason": "official_display_label_without_callable_wire_id"+ }+ },+ {+ "kind": "display_label",+ "sourceText": "Claude Opus 4.8",+ "resolution": {+ "status": "unknown",+ "reason": "official_display_label_without_callable_wire_id"+ }+ },+ {+ "kind": "display_label",+ "sourceText": "Claude Opus 4.8 (fast mode) (preview)",+ "resolution": {+ "status": "unknown",+ "reason": "official_display_label_without_callable_wire_id"+ }+ },+ {+ "kind": "display_label",+ "sourceText": "Claude Opus 5",+ "resolution": {+ "status": "unknown",+ "reason": "official_display_label_without_callable_wire_id"+ }+ },+ {+ "kind": "display_label",+ "sourceText": "Claude Opus 5.5",+ "resolution": {+ "status": "unknown",+ "reason": "official_display_label_without_callable_wire_id"+ }+ },+ {+ "kind": "display_label",+ "sourceText": "Claude Sonnet 4.6",+ "resolution": {+ "status": "unknown",+ "reason": "official_display_label_without_callable_wire_id"+ }+ },+ {+ "kind": "display_label",+ "sourceText": "Claude Sonnet 5",+ "resolution": {+ "status": "unknown",+ "reason": "official_display_label_without_callable_wire_id"+ }+ },+ {+ "kind": "display_label",+ "sourceText": "Claude Sonnet 5.5",+ "resolution": {+ "status": "unknown",+ "reason": "official_display_label_without_callable_wire_id"+ }+ },+ {+ "kind": "display_label",+ "sourceText": "Gemini 3.7 Flash",+ "resolution": {+ "status": "unknown",+ "reason": "official_display_label_without_callable_wire_id"+ }+ },+ {+ "kind": "display_label",+ "sourceText": "Gemini 3.8 Flash",+ "resolution": {+ "status": "unknown",+ "reason": "official_display_label_without_callable_wire_id"+ }+ },+ {+ "kind": "display_label",+ "sourceText": "MAI-Code-1.1-Flash",+ "resolution": {+ "status": "unknown",+ "reason": "official_display_label_without_callable_wire_id"+ }+ },+ {+ "kind": "display_label",+ "sourceText": "Kimi K3",+ "resolution": {+ "status": "unknown",+ "reason": "official_display_label_without_callable_wire_id"+ }+ },+ {+ "kind": "display_label",+ "sourceText": "Grok 4.5",+ "resolution": {+ "status": "unknown",+ "reason": "official_display_label_without_callable_wire_id"+ }+ },+ {+ "kind": "display_label",+ "sourceText": "Grok 4.6",+ "resolution": {+ "status": "unknown",+ "reason": "official_display_label_without_callable_wire_id"+ }+ },+ {+ "kind": "display_label",+ "sourceText": "Grok 4.7",+ "resolution": {+ "status": "unknown",+ "reason": "official_display_label_without_callable_wire_id"+ }+ }+ ],+ "features": [+ "IDE completions, chat, agent mode, code review, cloud agent, and Copilot CLI",+ "Premium request allowances vary by plan",+ "Business and Enterprise add organization controls and policy management",+ "New self-serve Business and Enterprise sign-ups are temporarily paused"+ ],+ "lastUpdated": "2026-10-12T10:09:26.574Z",+ "routeStatus": "unsupported",+ "routeReason": "no_reviewed_consumer_route",+ "membershipRequirements": [],+ "membershipCoverage": {+ "status": "unknown",+ "reason": "unavailable"+ }+ },+ {+ "contractVersion": 3,+ "id": "google-antigravity",+ "displayName": "Google Antigravity",+ "provider": "google",+ "pricing": [+ {+ "period": "monthly",+ "price": 0,+ "currency": "USD",+ "description": "Free"+ },+ {+ "period": "monthly",+ "price": 7.99,+ "currency": "USD",+ "description": "Google AI Plus"+ },+ {+ "period": "monthly",+ "price": 19.99,+ "currency": "USD",+ "description": "Google AI Pro"+ },+ {+ "period": "monthly",+ "price": 249.99,+ "currency": "USD",+ "description": "Google AI Ultra"+ }+ ],+ "modelDiscovery": "client",+ "inclusions": [+ {+ "kind": "family_label",+ "sourceText": "Gemini 3.8 Flash",+ "resolution": {+ "status": "unknown",+ "reason": "dynamic_variant_catalog_required"+ }+ },+ {+ "kind": "family_label",+ "sourceText": "Gemini 3.7 Flash",+ "resolution": {+ "status": "unknown",+ "reason": "dynamic_variant_catalog_required"+ }+ },+ {+ "kind": "family_label",+ "sourceText": "Gemini 3.6 Flash",+ "resolution": {+ "status": "unknown",+ "reason": "dynamic_variant_catalog_required"+ }+ },+ {+ "kind": "family_label",+ "sourceText": "Gemini 3.1 Pro",+ "resolution": {+ "status": "unknown",+ "reason": "dynamic_variant_catalog_required"+ }+ },+ {+ "kind": "family_label",+ "sourceText": "Claude Sonnet 5.5 (thinking)",+ "resolution": {+ "status": "unknown",+ "reason": "dynamic_variant_catalog_required"+ }+ },+ {+ "kind": "family_label",+ "sourceText": "Claude Opus 5.5 (thinking)",+ "resolution": {+ "status": "unknown",+ "reason": "dynamic_variant_catalog_required"+ }+ },+ {+ "kind": "family_label",+ "sourceText": "Claude Sonnet 4.6 (thinking)",+ "resolution": {+ "status": "unknown",+ "reason": "dynamic_variant_catalog_required"+ }+ },+ {+ "kind": "family_label",+ "sourceText": "Claude Opus 4.6 (thinking)",+ "resolution": {+ "status": "unknown",+ "reason": "dynamic_variant_catalog_required"+ }+ },+ {+ "kind": "family_label",+ "sourceText": "GPT-OSS-120b",+ "resolution": {+ "status": "unknown",+ "reason": "dynamic_variant_catalog_required"+ }+ }+ ],+ "features": [+ "Public family-level model availability across Antigravity subscription tiers",+ "Availability varies by Google AI and Enterprise tier; consult the source matrix for each family",+ "Family labels are not callable route IDs; exact selectable variants and entitlements come from the signed-in Antigravity client"+ ],+ "lastUpdated": "2026-10-12T10:09:24.923Z",+ "routeStatus": "supported",+ "route": {+ "routeId": "google",+ "routeProfileId": "antigravity-subscription"+ },+ "membershipRequirements": [],+ "membershipCoverage": {+ "status": "unknown",+ "reason": "unavailable"+ }+ },+ {+ "contractVersion": 3,+ "id": "kimi-code",+ "displayName": "Kimi Code",+ "provider": "moonshotai",+ "pricing": [+ {+ "period": "monthly",+ "price": 19,+ "currency": "USD",+ "description": "Moderato: basic Kimi Code usage"+ },+ {+ "period": "monthly",+ "price": 39,+ "currency": "USD",+ "description": "Allegretto: 5x more requests for Kimi Code"+ },+ {+ "period": "monthly",+ "price": 99,+ "currency": "USD",+ "description": "Allegro: 15x more requests for Kimi Code"+ },+ {+ "period": "monthly",+ "price": 199,+ "currency": "USD",+ "description": "Vivace: highest Kimi Code weekly quotas"+ },+ {+ "period": "yearly",+ "price": 180,+ "currency": "USD",+ "description": "Moderato annual: $15/month equivalent"+ },+ {+ "period": "yearly",+ "price": 372,+ "currency": "USD",+ "description": "Allegretto annual: $31/month equivalent"+ },+ {+ "period": "yearly",+ "price": 948,+ "currency": "USD",+ "description": "Allegro annual: $79/month equivalent"+ },+ {+ "period": "yearly",+ "price": 1908,+ "currency": "USD",+ "description": "Vivace annual: $159/month equivalent"+ }+ ],+ "modelDiscovery": "hybrid",+ "inclusions": [+ {+ "kind": "provider_model",+ "sourceText": "k3",+ "provider": "moonshotai",+ "externalModelId": "k3",+ "resolution": {+ "status": "mapped",+ "modelId": "kimi-k3"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "k3-256k",+ "provider": "moonshotai",+ "externalModelId": "k3-256k",+ "resolution": {+ "status": "mapped",+ "modelId": "kimi-k3-256k"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "kimi-for-coding",+ "provider": "moonshotai",+ "externalModelId": "kimi-for-coding",+ "resolution": {+ "status": "mapped",+ "modelId": "kimi-k2.8-preview"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "kimi-for-coding-highspeed",+ "provider": "moonshotai",+ "externalModelId": "kimi-for-coding-highspeed",+ "resolution": {+ "status": "mapped",+ "modelId": "kimi-k2.7-code-highspeed"+ }+ }+ ],+ "features": [+ "Kimi Code CLI and IDE coding workflow",+ "Membership quota works in official clients and third-party coding agents",+ "OpenAI-compatible and Anthropic-compatible Kimi Code API endpoints",+ "New purchases currently route to a waitlist"+ ],+ "lastUpdated": "2026-10-12T10:09:24.722Z",+ "routeStatus": "supported",+ "route": {+ "routeId": "moonshotai",+ "routeProfileId": "kimi-code-subscription"+ },+ "membershipRequirements": [+ {+ "membershipId": "kimi-code-live",+ "authority": "authoritative",+ "requiredForActivation": true,+ "maxAgeHours": 24+ }+ ],+ "membershipCoverage": {+ "status": "complete",+ "observedAt": "2026-10-12T10:09:24.722Z",+ "expiresAt": "2026-10-13T10:09:24.722Z"+ }+ },+ {+ "contractVersion": 3,+ "id": "llm-gateway-devpass",+ "displayName": "DevPass by LLM Gateway",+ "provider": "llm-gateway",+ "pricing": [+ {+ "period": "monthly",+ "price": 29,+ "currency": "USD",+ "description": "Lite: $87 in monthly model usage"+ },+ {+ "period": "monthly",+ "price": 79,+ "currency": "USD",+ "description": "Pro: $237 in monthly model usage"+ },+ {+ "period": "monthly",+ "price": 179,+ "currency": "USD",+ "description": "Max: $537 in monthly model usage"+ }+ ],+ "modelDiscovery": "client",+ "inclusions": [+ {+ "kind": "display_label",+ "sourceText": "qwen3.8-flash",+ "resolution": {+ "status": "unknown",+ "reason": "dynamic_models_catalog_required"+ }+ },+ {+ "kind": "display_label",+ "sourceText": "glm-5.3-flash",+ "resolution": {+ "status": "unknown",+ "reason": "dynamic_models_catalog_required"+ }+ },+ {+ "kind": "display_label",+ "sourceText": "deepseek-v4-flash-vision-exp",+ "resolution": {+ "status": "unknown",+ "reason": "dynamic_models_catalog_required"+ }+ },+ {+ "kind": "display_label",+ "sourceText": "muse-spark-1.2",+ "resolution": {+ "status": "unknown",+ "reason": "dynamic_models_catalog_required"+ }+ },+ {+ "kind": "display_label",+ "sourceText": "kimi-k3",+ "resolution": {+ "status": "unknown",+ "reason": "dynamic_models_catalog_required"+ }+ },+ {+ "kind": "display_label",+ "sourceText": "minimax-m3",+ "resolution": {+ "status": "unknown",+ "reason": "dynamic_models_catalog_required"+ }+ },+ {+ "kind": "display_label",+ "sourceText": "nemotron-3-ultra-550b",+ "resolution": {+ "status": "unknown",+ "reason": "dynamic_models_catalog_required"+ }+ },+ {+ "kind": "display_label",+ "sourceText": "mimo-v2.5-pro",+ "resolution": {+ "status": "unknown",+ "reason": "dynamic_models_catalog_required"+ }+ },+ {+ "kind": "display_label",+ "sourceText": "Claude Opus 4.8",+ "resolution": {+ "status": "unknown",+ "reason": "dynamic_models_catalog_required"+ }+ },+ {+ "kind": "display_label",+ "sourceText": "GPT-5.5",+ "resolution": {+ "status": "unknown",+ "reason": "dynamic_models_catalog_required"+ }+ },+ {+ "kind": "display_label",+ "sourceText": "Gemini 3.1 Pro",+ "resolution": {+ "status": "unknown",+ "reason": "dynamic_models_catalog_required"+ }+ }+ ],+ "features": [+ "Flat-rate AI coding subscription for Claude Code, SoulForge, Cursor, Cline, OpenCode, and OpenAI-compatible tools",+ "All plans include 200+ models with one API key and a monthly usage allowance",+ "Frontier-model fair-use allowances are 12%, 15%, and 18% on Lite, Pro, and Max",+ "Anthropic-compatible and OpenAI-compatible endpoints through api.llmgateway.io"+ ],+ "lastUpdated": "2026-09-29T21:17:24.000Z",+ "routeStatus": "unsupported",+ "routeReason": "no_reviewed_consumer_route",+ "membershipRequirements": [],+ "membershipCoverage": {+ "status": "unknown",+ "reason": "unavailable"+ }+ },+ {+ "contractVersion": 3,+ "id": "minimax-token-plan",+ "displayName": "MiniMax Code Plan",+ "provider": "minimax",+ "pricing": [+ {+ "period": "monthly",+ "price": 22,+ "currency": "USD",+ "description": "Standard Plus"+ },+ {+ "period": "monthly",+ "price": 55,+ "currency": "USD",+ "description": "Standard Max"+ },+ {+ "period": "monthly",+ "price": 132,+ "currency": "USD",+ "description": "Standard Ultra"+ }+ ],+ "modelDiscovery": "hybrid",+ "inclusions": [+ {+ "kind": "provider_model",+ "sourceText": "MiniMax-M2.7",+ "provider": "minimax",+ "externalModelId": "MiniMax-M2.7",+ "resolution": {+ "status": "mapped",+ "modelId": "minimax-m2.7"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "MiniMax-M3",+ "provider": "minimax",+ "externalModelId": "MiniMax-M3",+ "resolution": {+ "status": "mapped",+ "modelId": "minimax-m3"+ }+ },+ {+ "kind": "family_label",+ "sourceText": "MiniMax image model family",+ "resolution": {+ "status": "unknown",+ "reason": "published_family_without_exact_callable_ids"+ }+ },+ {+ "kind": "family_label",+ "sourceText": "MiniMax speech model family",+ "resolution": {+ "status": "unknown",+ "reason": "published_family_without_exact_callable_ids"+ }+ }+ ],+ "features": [+ "Covers the full MiniMax M3, M2.7, image, and speech lineup",+ "Evidence pages: https://platform.minimax.io/docs/guides/pricing-token-plan, https://platform.minimax.io/subscribe/token-plan, https://hermesguide.xyz/coding-plans",+ "Excludes special models including MiniMax H3, voice design, and rapid voice cloning"+ ],+ "lastUpdated": "2026-10-12T10:09:25.085Z",+ "routeStatus": "supported",+ "route": {+ "routeId": "minimax",+ "routeProfileId": "coding-plan-subscription"+ },+ "membershipRequirements": [+ {+ "membershipId": "minimax-token-plan-public-live",+ "authority": "supplemental",+ "requiredForActivation": false,+ "maxAgeHours": 24+ }+ ],+ "membershipCoverage": {+ "status": "unknown",+ "reason": "supplemental_only"+ }+ },+ {+ "contractVersion": 3,+ "id": "mistral-vibe",+ "displayName": "Mistral Vibe",+ "provider": "mistralai",+ "pricing": [+ {+ "period": "monthly",+ "price": 0,+ "currency": "USD",+ "description": "Free: Le Chat with daily usage limits"+ },+ {+ "period": "monthly",+ "price": 5.99,+ "currency": "USD",+ "description": "Student: Le Chat Pro student rate"+ },+ {+ "period": "monthly",+ "price": 14.99,+ "currency": "USD",+ "description": "Pro: includes Mistral Vibe for all-day coding, PAYG beyond"+ },+ {+ "period": "monthly",+ "price": 24.99,+ "currency": "USD",+ "description": "Team: per user, shared usage for small development teams"+ }+ ],+ "modelDiscovery": "client",+ "inclusions": [+ {+ "kind": "display_label",+ "sourceText": "Devstral (Vibe CLI and IDE)",+ "resolution": {+ "status": "unknown",+ "reason": "no_exact_callable_model_ids"+ }+ },+ {+ "kind": "family_label",+ "sourceText": "Mistral models in Vibe web (exact model list not published)",+ "resolution": {+ "status": "unknown",+ "reason": "no_exact_callable_model_ids"+ }+ }+ ],+ "features": [+ "Terminal-native coding agent with multi-file repository context",+ "Included in every Le Chat Pro subscription with a monthly Vibe budget",+ "Pro and Team subscription routes plus API and Enterprise options for coding models"+ ],+ "lastUpdated": "2026-09-29T21:17:24.000Z",+ "routeStatus": "unsupported",+ "routeReason": "no_reviewed_subscription_route",+ "membershipRequirements": [],+ "membershipCoverage": {+ "status": "unknown",+ "reason": "unavailable"+ }+ },+ {+ "contractVersion": 3,+ "id": "ollama-cloud",+ "displayName": "Ollama Cloud",+ "provider": "ollama",+ "pricing": [+ {+ "period": "monthly",+ "price": 0,+ "currency": "USD",+ "description": "Free: starter usage credits and access to starter models"+ },+ {+ "period": "monthly",+ "price": 20,+ "currency": "USD",+ "description": "Pro: $60 of monthly usage credits"+ },+ {+ "period": "yearly",+ "price": 200,+ "currency": "USD",+ "description": "Pro annual: $16.67/month equivalent"+ },+ {+ "period": "monthly",+ "price": 100,+ "currency": "USD",+ "description": "Max: $300 of monthly usage credits"+ },+ {+ "period": "monthly",+ "price": 500,+ "currency": "USD",+ "description": "Team: unlimited users and $1,000 in shared monthly usage credits"+ }+ ],+ "modelDiscovery": "catalog",+ "inclusions": [+ {+ "kind": "provider_model",+ "sourceText": "nemotron-3-ultra",+ "provider": "ollamacloud",+ "externalModelId": "nemotron-3-ultra",+ "resolution": {+ "status": "mapped",+ "modelId": "nemotron-3-ultra-base"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "kimi-k2.6",+ "provider": "ollamacloud",+ "externalModelId": "kimi-k2.6",+ "resolution": {+ "status": "mapped",+ "modelId": "kimi-k2.6"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "kimi-k3",+ "provider": "ollamacloud",+ "externalModelId": "kimi-k3",+ "resolution": {+ "status": "mapped",+ "modelId": "kimi-k3"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "deepseek-v4.1-flash",+ "provider": "ollamacloud",+ "externalModelId": "deepseek-v4.1-flash",+ "resolution": {+ "status": "mapped",+ "modelId": "deepseek-v4.1-flash"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "gpt-oss:120b",+ "provider": "ollamacloud",+ "externalModelId": "gpt-oss:120b",+ "resolution": {+ "status": "mapped",+ "modelId": "gpt-oss-120b"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "mistral-large-4",+ "provider": "ollamacloud",+ "externalModelId": "mistral-large-4",+ "resolution": {+ "status": "mapped",+ "modelId": "mistral-large-4"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "minimax-m2.7",+ "provider": "ollamacloud",+ "externalModelId": "minimax-m2.7",+ "resolution": {+ "status": "mapped",+ "modelId": "minimax-m2.7"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "glm-5.3",+ "provider": "ollamacloud",+ "externalModelId": "glm-5.3",+ "resolution": {+ "status": "mapped",+ "modelId": "glm-5.3"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "minimax-m3",+ "provider": "ollamacloud",+ "externalModelId": "minimax-m3",+ "resolution": {+ "status": "mapped",+ "modelId": "minimax-m3"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "nemotron-3-nano:30b",+ "provider": "ollamacloud",+ "externalModelId": "nemotron-3-nano:30b",+ "resolution": {+ "status": "mapped",+ "modelId": "nemotron-3-nano-30b"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "glm-5.3-flash",+ "provider": "ollamacloud",+ "externalModelId": "glm-5.3-flash",+ "resolution": {+ "status": "mapped",+ "modelId": "glm-5.3-flash"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "gemma4:31b",+ "provider": "ollamacloud",+ "externalModelId": "gemma4:31b",+ "resolution": {+ "status": "mapped",+ "modelId": "gemma4-31b"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "nemotron-3-super",+ "provider": "ollamacloud",+ "externalModelId": "nemotron-3-super",+ "resolution": {+ "status": "mapped",+ "modelId": "nemotron-3-super"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "glm-5.2",+ "provider": "ollamacloud",+ "externalModelId": "glm-5.2",+ "resolution": {+ "status": "mapped",+ "modelId": "glm-5.2"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "kimi-k2.7-code",+ "provider": "ollamacloud",+ "externalModelId": "kimi-k2.7-code",+ "resolution": {+ "status": "mapped",+ "modelId": "kimi-k2.7-code"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "mistral-large-3:675b",+ "provider": "ollamacloud",+ "externalModelId": "mistral-large-3:675b",+ "resolution": {+ "status": "mapped",+ "modelId": "mistral-large-3-675b"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "deepseek-v4-pro:0813",+ "provider": "ollamacloud",+ "externalModelId": "deepseek-v4-pro:0813",+ "resolution": {+ "status": "mapped",+ "modelId": "deepseek-v4-pro-0813"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "gpt-oss:20b",+ "provider": "ollamacloud",+ "externalModelId": "gpt-oss:20b",+ "resolution": {+ "status": "mapped",+ "modelId": "gpt-oss-20b"+ }+ }+ ],+ "features": [+ "CLI, API, desktop apps, and cloud model access",+ "All plans can add usage credits; credits are consumed at each model's published per-token rate",+ "Free, Pro, and Max include one, three, and ten concurrent requests respectively",+ "Pro includes access to larger pro models; Max adds early access to the newest models",+ "Team includes unlimited users, ten concurrent requests, centralized billing, and shared usage credits"+ ],+ "lastUpdated": "2026-10-12T10:09:22.262Z",+ "routeStatus": "supported",+ "route": {+ "routeId": "ollama",+ "routeProfileId": "cloud"+ },+ "membershipRequirements": [+ {+ "membershipId": "ollama-cloud-live",+ "authority": "authoritative",+ "requiredForActivation": true,+ "maxAgeHours": 24+ }+ ],+ "membershipCoverage": {+ "status": "complete",+ "observedAt": "2026-10-12T10:09:22.262Z",+ "expiresAt": "2026-10-13T10:09:22.262Z"+ }+ },+ {+ "contractVersion": 3,+ "id": "openai-codex",+ "displayName": "OpenAI Codex",+ "provider": "openai",+ "pricing": [+ {+ "period": "monthly",+ "price": 0,+ "currency": "USD",+ "description": "Free: limited trial access to Codex"+ },+ {+ "period": "monthly",+ "price": 8,+ "currency": "USD",+ "description": "Go: more GPT access and Codex trial usage"+ },+ {+ "period": "monthly",+ "price": 20,+ "currency": "USD",+ "description": "Plus: expanded Codex usage"+ },+ {+ "period": "monthly",+ "price": 100,+ "currency": "USD",+ "description": "Pro 5x: maximum Codex tasks with 5x Plus usage"+ },+ {+ "period": "monthly",+ "price": 200,+ "currency": "USD",+ "description": "Pro 20x: maximum Codex tasks with 20x Plus usage"+ }+ ],+ "modelDiscovery": "hybrid",+ "inclusions": [+ {+ "kind": "provider_model",+ "sourceText": "gpt-5.5",+ "provider": "openai",+ "externalModelId": "gpt-5.5",+ "resolution": {+ "status": "mapped",+ "modelId": "gpt-5.5"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "gpt-5.6-luna",+ "provider": "openai",+ "externalModelId": "gpt-5.6-luna",+ "resolution": {+ "status": "mapped",+ "modelId": "gpt-5.6-luna"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "gpt-5.6-sol",+ "provider": "openai",+ "externalModelId": "gpt-5.6-sol",+ "resolution": {+ "status": "mapped",+ "modelId": "gpt-5.6-sol"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "gpt-5.6-terra",+ "provider": "openai",+ "externalModelId": "gpt-5.6-terra",+ "resolution": {+ "status": "mapped",+ "modelId": "gpt-5.6-terra"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "gpt-6-astra",+ "provider": "openai",+ "externalModelId": "gpt-6-astra",+ "resolution": {+ "status": "mapped",+ "modelId": "gpt-6-astra"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "gpt-6-luna",+ "provider": "openai",+ "externalModelId": "gpt-6-luna",+ "resolution": {+ "status": "mapped",+ "modelId": "gpt-6-luna"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "gpt-6-sol",+ "provider": "openai",+ "externalModelId": "gpt-6-sol",+ "resolution": {+ "status": "mapped",+ "modelId": "gpt-6-sol"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "gpt-6.1-sol",+ "provider": "openai",+ "externalModelId": "gpt-6.1-sol",+ "resolution": {+ "status": "mapped",+ "modelId": "gpt-6.1-sol"+ }+ }+ ],+ "features": [+ "Included in ChatGPT Free, Go, Plus, Pro, Business, and Enterprise plans",+ "Codex app for macOS and Windows on paid tiers",+ "API-key mode for local and CI automation billed by token usage"+ ],+ "lastUpdated": "2026-10-12T10:09:23.008Z",+ "routeStatus": "supported",+ "route": {+ "routeId": "openai",+ "routeProfileId": "codex-subscription"+ },+ "membershipRequirements": [+ {+ "membershipId": "openai-codex-public-registry",+ "authority": "supplemental",+ "requiredForActivation": false,+ "maxAgeHours": 24+ }+ ],+ "membershipCoverage": {+ "status": "unknown",+ "reason": "supplemental_only"+ }+ },+ {+ "contractVersion": 3,+ "id": "opencode-go",+ "displayName": "OpenCode Go",+ "provider": "opencode",+ "pricing": [+ {+ "period": "monthly",+ "price": 10,+ "currency": "USD",+ "description": "Monthly"+ }+ ],+ "modelDiscovery": "catalog",+ "inclusions": [+ {+ "kind": "provider_model",+ "sourceText": "grok-4.7",+ "provider": "opencode",+ "externalModelId": "grok-4.7",+ "resolution": {+ "status": "mapped",+ "modelId": "grok-4.7"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "grok-4.6",+ "provider": "opencode",+ "externalModelId": "grok-4.6",+ "resolution": {+ "status": "mapped",+ "modelId": "grok-4.6"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "glm-5.3-flash",+ "provider": "opencode",+ "externalModelId": "glm-5.3-flash",+ "resolution": {+ "status": "mapped",+ "modelId": "glm-5.3-flash"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "glm-5.3",+ "provider": "opencode",+ "externalModelId": "glm-5.3",+ "resolution": {+ "status": "mapped",+ "modelId": "glm-5.3"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "glm-5.2",+ "provider": "opencode",+ "externalModelId": "glm-5.2",+ "resolution": {+ "status": "mapped",+ "modelId": "glm-5.2"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "gpt-6-luna",+ "provider": "opencode",+ "externalModelId": "gpt-6-luna",+ "resolution": {+ "status": "mapped",+ "modelId": "gpt-6-luna"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "gpt-5.6-luna",+ "provider": "opencode",+ "externalModelId": "gpt-5.6-luna",+ "resolution": {+ "status": "mapped",+ "modelId": "gpt-5.6-luna"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "claude-haiku-5-5",+ "provider": "opencode",+ "externalModelId": "claude-haiku-5-5",+ "resolution": {+ "status": "mapped",+ "modelId": "claude-haiku-5-5"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "kimi-k3",+ "provider": "opencode",+ "externalModelId": "kimi-k3",+ "resolution": {+ "status": "mapped",+ "modelId": "kimi-k3"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "kimi-k2.7-code",+ "provider": "opencode",+ "externalModelId": "kimi-k2.7-code",+ "resolution": {+ "status": "mapped",+ "modelId": "kimi-k2.7-code"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "kimi-k2.6",+ "provider": "opencode",+ "externalModelId": "kimi-k2.6",+ "resolution": {+ "status": "mapped",+ "modelId": "kimi-k2.6"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "longcat-2.0",+ "provider": "opencode",+ "externalModelId": "longcat-2.0",+ "resolution": {+ "status": "mapped",+ "modelId": "longcat-2.0"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "longcat-2.5-preview-free",+ "provider": "opencode",+ "externalModelId": "longcat-2.5-preview-free",+ "resolution": {+ "status": "mapped",+ "modelId": "longcat-2.5-preview"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "step-5-preview-free",+ "provider": "opencode",+ "externalModelId": "step-5-preview-free",+ "resolution": {+ "status": "mapped",+ "modelId": "step-5-preview"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "mimo-v2.6-flash",+ "provider": "opencode",+ "externalModelId": "mimo-v2.6-flash",+ "resolution": {+ "status": "mapped",+ "modelId": "mimo-v2.6-flash"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "mimo-v2.6-pro",+ "provider": "opencode",+ "externalModelId": "mimo-v2.6-pro",+ "resolution": {+ "status": "mapped",+ "modelId": "mimo-v2.6-pro"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "mimo-v2.5",+ "provider": "opencode",+ "externalModelId": "mimo-v2.5",+ "resolution": {+ "status": "mapped",+ "modelId": "mimo-v2.5"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "mimo-v2.5-pro",+ "provider": "opencode",+ "externalModelId": "mimo-v2.5-pro",+ "resolution": {+ "status": "mapped",+ "modelId": "mimo-v2.5-pro"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "minimax-m3",+ "provider": "opencode",+ "externalModelId": "minimax-m3",+ "resolution": {+ "status": "mapped",+ "modelId": "minimax-m3"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "minimax-m2.7",+ "provider": "opencode",+ "externalModelId": "minimax-m2.7",+ "resolution": {+ "status": "mapped",+ "modelId": "minimax-m2.7"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "muse-spark-1.3-contributor",+ "provider": "opencode",+ "externalModelId": "muse-spark-1.3-contributor",+ "resolution": {+ "status": "mapped",+ "modelId": "muse-spark-1.3"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "muse-spark-1.2-contributor",+ "provider": "opencode",+ "externalModelId": "muse-spark-1.2-contributor",+ "resolution": {+ "status": "mapped",+ "modelId": "muse-spark-1.2"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "qwen3.8-max",+ "provider": "opencode",+ "externalModelId": "qwen3.8-max",+ "resolution": {+ "status": "mapped",+ "modelId": "qwen3.8-max"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "qwen3.8-flash",+ "provider": "opencode",+ "externalModelId": "qwen3.8-flash",+ "resolution": {+ "status": "mapped",+ "modelId": "qwen3.8-flash"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "qwen3.7-plus",+ "provider": "opencode",+ "externalModelId": "qwen3.7-plus",+ "resolution": {+ "status": "mapped",+ "modelId": "qwen3.7-plus"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "deepseek-v4.1-flash",+ "provider": "opencode",+ "externalModelId": "deepseek-v4.1-flash",+ "resolution": {+ "status": "mapped",+ "modelId": "deepseek-v4.1-flash"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "deepseek-v4-pro",+ "provider": "opencode",+ "externalModelId": "deepseek-v4-pro",+ "resolution": {+ "status": "mapped",+ "modelId": "deepseek-v4-pro"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "deepseek-v4-flash",+ "provider": "opencode",+ "externalModelId": "deepseek-v4-flash",+ "resolution": {+ "status": "mapped",+ "modelId": "deepseek-v4-flash"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "deepseek-v4-flash-vision-exp",+ "provider": "opencode",+ "externalModelId": "deepseek-v4-flash-vision-exp",+ "resolution": {+ "status": "mapped",+ "modelId": "deepseek-v4-flash-vision-exp"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "hy4-preview",+ "provider": "opencode",+ "externalModelId": "hy4-preview",+ "resolution": {+ "status": "mapped",+ "modelId": "hy4-preview"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "hy3",+ "provider": "opencode",+ "externalModelId": "hy3",+ "resolution": {+ "status": "mapped",+ "modelId": "hy3"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "space-bunny",+ "provider": "opencode",+ "externalModelId": "space-bunny",+ "resolution": {+ "status": "mapped",+ "modelId": "space-bunny"+ }+ }+ ],+ "features": [+ "Lower-cost access to the models below",+ "$10/month subscription",+ "Usage budgets are per model: five-hour is 20%, weekly is 50%, and monthly is 100% of that model's published monthly limit",+ "Each model's published monthly limit determines how its usage counts toward the plan allowance",+ "OpenAI-compatible, Anthropic-compatible, and provider-specific Go endpoints"+ ],+ "lastUpdated": "2026-10-12T10:09:25.039Z",+ "routeStatus": "supported",+ "route": {+ "routeId": "opencode",+ "routeProfileId": "go-subscription"+ },+ "membershipRequirements": [+ {+ "membershipId": "opencode-go-live",+ "authority": "authoritative",+ "requiredForActivation": true,+ "maxAgeHours": 24+ }+ ],+ "membershipCoverage": {+ "status": "complete",+ "observedAt": "2026-10-12T10:09:25.039Z",+ "expiresAt": "2026-10-13T10:09:25.039Z"+ }+ },+ {+ "contractVersion": 3,+ "id": "opencode-go-plus",+ "displayName": "OpenCode Go Plus",+ "provider": "opencode",+ "pricing": [+ {+ "period": "monthly",+ "price": 40,+ "currency": "USD",+ "description": "Monthly"+ }+ ],+ "modelDiscovery": "catalog",+ "inclusions": [+ {+ "kind": "provider_model",+ "sourceText": "grok-4.7",+ "provider": "opencode",+ "externalModelId": "grok-4.7",+ "resolution": {+ "status": "mapped",+ "modelId": "grok-4.7"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "grok-4.6",+ "provider": "opencode",+ "externalModelId": "grok-4.6",+ "resolution": {+ "status": "mapped",+ "modelId": "grok-4.6"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "glm-5.3-flash",+ "provider": "opencode",+ "externalModelId": "glm-5.3-flash",+ "resolution": {+ "status": "mapped",+ "modelId": "glm-5.3-flash"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "glm-5.3",+ "provider": "opencode",+ "externalModelId": "glm-5.3",+ "resolution": {+ "status": "mapped",+ "modelId": "glm-5.3"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "glm-5.2",+ "provider": "opencode",+ "externalModelId": "glm-5.2",+ "resolution": {+ "status": "mapped",+ "modelId": "glm-5.2"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "gpt-6-luna",+ "provider": "opencode",+ "externalModelId": "gpt-6-luna",+ "resolution": {+ "status": "mapped",+ "modelId": "gpt-6-luna"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "gpt-5.6-luna",+ "provider": "opencode",+ "externalModelId": "gpt-5.6-luna",+ "resolution": {+ "status": "mapped",+ "modelId": "gpt-5.6-luna"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "claude-haiku-5-5",+ "provider": "opencode",+ "externalModelId": "claude-haiku-5-5",+ "resolution": {+ "status": "mapped",+ "modelId": "claude-haiku-5-5"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "kimi-k3",+ "provider": "opencode",+ "externalModelId": "kimi-k3",+ "resolution": {+ "status": "mapped",+ "modelId": "kimi-k3"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "kimi-k2.7-code",+ "provider": "opencode",+ "externalModelId": "kimi-k2.7-code",+ "resolution": {+ "status": "mapped",+ "modelId": "kimi-k2.7-code"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "kimi-k2.6",+ "provider": "opencode",+ "externalModelId": "kimi-k2.6",+ "resolution": {+ "status": "mapped",+ "modelId": "kimi-k2.6"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "longcat-2.0",+ "provider": "opencode",+ "externalModelId": "longcat-2.0",+ "resolution": {+ "status": "mapped",+ "modelId": "longcat-2.0"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "longcat-2.5-preview-free",+ "provider": "opencode",+ "externalModelId": "longcat-2.5-preview-free",+ "resolution": {+ "status": "mapped",+ "modelId": "longcat-2.5-preview"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "step-5-preview-free",+ "provider": "opencode",+ "externalModelId": "step-5-preview-free",+ "resolution": {+ "status": "mapped",+ "modelId": "step-5-preview"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "mimo-v2.6-flash",+ "provider": "opencode",+ "externalModelId": "mimo-v2.6-flash",+ "resolution": {+ "status": "mapped",+ "modelId": "mimo-v2.6-flash"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "mimo-v2.6-pro",+ "provider": "opencode",+ "externalModelId": "mimo-v2.6-pro",+ "resolution": {+ "status": "mapped",+ "modelId": "mimo-v2.6-pro"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "mimo-v2.5",+ "provider": "opencode",+ "externalModelId": "mimo-v2.5",+ "resolution": {+ "status": "mapped",+ "modelId": "mimo-v2.5"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "mimo-v2.5-pro",+ "provider": "opencode",+ "externalModelId": "mimo-v2.5-pro",+ "resolution": {+ "status": "mapped",+ "modelId": "mimo-v2.5-pro"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "minimax-m3",+ "provider": "opencode",+ "externalModelId": "minimax-m3",+ "resolution": {+ "status": "mapped",+ "modelId": "minimax-m3"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "minimax-m2.7",+ "provider": "opencode",+ "externalModelId": "minimax-m2.7",+ "resolution": {+ "status": "mapped",+ "modelId": "minimax-m2.7"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "muse-spark-1.3-contributor",+ "provider": "opencode",+ "externalModelId": "muse-spark-1.3-contributor",+ "resolution": {+ "status": "mapped",+ "modelId": "muse-spark-1.3"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "muse-spark-1.2-contributor",+ "provider": "opencode",+ "externalModelId": "muse-spark-1.2-contributor",+ "resolution": {+ "status": "mapped",+ "modelId": "muse-spark-1.2"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "qwen3.8-max",+ "provider": "opencode",+ "externalModelId": "qwen3.8-max",+ "resolution": {+ "status": "mapped",+ "modelId": "qwen3.8-max"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "qwen3.8-flash",+ "provider": "opencode",+ "externalModelId": "qwen3.8-flash",+ "resolution": {+ "status": "mapped",+ "modelId": "qwen3.8-flash"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "qwen3.7-plus",+ "provider": "opencode",+ "externalModelId": "qwen3.7-plus",+ "resolution": {+ "status": "mapped",+ "modelId": "qwen3.7-plus"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "deepseek-v4.1-flash",+ "provider": "opencode",+ "externalModelId": "deepseek-v4.1-flash",+ "resolution": {+ "status": "mapped",+ "modelId": "deepseek-v4.1-flash"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "deepseek-v4-pro",+ "provider": "opencode",+ "externalModelId": "deepseek-v4-pro",+ "resolution": {+ "status": "mapped",+ "modelId": "deepseek-v4-pro"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "deepseek-v4-flash",+ "provider": "opencode",+ "externalModelId": "deepseek-v4-flash",+ "resolution": {+ "status": "mapped",+ "modelId": "deepseek-v4-flash"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "deepseek-v4-flash-vision-exp",+ "provider": "opencode",+ "externalModelId": "deepseek-v4-flash-vision-exp",+ "resolution": {+ "status": "mapped",+ "modelId": "deepseek-v4-flash-vision-exp"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "hy4-preview",+ "provider": "opencode",+ "externalModelId": "hy4-preview",+ "resolution": {+ "status": "mapped",+ "modelId": "hy4-preview"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "hy3",+ "provider": "opencode",+ "externalModelId": "hy3",+ "resolution": {+ "status": "mapped",+ "modelId": "hy3"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "space-bunny",+ "provider": "opencode",+ "externalModelId": "space-bunny",+ "resolution": {+ "status": "mapped",+ "modelId": "space-bunny"+ }+ }+ ],+ "features": [+ "Higher usage limits across the models below",+ "$40/month subscription",+ "Usage budgets are per model: five-hour is 20%, weekly is 50%, and monthly is 100% of that model's published monthly limit",+ "Each model's published monthly limit determines how its usage counts toward the plan allowance",+ "OpenAI-compatible, Anthropic-compatible, and provider-specific Go endpoints"+ ],+ "lastUpdated": "2026-10-12T10:09:25.039Z",+ "routeStatus": "supported",+ "route": {+ "routeId": "opencode",+ "routeProfileId": "go-subscription"+ },+ "membershipRequirements": [+ {+ "membershipId": "opencode-go-live",+ "authority": "authoritative",+ "requiredForActivation": true,+ "maxAgeHours": 24+ }+ ],+ "membershipCoverage": {+ "status": "complete",+ "observedAt": "2026-10-12T10:09:25.039Z",+ "expiresAt": "2026-10-13T10:09:25.039Z"+ }+ },+ {+ "contractVersion": 3,+ "id": "routing-run",+ "displayName": "routing.run",+ "provider": "routing-run",+ "pricing": [+ {+ "period": "monthly",+ "price": 10,+ "currency": "USD",+ "description": "Basic: includes $10 in routing credit"+ }+ ],+ "modelDiscovery": "catalog",+ "inclusions": [+ {+ "kind": "provider_model",+ "sourceText": "gpt-5.6-sol",+ "provider": "routing-run",+ "externalModelId": "gpt-5.6-sol",+ "resolution": {+ "status": "unknown",+ "reason": "authoritative_membership_identity_unresolved"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "gpt-5.6-terra",+ "provider": "routing-run",+ "externalModelId": "gpt-5.6-terra",+ "resolution": {+ "status": "unknown",+ "reason": "authoritative_membership_identity_unresolved"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "gpt-5.6-luna",+ "provider": "routing-run",+ "externalModelId": "gpt-5.6-luna",+ "resolution": {+ "status": "unknown",+ "reason": "authoritative_membership_identity_unresolved"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "deepseek-v4-flash",+ "provider": "routing-run",+ "externalModelId": "deepseek-v4-flash",+ "resolution": {+ "status": "unknown",+ "reason": "authoritative_membership_identity_unresolved"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "deepseek-v4-pro",+ "provider": "routing-run",+ "externalModelId": "deepseek-v4-pro",+ "resolution": {+ "status": "unknown",+ "reason": "authoritative_membership_identity_unresolved"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "glm-5.3",+ "provider": "routing-run",+ "externalModelId": "glm-5.3",+ "resolution": {+ "status": "unknown",+ "reason": "authoritative_membership_identity_unresolved"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "kimi-k3",+ "provider": "routing-run",+ "externalModelId": "kimi-k3",+ "resolution": {+ "status": "unknown",+ "reason": "authoritative_membership_identity_unresolved"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "kimi-k2.7-code",+ "provider": "routing-run",+ "externalModelId": "kimi-k2.7-code",+ "resolution": {+ "status": "unknown",+ "reason": "authoritative_membership_identity_unresolved"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "kimi-k2.6",+ "provider": "routing-run",+ "externalModelId": "kimi-k2.6",+ "resolution": {+ "status": "unknown",+ "reason": "authoritative_membership_identity_unresolved"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "glm-5.2",+ "provider": "routing-run",+ "externalModelId": "glm-5.2",+ "resolution": {+ "status": "unknown",+ "reason": "authoritative_membership_identity_unresolved"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "glm-5.3-flash",+ "provider": "routing-run",+ "externalModelId": "glm-5.3-flash",+ "resolution": {+ "status": "unknown",+ "reason": "authoritative_membership_identity_unresolved"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "deepseek-v4-flash-0731",+ "provider": "routing-run",+ "externalModelId": "deepseek-v4-flash-0731",+ "resolution": {+ "status": "unknown",+ "reason": "authoritative_membership_identity_unresolved"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "deepseek-v4-pro-0813",+ "provider": "routing-run",+ "externalModelId": "deepseek-v4-pro-0813",+ "resolution": {+ "status": "unknown",+ "reason": "authoritative_membership_identity_unresolved"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "deepseek-v4-flash-0731-fast",+ "provider": "routing-run",+ "externalModelId": "deepseek-v4-flash-0731-fast",+ "resolution": {+ "status": "unknown",+ "reason": "authoritative_membership_identity_unresolved"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "claude-fable-5.1",+ "provider": "routing-run",+ "externalModelId": "claude-fable-5.1",+ "resolution": {+ "status": "unknown",+ "reason": "authoritative_membership_identity_unresolved"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "claude-opus-5",+ "provider": "routing-run",+ "externalModelId": "claude-opus-5",+ "resolution": {+ "status": "unknown",+ "reason": "authoritative_membership_identity_unresolved"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "claude-opus-4.6",+ "provider": "routing-run",+ "externalModelId": "claude-opus-4.6",+ "resolution": {+ "status": "unknown",+ "reason": "authoritative_membership_identity_unresolved"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "claude-opus-4.7",+ "provider": "routing-run",+ "externalModelId": "claude-opus-4.7",+ "resolution": {+ "status": "unknown",+ "reason": "authoritative_membership_identity_unresolved"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "claude-opus-4.8",+ "provider": "routing-run",+ "externalModelId": "claude-opus-4.8",+ "resolution": {+ "status": "unknown",+ "reason": "authoritative_membership_identity_unresolved"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "claude-sonnet-5",+ "provider": "routing-run",+ "externalModelId": "claude-sonnet-5",+ "resolution": {+ "status": "unknown",+ "reason": "authoritative_membership_identity_unresolved"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "claude-sonnet-4.6",+ "provider": "routing-run",+ "externalModelId": "claude-sonnet-4.6",+ "resolution": {+ "status": "unknown",+ "reason": "authoritative_membership_identity_unresolved"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "claude-haiku-4.5",+ "provider": "routing-run",+ "externalModelId": "claude-haiku-4.5",+ "resolution": {+ "status": "unknown",+ "reason": "authoritative_membership_identity_unresolved"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "gpt-6-astra",+ "provider": "routing-run",+ "externalModelId": "gpt-6-astra",+ "resolution": {+ "status": "unknown",+ "reason": "authoritative_membership_identity_unresolved"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "gpt-5.5",+ "provider": "routing-run",+ "externalModelId": "gpt-5.5",+ "resolution": {+ "status": "unknown",+ "reason": "authoritative_membership_identity_unresolved"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "gpt-5.4",+ "provider": "routing-run",+ "externalModelId": "gpt-5.4",+ "resolution": {+ "status": "unknown",+ "reason": "authoritative_membership_identity_unresolved"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "gpt-5.4-mini",+ "provider": "routing-run",+ "externalModelId": "gpt-5.4-mini",+ "resolution": {+ "status": "unknown",+ "reason": "authoritative_membership_identity_unresolved"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "gpt-5.4-nano",+ "provider": "routing-run",+ "externalModelId": "gpt-5.4-nano",+ "resolution": {+ "status": "unknown",+ "reason": "authoritative_membership_identity_unresolved"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "gpt-5.3-codex",+ "provider": "routing-run",+ "externalModelId": "gpt-5.3-codex",+ "resolution": {+ "status": "unknown",+ "reason": "authoritative_membership_identity_unresolved"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "gpt-oss-120b",+ "provider": "routing-run",+ "externalModelId": "gpt-oss-120b",+ "resolution": {+ "status": "unknown",+ "reason": "authoritative_membership_identity_unresolved"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "gemini-3.8-flash",+ "provider": "routing-run",+ "externalModelId": "gemini-3.8-flash",+ "resolution": {+ "status": "unknown",+ "reason": "authoritative_membership_identity_unresolved"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "gemini-3.5-flash-lite",+ "provider": "routing-run",+ "externalModelId": "gemini-3.5-flash-lite",+ "resolution": {+ "status": "unknown",+ "reason": "authoritative_membership_identity_unresolved"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "grok-4.5",+ "provider": "routing-run",+ "externalModelId": "grok-4.5",+ "resolution": {+ "status": "unknown",+ "reason": "authoritative_membership_identity_unresolved"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "grok-4.3",+ "provider": "routing-run",+ "externalModelId": "grok-4.3",+ "resolution": {+ "status": "unknown",+ "reason": "authoritative_membership_identity_unresolved"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "qwen3.8-max",+ "provider": "routing-run",+ "externalModelId": "qwen3.8-max",+ "resolution": {+ "status": "unknown",+ "reason": "authoritative_membership_identity_unresolved"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "qwen3.8-flash",+ "provider": "routing-run",+ "externalModelId": "qwen3.8-flash",+ "resolution": {+ "status": "unknown",+ "reason": "authoritative_membership_identity_unresolved"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "qwen3-coder",+ "provider": "routing-run",+ "externalModelId": "qwen3-coder",+ "resolution": {+ "status": "unknown",+ "reason": "authoritative_membership_identity_unresolved"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "deepseek-v4.1-flash",+ "provider": "routing-run",+ "externalModelId": "deepseek-v4.1-flash",+ "resolution": {+ "status": "unknown",+ "reason": "authoritative_membership_identity_unresolved"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "minimax-m3",+ "provider": "routing-run",+ "externalModelId": "minimax-m3",+ "resolution": {+ "status": "unknown",+ "reason": "authoritative_membership_identity_unresolved"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "mistral-small-4",+ "provider": "routing-run",+ "externalModelId": "mistral-small-4",+ "resolution": {+ "status": "unknown",+ "reason": "authoritative_membership_identity_unresolved"+ }+ }+ ],+ "features": [+ "Model usage is billed at the live catalog price against included credit and optional top-ups",+ "Provider failover, routing rules, and live routing control",+ "Prompt bodies are not stored"+ ],+ "lastUpdated": "2026-10-12T10:09:22.152Z",+ "routeStatus": "unsupported",+ "routeReason": "no_reviewed_consumer_route",+ "membershipRequirements": [+ {+ "membershipId": "routing-run-live",+ "authority": "authoritative",+ "requiredForActivation": true,+ "maxAgeHours": 24+ }+ ],+ "membershipCoverage": {+ "status": "complete",+ "observedAt": "2026-10-12T10:09:22.152Z",+ "expiresAt": "2026-10-13T10:09:22.152Z"+ }+ },+ {+ "contractVersion": 3,+ "id": "streamlake-kwaikat-coding-plan",+ "displayName": "StreamLake KwaiKAT Coding Plan",+ "provider": "streamlake",+ "pricing": [+ {+ "period": "monthly",+ "price": 5,+ "currency": "USD",+ "description": "Mini: 40 Prompts / 5 Hours"+ },+ {+ "period": "monthly",+ "price": 10,+ "currency": "USD",+ "description": "Starter: 100 Prompts / 5 Hours"+ },+ {+ "period": "monthly",+ "price": 20,+ "currency": "USD",+ "description": "Pro: 300 Prompts / 5 Hours"+ },+ {+ "period": "monthly",+ "price": 50,+ "currency": "USD",+ "description": "Max: 1,000 Prompts / 5 Hours"+ },+ {+ "period": "payg",+ "price": 0.207,+ "currency": "USD",+ "description": "kat-coder-pro-v2.5 input price, current configuration per million tokens"+ },+ {+ "period": "payg",+ "price": 0.74,+ "currency": "USD",+ "description": "kat-coder-pro-v2.5 input price, list price per million tokens"+ },+ {+ "period": "payg",+ "price": 0.828,+ "currency": "USD",+ "description": "kat-coder-pro-v2.5 output price, current configuration per million tokens"+ },+ {+ "period": "payg",+ "price": 2.96,+ "currency": "USD",+ "description": "kat-coder-pro-v2.5 output price, list price per million tokens"+ },+ {+ "period": "payg",+ "price": 0.041,+ "currency": "USD",+ "description": "kat-coder-pro-v2.5 cache read, current configuration per million tokens"+ },+ {+ "period": "payg",+ "price": 0.06,+ "currency": "USD",+ "description": "kat-coder-pro-v2.5 cache read, list price per million tokens"+ }+ ],+ "modelDiscovery": "catalog",+ "inclusions": [+ {+ "kind": "provider_model",+ "sourceText": "KAT-Coder-Pro V2.5",+ "provider": "kwaipilot",+ "externalModelId": "kat-coder-pro-v2.5",+ "resolution": {+ "status": "mapped",+ "modelId": "kat-coder-pro-v2.5"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "KAT-Coder-Pro V2.5",+ "provider": "streamlake",+ "externalModelId": "kat-coder-pro-v2.5",+ "resolution": {+ "status": "mapped",+ "modelId": "kat-coder-pro-v2.5"+ }+ }+ ],+ "features": [+ "Mini: A lightweight option for first-time users; Full access to KAT-Coder-Pro V2.5 at the lowest cost; Covers daily coding scenarios; 40 Prompts / 5 Hours",+ "Starter: Ideal partner for daily core development; Powered by the latest KAT-Coder-Pro V2.5; Optimized for Claude Code and major IDEs; 100 Prompts / 5 Hours",+ "Pro: Advanced engine for complex architecture; All Starter features with a massive performance boost; 3x more usage than the Starter plan; 300 Prompts / 5 Hours",+ "Max: Flagship config for high-intensity dev; Superior cross-file & repository-level deep understanding; Over 3x the usage of the Pro plan; 1,000 Prompts / 5 Hours",+ "The public coding-plan page currently lists 1 pay-as-you-go model: kat-coder-pro-v2.5",+ "Pay-as-you-go kat-coder-pro-v2.5: Input Price: current $0.207, list $0.74 per million tokens; Output Price: current $0.828, list $2.96 per million tokens; Cache Read: current $0.041, list $0.06 per million tokens",+ "Subscription requests consume the plan quota; pay-as-you-go requests are billed by token",+ "OpenAI-compatible and Anthropic-compatible coding endpoints use the exact mapped model identifiers in structured inclusions",+ "Evidence: https://www.streamlake.ai/api/get-kconf-content?key=website_kat_coder_coding_plan&name=platform_web&folder=streamlake",+ "Pricing evidence: https://console.streamlake.ai/api/common/describe-product-detail",+ "Integration evidence: https://www.streamlake.ai/document/DOC/mg6k6nlp8j6qxicx4c9",+ "Product page: https://www.streamlake.ai/marketing/coding-plan"+ ],+ "lastUpdated": "2026-10-12T10:09:21.549Z",+ "routeStatus": "unsupported",+ "routeReason": "no_reviewed_consumer_route",+ "membershipRequirements": [+ {+ "membershipId": "streamlake-kwaikat-coding-plan-live",+ "authority": "authoritative",+ "requiredForActivation": true,+ "maxAgeHours": 24+ }+ ],+ "membershipCoverage": {+ "status": "complete",+ "observedAt": "2026-10-12T10:09:21.549Z",+ "expiresAt": "2026-10-13T10:09:21.549Z"+ }+ },+ {+ "contractVersion": 3,+ "id": "xai-supergrok",+ "displayName": "SuperGrok / X Premium+",+ "provider": "x-ai",+ "pricing": [+ {+ "period": "monthly",+ "price": 0,+ "currency": "USD",+ "description": "Free: limited Grok and Grok Build access"+ },+ {+ "period": "monthly",+ "price": 30,+ "currency": "USD",+ "description": "SuperGrok: higher limits and frontier-model access"+ },+ {+ "period": "monthly",+ "price": 100,+ "currency": "USD",+ "description": "SuperGrok Plus: significantly higher Chat, Imagine, Voice, and Build usage"+ }+ ],+ "modelDiscovery": "client",+ "inclusions": [+ {+ "kind": "prose_placeholder",+ "sourceText": "account-specific Grok models catalog",+ "resolution": {+ "status": "unknown",+ "reason": "dynamic_models_catalog_required"+ }+ }+ ],+ "features": [+ "Grok Build terminal coding agent with account sign-in",+ "SuperGrok and X Premium+ OAuth access in supported coding clients without a separate API key",+ "Exact callable models and entitlement are discovered from the signed-in account"+ ],+ "lastUpdated": "2026-09-29T21:17:24.000Z",+ "routeStatus": "supported",+ "route": {+ "routeId": "x-ai",+ "routeProfileId": "supergrok-subscription"+ },+ "membershipRequirements": [],+ "membershipCoverage": {+ "status": "unknown",+ "reason": "unavailable"+ }+ },+ {+ "contractVersion": 3,+ "id": "z-ai-glm-coding-plan",+ "displayName": "GLM Coding Plan",+ "provider": "z-ai",+ "pricing": [+ {+ "period": "monthly",+ "price": 18,+ "currency": "USD",+ "description": "Lite Plan"+ },+ {+ "period": "monthly",+ "price": 72,+ "currency": "USD",+ "description": "Pro Plan"+ },+ {+ "period": "monthly",+ "price": 160,+ "currency": "USD",+ "description": "Max Plan"+ }+ ],+ "modelDiscovery": "catalog",+ "inclusions": [+ {+ "kind": "provider_model",+ "sourceText": "GLM-5.3",+ "provider": "z-ai",+ "externalModelId": "GLM-5.3",+ "resolution": {+ "status": "mapped",+ "modelId": "glm-5.3"+ }+ },+ {+ "kind": "provider_model",+ "sourceText": "GLM-5.3-Flash",+ "provider": "z-ai",+ "externalModelId": "GLM-5.3-Flash",+ "resolution": {+ "status": "mapped",+ "modelId": "glm-5.3-flash"+ }+ }+ ],+ "features": [+ "Subscription package designed for AI-powered coding",+ "Lite, Pro, and Max include 2,000/10,000, 12,000/60,000, and 28,000/140,000 five-hour/weekly credits",+ "Supports Claude Code, Cline, OpenCode, and MCP-assisted development workflows"+ ],+ "lastUpdated": "2026-10-12T10:09:23.573Z",+ "routeStatus": "supported",+ "route": {+ "routeId": "z-ai",+ "routeProfileId": "glm-coding-subscription"+ },+ "membershipRequirements": [+ {+ "membershipId": "z-ai-glm-coding-plan-live",+ "authority": "authoritative",+ "requiredForActivation": true,+ "maxAgeHours": 24+ }+ ],+ "membershipCoverage": {+ "status": "complete",+ "observedAt": "2026-10-12T10:09:23.573Z",+ "expiresAt": "2026-10-13T10:09:23.573Z"+ }+ }+ ],+ "catalogGenerationId": "g-20261012101007285-7770c36e",+ "routeRegistry": {+ "generationId": "g-20261012101007285-7770c36e",+ "registry": {+ "contractVersion": 3,+ "registryVersion": "3.7.0",+ "routes": {+ "anthropic": {+ "routeId": "anthropic",+ "consumerProviderId": "anthropic",+ "profiles": {+ "direct-api": {+ "kind": "direct",+ "endpointProfileId": "anthropic-direct",+ "credentialProfileId": "anthropic-api-key",+ "nativeModelProviders": [+ "anthropic"+ ],+ "apis": {+ "chat-completions": {+ "baseUrl": "https://api.anthropic.com/v1"+ },+ "anthropic-messages": {+ "baseUrl": "https://api.anthropic.com/v1"+ }+ },+ "admission": "api_roster"+ },+ "claude-code-subscription": {+ "kind": "subscription",+ "endpointProfileId": "anthropic-claude-code",+ "credentialProfileId": "anthropic-claude-code-oauth",+ "nativeModelProviders": [+ "anthropic"+ ],+ "apis": {+ "anthropic-messages": {+ "baseUrl": "https://api.anthropic.com/v1"+ }+ },+ "admission": "docs_roster"+ }+ }+ },+ "openai": {+ "routeId": "openai",+ "consumerProviderId": "openai",+ "profiles": {+ "direct-api": {+ "kind": "direct",+ "endpointProfileId": "openai-direct",+ "credentialProfileId": "openai-api-key",+ "nativeModelProviders": [+ "openai"+ ],+ "apis": {+ "chat-completions": {+ "baseUrl": "https://api.openai.com/v1"+ },+ "responses": {+ "baseUrl": "https://api.openai.com/v1"+ }+ },+ "admission": "api_roster"+ },+ "codex-subscription": {+ "kind": "subscription",+ "endpointProfileId": "openai-codex",+ "credentialProfileId": "openai-codex-oauth",+ "nativeModelProviders": [+ "openai"+ ],+ "apis": {+ "responses": {+ "baseUrl": "https://chatgpt.com/backend-api/codex"+ }+ },+ "admission": "docs_roster"+ }+ }+ },+ "google": {+ "routeId": "google",+ "consumerProviderId": "google",+ "profiles": {+ "direct-api": {+ "kind": "direct",+ "endpointProfileId": "google-gemini-direct",+ "credentialProfileId": "google-gemini-api-key",+ "nativeModelProviders": [+ "google"+ ],+ "apis": {+ "chat-completions": {+ "baseUrl": "https://generativelanguage.googleapis.com/v1beta/openai"+ },+ "gemini": {+ "baseUrl": "https://generativelanguage.googleapis.com/v1beta"+ }+ },+ "admission": "api_roster"+ },+ "antigravity-subscription": {+ "kind": "subscription",+ "endpointProfileId": "google-antigravity",+ "credentialProfileId": "google-antigravity-oauth",+ "nativeModelProviders": [+ "google"+ ],+ "apis": {},+ "admission": "docs_roster"+ }+ }+ },+ "x-ai": {+ "routeId": "x-ai",+ "consumerProviderId": "x-ai",+ "profiles": {+ "direct-api": {+ "kind": "direct",+ "endpointProfileId": "xai-direct",+ "credentialProfileId": "xai-api-key",+ "nativeModelProviders": [+ "x-ai"+ ],+ "apis": {+ "chat-completions": {+ "baseUrl": "https://api.x.ai/v1"+ },+ "responses": {+ "baseUrl": "https://api.x.ai/v1"+ }+ },+ "admission": "api_roster"+ },+ "supergrok-subscription": {+ "kind": "subscription",+ "endpointProfileId": "xai-grok-build",+ "credentialProfileId": "xai-grok-build-oauth",+ "nativeModelProviders": [+ "x-ai"+ ],+ "apis": {},+ "admission": "docs_roster"+ }+ }+ },+ "mistralai": {+ "routeId": "mistralai",+ "consumerProviderId": "mistralai",+ "profiles": {+ "direct-api": {+ "kind": "direct",+ "endpointProfileId": "mistral-direct",+ "credentialProfileId": "mistral-api-key",+ "nativeModelProviders": [+ "mistralai"+ ],+ "apis": {+ "chat-completions": {+ "baseUrl": "https://api.mistral.ai/v1"+ }+ },+ "admission": "api_roster"+ }+ }+ },+ "moonshotai": {+ "routeId": "moonshotai",+ "consumerProviderId": "moonshotai",+ "profiles": {+ "direct-api": {+ "kind": "direct",+ "endpointProfileId": "moonshot-direct",+ "credentialProfileId": "moonshot-api-key",+ "nativeModelProviders": [+ "moonshotai"+ ],+ "apis": {+ "chat-completions": {+ "baseUrl": "https://api.moonshot.ai/v1"+ },+ "responses": {+ "baseUrl": "https://api.moonshot.ai/v1"+ },+ "anthropic-messages": {+ "baseUrl": "https://api.moonshot.ai/anthropic/v1"+ }+ },+ "admission": "api_roster"+ },+ "kimi-code-subscription": {+ "kind": "subscription",+ "endpointProfileId": "kimi-code",+ "credentialProfileId": "kimi-code-membership-token",+ "nativeModelProviders": [+ "moonshotai"+ ],+ "apis": {+ "chat-completions": {+ "baseUrl": "https://api.kimi.ai/coding/v1"+ },+ "anthropic-messages": {+ "baseUrl": "https://api.kimi.ai/coding/v1"+ }+ },+ "admission": "docs_roster"+ }+ }+ },+ "minimax": {+ "routeId": "minimax",+ "consumerProviderId": "minimax",+ "profiles": {+ "direct-api": {+ "kind": "direct",+ "endpointProfileId": "minimax-direct",+ "credentialProfileId": "minimax-api-key",+ "nativeModelProviders": [+ "minimax"+ ],+ "apis": {+ "chat-completions": {+ "baseUrl": "https://api.minimax.io/v1"+ },+ "responses": {+ "baseUrl": "https://api.minimax.io/v1"+ },+ "anthropic-messages": {+ "baseUrl": "https://api.minimax.io/anthropic/v1"+ }+ },+ "admission": "api_roster"+ },+ "coding-plan-subscription": {+ "kind": "subscription",+ "endpointProfileId": "minimax-coding-plan",+ "credentialProfileId": "minimax-subscription-key",+ "nativeModelProviders": [+ "minimax"+ ],+ "apis": {+ "chat-completions": {+ "baseUrl": "https://api.minimax.io/v1"+ },+ "anthropic-messages": {+ "baseUrl": "https://api.minimax.io/anthropic/v1"+ }+ },+ "admission": "docs_roster"+ }+ }+ },+ "deepseek": {+ "routeId": "deepseek",+ "consumerProviderId": "deepseek",+ "profiles": {+ "direct-api": {+ "kind": "direct",+ "endpointProfileId": "deepseek-direct",+ "credentialProfileId": "deepseek-api-key",+ "nativeModelProviders": [+ "deepseek"+ ],+ "apis": {+ "chat-completions": {+ "baseUrl": "https://api.deepseek.com"+ },+ "responses": {+ "baseUrl": "https://api.deepseek.com"+ }+ },+ "admission": "api_roster"+ }+ }+ },+ "qwen": {+ "routeId": "qwen",+ "consumerProviderId": "qwen",+ "profiles": {+ "dashscope-direct": {+ "kind": "direct",+ "endpointProfileId": "dashscope-direct",+ "credentialProfileId": "dashscope-api-key",+ "nativeModelProviders": [+ "qwen"+ ],+ "apis": {+ "chat-completions": {+ "baseUrl": "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"+ },+ "responses": {+ "baseUrl": "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"+ },+ "anthropic-messages": {+ "baseUrl": "https://dashscope-intl.aliyuncs.com/apps/anthropic/v1"+ }+ },+ "admission": "api_roster"+ },+ "realtime-websocket": {+ "kind": "direct",+ "endpointProfileId": "modelstudio-realtime-websocket",+ "credentialProfileId": "dashscope-api-key",+ "nativeModelProviders": [+ "qwen"+ ],+ "apis": {},+ "admission": "api_roster"+ },+ "modelstudio-coding-plan": {+ "kind": "subscription",+ "endpointProfileId": "modelstudio-coding-plan",+ "credentialProfileId": "modelstudio-coding-plan-key",+ "nativeModelProviders": [+ "qwen"+ ],+ "apis": {+ "chat-completions": {+ "baseUrl": "https://coding-intl.dashscope.aliyuncs.com/v1"+ }+ },+ "admission": "docs_roster"+ },+ "qwencloud-token-plan": {+ "kind": "subscription",+ "endpointProfileId": "qwencloud-token-plan",+ "credentialProfileId": "qwencloud-token-plan-key",+ "nativeModelProviders": [+ "qwen"+ ],+ "apis": {+ "chat-completions": {+ "baseUrl": "https://token-plan.maas.qwencloudapi.com/compatible-mode/v1"+ }+ },+ "admission": "docs_roster"+ }+ }+ },+ "z-ai": {+ "routeId": "z-ai",+ "consumerProviderId": "z-ai",+ "profiles": {+ "direct-api": {+ "kind": "direct",+ "endpointProfileId": "zai-direct",+ "credentialProfileId": "zai-api-key",+ "nativeModelProviders": [+ "z-ai"+ ],+ "apis": {+ "chat-completions": {+ "baseUrl": "https://api.z.ai/api/paas/v4"+ }+ },+ "admission": "api_roster"+ },+ "glm-coding-subscription": {+ "kind": "subscription",+ "endpointProfileId": "zai-glm-coding",+ "credentialProfileId": "zai-glm-coding-token",+ "nativeModelProviders": [+ "z-ai"+ ],+ "apis": {+ "chat-completions": {+ "baseUrl": "https://api.z.ai/api/coding/paas/v4"+ },+ "responses": {+ "baseUrl": "https://api.z.ai/api/v1"+ }+ },+ "admission": "docs_roster"+ }+ }+ },+ "openrouter": {+ "routeId": "openrouter",+ "consumerProviderId": "openrouter",+ "profiles": {+ "gateway": {+ "kind": "gateway",+ "endpointProfileId": "openrouter-gateway",+ "credentialProfileId": "openrouter-api-key",+ "nativeModelProviders": [],+ "apis": {+ "chat-completions": {+ "baseUrl": "https://openrouter.ai/api/v1"+ },+ "responses": {+ "baseUrl": "https://openrouter.ai/api/v1"+ },+ "anthropic-messages": {+ "baseUrl": "https://openrouter.ai/api/v1"+ }+ },+ "admission": "api_roster"+ },+ "decisions": {+ "kind": "gateway",+ "endpointProfileId": "openrouter-decisions",+ "credentialProfileId": "openrouter-api-key",+ "nativeModelProviders": [],+ "apis": {},+ "admission": "api_roster"+ }+ }+ },+ "together-ai": {+ "routeId": "together-ai",+ "consumerProviderId": "together-ai",+ "profiles": {+ "gateway": {+ "kind": "gateway",+ "endpointProfileId": "together-inference",+ "credentialProfileId": "together-api-key",+ "nativeModelProviders": [],+ "apis": {+ "chat-completions": {+ "baseUrl": "https://api.together.ai/v1"+ }+ },+ "admission": "api_roster"+ }+ }+ },+ "fireworks": {+ "routeId": "fireworks",+ "consumerProviderId": "fireworks",+ "profiles": {+ "gateway": {+ "kind": "gateway",+ "endpointProfileId": "fireworks-inference",+ "credentialProfileId": "fireworks-api-key",+ "nativeModelProviders": [],+ "apis": {+ "chat-completions": {+ "baseUrl": "https://api.fireworks.ai/inference/v1"+ },+ "responses": {+ "baseUrl": "https://api.fireworks.ai/inference/v1"+ },+ "anthropic-messages": {+ "baseUrl": "https://api.fireworks.ai/inference/v1"+ }+ },+ "admission": "api_roster"+ }+ }+ },+ "poe": {+ "routeId": "poe",+ "consumerProviderId": "poe",+ "profiles": {+ "gateway": {+ "kind": "gateway",+ "endpointProfileId": "poe-api",+ "credentialProfileId": "poe-api-key",+ "nativeModelProviders": [],+ "apis": {+ "chat-completions": {+ "baseUrl": "https://api.poe.com/v1"+ },+ "responses": {+ "baseUrl": "https://api.poe.com/v1"+ },+ "anthropic-messages": {+ "baseUrl": "https://api.poe.com/v1"+ }+ },+ "admission": "api_roster"+ }+ }+ },+ "vertex": {+ "routeId": "vertex",+ "consumerProviderId": "vertex",+ "profiles": {+ "google-cloud": {+ "kind": "gateway",+ "endpointProfileId": "vertex-google-cloud",+ "credentialProfileId": "vertex-auth",+ "nativeModelProviders": [],+ "apis": {},+ "admission": "docs_roster"+ }+ }+ },+ "opencode": {+ "routeId": "opencode",+ "consumerProviderId": "opencode",+ "profiles": {+ "zen": {+ "kind": "gateway",+ "endpointProfileId": "opencode-zen",+ "credentialProfileId": "opencode-zen-api-key",+ "nativeModelProviders": [],+ "apis": {+ "chat-completions": {+ "baseUrl": "https://opencode.ai/zen/v1"+ },+ "responses": {+ "baseUrl": "https://opencode.ai/zen/v1"+ },+ "anthropic-messages": {+ "baseUrl": "https://opencode.ai/zen/v1"+ },+ "gemini": {+ "baseUrl": "https://opencode.ai/zen/v1"+ }+ },+ "admission": "api_roster"+ },+ "systemone": {+ "kind": "gateway",+ "endpointProfileId": "opencode-zen-systemone",+ "credentialProfileId": "opencode-zen-api-key",+ "nativeModelProviders": [],+ "apis": {},+ "admission": "api_roster"+ },+ "go-subscription": {+ "kind": "subscription",+ "endpointProfileId": "opencode-go",+ "credentialProfileId": "opencode-go-token",+ "nativeModelProviders": [],+ "apis": {+ "chat-completions": {+ "baseUrl": "https://opencode.ai/zen/go/v1"+ },+ "responses": {+ "baseUrl": "https://opencode.ai/zen/go/v1"+ },+ "anthropic-messages": {+ "baseUrl": "https://opencode.ai/zen/go/v1"+ }+ },+ "admission": "api_roster"+ }+ }+ },+ "sakana": {+ "routeId": "sakana",+ "consumerProviderId": "sakana",+ "profiles": {+ "direct-api": {+ "kind": "direct",+ "endpointProfileId": "sakana-direct",+ "credentialProfileId": "sakana-api-key",+ "nativeModelProviders": [+ "sakana"+ ],+ "apis": {+ "chat-completions": {+ "baseUrl": "https://api.sakana.ai/v1"+ },+ "responses": {+ "baseUrl": "https://api.sakana.ai/v1"+ }+ },+ "admission": "api_roster"+ },+ "fugu-subscription": {+ "kind": "subscription",+ "endpointProfileId": "sakana-fugu",+ "credentialProfileId": "sakana-subscription-key",+ "nativeModelProviders": [+ "sakana"+ ],+ "apis": {+ "chat-completions": {+ "baseUrl": "https://api.sakana.ai/v1"+ },+ "responses": {+ "baseUrl": "https://api.sakana.ai/v1"+ }+ },+ "admission": "api_roster"+ }+ }+ },+ "ollama": {+ "routeId": "ollama",+ "consumerProviderId": "ollama",+ "profiles": {+ "cloud": {+ "kind": "gateway",+ "endpointProfileId": "ollama-cloud",+ "credentialProfileId": "ollama-cloud-token",+ "nativeModelProviders": [],+ "apis": {+ "chat-completions": {+ "baseUrl": "https://ollama.com/v1"+ },+ "responses": {+ "baseUrl": "https://ollama.com/v1"+ },+ "anthropic-messages": {+ "baseUrl": "https://ollama.com/v1"+ }+ },+ "admission": "api_roster"+ }+ }+ },+ "cognition": {+ "routeId": "cognition",+ "consumerProviderId": "cognition",+ "profiles": {+ "devin-subscription": {+ "kind": "subscription",+ "endpointProfileId": "cognition-devin-connect",+ "credentialProfileId": "cognition-devin-session",+ "nativeModelProviders": [+ "cognition"+ ],+ "apis": {},+ "admission": "docs_roster"+ }+ }+ }+ }+ }+ }+}\ No newline at end of file