cartethyia 2.7.5 → 2.7.7

package/src/providers/default-registry.ts

@@ -202,7 +202,10 @@ export const PROVIDER_CAPABILITIES = {
   },
   codex: {
     loadAdapter: async () => (await import("./integrations/codex/codex")).createCodexAdapter({ provider_id: "codex" }),
-    loadModels: async () => (await import("./integrations/codex/codex")).CODEX_MODELS,
+    loadModels: async () => {
+      const { CODEX_MODELS, CODEX_SEARCH_MODELS } = await import("./integrations/codex/codex");
+      return [...CODEX_MODELS, ...CODEX_SEARCH_MODELS];
+    },
     loadAuthentication: oauthCapability(() => import("./integrations/codex/codex-oauth"), "codexOAuthClient", { withRefresher: true }),
     loadQuotaCollector: quotaCapability(() => import("./integrations/codex/codex-quota"), "fetchCodexQuota"),
     loadModelDiscovery: async () => async ({ credential, fetcher }) =>
@@ -235,12 +238,25 @@ export const PROVIDER_CAPABILITIES = {
   },
   antigravity: {
     loadAdapter: async () => (await import("./integrations/antigravity/antigravity")).antigravityAdapter,
-    loadModels: async () => (await import("./integrations/antigravity/antigravity")).ANTIGRAVITY_MODELS,
+    loadModels: async () => {
+      const { ANTIGRAVITY_MODELS, ANTIGRAVITY_SEARCH_MODELS } = await import("./integrations/antigravity/antigravity");
+      return [...ANTIGRAVITY_MODELS, ...ANTIGRAVITY_SEARCH_MODELS];
+    },
     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/discovery/discovery-types.ts

@@ -74,6 +74,17 @@ export interface ProbeModelRequest {
   reasoningEffort?: ProbeReasoningEffort;
   maxOutputTokens?: number;
   stream?: boolean;
+  /**
+   * Provider-specific transport override for the probe.
+   *
+   * `undefined` (default) probes through the same transport live traffic
+   * uses. A provider may expose extra surfaces that only a probe can force —
+   * Qoder's IDE surface (`/model/v1`) is the only one that echoes strategy
+   * metadata (`provider_model`, `target`, …) alongside the answer, while the
+   * production transports (gRPC / COSY) do not. Forcing it makes the probe
+   * result the richest available source of truth.
+   */
+  surface?: "default" | "cosy" | "grpc" | "ide";
 }
 export interface ProbeModelResult {
   accountId?: string;
@@ -93,6 +104,13 @@ export interface ProbeModelResult {
   reportedModel?: string;
   statusCode?: number;
   error?: string;
+  /**
+   * Provider-specific upstream metadata about the model that actually served
+   * the turn (native model id, supply target, tier). Filled when the probed
+   * transport exposes it — Qoder's IDE surface reports it in `raw_usage`;
+   * the production transports do not.
+   */
+  providerMetadata?: Readonly<Record<string, unknown>>;
   /** Normalized hits a `websearch` probe returned, so the console can show them. */
   searchResults?: ReadonlyArray<{
     readonly title: string;

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

@@ -150,6 +150,27 @@ export function extractSample(events: readonly CanonicalEvent[]): string | undef
   return trimmed.length > 0 ? trimmed.slice(0, 200) : undefined;
 }
 
+/**
+ * Reads the model an adapter reported in its canonical events.
+ *
+ * The HTTP-only `readReportedModel` inspects the raw response body, so it
+ * cannot see the model on non-HTTP transports (Qoder gRPC). Adapters surface
+ * the upstream echo as `response_start`/`message_start` with a `model` field;
+ * this reads that as a fallback.
+ */
+export function modelFromEvents(events: readonly CanonicalEvent[]): string | undefined {
+  for (const event of events) {
+    if (
+      (event.type === "response_start" || event.type === "message_start") &&
+      typeof event.model === "string" &&
+      event.model.trim().length > 0
+    ) {
+      return event.model.trim();
+    }
+  }
+  return undefined;
+}
+
 export function hasMeaningfulOutput(events: readonly CanonicalEvent[]): boolean {
   return events.some((event) => {
     if (event.type === "tool_call_delta") return true;
@@ -581,6 +602,30 @@ export async function loadProbePreferences(args: {
   return { probeReasoning, payloadCapture };
 }
 
+/**
+ * The probe's default identity prompt (`What model are you...`) works for
+ * every Qoder roster row except `cmodel` (virtual id `cantus`): that row's
+ * gRPC surface answers the identity question with `406 Upstream error [stream]`
+ * from the upstream proxy (verified live 2026-11-04; dmodel/qmodel/smodel all
+ * accept it). Returns the neutral replacement prompt when the probe targets
+ * that row with no explicit prompt, `undefined` otherwise.
+ *
+ * The replacement prompt must never *ask* an identity question: the upstream
+ * guardrail is content-based and swallows the reply (empty sample) for any
+ * phrasing that interrogates identity — even indirect ones (`what would you
+ * call yourself`, `which model are you`, `perkenalkan dirimu`). A plain
+ * greeting that *asserts* the wrong identity (`halo gpt`) makes the model
+ * correct us on its own, and returns a sample 3/3 runs (verified live
+ * 2026-11-04). We keep that phrasing — it is 100% consistent and the model
+ * names itself ("saya Claude... buatan Anthropic") without us ever asking.
+ */
+export function qoderCmodelProbePrompt(providerId: string, modelId: string, prompt: string | undefined): string | undefined {
+  if (prompt !== undefined) return undefined;
+  if (providerId !== "qoder" && providerId !== "qodercn") return undefined;
+  if (modelId !== "cmodel" && modelId !== "cantus") return undefined;
+  return "halo gpt";
+}
+
 /**
  * Phase 5 — build the canonical probe request. The probe prompt must pass every
  * provider's content-policy review (a bare "hi" trips CodeBuddy's 11140 safety

package/src/providers/discovery/probing-service.ts

@@ -42,10 +42,12 @@ import {
   buildProbeCanonicalRequest,
   computeProbeVerdict,
   extractSample,
+  modelFromEvents,
   GROK_407_PROBE_PROMPT,
   grok407ProbeFailure,
   hasMeaningfulOutput,
   loadProbePreferences,
+  qoderCmodelProbePrompt,
   recordProbeHealth,
   resolveProbeAdapter,
   resolveProbeTarget,
@@ -186,7 +188,16 @@ export class ProviderProbingService {
     request: ProbeModelRequest,
   ): Promise<ProbeModelResult> {
     const startedAt = Date.now();
-    const modelId = request.modelId;
+    // Qoder's IDE surface is the only transport that echoes provider metadata
+    // (`provider_model`, `target`, …) in its raw_usage, so probes for Qoder
+    // default to it unless the operator picked a surface explicitly. This
+    // covers every entry point (single model, all models, all accounts).
+    const normalizedRequest: ProbeModelRequest =
+      (providerId === "qoder" || providerId === "qodercn") &&
+      (request.surface === undefined || request.surface === "default")
+        ? { ...request, surface: "ide" }
+        : request;
+    const modelId = normalizedRequest.modelId;
     // One provider snapshot per probe: the contract gate, the account gate, the
     // custom-adapter fallback, and the wire context all read this same row, so a
     // concurrent edit cannot make two reads disagree.
@@ -207,10 +218,10 @@ export class ProviderProbingService {
       db: this.db,
       tenantId,
       providerId,
-      requestedAccountId: request.accountId,
+      requestedAccountId: normalizedRequest.accountId,
       requiresAccount,
       allowCoolingAccount:
-        providerId === "grok" && request.prompt === GROK_407_PROBE_PROMPT,
+        providerId === "grok" && normalizedRequest.prompt === GROK_407_PROBE_PROMPT,
     });
     if (!account.ok) {
       return { ok: false, latencyMs: Date.now() - startedAt, error: account.error };
@@ -236,9 +247,16 @@ export class ProviderProbingService {
       wireFamily,
       request,
     });
+    // Qoder's gRPC surface refuses a probe that asks a model to identify
+    // itself (406 from the upstream proxy) for one roster row (`cmodel`,
+    // virtual id `cantus`). dmodel/qmodel/smodel accept the identity prompt
+    // fine — only cmodel refuses it — so the workaround is scoped to that
+    // row, not to every Qoder probe, and never overrides an explicit prompt.
+    const qoderCmodelPrompt = qoderCmodelProbePrompt(providerId, modelId, normalizedRequest.prompt);
+    const probeRequest = qoderCmodelPrompt === undefined ? normalizedRequest : { ...normalizedRequest, prompt: qoderCmodelPrompt };
     const canonicalRequest = buildProbeCanonicalRequest({
       modelId,
-      request,
+      request: probeRequest,
       probeReasoning,
       sourceSurface,
     });
@@ -257,6 +275,11 @@ export class ProviderProbingService {
       // The model row's own output ceiling, so a probe with a max-output
       // ceiling (OpenCode free) shapes with the model's limit, not a guess.
       ...(outputLimit == null ? {} : { output_limit: outputLimit }),
+      // Probe-only transport override, when the operator asked for one. Live
+      // dispatch never sets this.
+      ...(normalizedRequest.surface === undefined || normalizedRequest.surface === "default"
+        ? {}
+        : { probe_surface: normalizedRequest.surface }),
     };
 
     const probeSignal = AbortSignal.timeout(30_000);
@@ -308,7 +331,7 @@ export class ProviderProbingService {
               `Provider ${providerId} has no web search transport (request {requestId}). Know your tools — this one just isn't in the box 🧰`,
             );
           }
-          const searchProbeQuery = request.prompt?.trim() || "Cartethyia gateway probe";
+          const searchProbeQuery = normalizedRequest.prompt?.trim() || "Cartethyia gateway probe";
           const response = await adapter.websearch(
             { model: modelId, query: searchProbeQuery, max_results: 3 },
             candidate,
@@ -574,7 +597,16 @@ export class ProviderProbingService {
     }
 
     const sample = extractSample(events);
-    const reportedModel = await probeCapture?.reportedModel?.catch(() => undefined);
+    // The HTTP-only `readReportedModel` covers response-body transports; a
+    // non-HTTP transport (Qoder gRPC) reports the upstream echo as a
+    // `response_start` event instead — fall back to that when the body read
+    // came up empty.
+    const reportedModel =
+      (await probeCapture?.reportedModel?.catch(() => undefined)) ?? modelFromEvents(events);
+    // Provider-specific upstream model metadata (Qoder IDE surface raw_usage):
+    // carried on the terminal event by the adapter, surfaced verbatim.
+    const terminal = events.find((event) => event.type === "terminal");
+    const providerMetadata = terminal?.type === "terminal" ? terminal.provider_metadata : undefined;
     return {
       ...(accountId ? { accountId } : {}),
       ok,
@@ -583,6 +615,9 @@ export class ProviderProbingService {
       ...(upstreamStatusCode === undefined ? {} : { statusCode: upstreamStatusCode }),
       ...(sample ? { sample } : {}),
       ...(reportedModel === undefined ? {} : { reportedModel }),
+      ...(providerMetadata === undefined || Object.keys(providerMetadata).length === 0
+        ? {}
+        : { providerMetadata }),
       ...(searchResults !== undefined && searchResults.length > 0 ? { searchResults } : {}),
       ...(errorMessage ? { error: errorMessage } : {}),
     };

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

@@ -17,7 +17,7 @@
  */
 import { createHash } from "node:crypto";
 import { providerBaseUrl } from "../../provider-metadata";
-import type { ModelDefinition } from "../../provider-model-definition";
+import { defineModel, type ModelDefinition } from "../../provider-model-definition";
 import { isRecord } from "../../../protocol/codecs";
 import { modelsDevCatalog } from "../../discovery/models-dev-catalog";
 import type { CanonicalRequest, ReasoningIntent } from "../../../protocol/canonical-model";
@@ -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;
@@ -427,7 +485,25 @@ export async function discoverAntigravityModels(
         (await response.json()) as unknown,
       );
       if (models === null) continue;
-      return models;
+      // Keep the static websearch row on top of discovered rows: the live
+      // catalog does not publish search SKUs, and `/v1/search` needs a
+      // `service_kind: "websearch"` row to route.
+      return [
+        ...models,
+        defineModel({
+          id: "gemini-2.5-flash",
+          providerId: "antigravity",
+          serviceKind: "websearch",
+          wireFamily: "chat",
+          // Empty endpoint — see `ANTIGRAVITY_SEARCH_MODELS`.
+          endpoint: "",
+          ctx: 1_000_000,
+          out: 65_535,
+          vision: true,
+          reasoning: true,
+          toolCall: false,
+        }),
+      ];
     } catch {
       // Best-effort: a failed live catalog must never break static routing.
     }
@@ -489,9 +565,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 +653,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 +784,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 +794,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,50 @@ 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),
+];
+
+/**
+ * Web-search rows served by `/v1/search`. Antigravity grounds search through a
+ * Gemini chat call with a `web_search` tool (see `websearch`); the cheap flash
+ * SKU is the default search model.
+ */
+export const ANTIGRAVITY_SEARCH_MODELS: readonly ModelDefinition[] = [
+  defineModel({
+    id: "gemini-2.5-flash",
+    providerId: "antigravity",
+    serviceKind: "websearch",
+    wireFamily: "chat",
+    // Empty endpoint: the adapter resolves the URL from the request stream flag
+    // (`GENERATE_PATH`), so the row only needs to exist as a websearch route.
+    // An empty value also keeps it distinct from the llm row (the unique key is
+    // provider+model+endpoint).
+    endpoint: "",
+    ctx: 1_000_000,
+    out: 65_535,
+    vision: true,
+    reasoning: true,
+    toolCall: false,
+  }),
 ];
 
 function normalizeAntigravityGrounding(data: unknown, maxResults: number): readonly WebSearchResult[] {
@@ -777,8 +805,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/codex/codex.ts

@@ -145,6 +145,30 @@ export const CODEX_MODELS: readonly ModelDefinition[] = [
 ];
 const CODEX_SEARCH_DEFAULT_MODEL = "gpt-5.6-luna";
 
+/**
+ * Web-search rows served by `/v1/search`. Codex grounds search through a
+ * Responses call with a `web_search` tool (see `websearch`); the cheap 5.6
+ * SKU is the default search model.
+ */
+export const CODEX_SEARCH_MODELS: readonly ModelDefinition[] = [
+  defineModel({
+    id: "gpt-5.6-luna",
+    providerId: "codex",
+    serviceKind: "websearch",
+    wireFamily: "responses",
+    // Empty endpoint: the adapter falls back to
+    // `/backend-api/codex/responses` when the candidate path is empty (see
+    // `dispatch`), and an empty value keeps the row distinct from the llm row
+    // in the (provider, model, endpoint) unique key.
+    endpoint: "",
+    ctx: 1_000_000,
+    out: 128_000,
+    vision: true,
+    reasoning: true,
+    toolCall: false,
+  }),
+];
+
 function normalizeCodexSearchCitations(
   citations: readonly unknown[],
   answerText: string,
@@ -528,7 +552,10 @@ export async function discoverCodexModels(input: {
       ),
     );
   }
-  return [...byId.values()].sort((a, b) => a.modelId.localeCompare(b.modelId));
+  // Keep the static websearch rows on top of discovered llm rows: the codex
+  // registry does not publish search SKUs, and `/v1/search` needs a
+  // `service_kind: "websearch"` row to route.
+  return [...byId.values(), ...CODEX_SEARCH_MODELS].sort((a, b) => a.modelId.localeCompare(b.modelId));
 }
 
 /** Reads just enough of an untyped body to tell SSE from JSON, then replays it. */

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 {