cartethyia 2.7.5 → 2.7.6

package/src/providers/integrations/github/github-oauth.ts

@@ -29,13 +29,31 @@ import type { OAuthTokenRefreshResult } from "../../authentication/oauth-refresh
 import { OAuthDeviceFlow } from "../../authentication/oauth-device-flow";
 import type { FetchLike } from "../../authentication/oauth-client";
 import { resolveGithubEnterpriseDomain } from "../../../config/providers";
+import { randomUUID, createHash } from "node:crypto";
+import { getOrCreateInstallId } from "../shared/install-id";
 
 
 /** Public GitHub OAuth app id the Copilot clients use; not a secret. */
 export const GITHUB_CLIENT_ID = "Iv1.b507a08c87ecfe98" as const;
+/** The OpenCode desktop client's own GitHub OAuth app id (used by its Copilot integration). */
+export const GITHUB_OPENCODE_CLIENT_ID = "Ov23li8tweQw6odWQebz" as const;
 export const GITHUB_ACCESS_TOKEN_URL = "https://github.com/login/oauth/access_token" as const;
 /** Default API host when a token carries no `proxy-ep` claim. */
 export const GITHUB_DEFAULT_API_HOST = "api.individual.githubcopilot.com" as const;
+/**
+ * The Copilot API host OpenCode's integration uses. The reference plugin always
+ * dials `api.githubcopilot.com` for GitHub.com (never the per-claim
+ * `api.individual.*` host the VS Code minted tokens carry), so an OpenCode
+ * login pins this host rather than falling back to the VS Code default.
+ */
+export const GITHUB_OPENCODE_API_HOST = "api.githubcopilot.com" as const;
+/**
+ * How long an OpenCode login's credential is treated as valid before the
+ * refresh sweep revisits it. The raw GitHub OAuth token has no Copilot token
+ * expiry (there is no minted token), so this is a far-future safeguard, not a
+ * real lifetime: a re-login or upstream expiry is what actually rotates it.
+ */
+const GITHUB_OPENCODE_TOKEN_LIFETIME_MS = 365 * 24 * 60 * 60 * 1000;
 
 /**
  * Headers every Copilot inference and policy request must carry.
@@ -55,6 +73,52 @@ export const GITHUB_REQUEST_HEADERS: Readonly<Record<string, string>> = Object.f
   "x-github-api-version": "2026-08-01",
 });
 
+/**
+ * Stable per-process Copilot session id.
+ *
+ * The reference extension (`_mixinHeaders`) stamps `VScode-SessionId` with the
+ * VS Code window session and `VScode-MachineId` with the machine id. There is
+ * no VS Code window here, so the closest 1:1 shapes are: a session id minted
+ * once per gateway process (a new window = a new process in the reference), and
+ * a stable per-installation identity for the machine id.
+ */
+export const GITHUB_COPILOT_SESSION_ID = randomUUID();
+
+/**
+ * Resolves the Copilot client identity headers shared by chat/auto/discovery.
+ *
+ * The machine id is derived deterministically from the persisted install id and
+ * an account fingerprint when one is provided. The reference extension uses one
+ * machine id per VS Code installation for every account, but this gateway pools
+ * many accounts on one host — sharing one id across all of them makes every
+ * account look like a single device (an easy clustering/abuse signal). A
+ * per-account machine id keeps each account looking like its own device while
+ * staying stable across restarts for the same account. Without an account key
+ * (e.g. credential could not be parsed) the raw install id is used.
+ */
+export async function githubCopilotClientIds(
+  accountKey?: string,
+): Promise<{
+  readonly sessionId: string;
+  readonly machineId: string;
+}> {
+  const installId = await getOrCreateInstallId("github");
+  const machineId =
+    accountKey === undefined || accountKey.length === 0
+      ? installId
+      : deterministicMachineId(installId, accountKey);
+  return {
+    sessionId: GITHUB_COPILOT_SESSION_ID,
+    machineId,
+  };
+}
+
+/** Stable UUID-shaped machine id derived from the install id and an account key. */
+export function deterministicMachineId(installId: string, accountKey: string): string {
+  const digest = createHash("sha256").update(`${installId}:${accountKey}`).digest("hex");
+  return `${digest.slice(0, 8)}-${digest.slice(8, 12)}-${digest.slice(12, 16)}-${digest.slice(16, 20)}-${digest.slice(20, 32)}`;
+}
+
 const DEVICE_INTERVAL_SECONDS = 5;
 const DEVICE_EXPIRY_SECONDS = 900;
 /** Copilot tokens are short-lived; a missing `expires_at` falls back to 25 minutes. */
