@yansigit/opencodex 2.33.0 → 2.35.0

package/src/adapters/google-http.ts

@@ -39,7 +39,7 @@ function requestForHost(request: AdapterRequest, host: string): AdapterRequest {
   return { ...request, url: target.toString() };
 }
 
-type CcaSseProbe = "empty" | "candidate" | "unavailable" | "quota_exhausted" | "geo_blocked" | "terminal";
+type CcaSseProbe = "empty" | "candidate" | "unavailable" | "quota_exhausted" | "rate_limit" | "geo_blocked" | "terminal";
 
 function probeCcaSseEvent(bytes: Uint8Array): CcaSseProbe {
   const text = new TextDecoder().decode(bytes);
@@ -67,6 +67,7 @@ function probeCcaSseEvent(bytes: Uint8Array): CcaSseProbe {
       }
       const serialized = JSON.stringify(frame);
       if (isQuotaExhaustedBody(serialized)) return "quota_exhausted";
+      if (/rate[- ]limit|too many requests|per[- ]minute|requests per minute|concurrent request/i.test(serialized)) return "rate_limit";
       if (isAntigravityGeoBlockedBody(serialized)) return "geo_blocked";
       return "terminal";
     }
@@ -209,15 +210,15 @@ async function prepareCcaSseResponse(
           if (probe === "unavailable") {
             return failoverOrPassthrough();
           }
-          if (probe === "quota_exhausted" || probe === "geo_blocked") {
+          if (probe === "quota_exhausted" || probe === "rate_limit" || probe === "geo_blocked") {
             if (accountId) {
               recordAntigravitySyntheticFailure(accountId, {
-                code: probe === "quota_exhausted" ? 429 : 403,
-                status: probe === "quota_exhausted" ? "RESOURCE_EXHAUSTED" : "PERMISSION_DENIED",
-                message: probe === "quota_exhausted" ? "quota exceeded" : "user location is not supported",
+                code: probe === "geo_blocked" ? 403 : 429,
+                status: probe === "geo_blocked" ? "PERMISSION_DENIED" : "RESOURCE_EXHAUSTED",
+                message: probe === "quota_exhausted" ? "quota exceeded" : probe === "rate_limit" ? "rate limit exceeded" : "user location is not supported",
               });
             }
-            const status = probe === "quota_exhausted" ? 429 : 403;
+            const status = probe === "geo_blocked" ? 403 : 429;
             return passthrough(undefined, status);
           }
         }
@@ -244,15 +245,15 @@ async function prepareCcaSseResponse(
           }
           return failoverOrPassthrough();
         }
