cartethyia 2.4.5 → 2.5.0

package/src/providers/default-registry.ts

@@ -12,6 +12,8 @@ import { createAnthropicCompatibleAdapter } from "./integrations/anthropic";
 import { defineModel } from "./provider-model-definition";
 import type { ProviderModelDiscovery } from "./discovery/discovery-types";
 import type { ProviderDispatchContext } from "./provider-contracts";
+import type { QoderRealm } from "./integrations/qoder/qoder-realm";
+import type { TraeRealm } from "./integrations/trae/trae-realm";
 import type { WireFamily } from "../protocol/canonical-model";
 import type { CanonicalRequest } from "../protocol/canonical-model";
 
@@ -25,6 +27,106 @@ function configuredProvider(
   };
 }
 
+/**
+ * Qoder's live model list for one realm.
+ *
+ * The request has to be signed with the account's COSY identity and has to
+ * carry the body that was signed — a bare GET is refused — so discovery cannot
+ * use the generic bearer helper. It resolves the same identity dispatch uses
+ * (PAT exchange or the persisted OAuth state) and then lists against the
+ * realm's own gateway hosts.
+ */
+/**
+ * Trae model discovery for one realm.
+ *
+ * The listing is per account region: it answers on CN and on the intl region
+ * host that serves the account. This returns the static roster when the live
+ * call yields nothing, rather than raising, so one unsupported account cannot
+ * fail the whole catalog refresh.
+ */
+function traeDiscovery(
+  realm: TraeRealm,
+  providerId: string,
+): NonNullable<ProviderModuleCapabilities["loadModelDiscovery"]> {
+  return async () => async (request: Parameters<ProviderModelDiscovery>[0]) => {
+    const { discoverTraeModels } = await import("./integrations/trae/trae");
+    const { TRAE_INTL_MODELS, TRAE_CN_MODELS } = await import("./integrations/trae/trae-catalog");
+    const secret = request.credential.trim();
+    const fetcher = request.fetcher as unknown as typeof fetch | undefined;
+    if (secret.length === 0 || fetcher === undefined) {
+      return realm === "cn" ? TRAE_CN_MODELS : TRAE_INTL_MODELS;
+    }
+    let token = secret;
+    if (secret.startsWith("{")) {
+      try {
+        const parsed = JSON.parse(secret) as Record<string, unknown>;
+        const found = ["accessToken", "access_token", "token"].find(
+          (key) => typeof parsed[key] === "string" && (parsed[key] as string).length > 0,
+        );
+        if (found !== undefined) token = parsed[found] as string;
+      } catch {
+        // Use the raw secret as the token.
+      }
+    }
+    const region = request.authState?.["region"];
+    const rows = await discoverTraeModels({
+      realm,
+      token,
+      uid: request.authState?.["accountId"] as string | undefined ?? "",
+      fetcher,
+      providerId,
+      ...(typeof region === "string" ? { region } : {}),
+    });
+    if (rows.length === 0) return realm === "cn" ? TRAE_CN_MODELS : TRAE_INTL_MODELS;
+    const fallback = realm === "cn" ? TRAE_CN_MODELS : TRAE_INTL_MODELS;
+    const byId = new Map(fallback.map((model) => [model.modelId, model]));
+    return rows.map((row) => {
+      const existing = byId.get(row.id);
+      if (existing === undefined) {
+        // Discovered upstream but absent from the static roster: clone the
+        // realm's first row so a new model is routable with the shape this
+        // provider serves, carrying the window upstream reported.
+        const template = fallback[0];
+        if (template === undefined) return undefined;
+        return { ...template, modelId: row.id, contextLimit: row.ctx ?? null };
+      }
+      return row.ctx === undefined ? existing : { ...existing, contextLimit: row.ctx };
+    }).filter((model): model is NonNullable<typeof model> => model !== undefined);
+  };
+}
+
+function qoderDiscovery(
+  realm: QoderRealm,
+  providerId: string,
+): NonNullable<ProviderModuleCapabilities["loadModelDiscovery"]> {
+  return async () => async (request: Parameters<ProviderModelDiscovery>[0]) => {
+    const { discoverQoderModels } = await import("./integrations/qoder/qoder-catalog");
+    const { resolveQoderAuth, qoderSignerFor, qoderEncodeBody } = await import("./integrations/qoder/qoder");
+    const secret = request.credential.trim();
+    if (secret.length === 0) throw new Error("Qoder credential is required");
+    const fetcher = request.fetcher as unknown as typeof fetch | undefined;
+    // The discovery context carries only the secret plus the non-secret
+    // `authState` an OAuth login persisted; the account id lives there too, so
+    // an OAuth credential resolves to the same identity dispatch would use.
+    const auth = await resolveQoderAuth({
+      secret,
+      authState: request.authState,
+      signal: AbortSignal.timeout(15_000),
+      fetcher: (url: string, init: RequestInit) => (fetcher ?? globalThis.fetch)(url, init),
+    });
+    const signer = qoderSignerFor(auth);
+    return discoverQoderModels({
+      realm,
+      providerId,
+      credential: secret,
+      headers: (url: string, body: string) => Promise.resolve(signer(url, body)),
+      ...(fetcher === undefined ? {} : { fetcher }),
+      encode: qoderEncodeBody,
+    });
+  };
+}
+
+
 /**
  * Builds the `loadAdapter` + `loadModelDiscovery` pair every plain bearer
  * provider needs.
@@ -201,6 +303,29 @@ export const PROVIDER_CAPABILITIES = {
     loadAuthentication: oauthCapability(() => import("./integrations/kimi/kimi-oauth"), "kimiCodeOAuthClient", { withRefresher: true }),
     loadQuotaCollector: quotaCapability(() => import("./integrations/kimi/kimi-quota"), "fetchKimiQuota"),
   },
+  cursor: {
+    // Cursor's Run is a Connect-RPC bidi stream on a *dynamically discovered*
+    // agent origin, not the API host the auth and catalog calls use. The path
+    // is pinned here so a probe verifies the endpoint dispatch actually calls;
+    // the origin itself is resolved per dispatch from GetServerConfig.
+    endpointPathsByWireFamily: { chat: "/agent.v1.AgentService/Run" },
+    loadAdapter: async () => (await import("./integrations/cursor/cursor")).cursorAdapter,
+    loadModels: async () => (await import("./integrations/cursor/cursor-catalog")).CURSOR_MODELS,
+    loadAuthentication: oauthCapability(() => import("./integrations/cursor/cursor-auth"), "cursorOAuthClient", {
+      withRefresher: true,
+    }),
+    // No quota collector: no Cursor quota endpoint is established by the donor
+    // or the API evidence, and inventing one would publish a balance this
+    // gateway cannot measure.
+    //
+    // The roster is per-account and per-plan, and Cursor declares each model's
+    // capabilities, so discovery is the catalog rather than a static list.
+    loadModelDiscovery: async () => async ({ credential, fetcher }) =>
+      (await import("./integrations/cursor/cursor-catalog")).discoverCursorModels({
+        credential,
+        ...(fetcher === undefined ? {} : { fetcher }),
+      }),
+  },
   cerebras: {
     endpointPathsByWireFamily: { chat: "/chat/completions" },
     loadAdapter: async () => createApiKeyAdapter((await import("./integrations/cerebras")).CEREBRAS_SPEC),
@@ -274,6 +399,10 @@ export const PROVIDER_CAPABILITIES = {
     loadAdapter: async () => createApiKeyAdapter((await import("./integrations/opencode/provider")).OPENCODE_GO_SPEC),
     loadModels: async () => (await import("./integrations/opencode/provider")).OPENCODE_GO_MODELS,
     loadModelDiscovery: openAIModelDiscovery("opencode-go", { transformBaseUrl: (baseUrl) => `${baseUrl.replace(/\/+$/, "")}/zen/go/v1`, headers: (credential) => ({ authorization: `Bearer ${credential}` }) }),
+    // The Go plan publishes a real usage surface; the anonymous free tier has
+    // none (it is rate-limited by egress IP, not by a balance), so this is
+    // deliberately registered on the keyed tier only.
+    loadQuotaCollector: async () => (await import("./integrations/opencode/opencode-go-quota")).fetchOpenCodeGoQuota,
   },
   agentrouter: {
     loadAdapter: async () => (await import("./integrations/agentrouter/agentrouter")).createAgentRouterAdapter(),
@@ -320,7 +449,10 @@ export const PROVIDER_CAPABILITIES = {
   },
   kilo: {
     loadAdapter: async () => (await import("./integrations/kilo/kilo")).kiloAdapter,
-    loadModels: async () => (await import("./integrations/kilo/kilo")).KILO_MODELS,
+    loadModels: async () => {
+      const spec = await import("./integrations/kilo/kilo");
+      return [...spec.KILO_MODELS, ...spec.KILO_FREE_MODELS];
+    },
     // No `withRefresher`: Kilo Code has no refresh grant, so this client
     // declares no refresher and the stored token is used exactly as issued.
     // Registering one would make the 401 retry path call a method that always
@@ -335,6 +467,14 @@ export const PROVIDER_CAPABILITIES = {
   commandcode: {
     loadAdapter: async () => (await import("./integrations/commandcode/commandcode")).createCommandCodeAdapter(),
     loadModels: async () => (await import("./integrations/commandcode/commandcode")).COMMANDCODE_MODELS,
+    // The Provider API publishes the real roster with each model's wire, so the
+    // static seed above is the offline floor rather than the catalog.
+    loadModelDiscovery: async () => async (input) =>
+      (await import("./integrations/commandcode/discovery")).discoverCommandCodeModels(input),
+    loadQuotaCollector: quotaCapability(
+      () => import("./integrations/commandcode/quota"),
+      "fetchCommandCodeQuota",
+    ),
   },
   qoder: {
     loadAdapter: async () => (await import("./integrations/qoder/qoder")).createQoderAdapter(),
@@ -343,6 +483,42 @@ export const PROVIDER_CAPABILITIES = {
     // device flow, so the issued token is used exactly as issued until the
     // operator re-runs login — same shape as Kilo Code.
     loadAuthentication: oauthCapability(() => import("./integrations/qoder/qoder-oauth"), "qoderOAuthClient"),
+    // Discovery signed by the account's own COSY identity: the model list is
+    // per-account and per-realm, and a GET without the signed body is 403.
+    loadModelDiscovery: qoderDiscovery("intl", "qoder"),
+  },
+  // Separate provider, not a region flag: a CN account has its own gateway
+  // host, OAuth client id, and model roster, and is refused by the global host.
+  qodercn: {
+    loadAdapter: async () => (await import("./integrations/qoder/qoder")).createQoderCnAdapter(),
+    loadModels: async () => (await import("./integrations/qoder/qoder-catalog")).QODER_CN_MODELS,
+    // The CN client, not the intl one: a device login opened on
+    // `qoder.com/device/selectAccounts` polled `openapi.qoder.sh`, which a CN
+    // account is refused by. `qoderCnOAuthClient` is the same class bound to
+    // `QODER_REALMS.cn` — its own login/token/userinfo hosts, client id, and
+    // native redirect.
+    loadAuthentication: oauthCapability(() => import("./integrations/qoder/qoder-oauth"), "qoderCnOAuthClient"),
+    loadModelDiscovery: qoderDiscovery("cn", "qodercn"),
+  },
+  trae: {
+    loadAdapter: async () => (await import("./integrations/trae/trae")).createTraeAdapter(),
+    loadModels: async () => (await import("./integrations/trae/trae-catalog")).TRAE_INTL_MODELS,
+    // A Trae credential is an access/refresh pair and the refresh token is what
+    // keeps it alive, so the refresher is registered rather than optional:
+    // without it the account dies at first expiry.
+    loadAuthentication: oauthCapability(() => import("./integrations/trae/trae-oauth"), "traeOAuthClient", { withRefresher: true }),
+    // Live model list is intl-unsupported: upstream answers `403 no schema
+    // found`, so discovery returning nothing is the truthful result and the
+    // static roster above stays authoritative.
+    loadModelDiscovery: traeDiscovery("intl", "trae"),
+  },
+  traecn: {
+    loadAdapter: async () => (await import("./integrations/trae/trae")).createTraeCnAdapter(),
+    loadModels: async () => (await import("./integrations/trae/trae-catalog")).TRAE_CN_MODELS,
+    // The CN client, not the intl one: the exchange runs on the CN account
+    // host, and a refresh posted to the intl host is refused.
+    loadAuthentication: oauthCapability(() => import("./integrations/trae/trae-oauth"), "traeCnOAuthClient", { withRefresher: true }),
+    loadModelDiscovery: traeDiscovery("cn", "traecn"),
   },
   inferhub: {
     loadAdapter: async () => (await import("./integrations/inferhub")).createInferhubAdapter(),

package/src/providers/discovery/catalog/catalog-format.ts

@@ -166,6 +166,16 @@ const decoder = new TextDecoder();
 
 const FLAG_REASONING = 1;
 const FLAG_TOOL_CALL = 2;
+
+/**
+ * Ceiling on {@link PackedCatalog}'s row-metadata cache.
+ *
+ * Sized well under the catalog's 8941 rows: a gateway resolves a working set of
+ * models, not the whole catalog, and every entry is rebuilt from the blob in a
+ * few typed-array reads. Holding more than this trades RAM for reads measured
+ * in nanoseconds.
+ */
+export const METADATA_CACHE_MAX_ENTRIES = 2048;
 const SLASH = 0x2f;
 
 /** Lowercases and trims an ASCII id into the exact bytes the blob stores. */
