cartethyia 2.4.6 → 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),
@@ -324,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
@@ -339,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(),
@@ -347,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/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,
+    }),
+  );
+}