-        if (probe === "quota_exhausted" || probe === "geo_blocked") {
+        if (probe === "quota_exhausted" || probe === "rate_limit" || probe === "geo_blocked") {
           if (accountId) {
             recordAntigravitySyntheticFailure(accountId, {
-              code: probe === "quota_exhausted" ? 429 : 403,
-              status: probe === "quota_exhausted" ? "RESOURCE_EXHAUSTED" : "PERMISSION_DENIED",
-              message: probe === "quota_exhausted" ? "quota exceeded" : "user location is not supported",
+              code: probe === "geo_blocked" ? 403 : 429,
+              status: probe === "geo_blocked" ? "PERMISSION_DENIED" : "RESOURCE_EXHAUSTED",
+              message: probe === "quota_exhausted" ? "quota exceeded" : probe === "rate_limit" ? "rate limit exceeded" : "user location is not supported",
             });
           }
-          const status = probe === "quota_exhausted" ? 429 : 403;
+          const status = probe === "geo_blocked" ? 403 : 429;
           return passthrough(overflow, status);
         }
         if (probe === "terminal") return passthrough(overflow);

package/src/adapters/google.ts

@@ -37,7 +37,7 @@ import {
 } from "../web-search/gemini-executor";
 import type { WebSearchSource } from "../web-search/parse";
 import { googleVertexLocationConfigError } from "../providers/google-vertex-location";
-import { lookupReplayThoughtSignature } from "../responses/thought-signature-replay";
+import { forgetThoughtSignatureForReplay, lookupReplayThoughtSignature } from "../responses/thought-signature-replay";
 import {
   isTranslatorBudgetExceededError,
   releaseTranslatedEvent,
@@ -48,6 +48,9 @@ import {
 import { buildNonOpenAIToolCatalogNudgeForTools } from "./tool-catalog-nudge";
 import { configuredReasoningEfforts, mapReasoningEffort } from "../reasoning-effort";
 import { normalizeAntigravityProviderError } from "../oauth/antigravity-routing";
+import { buildAiStudioHeaders, parseGoogleCookieJar } from "../oauth/google-aistudio-auth";
+import { resolveAiStudioCredentials } from "../oauth/aistudio-credentials";
+import { parseMakerSuiteChunk } from "./google-aistudio-parser";
 
 const INLINE_ERROR_URL_USERINFO = /https?:\/\/[^\s"'<>]*@/gi;
 
@@ -71,6 +74,43 @@ const GOOGLE_BREVITY_INSTRUCTION = [
   "- This applies only to intermediate progress text. Your final answer after the work is done is exempt: write it in full and at whatever length the task requires.",
 ].join("\n");
 
+/**
+ * Documented output ceiling for a Google-surface model, or `undefined` when the id is not
+ * recognized.
+ *
+ * Unknown ids return `undefined` deliberately. An earlier revision returned a 16,384 floor for
+ * anything unmatched, which silently truncated aliases, gateway ids, and any model added after
+ * this table was written — the operator asked for N tokens and got 16,384 with no signal. A cap
+ * we cannot justify is worse than no cap: `structure/02_config-and-codex-home.md` is explicit
+ * that an explicit request value wins, so an unrecognized model passes through untouched and the
+ * upstream remains the authority on its own limit.
+ *
+ * Matching is prefix/family based rather than substring based for the same reason: `includes("pro")`
+ * matched any id containing "pro" (`my-prototype-model`), and `includes("oss")` matched any id
+ * containing "oss" (`crossover-v2`).
+ */
+export function maxOutputTokensForGoogleModel(modelId: string): number | undefined {
+  const lower = modelId.toLowerCase().trim();
+  if (lower.startsWith("gemini")) {
+    // Pro tops out one token below the flash/other Gemini ceiling; both are documented values.
+    return /(^|[-.])pro([-.]|$)/.test(lower) ? 65535 : 65536;
+  }
+  if (lower.startsWith("claude")) return 64000;
+  if (lower.startsWith("gpt-oss")) return 32768;
+  return undefined;
+}
+
+export function clampGoogleMaxOutputTokens(
+  modelId: string,
+  requestedTokens?: number,
+): number | undefined {
+  if (requestedTokens === undefined || requestedTokens <= 0) return undefined;
+  const modelMax = maxOutputTokensForGoogleModel(modelId);
+  // Unknown model: honour the request as-is rather than inventing a ceiling for it.
+  if (modelMax === undefined) return requestedTokens;
+  return Math.min(requestedTokens, modelMax);
+}
+
 /**
  * Some Google direct deployments expose current Gemini Flash generations with a `-tiered`
  * wire suffix (`gemini-3.7-flash` -> `gemini-3.7-flash-tiered`). Keep the picker-visible id
@@ -177,7 +217,7 @@ function geminiTextPart(text: unknown): { text: string } | undefined {
  */
 function geminiToolResultText(content: string | OcxContentPart[]): string {
   if (typeof content === "string") return content || GEMINI_EMPTY_TOOL_OUTPUT_PLACEHOLDER;
-  const hasContent = content.some(p => p.type === "image" || (typeof p.text === "string" && p.text.length > 0));
+  const hasContent = content.some(p => p.type !== "text" || p.text.length > 0);
   return hasContent ? contentPartsToText(content) : GEMINI_EMPTY_TOOL_OUTPUT_PLACEHOLDER;
 }
 
@@ -221,7 +261,7 @@ function messagesToGeminiFormat(
   parsed: OcxParsedRequest,
   identityModelId: string,
   repairToolPairs: boolean,
-): { systemInstruction?: unknown; contents: unknown[] } {
+): { systemInstruction?: unknown; contents: unknown[]; replayedCallIds: string[] } {
   // Neutralize Codex's GPT-5 identity line (Gemini/Antigravity share this path) so a routed model
   // never misreports as GPT-5/OpenAI, and never leaks the proxy identity upstream.
   const toolCatalogNudge = buildNonOpenAIToolCatalogNudgeForTools(parsed.context.tools, parsed.options.toolChoice);
@@ -233,6 +273,7 @@ function messagesToGeminiFormat(
   const systemInstruction = { parts: [{ text: systemText }] };
 
   const contents: unknown[] = [];
+  const replayedCallIds: string[] = [];
   let userMergeBarrier = false;
   const appendContent = (next: { role: string; parts: unknown[] }): void => {
     appendGeminiContent(contents, next, !userMergeBarrier);
@@ -267,6 +308,13 @@ function messagesToGeminiFormat(
               parts.push(data ? { inline_data: { mime_type: data.mediaType, data: data.base64 } } : { text: `[image: ${p.imageUrl}]` });
               continue;
             }
+            if (p.type === "video") {
+              const data = parseDataUrl(p.videoUrl);
+              // Gemini accepts inline video bytes in the same Part union as images. Arbitrary
+              // remote URLs are not valid fileData references, so retain only a short marker.
+              parts.push(data ? { inline_data: { mime_type: data.mediaType, data: data.base64 } } : { text: `[video: ${p.videoUrl}]` });
+              continue;
+            }
             // Drop empty/malformed text instead of emitting `{ text: "" }` or a bare `{}` part.
             const textPart = geminiTextPart(p.text);
             if (textPart) parts.push(textPart);
@@ -314,7 +362,10 @@ function messagesToGeminiFormat(
             const signature = tc.providerMetadata?.google?.thoughtSignature
               ?? tc.thoughtSignature
               ?? lookupReplayThoughtSignature(tc.id, parsed._reasoningReplayScope);
-            if (isLikelyRealThoughtSignature(signature)) part.thoughtSignature = signature;
+            if (isLikelyRealThoughtSignature(signature)) {
+              part.thoughtSignature = signature;
+              replayedCallIds.push(tc.id);
+            }
             parts.push(part);
           }
         }
@@ -371,7 +422,7 @@ function messagesToGeminiFormat(
     }
   }
 
-  return { systemInstruction, contents };
+  return { systemInstruction, contents, replayedCallIds };
 }
 
 function toolsToGeminiFormat(
@@ -540,6 +591,21 @@ function googlePartThoughtSignature(part: GoogleResponsePart): string | undefine
   return typeof nested === "string" && nested.length > 0 ? nested : undefined;
 }
 
+function ensureThoughtSignatureBypassSentinel(contents: unknown[], modelId?: string): void {
+  if (modelId && !/gemini-(?:3.7|2.5)|thinking/i.test(modelId)) return;
+  for (const c of contents as { role?: string; parts?: unknown[] }[]) {
+    if (c?.role !== "model" || !Array.isArray(c.parts)) continue;
+    for (const p of c.parts) {
+      if (p && typeof p === "object") {
+        const partObj = p as Record<string, unknown>;
+        if (partObj.functionCall && !partObj.thoughtSignature && !partObj.thought_signature) {
+          partObj.thoughtSignature = ANTIGRAVITY_SIGNATURE_BYPASS_SENTINEL;
+        }
+      }
+    }
+  }
+}
+
 /**
  * Carry a Gemini thought signature with the exact function-call part that produced it. Google
  * validates the signature against that specific part, so it must ride the individual tool call
@@ -725,6 +791,47 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
   const truncationErrorMessage = provider.googleMode === "vertex" || provider.googleMode === "cloud-code-assist"
     ? vertexTruncationErrorMessage
     : googleTruncationErrorMessage;
+  let lastInjectedCallIds: string[] = [];
+  let lastReasoningReplayScope: OcxParsedRequest["_reasoningReplayScope"];
+
+  // Conservative batch invalidation: upstream Gemini/Antigravity errors (e.g.
+  // "Function call is missing a thought_signature in functionCall parts") do not specify which
+  // specific call_id was rejected. When a request containing replayed signatures is rejected,
+  // we evict all callIds injected in that turn (lastInjectedCallIds) from the durable store
+  // and clear the session replay cache, preventing poisoned-signature loops while allowing
+  // subsequent turns to re-accumulate valid signatures. Unrelated calls from other turns remain intact.
+  //
+  // Memory-cache clearing stays broad (any invalid-argument/signature error can poison the
+  // session replay cache), but durable-store eviction is intentionally narrower: it only runs
+  // when the error text explicitly mentions a signature, so a generic tool-schema
+  // INVALID_ARGUMENT does not destroy valid durable signatures.
+  function handleSignatureRejection(errorMessage?: string) {
+    const replayModel = provider.googleMode === "cloud-code-assist" ? antigravityModel : vertexReplayModel;
+    const replaySession = provider.googleMode === "cloud-code-assist" ? antigravitySession : vertexReplaySession;
+    const text = errorMessage ?? "";
+    const isInvalidArgument = /invalid_argument|invalid argument/i.test(text);
+    const isSignatureError = /signature|thought_signature|thoughtSignature/i.test(text);
+    // The in-memory Antigravity replay cache only exists for CCA/Vertex, so clearing it stays
+    // scoped to those modes (replayModel/replaySession are undefined elsewhere anyway).
+    if (
+      (provider.googleMode === "cloud-code-assist" || provider.googleMode === "vertex")
+      && replayModel && replaySession && (isInvalidArgument || isSignatureError)
+    ) {
+      clearAntigravityReplay(replayModel, replaySession);
+    }
+    // The DURABLE store is not mode-scoped: signatures are remembered through
+    // rememberAndSerializeExtraContent and read back by lookupReplayThoughtSignature on every
+    // Google mode, including AI Studio. Gating eviction on CCA/Vertex therefore left AI Studio
+    // with rejected signatures cached forever, replaying them into every subsequent turn — the
+    // store poisons itself and the request keeps failing. Eviction follows the same scope the
+    // write does.
+    if (isSignatureError) {
+      for (const callId of lastInjectedCallIds) {
+        forgetThoughtSignatureForReplay(callId, lastReasoningReplayScope);
+      }
+    }
+  }
+
   return {
     name: "google",
     validateRequest(parsed: OcxParsedRequest) {
@@ -766,11 +873,13 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
           : resolveDirectGeminiWireModelId(parsed.modelId, provider.directGeminiWireRenames !== false);
       // AI Studio's `-tiered` spelling is wire-only; CCA aliases may migrate to another generation.
       const identityModelId = provider.googleMode === "cloud-code-assist" ? routedModelId : parsed.modelId;
-      const { systemInstruction, contents } = messagesToGeminiFormat(
+      const { systemInstruction, contents, replayedCallIds } = messagesToGeminiFormat(
         parsed,
         identityModelId,
         provider.googleMode === "cloud-code-assist",
       );
+      lastInjectedCallIds = [...replayedCallIds];
+      lastReasoningReplayScope = parsed._reasoningReplayScope;
       const tools = toolsToGeminiFormat(parsed, routedModelId);
 
       const body: Record<string, unknown> = { contents };
@@ -785,7 +894,8 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
       if (googleOptions?.cachedContent) body.cachedContent = googleOptions.cachedContent;
 
       const generationConfig: Record<string, unknown> = {};
-      if (parsed.options.maxOutputTokens) generationConfig.maxOutputTokens = parsed.options.maxOutputTokens;
+      const clampedMaxOutputTokens = clampGoogleMaxOutputTokens(identityModelId, parsed.options.maxOutputTokens);
+      if (clampedMaxOutputTokens !== undefined) generationConfig.maxOutputTokens = clampedMaxOutputTokens;
       if (parsed.options.temperature !== undefined) generationConfig.temperature = parsed.options.temperature;
       if (parsed.options.topP !== undefined) generationConfig.topP = parsed.options.topP;
       if (parsed.options.stopSequences) generationConfig.stopSequences = parsed.options.stopSequences;
@@ -882,19 +992,7 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
           const strippedModelTail = /claude/i.test(wireModelId) ? stripTrailingClaudePrefill(contents) : false;
           if (antigravityUsesReplayCache(wireModelId)) {
             applyAntigravityReplay(wireModelId, sessionId, contents);
-            // If any functionCall still lacks a thoughtSignature on Gemini Antigravity,
-            // supply the bypass sentinel so Antigravity does not reject the turn with HTTP 400.
-            for (const c of contents as { role?: string; parts?: unknown[] }[]) {
-              if (c?.role !== "model" || !Array.isArray(c.parts)) continue;
-              for (const p of c.parts) {
-                if (p && typeof p === "object") {
-                  const partObj = p as Record<string, unknown>;
-                  if (partObj.functionCall && !partObj.thoughtSignature && !partObj.thought_signature) {
-                    partObj.thoughtSignature = ANTIGRAVITY_SIGNATURE_BYPASS_SENTINEL;
-                  }
-                }
-              }
-            }
+            ensureThoughtSignatureBypassSentinel(contents);
           } else {
             sanitizeAntigravityClaudeSignatures(contents);
           }
@@ -970,6 +1068,23 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
         return { url, method: "POST", headers, body: JSON.stringify(compiled.body) };
       }
 
+      if (provider.googleMode === "ai-studio-web") {
+        const base = (provider.baseUrl || "https://alkalimakersuite-pa.clients6.google.com").replace(/\/+$/, "");
+        const url = `${base}/v1internal:${method}${streamParam}`;
+        const credentials = resolveAiStudioCredentials(provider);
+        if (credentials.kind !== "ready") throw new Error(credentials.reason);
+        const jar = parseGoogleCookieJar(credentials.cookieHeader);
+        const aiStudioHeaders = await buildAiStudioHeaders(jar, "https://aistudio.google.com");
+        Object.assign(headers, aiStudioHeaders);
+        const compiled = compileGoogleWireBody({ ...body, model: routedModelId });
+        restoreGoogleToolName = compiled.restoreToolName;
+        if (Array.isArray((compiled.body as { contents?: unknown[] }).contents)) {
+          ensureThoughtSignatureBypassSentinel((compiled.body as { contents: unknown[] }).contents, routedModelId);
+        }
+        emitInTurnGroundingSourcesQueue.push(!!parsed._ccaInTurnGrounding);
+        return { url, method: "POST", headers, body: JSON.stringify(compiled.body) };
+      }
+
       // ai-studio (default): Generative Language API + x-goog-api-key.
       const url = `${provider.baseUrl}/v1beta/models/${routedModelId}:${method}${streamParam}`;
       const apiKey = provider.apiKey?.trim();
@@ -978,6 +1093,9 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
 
       const compiled = compileGoogleWireBody(body);
       restoreGoogleToolName = compiled.restoreToolName;
+      if (Array.isArray((compiled.body as { contents?: unknown[] }).contents)) {
+        ensureThoughtSignatureBypassSentinel((compiled.body as { contents: unknown[] }).contents, routedModelId);
+      }
       emitInTurnGroundingSourcesQueue.push(!!parsed._ccaInTurnGrounding);
       return { url, method: "POST", headers, body: JSON.stringify(compiled.body) };
     },
@@ -986,6 +1104,11 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
       const emitInTurnGroundingSources = emitInTurnGroundingSourcesQueue.shift() ?? false;
       const filterCcaSearchSuggestionHtml =
         provider.googleMode === "cloud-code-assist" && emitInTurnGroundingSources;
+      if (provider.googleMode === "ai-studio-web" && (response.status === 401 || response.status === 403 || (response.status >= 300 && response.status < 400))) {
+        try { await response.body?.cancel(); } catch { /* ignore */ }
+        yield { type: "error", message: "Google AI Studio session expired — re-authentication required" };
+        return;
+      }
       if (!response.body) {
         yield { type: "error", message: "No response body" };
         return;
@@ -998,6 +1121,17 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
       const reader = response.body.getReader();
       const decoder = new TextDecoder();
       const budgetEncoder = new TextEncoder();
+      const contentType = response.headers.get("content-type") ?? "";
+      const isHtmlContentType = contentType.toLowerCase().includes("text/html");
+      const isHtmlRedirect = (text: string) => {
+        const lower = text.trim().toLowerCase();
+        return lower.startsWith("<!doctype") || lower.includes("accounts.google.com/v3/signin");
+      };
+      const reauthError = "Google AI Studio session expired — re-authentication required";
+      if (isHtmlContentType) {
+        yield { type: "error", message: reauthError };
+        return;
+      }
       let buffer = "";
       let bufferBytes = 0;
       // Raw unterminated-line bytes, independent of TextDecoder's pending UTF-8
@@ -1059,15 +1193,9 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
           if (provider.googleMode === "cloud-code-assist" && error) observeProviderError?.(error);
           const err = { ...(error ?? {}), message: error?.message ?? safeMessage ?? "upstream error" };
           // Clear-on-invalid: a signature rejection means our replayed thoughtSignatures are stale.
-          // Drop the cache entry so the next turn starts clean instead of re-injecting a bad sig.
-          const replayModel = provider.googleMode === "cloud-code-assist" ? antigravityModel : vertexReplayModel;
-          const replaySession = provider.googleMode === "cloud-code-assist" ? antigravitySession : vertexReplaySession;
-          if ((provider.googleMode === "cloud-code-assist" || provider.googleMode === "vertex")
-            && replayModel && replaySession
-            && !/missing.*thought_signature/i.test(err?.message ?? "")
-            && /signature|invalid_argument|invalid argument/i.test(err?.message ?? "")) {
-            clearAntigravityReplay(replayModel, replaySession);
-          }
+          // Drop the cache entry and durable store entry for rejected calls so the next turn
+          // starts clean instead of re-injecting a bad sig.
+          handleSignatureRejection(err?.message);
           yield {
             type: "error",
             ...(error?.status !== undefined ? { status: error.status } : {}),
@@ -1256,6 +1384,11 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
           }
           incompleteLineBytes = lineScan.residual;
           const nextBuffer = buffer + decoder.decode(value, { stream: true });
+          if (isHtmlRedirect(nextBuffer)) {
+            yield { type: "error", message: reauthError };
+            try { await reader.cancel(); } catch { /* ignore */ }
+            return;
+          }
           const nextBufferBytes = budgetEncoder.encode(nextBuffer).byteLength;
           const appendReservation = budget.reserveTransient(nextBufferBytes, { kind: "live_transient" });
           buffer = nextBuffer;
@@ -1280,6 +1413,16 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
               if (result === "content") sawContentEvent = true;
               continue;
             }
+            if (provider.googleMode === "ai-studio-web") {
+              const parsed = parseMakerSuiteChunk(line);
+              if (parsed.text) {
+                sawAnyFrame = true;
+                sawTerminalSignal = true;
+                sawContentEvent = true;
+                yield { type: "text_delta", text: parsed.text };
+                continue;
+              }
+            }
             sawLiveness = true;
             if (line.startsWith(":") || !line.trim()) continue;
             debugDroppedFrame("google", line);
@@ -1292,7 +1435,28 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
           if (residual.startsWith(":")) {
             yield { type: "heartbeat" };
           } else if (!residual.startsWith("data:")) {
-            yield { type: "error", message: "upstream stream ended with an incomplete SSE frame — possible truncation" };
+            try {
+              const parsedErr = JSON.parse(residual);
+              if (parsedErr.error?.message) {
+                yield { type: "error", message: parsedErr.error.message };
+                return;
+              }
+            } catch (err) {
+              void err;
+            }
+            if (provider.googleMode === "ai-studio-web") {
+              const parsed = parseMakerSuiteChunk(residual);
+              if (parsed.text) {
+                yield { type: "text_delta", text: parsed.text };
+                yield { type: "done" };
+                return;
+              }
+            }
+            if (isHtmlContentType || isHtmlRedirect(residual)) {
+              yield { type: "error", message: reauthError };
+              return;
+            }
+            yield { type: "error", message: `upstream non-SSE response: ${residual.slice(0, 300)}` };
             return;
           } else if ((yield* handleDataLine(residual)) === "terminate") return;
         }
@@ -1344,7 +1508,7 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
       // buffered adapter entry point, so collect the exact same events parseStream emits
       // instead of maintaining a second CCA JSON parser.
       const isSse = response.headers.get("content-type")?.includes("text/event-stream") ?? false;
-      if (provider.googleMode === "cloud-code-assist" && isSse) {
+      if ((provider.googleMode === "cloud-code-assist" && isSse) || provider.googleMode === "ai-studio-web") {
         const events: AdapterEvent[] = [];
         let previousTail: AdapterEvent | undefined;
         try {
@@ -1417,7 +1581,18 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
       let raw: Record<string, unknown>;
       let rawBytes = 0;
       try {
-        raw = JSON.parse(rawText) as Record<string, unknown>;
+        const parsedRaw: unknown = JSON.parse(rawText);
+        // `JSON.parse("null")` returns null instead of throwing, so the catch below cannot see it
+        // and the `raw.error` read crashed the turn — #1219 at the buffered body root, which #1240
+        // never reached because that audit swept SSE frame parsers only. There is no next frame to
+        // recover into here, so unlike a stream frame this fails closed, matching the
+        // unparseable-body branch just below and the buffered candidate guards added in #2232.
+        if (!isGoogleRecord(parsedRaw)) {
+          budget.releaseRetained(rawTextBytes, { kind: "retained_collectors" });
+          const valueType = googleStructuralValueType(parsedRaw);
+          return [{ type: "error", message: `google response was not a JSON object (${valueType})` }];
+        }
+        raw = parsedRaw;
         rawBytes = new TextEncoder().encode(JSON.stringify(raw)).byteLength;
         const rawReservation = budget.reserveTransient(rawBytes, { kind: "retained_collectors" });
         rawReservation.commitRetained();
@@ -1441,16 +1616,24 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
           message: safeMessage,
         });
         if (error) observeProviderError?.(error);
+        const message = error?.message ?? safeMessage ?? "upstream error";
+        handleSignatureRejection(message);
         return finish([{
           type: "error",
           ...(error?.status !== undefined ? { status: error.status } : {}),
           ...(error?.code ? { code: error.code } : {}),
-          message: error?.message ?? safeMessage ?? "upstream error",
+          message,
         }]);
       }
-      const json = (provider.googleMode === "cloud-code-assist" && raw.response && typeof raw.response === "object" && !Array.isArray(raw.response))
-        ? (raw.response as Record<string, unknown>)
-        : raw;
+      // Antigravity (CCA) nests the standard Gemini payload under `response`; unwrap it.
+      let json = raw;
+      if (provider.googleMode === "cloud-code-assist") {
+        const wrapped = raw.response;
+        if (!wrapped || typeof wrapped !== "object" || Array.isArray(wrapped)) {
+          return finish([{ type: "error", message: "google-antigravity response missing response wrapper" }]);
+        }
+        json = wrapped as Record<string, unknown>;
+      }
       const events: AdapterEvent[] = [];
 
       const rawCandidates: unknown = json.candidates;

package/src/adapters/image.ts

@@ -18,6 +18,6 @@ export function parseDataUrl(url: string): { mediaType: string; base64: string }
  */
 export function contentPartsToText(content: string | OcxContentPart[]): string {
   if (typeof content === "string") return content;
-  const text = content.map(p => (p.type === "text" ? p.text : "[image]")).join("");
+  const text = content.map(p => p.type === "text" ? p.text : p.type === "image" ? "[image]" : "[video]").join("");
   return text || "[image]";
 }

package/src/adapters/kiro-constants.ts

@@ -1,4 +1,19 @@
 export const KIRO_COMPLETION_TOOL_NAME = "codex_kiro_final_answer";
+
+/**
+ * Request-scoped CodeWhisperer service profile for AWS Builder ID accounts.
+ *
+ * Builder ID is a personal identity with no AWS account behind it, so AWS never mints an
+ * account-scoped `profile/<id>` ARN for it. The Kiro CLI resolves this the same way: it carries
+ * this fixed service profile on Builder ID requests. The embedded account id is Amazon's own, not
+ * the user's, which is why sending it is not the same as synthesizing an account identity.
+ *
+ * Request-scoped is load-bearing. This value must never be persisted into `KiroOAuthMetadata`,
+ * never seed region inference (it is `us-east-1` and would pin every Builder ID account there),
+ * and never participate in account matching.
+ */
+export const KIRO_BUILDER_ID_SERVICE_PROFILE_ARN =
+  "arn:aws:codewhisperer:us-east-1:638616132270:profile/AAAACCCCXXXX";
 export const KIRO_CONTINUATION_MESSAGE =
   "Continue from the prior conversation. Do not quote or mention this instruction.";
 export const KIRO_COMPLETION_RETRY_MESSAGE =

package/src/adapters/kiro-tools.ts

@@ -1,6 +1,7 @@
 import type { OcxParsedRequest, OcxTool } from "../types";
 import { namespacedToolName } from "../types";
 import { normalizeKiroModelId } from "../providers/kiro-models";
+import { isCodexCodeModeExecTool } from "./tool-catalog-nudge";
 import { createKiroToolNameRegistry, type KiroToolNameRegistry } from "./kiro-wire";
 
 const MAX_KIRO_TOOL_DESCRIPTION_UNVERIFIED = 1024;
@@ -103,7 +104,7 @@ function ensureRootObjectType(schema: unknown): Record<string, unknown> {
   // Seed with the root's own properties/required so a schema like
   // { type:"object", properties:{path}, required:["path"], oneOf:[...] } keeps them.
   if (obj.properties && typeof obj.properties === "object") {
-    Object.assign(props, sanitizeKiroSchema(obj.properties) as Record<string, unknown>);
+    Object.assign(props, sanitizeSchemaMap(obj.properties) as Record<string, unknown>);
   }
   if (Array.isArray(obj.required)) {
     for (const r of obj.required) if (typeof r === "string") required.add(r);
@@ -118,7 +119,7 @@ function ensureRootObjectType(schema: unknown): Record<string, unknown> {
       if (!variant || typeof variant !== "object" || Array.isArray(variant)) continue;
       const v = variant as Record<string, unknown>;
       if (v.properties && typeof v.properties === "object") {
-        Object.assign(props, sanitizeKiroSchema(v.properties) as Record<string, unknown>);
+        Object.assign(props, sanitizeSchemaMap(v.properties) as Record<string, unknown>);
       }
       if (mergeRequired && Array.isArray(v.required)) {
         for (const r of v.required) if (typeof r === "string") required.add(r);
@@ -174,8 +175,14 @@ function omittedToolCatalogNotice(kept: number, omitted: readonly OcxTool[], reg
 
 function boundedCatalogPriority(tool: OcxTool): number {
   if (tool.loadedFromToolSearch) return 0;
-  if (tool.toolSearch) return 1;
-  return 2;
+  // Codex code mode reaches shell, file edits, apply_patch and every MCP helper ONLY as nested
+  // `tools.<name>(...)` calls inside this one tool. Dropping it does not shrink the catalog, it
+  // makes the rest of the catalog uncallable -- so it outranks the search gateway and filler.
+  // It stays BEHIND `loadedFromToolSearch` because those are tools the model asked for by name
+  // this turn (#2475). Cursor pins its execution path the same way (request-builder.ts, #399).
+  if (isCodexCodeModeExecTool(tool)) return 1;
+  if (tool.toolSearch) return 2;
+  return 3;
 }
 
 export function convertKiroToolContext(
@@ -209,19 +216,40 @@ export function convertKiroToolContext(
   const candidates = exceedsBudget
     ? convertedEntries.toSorted((a, b) => boundedCatalogPriority(a.tool) - boundedCatalogPriority(b.tool) || a.index - b.index)
     : convertedEntries;
-  const convertedTools: unknown[] = [];
-  let omittedAt = candidates.length;
-  for (const [index, entry] of candidates.entries()) {
+  // Reserve a seat for the code-mode execution path before filling the rest.
+  //
+  // Priority alone cannot save it. `loadedFromToolSearch` tools outrank it and arrive unbounded
+  // (the Responses parser pushes every `tool_search_output` spec), so a session that accumulated
+  // MAX_KIRO_TOOL_COUNT loaded tools would exhaust the budget before reaching tier 1 and drop the
+  // one tool through which all of them are actually callable.
+  //
+  // Reservation rather than eviction: this lowers the room the fill loop sees, so it admits one
+  // fewer tool. It never removes a tool that already fit, which is what keeps #2475's loaded-result
+  // guarantee intact -- Cursor's `evictNonExecutionPath` exempts only the execution path and could
+  // evict a loaded tool instead.
+  const reserved = candidates.find(entry => isCodexCodeModeExecTool(entry.tool));
+  const admitted = new Set<number>();
+  const filled: unknown[] = [];
+  for (const entry of candidates) {
+    if (entry === reserved) continue;
+    // Measure the projected FINAL array: the byte budget is computed over the serialized array, so
+    // subtracting a standalone size would misjudge it by the separators JSON adds between entries.
+    const projected = reserved ? [...filled, entry.converted, reserved.converted] : [...filled, entry.converted];
     if (
-      convertedTools.length >= MAX_KIRO_TOOL_COUNT
-      || serializedToolCatalogBytes([...convertedTools, entry.converted]) > MAX_KIRO_TOOL_CATALOG_BYTES
-    ) {
-      omittedAt = index;
-      break;
-    }
-    convertedTools.push(entry.converted);
+      projected.length > MAX_KIRO_TOOL_COUNT
+      || serializedToolCatalogBytes(projected) > MAX_KIRO_TOOL_CATALOG_BYTES
+    ) break;
+    filled.push(entry.converted);
+    admitted.add(entry.index);
   }
-  const omittedTools = candidates.slice(omittedAt).map(entry => entry.tool);
+  if (reserved) admitted.add(reserved.index);
+  // Rebuild in sorted-candidate order so the wire order stays loaded -> exec -> gateway -> filler.
+  // Pushing the reserved entry after the loop would place it last instead.
+  const convertedTools = candidates.filter(entry => admitted.has(entry.index)).map(entry => entry.converted);
+  // Derive omissions by set difference. The old `candidates.slice(omittedAt)` assumed every
+  // candidate after the first rejection was omitted, which stops being true once one of them was
+  // reserved and admitted: the notice would name `exec` unavailable while it is on the wire.
+  const omittedTools = candidates.filter(entry => !admitted.has(entry.index)).map(entry => entry.tool);
   return {
     tools: convertedTools,
     systemAdditions: omittedTools.length > 0 ? [omittedToolCatalogNotice(convertedTools.length, omittedTools, registry)] : [],