@@ -196,17 +260,80 @@ async function fetchGitHubLogin(
   }
 }
 
+interface CopilotUserProfile {
+  readonly chat_enabled?: boolean;
+  readonly can_signup_for_limited?: boolean;
+}
+
+/**
+ * Reads the Copilot entitlement profile for a freshly approved GitHub token.
+ *
+ * OAuth itself succeeds for any GitHub account; entitlement is the only signal
+ * that the account can chat. Mirrors the reference OpenCode provider: an
+ * explicit `chat_enabled: false` is a denial (the account is not signed up or
+ * has no seat), and a failed/malformed lookup must not turn a GitHub hiccup
+ * into a denial — only an explicit answer blocks login.
+ */
+async function fetchGitHubCopilotEntitlement(
+  githubAccessToken: string,
+  domain: string,
+  fetchFn: FetchLike,
+  signal: AbortSignal,
+): Promise<{ denied: string } | { denied?: undefined }> {
+  try {
+    const endpoint =
+      domain === "github.com"
+        ? "https://api.github.com/copilot_internal/user"
+        : `https://api.${domain}/copilot_internal/user`;
+    const response = await fetchFn(endpoint, {
+      headers: {
+        accept: "application/json",
+        authorization: `Bearer ${githubAccessToken}`,
+        "user-agent": GITHUB_REQUEST_HEADERS["user-agent"]!,
+        "x-github-api-version": "2025-04-01",
+      },
+      signal,
+    });
+    if (!response.ok) return { denied: undefined };
+    const profile = record(await response.json()) as CopilotUserProfile | undefined;
+    if (profile?.chat_enabled === false) {
+      if (profile.can_signup_for_limited) {
+        return {
+          denied:
+            "This GitHub account is not signed up for GitHub Copilot. Sign up for Copilot Free at https://github.com/features/copilot/plans and connect again.",
+        };
+      }
+      return {
+        denied:
+          "This GitHub account does not have GitHub Copilot access. It needs an active Copilot subscription or a seat assigned by an organization.",
+      };
+    }
+    return { denied: undefined };
+  } catch {
+    // Entitlement is a gate, not a reliability dependency: a network glitch
+    // here must not lock out an account that did approve the login.
+    return { denied: undefined };
+  }
+}
+
 export class GithubOAuthClient extends OAuthDeviceFlow {
   override readonly supportsDeviceCode = true;
   override readonly supportsBrowserCode = false;
 
   protected override readonly providerLabel = "GitHub Copilot";
-  protected override readonly clientId = GITHUB_CLIENT_ID;
   protected override readonly tokenUrl = GITHUB_ACCESS_TOKEN_URL;
   protected override readonly scopes = "read:user";
 
-  constructor(fetchFn: FetchLike = globalThis.fetch) {
+  /** Which GitHub OAuth app this flow presents. Defaults to the Copilot Chat
+   *  extension's app; OpenCode's own app differs (`GITHUB_OPENCODE_CLIENT_ID`). */
+  protected override readonly clientId: string;
+
+  constructor(
+    fetchFn: FetchLike = globalThis.fetch,
+    clientId: string = GITHUB_CLIENT_ID,
+  ) {
     super(fetchFn);
+    this.clientId = clientId;
   }
 
   override async startDeviceAuth(_context?: OAuthDeviceFlowContext): Promise<OAuthDeviceStartResult> {
@@ -218,7 +345,7 @@ export class GithubOAuthClient extends OAuthDeviceFlow {
         "content-type": "application/x-www-form-urlencoded",
         "user-agent": GITHUB_REQUEST_HEADERS["user-agent"]!,
       },
-      body: new URLSearchParams({ client_id: GITHUB_CLIENT_ID, scope: "read:user" }),
+      body: new URLSearchParams({ client_id: this.clientId, scope: "read:user" }),
     });
     const body = record(await readJsonResponse(response, "GitHub device authorization"));
     const deviceCode = nonEmptyTrimmedString(body?.device_code);
@@ -272,7 +399,7 @@ export class GithubOAuthClient extends OAuthDeviceFlow {
         "user-agent": GITHUB_REQUEST_HEADERS["user-agent"]!,
       },
       body: new URLSearchParams({
-        client_id: GITHUB_CLIENT_ID,
+        client_id: this.clientId,
         device_code: deviceAuthId,
         grant_type: "urn:ietf:params:oauth:grant-type:device_code",
       }),
@@ -315,21 +442,48 @@ export class GithubOAuthClient extends OAuthDeviceFlow {
           : `GitHub device polling failed (${response.status})`;
       return { status: "failed", reason };
     }
-    let minted;
+    let minted: Awaited<ReturnType<typeof mintGithubToken>> | undefined;
     try {
-      minted = await mintGithubToken(githubToken, domain, this.fetchFn);
+      // OAuth succeeds for any GitHub account; the entitlement profile is the
+      // only signal that the account can actually chat. An explicit denial is
+      // surfaced as a failed verdict before any token is minted or stored,
+      // mirroring the reference OpenCode provider.
+      const entitlement = await fetchGitHubCopilotEntitlement(
+        githubToken,
+        domain,
+        this.fetchFn,
+        AbortSignal.timeout(10_000),
+      );
+      if (entitlement.denied !== undefined) {
+        return { status: "failed", reason: entitlement.denied };
+      }
+      // OpenCode's OAuth app is the client the `opencode-copilot` wire mode
+      // presents upstream, and that mode uses the raw GitHub token directly —
+      // no minted Copilot token. The VS Code mint endpoint
+      // (`/copilot_internal/v2/token`) rejects non-VS-Code client ids with 403
+      // (GitHub's anti-scraping gate), so an OpenCode login must not mint.
+      if (this.clientId !== GITHUB_OPENCODE_CLIENT_ID) {
+        minted = await mintGithubToken(githubToken, domain, this.fetchFn);
+      }
     } catch (error) {
       // The mint runs after approval: surface its reason as a failed verdict,
       // not an exception that escapes the dashboard's poll request.
       return { status: "failed", reason: error instanceof Error ? error.message : "GitHub Copilot token mint failed" };
     }
     const label = await fetchGitHubLogin(githubToken, domain, this.fetchFn, AbortSignal.timeout(10_000));
+    const access = minted === undefined ? githubToken : minted.access;
+    const apiHost = minted === undefined ? GITHUB_OPENCODE_API_HOST : minted.apiHost;
+    const expiresAt =
+      minted === undefined
+        ? new Date(Date.now() + GITHUB_OPENCODE_TOKEN_LIFETIME_MS)
+        : minted.expiresAt;
     const result: OAuthExchangeResult = {
-      access: encodeGithubCredential(minted.access, minted.apiHost, githubToken),
+      access: encodeGithubCredential(access, apiHost, githubToken),
       // The GitHub token is the refresh value: it is what re-mints the Copilot
-      // token, which expires on its own much shorter clock.
+      // token (VS Code app) or is the raw credential itself (OpenCode app),
+      // depending on which app the flow presented.
       refresh: githubToken,
-      expiresAt: minted.expiresAt,
+      expiresAt,
       ...(label === undefined ? {} : { accountLabel: label }),
     };
     return { status: "complete", result };
@@ -337,6 +491,21 @@ export class GithubOAuthClient extends OAuthDeviceFlow {
 
 
   override async refresh(refreshToken: string, signal?: AbortSignal): Promise<OAuthTokenRefreshResult> {
+    // OpenCode's app uses the raw GitHub token directly — there is no minted
+    // Copilot token to re-mint, and the VS Code mint endpoint rejects the
+    // OpenCode client id. Refresh is then a no-op that keeps the credential
+    // valid on its far-future lifetime.
+    if (this.clientId === GITHUB_OPENCODE_CLIENT_ID) {
+      return {
+        access: encodeGithubCredential(
+          refreshToken,
+          GITHUB_OPENCODE_API_HOST,
+          refreshToken,
+        ),
+        refresh: refreshToken,
+        expiresAt: new Date(Date.now() + GITHUB_OPENCODE_TOKEN_LIFETIME_MS),
+      };
+    }
     const minted = await mintGithubToken(
       refreshToken,
       copilotGitHubDomain(),

package/src/providers/integrations/github/github.ts

@@ -23,14 +23,16 @@ import { allParts, type CanonicalEvent, type CanonicalRequest, type ContentPart
 import { OpenAICompatibleAdapter, withBearerAuthentication } from "../../adapters/compatible-adapter";
 import { postUpstreamJson } from "../../../protocol/upstream/post-json";
 import { providerBaseUrl } from "../../provider-metadata";
-import { getOrCreateInstallId } from "../shared/install-id";
 import { resolveRedisClient } from "../../../persistence/redis";
 import { applyParamQuirks } from "../../../protocol/translation/quirks";
 import { resolveInboundSessionId } from "../../operations/session-resolution";
 import {
   GITHUB_REQUEST_HEADERS,
+  githubCopilotClientIds,
   parseGithubCredential,
+  type GithubCredential,
 } from "./github-oauth";
+import { resolveGithubCopilotMode } from "../../../config/providers";
 
 export const GITHUB_PROVIDER_ID = "github" as const;
 
@@ -502,6 +504,36 @@ class GithubAdapter extends OpenAICompatibleAdapter {
     );
   }
 
+  /**
+   * Minimal OpenCode-style Copilot headers using the long-lived GitHub OAuth
+   * token directly (no minted Copilot token, no VS Code identity). This is
+   * the shape the official OpenCode plugin sends; proven live (2026-11-03):
+   *
+   * - POST /auto with these headers + the raw GitHub token -> 200, returns the
+   *   session token and selects gpt-6-luna;
+   * - POST /responses with `Copilot-Session-Token` + GitHub token -> 200 stream.
+   */
+  async #opencodeStyleHeaders(
+    context: ProviderDispatchContext,
+    request: CanonicalRequest,
+    credential: GithubCredential,
+  ): Promise<Record<string, string>> {
+    const headers: Record<string, string> = {
+      "content-type": "application/json",
+      "user-agent": "opencode/0.1.0",
+      "openai-intent": "conversation-edits",
+      "x-github-api-version": "2026-08-01",
+      "x-interaction-type": "conversation-agent",
+      "x-interaction-id": randomUUID(),
+      "x-initiator": isAgentInitiated(request) ? "agent" : "user",
+      "x-request-id": context.request_id ?? randomUUID(),
+    };
+    if (credential.github !== undefined && credential.github.length > 0) {
+      headers.authorization = `Bearer ${credential.github}`;
+    }
+    return headers;
+  }
+
   async #selectAutoModel(
     prompt: string,
     tier: "efficiency" | "balance" | "intelligence",
@@ -510,13 +542,24 @@ class GithubAdapter extends OpenAICompatibleAdapter {
     candidate: ProviderDispatchTarget,
     context: ProviderDispatchContext,
   ): Promise<GithubAutoDecision> {
-    const headers = await this.prepareHeaders(context, request, candidate);
     const credential = context.credential.secret === undefined
       ? undefined
       : parseGithubCredential(new TextDecoder().decode(context.credential.secret));
     if (credential === undefined) {
       throw new GatewayError("authentication_failed", 401, "GitHub Copilot credential is missing (request {requestId}). Wrong key, right door — check the credential 🔑");
     }
+    // `opencode-copilot` mode (default): raw GitHub token + minimal headers,
+    // proven the most stable (single token, no mint expiry). The reference
+    // mode (`vscode-client-real`) uses the minted Copilot token + full VS Code
+    // headers — but a stale/expired minted token fails with 403 and the
+    // reference headers on /auto can answer 400 "invalid apiVersion" unless the
+    // minted token is fresh, so the default stays opencode.
+    const headers =
+      resolveGithubCopilotMode() === "opencode-copilot" &&
+      credential.github !== undefined &&
+      credential.github.length > 0
+        ? await this.#opencodeStyleHeaders(context, request, credential)
+        : await this.prepareHeaders(context, request, candidate);
     const payload: Record<string, unknown> = { prompt, tier };
     if (hasImage) payload.has_image = true;
     const outboundFetch = context.outbound_fetch ?? this.#fetch ?? globalThis.fetch;
@@ -648,20 +691,64 @@ class GithubAdapter extends OpenAICompatibleAdapter {
     // it and wins — the route-level User-Agent is for generic OpenAI-compatible
     // hosts and would be rejected here.
     Object.assign(headers, GITHUB_REQUEST_HEADERS);
+    const secret = context.credential.secret;
+    let parsedCredential: ReturnType<typeof parseGithubCredential> | undefined;
+    if (secret !== undefined && secret.length > 0) {
+      try {
+        parsedCredential = parseGithubCredential(new TextDecoder().decode(secret));
+      } catch {
+        // Unparseable credential; fall back to the reference identity below.
+      }
+    }
     const autoSessionToken = this.#autoSessionTokens.get(request);
-    if (autoSessionToken !== undefined) {
+    // Auto-selected requests stream behind the session token. In the default
+    // `opencode-copilot` mode (raw GitHub token + minimal headers, proven 200
+    // on /auto and /responses), the whole request uses the OpenCode shape. The
+    // reference mode (`vscode-client-real`) keeps the reference identity and
+    // the minted Copilot token.
+    if (autoSessionToken !== undefined && parsedCredential?.github !== undefined) {
+      if (resolveGithubCopilotMode() === "opencode-copilot") {
+        const opencode = await this.#opencodeStyleHeaders(context, request, parsedCredential);
+        for (const key of Object.keys(headers)) delete headers[key];
+        Object.assign(headers, opencode);
+        headers["Copilot-Session-Token"] = autoSessionToken;
+        return headers;
+      }
+      headers["Copilot-Session-Token"] = autoSessionToken;
+    } else if (autoSessionToken !== undefined) {
       headers["Copilot-Session-Token"] = autoSessionToken;
     }
     const requestId = context.request_id ?? randomUUID();
+    // Reference (`_mixinHeaders` + request path): the interaction id is a
+    // separate value from the request id (`X-Request-Id`), and the Copilot
+    // client identity is stamped as `VScode-SessionId`/`VScode-MachineId`.
+    // The library version header carries the fetcher library id (`node-http`
+    // etc.), not the extension version — we previously sent the extension
+    // version there, which the upstream reads as a different client fingerprint.
+    const interactionId = randomUUID();
+    // Machine id is per-account (stable derive from install id + account
+    // fingerprint), so a pooled gateway does not make every account look like
+    // one device.
+    const accountKey =
+      parsedCredential === undefined
+        ? undefined
+        : createHash("sha256")
+            .update(`${parsedCredential.apiHost}:${parsedCredential.access}`)
+            .digest("hex");
+    const { sessionId, machineId } = await githubCopilotClientIds(accountKey);
     Object.assign(headers, {
-      "editor-device-id": await getOrCreateInstallId("github"),
+      "editor-device-id": machineId,
+      "VScode-MachineId": machineId,
+      "VScode-SessionId": sessionId,
       "openai-intent": "conversation-agent",
+      // Reference stamps `Openai-Organization` on HTTP chat requests.
+      ...(candidate?.wire_family === "chat" ? { "Openai-Organization": "github-copilot" } : {}),
       "x-agent-task-id": requestId,
-      "x-interaction-id": requestId,
+      "x-interaction-id": interactionId,
       "x-initiator": isAgentInitiated(request) ? "agent" : "user",
       "x-interaction-type": "conversation-agent",
       "x-request-id": requestId,
-      "x-vscode-user-agent-library-version": "vscode-chat/0.72.0",
+      "x-vscode-user-agent-library-version": "node-http",
     });
     // The copy Claude family is served on the native Anthropic Messages wire,
     // which gates feature betas behind `anthropic-beta` (mirroring the
@@ -676,14 +763,8 @@ class GithubAdapter extends OpenAICompatibleAdapter {
     } else {
       delete headers["copilot-vision-request"];
     }
-    const secret = context.credential.secret;
-    if (secret === undefined || secret.length === 0) return headers;
-    try {
-      const { access } = parseGithubCredential(new TextDecoder().decode(secret));
-      headers.authorization = `Bearer ${access}`;
-    } catch {
-      // Left as the factory sent it: the request fails closed at the upstream
-      // auth boundary, and the parse error belongs to the credential boundary.
+    if (parsedCredential !== undefined) {
+      headers.authorization = `Bearer ${parsedCredential.access}`;
     }
     return headers;
   }

package/src/providers/integrations/kiro/kiro.ts

@@ -52,7 +52,6 @@ import {
 } from "./kiro-request";
 import { machineIdForAuthState } from "./kiro-machine-id";
 import { estimateKiroSessionCache } from "./kiro-cache";
-import { applyCacheMode } from "../../provider-usage";
 import { resolveKiroProfileArn } from "./kiro-profile";
 import {
   AWS_REGION_PATTERN,
@@ -284,7 +283,7 @@ function kiroUsage(
   // The runtime never reports cache hits; close the gap with our own history.
   // A genuine ( >0) report conserves the complete record. Then the operator's
   // cache mode decides whether a hit makes the whole input count as cached.
-  return applyCacheMode(estimateKiroSessionCache(record, sessionId, messages));
+  return estimateKiroSessionCache(record, sessionId, messages);
 }
 
 /**

package/src/providers/integrations/qoder/qoder-catalog.ts

@@ -126,7 +126,13 @@ export const QODER_CN_MODEL_CONFIGS: Readonly<Record<string, QoderModelConfig>>
  * `qmodel` carries a 1M window. That is why the rosters are not merged.
  */
 export const QODER_INTL_MODEL_CONFIGS: Readonly<Record<string, QoderModelConfig>> = {
-  auto: { id: "auto", display_name: "Auto", max_input_tokens: 200000, max_output_tokens: 64_000, is_vl: true, is_reasoning: false },
+  // Every row declares its *maximum selectable* window (1M), not the currently
+  // active one: Qoder publishes a `context_config` of selectable windows per
+  // row (1M/400K/200K/…), and the adapter dispatches the widest
+  // (`qoderMaxContextFor`). The live list's `max_input_tokens` only names the
+  // currently-selected window (often 180K/200K), which is not a ceiling —
+  // declaring that would cap a conversation a 1M-capable account could run.
+  auto: { id: "auto", display_name: "Auto", max_input_tokens: 1000000, max_output_tokens: 64_000, is_vl: true, is_reasoning: false },
   ultimate: { id: "ultimate", display_name: "Ultimate", max_input_tokens: 1000000, max_output_tokens: 128_000, is_vl: true, is_free: false, is_reasoning: true },
   // `fast` is what the live roster reports today; `performance` is the older
   // key for the same slot. Both are kept so a hand-added model id written
@@ -134,7 +140,7 @@ export const QODER_INTL_MODEL_CONFIGS: Readonly<Record<string, QoderModelConfig>
   // discovery supersedes it on the first successful fetch.
   fast: { id: "fast", display_name: "Fast", max_input_tokens: 1000000, max_output_tokens: 64_000, is_vl: true, is_reasoning: false },
   performance: { id: "performance", display_name: "Performance", max_input_tokens: 1000000, max_output_tokens: 64_000, is_vl: true, is_reasoning: false },
-  efficient: { id: "efficient", display_name: "Efficient", max_input_tokens: 200000, max_output_tokens: 64_000, is_vl: true, is_reasoning: false },
+  efficient: { id: "efficient", display_name: "Efficient", max_input_tokens: 1000000, max_output_tokens: 64_000, is_vl: true, is_reasoning: false },
   // Sonus/Cantus need an explicit effort on the IDE surface; without it the
   // upstream streams text only, no reasoning (verified live). DeepSeek-family
   // models think by default and are left untouched.
@@ -152,7 +158,7 @@ export const QODER_INTL_MODEL_CONFIGS: Readonly<Record<string, QoderModelConfig>
   // Live roster (2026-11-01) reports dfmodel as billed (is_free false); it was
   // previously marked free. Display names are corrected from the same capture.
   dfmodel: { id: "dfmodel", display_name: "DeepSeek-Flash", max_input_tokens: 1000000, max_output_tokens: 384_000, is_vl: true, is_free: false, is_reasoning: true },
-  mmodel: { id: "mmodel", display_name: "MiniMax-M3.1-Flash", max_input_tokens: 1000000, max_output_tokens: 512_000, is_vl: true, is_free: false, is_reasoning: false },
+  mmodel: { id: "mmodel", display_name: "MiniMax-M3.1-Flash", max_input_tokens: 1000000, max_output_tokens: 512_000, is_vl: true, is_free: false, is_reasoning: true },
   // `lite` is the free-tier plan package: same 1M window and multimodal input
   // as `qmodel` (Qwen3.7-Plus), capped at 64k output, free tier.
   lite: { id: "lite", display_name: "Lite-Qwen-3.7-Plus", max_input_tokens: 1000000, max_output_tokens: 65_536, is_vl: true, is_free: true, is_reasoning: false },