@@ -182,6 +192,12 @@ export function lowerAscii(value: string): Uint8Array {
  * Holds typed-array views (zero-copy) and nothing else. Metadata objects are
  * created only for rows a caller actually resolves, and cached, so a long-lived
  * process pays for the handful of ids it queried rather than for all 8090.
+ *
+ * That cache is **bounded**: an entry is rebuilt from the blob in a few
+ * typed-array reads, so holding one at the cost of another is never worth it,
+ * and an unbounded memo over 8941 rows is memory the operator pays for at idle
+ * whether or not those rows are ever queried again. Bounded LRU, oldest
+ * insertion evicted first — the same shape the rest of the codebase uses.
  */
 export class PackedCatalog {
   private readonly bytes: Uint8Array;
@@ -399,6 +415,10 @@ export class PackedCatalog {
       reasoning: (flags & FLAG_REASONING) !== 0,
       toolCall: (flags & FLAG_TOOL_CALL) !== 0,
     };
+    if (this.metadataCache.size >= METADATA_CACHE_MAX_ENTRIES) {
+      const oldest = this.metadataCache.keys().next().value;
+      if (oldest !== undefined) this.metadataCache.delete(oldest);
+    }
     this.metadataCache.set(index, metadata);
     return metadata;
   }

package/src/providers/discovery/models-dev-catalog.ts

@@ -134,25 +134,38 @@ const UNKNOWN_COST: ModelsDevModelCost = {
 };
 
 /**
- * Decoded once, at module load.
+ * The packed catalog, decompressed on first use and memoized.
  *
  * Brotli + base64, not `JSON.parse`: the blob is columnar, so this allocates
  * one buffer and takes typed-array views over it rather than materialising
  * 8900 objects. `CATALOG_BLOB_BYTES` is the decompressed length, checked here
- * so a consumer paired with a half-regenerated blob fails at boot rather than
- * resolving a truncated catalog.
+ * so a consumer paired with a half-regenerated blob fails on first access
+ * rather than resolving a truncated catalog.
+ *
+ * The decode is lazy on purpose. It is ~105 KB of base64 that expands to a
+ * much larger buffer, and it used to run at module load — so every process,
+ * including the ones that never resolve a model (a CLI subcommand, a migration
+ * run, a test that only touches the console), paid it on the boot path.
+ * Deferring it moves that cost to the first catalog lookup and pays it once.
  */
-const CATALOG_BYTES = brotliDecompressSync(Buffer.from(CATALOG_BLOB_BROTLI_BASE64, "base64"));
-if (CATALOG_BYTES.byteLength !== CATALOG_BLOB_BYTES) {
-  throw new Error(
-    `The packed model catalog is ${CATALOG_BYTES.byteLength} B, expected ` +
-      `${CATALOG_BLOB_BYTES} B — regenerate it.`,
-  );
-}
+let catalogCache: PackedCatalog | undefined;
 
-// `PackedCatalog` copies into a 4-byte-aligned buffer of its own, so the
-// decompressed buffer is dropped here rather than held beside the copy.
-const CATALOG = new PackedCatalog(CATALOG_BYTES);
+function catalog(): PackedCatalog {
+  const cached = catalogCache;
+  if (cached !== undefined) return cached;
+  const bytes = brotliDecompressSync(Buffer.from(CATALOG_BLOB_BROTLI_BASE64, "base64"));
+  if (bytes.byteLength !== CATALOG_BLOB_BYTES) {
+    throw new Error(
+      `The packed model catalog is ${bytes.byteLength} B, expected ` +
+        `${CATALOG_BLOB_BYTES} B — regenerate it.`,
+    );
+  }
+  // `PackedCatalog` copies into a 4-byte-aligned buffer of its own, so the
+  // decompressed buffer is dropped here rather than held beside the copy.
+  const packed = new PackedCatalog(bytes);
+  catalogCache = packed;
+  return packed;
+}
 
 /**
  * Resolves model metadata and pricing exclusively from the packed base catalog
@@ -160,9 +173,13 @@ const CATALOG = new PackedCatalog(CATALOG_BYTES);
  */
 export class ModelsDevCatalog {
   /** When the generator fetched the upstream catalogs. */
-  readonly fetchedAt: string = CATALOG.fetchedAt;
+  get fetchedAt(): string {
+    return catalog().fetchedAt;
+  }
   /** Every provider key the catalog files. */
-  readonly providers: readonly string[] = CATALOG.providers;
+  get providers(): readonly string[] {
+    return catalog().providers;
+  }
 
   /**
    * Metadata for an exact `(providerIndex, idLower)` pair, or `undefined`.
@@ -172,19 +189,19 @@ export class ModelsDevCatalog {
    * matches exactly keeps winning.
    */
   private exactMetadata(providerLower: string, idLower: Uint8Array): ModelsDevModelMetadata | undefined {
-    const direct = CATALOG.exactIndex(CATALOG.providerIndex(providerLower), idLower);
-    if (direct >= 0) return CATALOG.metadataAt(direct);
+    const direct = catalog().exactIndex(catalog().providerIndex(providerLower), idLower);
+    if (direct >= 0) return catalog().metadataAt(direct);
     const mapped = CATALOG_PROVIDER_IDS[providerLower];
     if (mapped === undefined) return undefined;
-    return CATALOG.metadataAt(CATALOG.exactIndex(CATALOG.providerIndex(mapped), idLower));
+    return catalog().metadataAt(catalog().exactIndex(catalog().providerIndex(mapped), idLower));
   }
 
   /** Metadata rows whose *bare* id equals `bare`, in catalog order. */
   private metadataForBare(bare: Uint8Array): ModelsDevModelMetadata[] {
-    const [start, end] = CATALOG.bareRange(bare);
+    const [start, end] = catalog().bareRange(bare);
     const out: ModelsDevModelMetadata[] = [];
     for (let position = start; position < end; position += 1) {
-      const metadata = CATALOG.metadataAt(CATALOG.bareOrderAt(position));
+      const metadata = catalog().metadataAt(catalog().bareOrderAt(position));
       if (metadata !== undefined) out.push(metadata);
     }
     return out;
@@ -327,8 +344,8 @@ export class ModelsDevCatalog {
       return own;
     }
     const idLower = lowerAscii(modelId);
-    const row = CATALOG.globalCostRow(bareBytes(idLower));
-    const global = row >= 0 ? CATALOG.rowCost(row) : undefined;
+    const row = catalog().globalCostRow(bareBytes(idLower));
+    const global = row >= 0 ? catalog().rowCost(row) : undefined;
     if (global !== undefined && global.pricing_model !== "unknown") return global;
     return own ?? global ?? UNKNOWN_COST;
   }

package/src/providers/discovery/openai-model-discovery.ts

@@ -54,10 +54,18 @@ export async function fetchOpenAICompatibleModels(
         modalityContextLimit(entry);
       const contextWindow = parsedContext ?? fallback?.contextLimit ?? 200_000;
 
+      // `max_completion_tokens` first: it is the name an OpenAI-shaped catalog
+      // uses, and it is the name this gateway's own `/v1/models` emits. A
+      // reader that knew only `max_output_tokens`/`maxTokens` saw none of them
+      // and fell through to the 64_192 default, so every model on such an
+      // upstream was advertised at the same wrong ceiling no matter what the
+      // upstream reported.
       const parsedOutput =
+        positiveNumber(entry.max_completion_tokens) ??
         positiveNumber(entry.max_output_tokens) ??
         positiveNumber((entry as Record<string, unknown>).max_output_tokens) ??
         positiveNumber(entry.maxTokens) ??
+        positiveNumber((entry as Record<string, unknown>).completion_token_limit) ??
         modalityOutputLimit(entry);
       const maxOutputTokens = parsedOutput ?? fallback?.outputLimit ?? 64_192;
       const outputTokens = Math.min(maxOutputTokens, contextWindow);
@@ -74,7 +82,14 @@ export async function fetchOpenAICompatibleModels(
       // the upstream declares for the model it serves. A catalog that declares
       // it as an `input_modalities[]` array instead of a `modality` string was
       // read as text-only, so a vision model lost image input.
-      const hasImage = rawModality.includes("image") || modalityImageInput(entry);
+      // `capabilities.input` is a third spelling — an array of modality names,
+      // used by OpenAI-shaped catalogs including this gateway's own. Read
+      // alongside the other two so a vision model is not downgraded to
+      // text-only, which then drops image parts before they reach the upstream.
+      const hasImage =
+        rawModality.includes("image") ||
+        modalityImageInput(entry) ||
+        capabilityImageInput(entry);
       const responsesWire = isResponsesNativeModelId(id);
       byId.set(id, {
         modelId: id,
@@ -83,8 +98,14 @@ export async function fetchOpenAICompatibleModels(
         contextLimit: contextWindow,
         outputLimit: outputTokens,
         modalities: { input: hasImage ? ["text", "image"] : ["text"], output: ["text"] },
-        reasoning: false,
-        toolCall: true,
+        // Upstream declares reasoning, so believe it rather than pinning false:
+        // a reasoning model advertised as non-reasoning is routed without the
+        // thinking budget it needs, and the caller's `reasoning_effort` is
+        // dropped as unsupported.
+        reasoning: entry.reasoning === true,
+        // Same for tool calling — an upstream that names a model as
+        // non-tool-capable must not have tools routed to it.
+        toolCall: entry.tool_call === false ? false : true,
         cost,
       });
     }
@@ -150,6 +171,21 @@ function modalityImageInput(entry: Record<string, unknown>): boolean {
 
 
 
+/**
+ * Image input from a `capabilities.input` array.
+ *
+ * The field is a plain list of modality names (`["text","image"]`), not the
+ * structured `input_modalities[]` objects the sibling reader expects. A catalog
+ * that spells it this way was read as text-only.
+ */
+function capabilityImageInput(entry: Record<string, unknown>): boolean {
+  const capabilities = entry.capabilities;
+  if (!isRecord(capabilities)) return false;
+  const inputs = capabilities.input;
+  if (!Array.isArray(inputs)) return false;
+  return inputs.some((name) => typeof name === "string" && name.toLowerCase().includes("image"));
+}
+
 function extractEntries(payload: unknown): readonly Record<string, unknown>[] | null {
   if (Array.isArray(payload)) return payload.filter(isRecord);
   if (typeof payload !== "object" || payload === null) return null;

package/src/providers/discovery/openrouter-free-roster.ts

@@ -0,0 +1,98 @@
+/**
+ * The free tier shared by the OpenRouter-backed providers.
+ *
+ * Cline, Kilo Code and OpenRouter serve one model catalog: the same 469 ids,
+ * and the same 17 of them carrying a `:free` suffix. Verified against all three
+ * live listings — every id below is present under `openrouter`, `kilo` and
+ * `cline` — so this roster is a catalog fact, not a per-provider guess, and it
+ * lives in one place rather than being restated three times.
+ *
+ * The limits, modalities and capability flags are read from OpenRouter's own
+ * `/api/v1/models`, which states `context_length`,
+ * `top_provider.max_completion_tokens`, `architecture.input_modalities` and
+ * `supported_parameters`. That is the serving catalog's declaration, so these
+ * are measurements rather than defaults.
+ *
+ * This is a floor, not the authority: each provider also discovers live, and a
+ * row the listing carries that this roster does not is still found there. The
+ * roster exists so a fresh install has a usable free tier before any fetch, and
+ * so the free section is populated even when discovery is unavailable.
+ */
+import { defineModel } from "../provider-model-definition";
+import type { ModelDefinition } from "../provider-model-definition";
+
+export interface FreeRosterOptions {
+  readonly providerId: string;
+  /** The wire suffix that completes the provider's base URL. */
+  readonly endpoint: string;
+}
+
+interface FreeRow {
+  readonly id: string;
+  readonly ctx: number;
+  readonly out: number;
+  readonly vision?: boolean;
+  /** `supported_parameters` omits `tools` on the safety classifier only. */
+  readonly toolCall?: boolean;
+}
+
+/**
+ * The 17 `:free` ids, with the limits the catalog states for each.
+ *
+ * Every row declares `reasoning`: `supported_parameters` lists it on all
+ * seventeen. `toolCall` is `true` unless stated otherwise, because a row that
+ * advertises tools must keep them — a false `toolCall` makes the preflight
+ * strip `tools` from the request, which is a wrong capability rather than a
+ * conservative one.
+ */
+const FREE_ROWS: readonly FreeRow[] = [
+  { id: "cohere/north-mini-code:free", ctx: 256_000, out: 64_000 },
+  { id: "dots-studio/dots-3-note-preview:free", ctx: 512_000, out: 460_800, vision: true },
+  { id: "google/gemma-4-26b-a4b-it:free", ctx: 262_144, out: 32_768, vision: true },
+  { id: "google/gemma-4-31b-it:free", ctx: 262_144, out: 32_768, vision: true },
+  { id: "liquid/lfm-2.5-2.6b:free", ctx: 65_536, out: 8_192 },
+  { id: "minimax/minimax-m3.1-flash:free", ctx: 1_000_000, out: 524_288, vision: true },
+  {
+    id: "nvidia/nemotron-3-nano-omni-30b-a3b-reasoning:free",
+    ctx: 256_000,
+    out: 65_536,
+    vision: true,
+  },
+  { id: "nvidia/nemotron-3-super-120b-a12b:free", ctx: 262_144, out: 235_929 },
+  { id: "nvidia/nemotron-3-ultra-550b-a55b:free", ctx: 1_000_000, out: 65_536 },
+  {
+    id: "nvidia/nemotron-3.5-content-safety:free",
+    ctx: 128_000,
+    out: 8_192,
+    vision: true,
+    toolCall: false,
+  },
+  { id: "nvidia/nemotron-3.5-lightning:free", ctx: 1_000_000, out: 65_536 },
+  { id: "nvidia/nemotron-3.5-super-vl:free", ctx: 1_000_000, out: 131_072, vision: true },
+  { id: "poolside/laguna-s-2.1:free", ctx: 262_144, out: 32_768 },
+  { id: "poolside/laguna-xs-2.1:free", ctx: 262_144, out: 32_768 },
+  { id: "thinkingmachines/inkling-small:free", ctx: 1_048_576, out: 262_144, vision: true },
+  { id: "thinkingmachines/inkling:free", ctx: 1_048_576, out: 262_144, vision: true },
+  { id: "xingchen-agi/xing4.0-29b-a4b:free", ctx: 262_144, out: 235_929 },
+];
+
+/** Builds this roster for one provider, since each spells its own endpoint. */
+export function openrouterFreeRoster(options: FreeRosterOptions): readonly ModelDefinition[] {
+  return FREE_ROWS.map((row) =>
+    defineModel({
+      id: row.id,
+      providerId: options.providerId,
+      wireFamily: "chat",
+      endpoint: options.endpoint,
+      ctx: row.ctx,
+      out: row.out,
+      vision: row.vision ?? false,
+      reasoning: true,
+      toolCall: row.toolCall ?? true,
+      // `free` is the billing statement and `freeTier` the catalog one. The
+      // `:free` suffix makes both true, and the model list groups on the tier.
+      free: true,
+      freeTier: true,
+    }),
+  );
+}

package/src/providers/discovery/probe-wire.ts

@@ -172,17 +172,41 @@ export function staticEndpointForWire(
   return catalog.get(providerId)?.find((def) => def.wireFamily === wireFamily)?.endpointPath;
 }
 
+/**
+ * Compiled-pattern memo.
+ *
+ * `matchModelWireFamily` runs per model on every discovery pass and on every
+ * manual registration, and it used to compile each rule's `RegExp` inside that
+ * loop — so the same handful of patterns were recompiled once per model per
+ * pass. Keyed by the pattern source, which is exactly what `new RegExp(source)`
+ * derives from.
+ *
+ * A pattern that fails to compile is not memoized; the tolerance stays at read
+ * time because an invalid pattern is rejected at write time, and a stored one
+ * must not throw during a listing.
+ */
+const compiledPatternCache = new Map<string, RegExp>();
+
+function compilePattern(pattern: string): RegExp | undefined {
+  const cached = compiledPatternCache.get(pattern);
+  if (cached !== undefined) return cached;
+  try {
+    const compiled = new RegExp(pattern);
+    compiledPatternCache.set(pattern, compiled);
+    return compiled;
+  } catch {
+    return undefined;
+  }
+}
+
 function matchModelWireFamily(
   modelId: string,
   rules: ReadonlyArray<{ pattern: string; wire_family: WireFamily }> | undefined,
 ): WireFamily | undefined {
   if (!rules?.length) return undefined;
   for (const rule of rules) {
-    try {
-      if (new RegExp(rule.pattern).test(modelId)) return rule.wire_family as WireFamily;
-    } catch {
-      // Invalid pattern is rejected at write time; be tolerant at read time.
-    }
+    const pattern = compilePattern(rule.pattern);
+    if (pattern !== undefined && pattern.test(modelId)) return rule.wire_family as WireFamily;
   }
   return undefined;
 }