cartethyia 2.7.5 → 2.7.6

package/src/persistence/stores/api-key-store.ts

@@ -1,6 +1,6 @@
 // Persisted API-key store: the console API-key domain and gateway authentication both consume this boundary.
 
-import { and, asc, count, desc, eq, inArray, isNotNull, isNull, lte, or, sql, type SQL } from "drizzle-orm";
+import { and, asc, count, desc, eq, gt, inArray, isNotNull, isNull, lte, or, sql, type SQL } from "drizzle-orm";
 import { nextSortIndex, reorderSortIndex, type SortOrderDb } from "../sort-order";
 import { getDbHandle } from "../boot";
 import type { CartethyiaDatabase } from "../db-handle";
@@ -253,6 +253,8 @@ async function writeSharePopup(
 /** Explicit persistence boundary. Production must provide this; there is no fallback store. */
 export interface ApiKeyStore {
   list(tenantId: string): Promise<readonly ApiKeyRecord[]>;
+  /** Active, non-revoked bans for one tenant, including share children. */
+  listActiveBanned(tenantId: string): Promise<readonly ApiKeyRecord[]>;
   get(tenantId: string, keyId: string): Promise<ApiKeyRecord | undefined>;
   listChildren(tenantId: string, parentKeyId: string): Promise<readonly ApiKeyRecord[]>;
   revokeChildrenByScope(
@@ -382,6 +384,22 @@ export class DrizzleApiKeyStore implements ApiKeyStore {
       .limit(1000);
     return this.withPopups(this.db, rows);
   }
+  async listActiveBanned(tenantId: string): Promise<readonly ApiKeyRecord[]> {
+    const now = new Date();
+    const rows = await this.db
+      .select()
+      .from(apiKeys)
+      .where(
+        and(
+          eq(apiKeys.tenantId, tenantId),
+          isNotNull(apiKeys.bannedAt),
+          isNull(apiKeys.revokedAt),
+          or(isNull(apiKeys.bannedUntil), gt(apiKeys.bannedUntil, now)),
+        ),
+      )
+      .orderBy(desc(apiKeys.bannedAt), apiKeys.id);
+    return rows.map((row) => this.map(row));
+  }
 
   /** Rewrites the list order for one tenant; `keyIds` is the full order. */
   async reorder(tenantId: string, keyIds: readonly string[]): Promise<void> {

package/src/protocol/dsml.ts

@@ -3,21 +3,11 @@
  *
  * DeepSeek-family models occasionally write their tool calls as XML-like DSML
  * markup inside the plain-text content stream instead of the structured
- * `tool_calls` field. Two upstream families in this gateway see it:
+ * `tool_calls` field. The gateway sees it from one upstream family:
  *
  * - CodeBuddy/WorkBuddy emit strict blocks (`<｜DSML｜ calls>…</｜DSML｜ calls>`)
  *   that must be parsed exactly, with declared-tool allowlisting.
- * - Qoder emits looser blocks (`<[^>]*DSML[^>]*calls>…`) that tolerate any
- *   intermediate characters in the tag, and its parameter values are plain
- *   strings.
- *
- * The two share the same recovery idea, so the mechanics live here once and
- * each caller picks its dialect through options. The defaults reproduce the
- * CodeBuddy dialect exactly (`app/dsml.py` in codebuddy2api); Qoder passes
- * `fuzzy: true` and its id factory, mirroring `qoder_proxy.py`.
  */
-import { randomUUID } from "node:crypto";
-
 export interface DsmlToolCall {
   readonly id: string;
   readonly name: string;
@@ -34,19 +24,15 @@ export interface DsmlParseOptions {
   readonly separators?: readonly string[];
   /** Block names a strict opener may name. */
   readonly blockNames?: readonly string[];
-  /** When true, match the Qoder fuzzy form (`<[^>]*DSML[^>]*…`). */
-  readonly fuzzy?: boolean;
-  /** How parameter values decode: `json` (CodeBuddy) or `string` (Qoder). */
+  /** How parameter values decode: `json` (CodeBuddy) or `string`. */
   readonly params?: "json" | "string";
-  /** Call id factory. Defaults to sequential for strict, uuid for fuzzy. */
+  /** Call id factory. Defaults to sequential. */
   readonly id?: (call: { readonly name: string }, index: number, seq: number) => string;
   /** Non-empty allowlist makes the strict dialect reject undeclared names. */
   readonly allowedNames?: ReadonlySet<string>;
   /**
    * When true, JSON stringifies argument objects with recursively sorted keys,
-   * matching the reference bridge (`json.dumps(..., sort_keys=True)`). The
-   * strict dialect defaults to true; the fuzzy dialect never sorts, matching
-   * its reference's `json.dumps(params)`.
+   * matching the reference bridge (`json.dumps(..., sort_keys=True)`).
    */
   readonly sortKeys?: boolean;
   /**
@@ -75,10 +61,6 @@ function sequentialId(_call: { readonly name: string }, _index: number, seq: num
   return `call_dsml_${seq}_${_call.name}`;
 }
 
-function uuidId(_call: { readonly name: string }, _index: number, _seq: number): string {
-  return `call_${randomUUID().replace(/-/g, "").slice(0, 16)}`;
-}
-
 interface DsmlParseResult {
   readonly text: string;
   readonly calls: readonly DsmlToolCall[];
@@ -257,63 +239,11 @@ function normalizeForSort(value: unknown): unknown {
   return out;
 }
 
-/** The Qoder fuzzy block scanner, mirroring the reference bridge's regexes. */
-const FUZZY_CALLS_RE = /<[^>]*DSML[^>]*calls>([\s\S]*?)<\/[^>]*DSML[^>]*calls>/;
-const FUZZY_INVOKE_RE = /<[^>]*DSML[^>]*invoke\s+name=["']([^"']+)["']>([\s\S]*?)<\/[^>]*invoke>/g;
-const FUZZY_PARAM_RE = /<[^>]*DSML[^>]*parameter\s+name=["']([^"']+)["'][^>]*>([\s\S]*?)<\/[^>]*parameter>/g;
-
-function parseFuzzyDsml(text: string, options: DsmlParseOptions): DsmlRecovery {
-  const id = options.id ?? uuidId;
-  if (text.length === 0 || !text.includes("DSML")) return { calls: [], clean: text };
-
-  const callsMatch = FUZZY_CALLS_RE.exec(text);
-  let block: string;
-  let clean: string;
-
-  if (callsMatch) {
-    block = callsMatch[1] ?? "";
-    const before = text.slice(0, callsMatch.index).trimEnd();
-    const after = text.slice(callsMatch.index + callsMatch[0].length).trimStart();
-    clean = (before + " " + after).trim();
-  } else {
-    // No <calls> wrapper (issue #51): find bare <invoke> blocks in the whole
-    // text, then cut the prose off at the last `<` before the first invoke —
-    // exclusive of the invoke's own tag start, exactly like the reference's
-    // `text.rfind("<", 0, first_index)`.
-    FUZZY_INVOKE_RE.lastIndex = 0;
-    const first = FUZZY_INVOKE_RE.exec(text);
-    if (!first) return { calls: [], clean: text };
-    block = text;
-    const cut = text.lastIndexOf("<", first.index - 1);
-    clean = text.slice(0, cut >= 0 ? cut : first.index).trim();
-  }
-
-  const calls: DsmlToolCall[] = [];
-  FUZZY_INVOKE_RE.lastIndex = 0;
-  let inv: RegExpExecArray | null;
-  let seq = 0;
-  while ((inv = FUZZY_INVOKE_RE.exec(block)) !== null) {
-    const params: Record<string, string> = {};
-    FUZZY_PARAM_RE.lastIndex = 0;
-    let par: RegExpExecArray | null;
-    while ((par = FUZZY_PARAM_RE.exec(inv[2] ?? "")) !== null) {
-      params[par[1] ?? ""] = (par[2] ?? "").trim();
-    }
-    const call = { name: inv[1] ?? "", arguments: JSON.stringify(params) };
-    calls.push({ ...call, id: id(call, calls.length, seq++) });
-  }
-
-  return { calls, clean };
-}
-
 /**
- * Recovers DSML tool calls from one plain-text string. The dialect is chosen
- * by `options.fuzzy`; each dialect keeps its exact public shape:
+ * Recovers DSML tool calls from one plain-text string.
  *
  * - strict (CodeBuddy): returns `{ text, calls }`, with `text` the clean
  *   prose; `undefined` when nothing was recovered.
- * - fuzzy (Qoder): returns `{ clean, calls }`, with no-DSML input returning
- *   `{ calls: [], clean: text }`.
  *
  * Callers that need the streaming strict parser use {@link DsmlStreamParser}.
  */
@@ -321,7 +251,6 @@ export function parseDsmlToolCalls(
   text: string,
   options: DsmlParseOptions = {},
 ): DsmlRecovery | DsmlParseResult | undefined {
-  if (options.fuzzy === true) return parseFuzzyDsml(text, options);
   if (!text.includes("DSML")) return undefined;
   const parser = new DsmlStreamParser(options);
   const first = parser.push(text);

package/src/providers/adapters/compatible-adapter.ts

@@ -28,6 +28,19 @@ import {
 } from "../../protocol/codecs";
 const TEXT_DECODER = new TextDecoder("utf-8", { fatal: false });
 
+/**
+ * Provider ids that understand the OpenAI-style `service_tier` control. Only
+ * these upstreams accept the field; every other OpenAI-compatible provider
+ * either ignores it or rejects the whole request with `unsupported_value`
+ * (measured: GitHub Copilot returns 400). `service_tier` is advisory on the
+ * providers that do support it, so dropping it elsewhere is lossless.
+ */
+const SERVICE_TIER_SUPPORTED_PROVIDERS: ReadonlySet<string> = new Set([
+  "openai",
+  "codex",
+  "anthropic",
+]);
+
 /**
  * The subset of a canonical request a native-service header hook may read.
  *
@@ -279,6 +292,18 @@ export class OpenAICompatibleAdapter extends BaseProviderAdapter {
       }
     }
     this.config.prePayload?.(payload, effectiveRequest, candidate, context);
+    // `service_tier` is an OpenAI-style control that only a small set of
+    // upstreams understand. Every other OpenAI-compatible provider either
+    // ignores it silently or rejects the whole request with
+    // `unsupported_value` (measured: GitHub Copilot returns 400). Since the
+    // field is purely advisory on the providers that support it, dropping it
+    // everywhere else is safe and prevents avoidable upstream 400s.
+    if (
+      payload["service_tier"] !== undefined &&
+      !SERVICE_TIER_SUPPORTED_PROVIDERS.has(candidate.provider_id)
+    ) {
+      delete payload["service_tier"];
+    }
     return payload;
   }
 
@@ -429,12 +454,15 @@ export class OpenAICompatibleAdapter extends BaseProviderAdapter {
       // the absence of every completion shape so a provider that merely
       // echoes an `error` field alongside real output is not misread.
       const envelopeError = json["error"];
+      const startPlanError = this.provider_id === "zcode-start" &&
+        (json["success"] === false || (json["code"] !== undefined &&
+          ![0, 200, "0", "200"].includes(json["code"] as string | number)));
       const hasCompletionShape =
         json["choices"] !== undefined ||
         json["output"] !== undefined ||
         json["content"] !== undefined ||
         json["candidates"] !== undefined;
-      if (envelopeError !== undefined && envelopeError !== null && !hasCompletionShape) {
+      if (((envelopeError !== undefined && envelopeError !== null) || startPlanError) && !hasCompletionShape) {
         const errorObject = isRecord(envelopeError) ? envelopeError : json;
         const identifier = upstreamErrorIdentifier(json);
         const providerStatus = [

package/src/providers/default-registry.ts

@@ -239,8 +239,18 @@ export const PROVIDER_CAPABILITIES = {
     loadAuthentication: oauthCapability(() => import("./integrations/antigravity/antigravity-oauth"), "antigravityOAuthClient", { withRefresher: true }),
     loadQuotaCollector: quotaCapability(() => import("./integrations/antigravity/antigravity-quota"), "fetchAntigravityQuota"),
     loadModelDiscovery: async () => async ({ baseUrl, credential, fetcher }) => {
-      const { discoverAntigravityModels } = await import("./integrations/antigravity/antigravity-protocol");
-      return discoverAntigravityModels(credential, { baseUrl, ...(fetcher ? { fetcher } : {}) });
+      const { discoverAntigravityModels, loadAntigravityProject } = await import("./integrations/antigravity/antigravity-protocol");
+      // The reference client resolves the project before catalog calls; the
+      // live backend accepts both, but sending it matches the captured wire.
+      const projectId = await loadAntigravityProject(credential, {
+        ...(baseUrl === undefined ? {} : { baseUrl }),
+        ...(fetcher ? { fetcher } : {}),
+      }).catch(() => undefined);
+      return discoverAntigravityModels(credential, {
+        baseUrl,
+        ...(fetcher ? { fetcher } : {}),
+        ...(projectId === undefined ? {} : { projectId }),
+      });
     },
   },
   muse: {

package/src/providers/integrations/antigravity/antigravity-protocol.ts

@@ -96,7 +96,8 @@ interface AntigravityModelWireProfile {
 
 /**
  * `maxOutputTokens` the backend enforces per wire id (captured from the real
- * `antigravity/hub` client). Claude on `daily-cloudcode-pa` rejects
+ * `antigravity/hub` client and verified live against `fetchAvailableModels`
+ * on 2026-11-03). Claude on `daily-cloudcode-pa` rejects
  * `maxOutputTokens > 64000` with a `400 Request contains an invalid argument`
  * regardless of the thinking budget; Gemini SKUs accept their discovered
  * output ceiling. Keyed by the routed upstream wire id (post effort-routing),
@@ -106,22 +107,75 @@ interface AntigravityModelWireProfile {
 const ANTIGRAVITY_MODEL_WIRE_PROFILES: Readonly<
   Record<string, AntigravityModelWireProfile>
 > = Object.freeze({
-  // Anthropic on Antigravity caps at 64000 output tokens.
-  "claude-opus-4-6-thinking": { maxOutputTokens: 64000 },
-  "claude-sonnet-4-6": { maxOutputTokens: 64000 },
-  // Gemini effort-routed wire ids (real deployment names).
-  "gemini-3-flash-agent": {
-    modelEnum: "MODEL_PLACEHOLDER_M132",
+  // Anthropic on Antigravity caps at 64000 output tokens (verified live).
+  "claude-opus-4-6-thinking": {
+    modelEnum: "MODEL_PLACEHOLDER_M26",
+    maxOutputTokens: 64000,
+  },
+  "claude-sonnet-4-6": {
+    modelEnum: "MODEL_PLACEHOLDER_M35",
+    maxOutputTokens: 64000,
+  },
+  // Gemini SKUs, as the live roster publishes them (2026-11-03).
+  "gemini-2.5-flash": {
+    modelEnum: "MODEL_GOOGLE_GEMINI_2_5_FLASH",
+    maxOutputTokens: 65535,
+  },
+  "gemini-2.5-flash-thinking": {
+    modelEnum: "MODEL_GOOGLE_GEMINI_2_5_FLASH_THINKING",
+    maxOutputTokens: 65535,
+  },
+  "gemini-2.5-flash-lite": {
+    modelEnum: "MODEL_GOOGLE_GEMINI_2_5_FLASH_LITE",
+    maxOutputTokens: 65535,
+  },
+  "gemini-2.5-pro": {
+    modelEnum: "MODEL_GOOGLE_GEMINI_2_5_PRO",
+    maxOutputTokens: 65535,
+  },
+  "gemini-3-flash": {
+    modelEnum: "MODEL_PLACEHOLDER_M18",
     maxOutputTokens: 65536,
   },
-  "gemini-3.1-pro-low": {
-    modelEnum: "MODEL_PLACEHOLDER_M36",
+  "gemini-3.1-flash-lite": {
+    modelEnum: "MODEL_PLACEHOLDER_M50",
     maxOutputTokens: 65535,
   },
-  "gemini-pro-agent": {
-    modelEnum: "MODEL_PLACEHOLDER_M16",
+  "gemini-3.1-flash-image": {
+    modelEnum: "MODEL_PLACEHOLDER_M21",
+    maxOutputTokens: 65536,
+  },
+  "gemini-3.5-flash-lite": {
+    modelEnum: "MODEL_PLACEHOLDER_M198",
     maxOutputTokens: 65535,
   },
+  // Gemini 3.8 Flash effort tiers (real deployment names).
+  "gemini-3.8-flash-low": {
+    modelEnum: "MODEL_PLACEHOLDER_M320",
+    maxOutputTokens: 65536,
+  },
+  "gemini-3.8-flash-medium": {
+    modelEnum: "MODEL_PLACEHOLDER_M319",
+    maxOutputTokens: 65536,
+  },
+  "gemini-3.8-flash-high": {
+    modelEnum: "MODEL_PLACEHOLDER_M318",
+    maxOutputTokens: 65536,
+  },
+  "gemini-3.8-flash-tiered": {
+    modelEnum: "MODEL_PLACEHOLDER_M322",
+    maxOutputTokens: 65536,
+  },
+  // GPT-OSS via Antigravity (verified live).
+  "gpt-oss-120b-medium": {
+    modelEnum: "MODEL_OPENAI_GPT_OSS_120B_MEDIUM",
+    maxOutputTokens: 32768,
+  },
+  // Tab (laptop-class) preview SKU.
+  "tab_flash_lite_preview": {
+    modelEnum: "MODEL_PLACEHOLDER_M19",
+    maxOutputTokens: 4096,
+  },
 });
 
 export function getAntigravityModelWireProfile(
@@ -398,6 +452,7 @@ export async function discoverAntigravityModels(
     readonly baseUrl?: string;
     readonly fetcher?: typeof fetch;
     readonly signal?: AbortSignal;
+    readonly projectId?: string;
   } = {},
 ): Promise<readonly ModelDefinition[] | null> {
   const fetcher = options.fetcher ?? fetch;
@@ -419,7 +474,10 @@ export async function discoverAntigravityModels(
           "content-type": "application/json",
           "user-agent": getAntigravityUserAgent(),
         },
-        body: "{}",
+        // The reference client always sends the resolved project
+        // (`cloudCodeMainService.js`); the live backend accepts both, but the
+        // project is required for billing-gated endpoints.
+        body: JSON.stringify(options.projectId === undefined ? {} : { project: options.projectId }),
         signal,
       });
       if (!response.ok) continue;
@@ -489,9 +547,16 @@ export function applySkipThoughtSignatureBypass(
  * Sending the Gemini shape makes the backend treat the call as a different
  * client and refuse to enroll the account, which the operator sees as
  * "You do not have a valid license of this product".
+ *
+ * The reference client (`cloudCodeMainService.js`) sends the full product
+ * identity: `ideName`, `ideType`, and `ideVersion`. `ideType` alone was
+ * accepted live, but the full shape is the captured wire and avoids any
+ * client-class gating on the control plane.
  */
 export const ANTIGRAVITY_LOAD_CODE_ASSIST_METADATA = Object.freeze({
+  ideName: "antigravity",
   ideType: "ANTIGRAVITY",
+  ideVersion: getAntigravityVersion(),
 });
 
 const projectIdCache = new Map<string, string>();
@@ -570,7 +635,9 @@ const FREE_TIER_ID = "free-tier";
 const ONBOARD_USER_PATH = "/v1internal:onboardUser";
 const ONBOARD_OPERATIONS_PATH = "/v1internal";
 const ONBOARD_TIMEOUT_MS = 30_000;
-const ONBOARD_POLL_INTERVAL_MS = 1_000;
+// Reference client (`cloudCodeMainService.js`) polls the operation every
+// 500ms (`gXa = 500`).
+const ONBOARD_POLL_INTERVAL_MS = 500;
 
 /** Thrown when an account cannot be enrolled in the Antigravity free tier. */
 export class AntigravityProvisioningError extends Error {
@@ -699,6 +766,9 @@ async function onboardUser(
     if (left <= 0) throw new AntigravityProvisioningError("onboardUser timed out");
     return left;
   };
+  const projectId = extractProjectId(
+    await loadCodeAssist(fetcher, base, accessToken, signal),
+  );
   let operation = await cloudCodeAssistCall(
     fetcher,
     base,
@@ -706,7 +776,11 @@ async function onboardUser(
     ONBOARD_USER_PATH,
     {
       method: "POST",
-      body: { tierId: FREE_TIER_ID, metadata: ANTIGRAVITY_LOAD_CODE_ASSIST_METADATA },
+      body: {
+        tierId: FREE_TIER_ID,
+        ...(projectId === undefined ? {} : { cloudaicompanionProject: projectId }),
+        metadata: ANTIGRAVITY_LOAD_CODE_ASSIST_METADATA,
+      },
     },
     signal,
   );

package/src/providers/integrations/antigravity/antigravity-quota.ts

@@ -118,9 +118,6 @@ function keepWorse(
   return candidateRemaining < currentRemaining ? candidate : current;
 }
 
-/** Total the upstream's fractional allowance is normalized against. */
-const QUOTA_TOTAL = 1000;
-
 /** Builds a window from a `remainingFraction` + `resetTime` pair. */
 function fractionWindow(
   kind: string,
@@ -129,9 +126,8 @@ function fractionWindow(
   resetsAt: string | null,
 ): ProviderQuotaWindow {
   const fraction = Math.min(1, Math.max(0, remainingFraction));
-  const used = QUOTA_TOTAL - Math.round(QUOTA_TOTAL * fraction);
   return {
-    ...percentWindow(kind, label, (1 - fraction) * 100, resetsAt, used, QUOTA_TOTAL, "independent"),
+    ...percentWindow(kind, label, (1 - fraction) * 100, resetsAt, null, null, "independent"),
     recurring: true,
   };
 }
@@ -316,7 +312,23 @@ export async function fetchAntigravityQuota(
           ...(project === undefined ? {} : { project }),
         }),
       );
-      windows.push(...parseModelQuotas(models));
+      // The summary endpoint already covers a family with a weekly window; the
+      // per-model windows are a subset of that same allowance, so rendering
+      // both doubles every row the operator sees. Per-model windows stay as a
+      // fallback when the summary was unavailable, so a family still reports
+      // something.
+      const summaryLabels = windows.map((window) => window.label.toLowerCase());
+      // Model family key → the summary family label it falls under.
+      const summaryLabelForModel = (key: string): string =>
+        key === "google" ? "gemini" : "claude";
+      const modelWindows = parseModelQuotas(models);
+      windows.push(
+        ...modelWindows.filter((window) => {
+          const familyKey = window.kind.split(":")[0] ?? "";
+          const summaryLabel = summaryLabelForModel(familyKey);
+          return !summaryLabels.some((label) => label.includes(summaryLabel));
+        }),
+      );
       plan = plan ?? text(models.tier) ?? text(models.plan);
       break;
     } catch {

package/src/providers/integrations/antigravity/antigravity.ts

@@ -94,22 +94,26 @@ export const ANTIGRAVITY_MODELS: readonly ModelDefinition[] = [
   antigravityModel("claude-opus-4-6", 250_000, 64_000, true),
   antigravityModel("claude-sonnet-5-5", 1_000_000, 128_000, true),
   antigravityModel("claude-opus-5-5", 1_000_000, 128_000, true),
-  // Gemini text SKUs, as the Antigravity roster publishes them.
-  antigravityModel("gemini-2.5-flash", 1_000_000, 66_000, true),
-  antigravityModel("gemini-2.5-flash-thinking", 1_000_000, 66_000, true),
-  antigravityModel("gemini-3-flash", 1_000_000, 66_000, true),
-  antigravityModel("gemini-3.1-flash-lite", 1_000_000, 66_000, true),
-  antigravityModel("gemini-2.5-flash-lite", 1_000_000, 66_000, true),
-  antigravityModel("gemini-3.5-flash-lite", 1_000_000, 66_000, true),
-  antigravityModel("gemini-3.8-flash", 1_000_000, 66_000, true),
+  // Gemini text SKUs, as the Antigravity roster publishes them (verified live
+  // 2026-11-03): Gemini SKUs ceiling at 65535/65536 output tokens.
+  antigravityModel("gemini-2.5-flash", 1_000_000, 65_535, true),
+  antigravityModel("gemini-2.5-flash-thinking", 1_000_000, 65_535, true),
+  antigravityModel("gemini-2.5-flash-lite", 1_000_000, 65_535, true),
+  antigravityModel("gemini-2.5-pro", 1_000_000, 65_535, true),
+  antigravityModel("gemini-3-flash", 1_000_000, 65_536, true),
+  antigravityModel("gemini-3.1-flash-lite", 1_000_000, 65_535, true),
+  antigravityModel("gemini-3.5-flash-lite", 1_000_000, 65_535, true),
+  antigravityModel("gemini-3.8-flash", 1_000_000, 65_536, true),
   antigravityModel("gemini-4-argon", 1_000_000, 65_536, true),
   antigravityModel("gemini-4-carbon", 1_000_000, 65_536, true),
   // Tab (laptop-class) preview SKU.
   antigravityModel("tab_flash_lite_preview", 16_000, 4_000, true),
   // Gemini image generation. `gemini-3-pro-image` uses the same catalog
   // limits/capabilities as the existing `gemini-3.1-flash-image` row.
-  antigravityModel("gemini-3.1-flash-image", 200_000, 64_000, false, true),
-  antigravityModel("gemini-3-pro-image", 200_000, 64_000, false, true),
+  antigravityModel("gemini-3.1-flash-image", 65_536, 65_536, false, true),
+  antigravityModel("gemini-3-pro-image", 65_536, 65_536, false, true),
+  // GPT-OSS via Antigravity (verified live 2026-11-03).
+  antigravityModel("gpt-oss-120b", 131_072, 32_768, true),
 ];
 
 function normalizeAntigravityGrounding(data: unknown, maxResults: number): readonly WebSearchResult[] {
@@ -777,8 +781,13 @@ function antigravityThinkingBudget(modelId: string): number | undefined {
   return modelId.includes("3.1-pro") ? 10_001 : 10_000;
 }
 
+// Original reference instruction (captured from the Antigravity client):
+//   "You are Antigravity, a powerful agentic AI coding assistant designed by the Google Deepmind team working on Advanced Agentic Coding.You are pair programming with a USER to solve their coding task. The task may require creating a new codebase, modifying or debugging an existing codebase, or simply answering a question.**Absolute paths only****Proactiveness**"
+// Generalized to a neutral identity so the gateway does not impersonate the
+// vendor's branded assistant. The brand-specific wording is kept above for
+// reference; re-enable it if an upstream behavior ever depends on it.
 const ANTIGRAVITY_SYSTEM_INSTRUCTION =
-  "You are Antigravity, a powerful agentic AI coding assistant designed by the Google Deepmind team working on Advanced Agentic Coding.You are pair programming with a USER to solve their coding task. The task may require creating a new codebase, modifying or debugging an existing codebase, or simply answering a question.**Absolute paths only****Proactiveness**";
+  "You are a helpful assistant.";
 
 /**
  * Restatement appended as a trailing user turn when a Gemini route carries a

package/src/providers/integrations/cursor/cursor.ts

@@ -27,7 +27,6 @@ import type {
 } from "../../../protocol/canonical-model";
 import { resolveImageSource, splitDataUrl } from "../../../protocol/codecs";
 import { IMAGE_CLAMP_MAX_BYTES } from "../../../protocol/image-clamp";
-import { applyCacheMode } from "../../provider-usage";
 import type { ProviderAdapter, ProviderDispatchContext, ProviderDispatchTarget } from "../../provider-contracts";
 import { readCredentialSecret } from "../../provider-contracts";
 import type { Http2BidiEndReason, ValidatedHttp2BidiStream } from "../../../network/http2-bidi";
@@ -281,7 +280,7 @@ function usageFromTurnEnded(turnEnded: Record<string, unknown>): UsageRecord {
   const input = count(turnEnded["input_tokens"]);
   const output = count(turnEnded["output_tokens"]);
   const cacheRead = count(turnEnded["cache_read"]);
-  return applyCacheMode({
+  return {
     input_tokens: input,
     cached_input_tokens: cacheRead,
     cache_write_tokens: count(turnEnded["cache_write"]),
@@ -290,7 +289,7 @@ function usageFromTurnEnded(turnEnded: Record<string, unknown>): UsageRecord {
     reasoning_tokens: count(turnEnded["reasoning_tokens"]),
     estimated_cost: null,
     total_tokens: input + output,
-  });
+  };
 }
 
 function nonEmptyStringOf(value: unknown): string | undefined {

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

@@ -33,7 +33,8 @@ import {
   GITHUB_AUTO_MODELS,
   recordGithubModelRoutes,
 } from "./github";
-import { GITHUB_REQUEST_HEADERS, parseGithubCredential } from "./github-oauth";
+import { GITHUB_REQUEST_HEADERS, githubCopilotClientIds, parseGithubCredential } from "./github-oauth";
+import { createHash } from "node:crypto";
 
 /** A context window above this is unsatisfiable headroom, not a real limit. */
 const MAX_CONTEXT = 1_000_000_000;
@@ -170,8 +171,20 @@ export async function discoverGithubModels(
   const signal =
     input.signal === undefined ? timeoutSignal : AbortSignal.any([input.signal, timeoutSignal]);
   try {
+    // The reference client stamps its Copilot identity on `/models` too
+    // (`_mixinHeaders` covers the Models request type): session + machine ids.
+    // Machine id is per-account — see `githubCopilotClientIds`.
+    const accountKey = createHash("sha256").update(`${apiHost}:${access}`).digest("hex");
+    const { sessionId, machineId } = await githubCopilotClientIds(accountKey);
     const response = await fetcher(`https://${apiHost}/models`, {
-      headers: { accept: "application/json", authorization: `Bearer ${access}`, ...GITHUB_REQUEST_HEADERS },
+      headers: {
+        accept: "application/json",
+        authorization: `Bearer ${access}`,
+        ...GITHUB_REQUEST_HEADERS,
+        "VScode-SessionId": sessionId,
+        "VScode-MachineId": machineId,
+        "editor-device-id": machineId,
+      },
       signal,
     });
     if (!response.ok) return null;