@yansigit/opencodex 2.32.0 → 2.33.0

package/src/adapters/google-http.ts

@@ -7,7 +7,7 @@ import {
 } from "./google-errors";
 import { isGoogleMixedBuiltinToolError, repairGoogleInvalidRequestBody, stripGoogleBuiltinToolsFromWireBody } from "./google-wire-compiler";
 import { normalizeUpstreamHttpErrorResponse, readDisplaySafeErrorPayloadText } from "./upstream-http-error";
-import { recordAntigravityCooldown } from "../oauth/antigravity-routing";
+import { recordAntigravityCooldown, recordAntigravitySyntheticFailure } from "../oauth/antigravity-routing";
 import {
   antigravityHostCandidates,
   canonicalAntigravityHttpsHost,
@@ -178,6 +178,7 @@ function responseWithBufferedBody(
 async function prepareCcaSseResponse(
   response: Response,
   fetchPeer: (() => Promise<Response>) | undefined,
+  accountId?: string,
 ): Promise<Response> {
   if (!response.body) return fetchPeer ? fetchPeer() : response;
   const reader = response.body.getReader();
@@ -209,6 +210,13 @@ async function prepareCcaSseResponse(
             return failoverOrPassthrough();
           }
           if (probe === "quota_exhausted" || 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",
+              });
+            }
             const status = probe === "quota_exhausted" ? 429 : 403;
             return passthrough(undefined, status);
           }
@@ -237,6 +245,13 @@ async function prepareCcaSseResponse(
           return failoverOrPassthrough();
         }
         if (probe === "quota_exhausted" || 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",
+            });
+          }
           const status = probe === "quota_exhausted" ? 429 : 403;
           return passthrough(overflow, status);
         }
@@ -262,6 +277,8 @@ function isUnavailableResponse(response: Response): boolean {
 export interface GoogleRetryOptions {
   /** Repair-and-replay structurally invalid 400 bodies (Vertex/Antigravity behavior). */
   repairInvalid400?: boolean;
+  /** Let the Responses layer own Antigravity's single same-account 429 replay. */
+  retry429?: boolean;
 }
 
 async function normalizeFinalGoogleError(label: string, res: Response, signal?: AbortSignal): Promise<Response> {
@@ -291,13 +308,15 @@ async function recordAntigravityHttpCooldown(
   if (response.status === 429) {
     recordAntigravityCooldown(
       accountId,
-      isQuotaExhaustedBody(payloadText) ? "quota_exhausted" : "rate_limited",
-      retryAfterMs(response.headers.get("retry-after")),
+      response.headers.get("retry-after"),
+      Date.now(),
+      isQuotaExhaustedBody(payloadText) ? "quota" : "rate-limit",
+      "synthetic",
     );
     return true;
   }
-  if (isAntigravityGeoBlockedBody(payloadText)) {
-    recordAntigravityCooldown(accountId, "geo_blocked");
+  if (response.status === 403 || isAntigravityGeoBlockedBody(payloadText)) {
+    recordAntigravityCooldown(accountId, response.headers.get("retry-after"), Date.now(), "geoblock", "synthetic");
     return true;
   }
   return false;
@@ -318,6 +337,7 @@ async function fetchGoogleWithRetryInternal(
   opts: GoogleRetryOptions = {},
 ): Promise<Response> {
   const repairInvalid400 = opts.repairInvalid400 ?? true;
+  const retry429 = opts.retry429 ?? true;
   const timeoutMs = ctx.timeoutMs ?? 200_000;
   const executor = ctx.executor ?? globalThis.fetch;
   let activeRequest = request;
@@ -369,7 +389,7 @@ async function fetchGoogleWithRetryInternal(
             opts,
           )
           : undefined;
-        return prepareCcaSseResponse(res, fetchPeer);
+        return prepareCcaSseResponse(res, fetchPeer, ctx.accountId);
       }
       if (res.status === 400 && repairInvalid400 && !compatibilityReplayUsed) {
         let payloadText = "";
@@ -397,6 +417,9 @@ async function fetchGoogleWithRetryInternal(
           continue;
         }
       }
+      if (res.status === 429 && !retry429) {
+        return ctx.returnRawErrors ? res : normalizeFinalGoogleError(label, res, ctx.abortSignal);
+      }
       if (!retryableGoogleStatus(res.status) || attempt === GOOGLE_RETRY_ATTEMPTS - 1) {
         return ctx.returnRawErrors ? res : normalizeFinalGoogleError(label, res, ctx.abortSignal);
       }
@@ -466,5 +489,5 @@ export function fetchVertexWithRetry(request: AdapterRequest, ctx: AdapterFetchC
 
 /** Antigravity (Cloud Code Assist) retry wrapper. */
 export function fetchAntigravityWithRetry(request: AdapterRequest, ctx: AdapterFetchContext = {}): Promise<Response> {
-  return fetchGoogleWithRetry("Antigravity", request, ctx);
+  return fetchGoogleWithRetry("Antigravity", request, ctx, { retry429: false });
 }

package/src/adapters/google-truncation.ts

@@ -12,6 +12,11 @@ export function vertexTruncationErrorMessage(reason?: string): string {
   return `Vertex AI response truncated upstream before the turn completed${suffix}`;
 }
 
+export function googleTruncationErrorMessage(reason?: string): string {
+  const suffix = reason ? ` (${redactSecretString(reason).slice(0, 160)})` : "";
+  return `Google AI Studio response truncated upstream before the turn completed${suffix}`;
+}
+
 /**
  * Whether a finished turn must fail closed. A truncation reason arriving mid tool call always
  * does. MALFORMED_FUNCTION_CALL fails closed even with zero started calls: the malformed call

package/src/adapters/google-wire-compiler.ts

@@ -5,6 +5,15 @@ type JsonObject = Record<string, unknown>;
 
 const GOOGLE_TOOL_NAME = /^[A-Za-z_][A-Za-z0-9_-]{0,63}$/;
 const GOOGLE_THINKING_LEVELS = new Set(["minimal", "low", "medium", "high"]);
+const GOOGLE_SAFETY_CATEGORIES = new Set([
+  "HARM_CATEGORY_HATE_SPEECH", "HARM_CATEGORY_SEXUALLY_EXPLICIT", "HARM_CATEGORY_DANGEROUS_CONTENT",
+  "HARM_CATEGORY_HARASSMENT", "HARM_CATEGORY_CIVIC_INTEGRITY", "HARM_CATEGORY_JAILBREAK",
+]);
+const GOOGLE_SAFETY_THRESHOLDS = new Set([
+  "HARM_BLOCK_THRESHOLD_UNSPECIFIED", "BLOCK_LOW_AND_ABOVE", "BLOCK_MEDIUM_AND_ABOVE",
+  "BLOCK_ONLY_HIGH", "BLOCK_NONE", "OFF",
+]);
+const GOOGLE_CACHED_CONTENT = /^(?:cachedContents\/[^/?#\s]+|projects\/[^/?#\s]+\/locations\/[^/?#\s]+\/cachedContents\/[^/?#\s]+)$/;
 
 function isObject(value: unknown): value is JsonObject {
   return !!value && typeof value === "object" && !Array.isArray(value);
@@ -158,12 +167,18 @@ function compileGenerationConfig(value: unknown): JsonObject | undefined {
     ))].slice(0, 5);
     if (stopSequences.length > 0) out.stopSequences = stopSequences;
   }
-  if (isObject(value.thinkingConfig) && typeof value.thinkingConfig.thinkingLevel === "string") {
-    const raw = value.thinkingConfig.thinkingLevel.toLowerCase();
-    const thinkingLevel = GOOGLE_THINKING_LEVELS.has(raw)
-      ? raw
-      : (["xhigh", "max", "ultra"].includes(raw) ? "high" : undefined);
-    if (thinkingLevel) out.thinkingConfig = { thinkingLevel };
+  if (isObject(value.thinkingConfig)) {
+    const config: JsonObject = {};
+    if (typeof value.thinkingConfig.thinkingBudget === "number"
+      && Number.isSafeInteger(value.thinkingConfig.thinkingBudget)
+      && value.thinkingConfig.thinkingBudget >= -1) config.thinkingBudget = value.thinkingConfig.thinkingBudget;
+    if (typeof value.thinkingConfig.includeThoughts === "boolean") config.includeThoughts = value.thinkingConfig.includeThoughts;
+    if (typeof value.thinkingConfig.thinkingLevel === "string") {
+      const raw = value.thinkingConfig.thinkingLevel.toLowerCase();
+      const thinkingLevel = GOOGLE_THINKING_LEVELS.has(raw) ? raw : (["xhigh", "max", "ultra"].includes(raw) ? "high" : undefined);
+      if (thinkingLevel && config.thinkingBudget === undefined) config.thinkingLevel = thinkingLevel;
+    }
+    if (Object.keys(config).length > 0) out.thinkingConfig = config;
   }
   if (Array.isArray(value.responseModalities)) {
     const valid = value.responseModalities.filter((m): m is string => typeof m === "string" && ["TEXT", "IMAGE", "AUDIO"].includes(m));
@@ -180,6 +195,20 @@ function compileGenerationConfig(value: unknown): JsonObject | undefined {
   return Object.keys(out).length > 0 ? out : undefined;
 }
 
+function compileSafetySettings(value: unknown): unknown[] | undefined {
+  if (!Array.isArray(value) || value.length > 16) return undefined;
+  const seen = new Set<string>();
+  const out: JsonObject[] = [];
+  for (const setting of value) {
+    if (!isObject(setting) || typeof setting.category !== "string" || !GOOGLE_SAFETY_CATEGORIES.has(setting.category)
+      || typeof setting.threshold !== "string" || !GOOGLE_SAFETY_THRESHOLDS.has(setting.threshold)
+      || seen.has(setting.category)) return undefined;
+    seen.add(setting.category);
+    out.push({ category: setting.category, threshold: setting.threshold });
+  }
+  return out.length > 0 ? out : undefined;
+}
+
 function compileToolConfig(value: unknown, toWireName: (name: string) => string): JsonObject | undefined {
   if (!isObject(value) || !isObject(value.functionCallingConfig)) return undefined;
   const raw = value.functionCallingConfig;
@@ -216,6 +245,9 @@ export function compileGoogleWireBody(input: unknown): {
   if (generationConfig) body.generationConfig = generationConfig;
   const toolConfig = compileToolConfig(source.toolConfig, names.toWire);
   if (toolConfig) body.toolConfig = toolConfig;
+  const safetySettings = compileSafetySettings(source.safetySettings);
+  if (safetySettings) body.safetySettings = safetySettings;
+  if (typeof source.cachedContent === "string" && GOOGLE_CACHED_CONTENT.test(source.cachedContent)) body.cachedContent = source.cachedContent;
   if (typeof source.sessionId === "string" && source.sessionId.length > 0) body.sessionId = source.sessionId;
   return { body, restoreToolName: names.fromWire };
 }

package/src/adapters/google.ts

@@ -1,7 +1,8 @@
-import type { AdapterFetchContext, AdapterRequest, ProviderAdapter } from "./base";
+import type { AdapterFetchContext, AdapterRequest, IncomingMeta, ProviderAdapter } from "./base";
 import { debugDroppedFrame } from "../lib/debug";
 import { createToolCallIdAllocator } from "./tool-call-id";
 import { createImageBudget, materializeInlineImage, MAX_ENCODED_BYTES_PER_IMAGE, artifactHttpUrl } from "../images/artifacts";
+import { OcxRequestValidationError } from "../lib/errors";
 import type {
   AdapterEvent,
   OcxAssistantMessage,
@@ -19,8 +20,9 @@ import { contentPartsToText, parseDataUrl } from "./image";
 import { getVertexAccessToken } from "../lib/gcp-adc";
 import { fetchAntigravityWithRetry, fetchVertexWithRetry } from "./google-http";
 import { safeAntigravityHttpErrorMessage, safeVertexHttpErrorMessage } from "./google-errors";
-import { isVertexTruncatedTurn, vertexTruncationErrorMessage } from "./google-truncation";
-import { ANTIGRAVITY_REQUEST_UA, antigravitySessionId, isLikelyRealThoughtSignature, sanitizeAntigravityClaudeSignatures } from "./google-antigravity-wire";
+import { sanitizeUpstreamErrorText } from "./upstream-http-error";
+import { googleTruncationErrorMessage, isVertexTruncatedTurn, vertexTruncationErrorMessage } from "./google-truncation";
+import { ANTIGRAVITY_REQUEST_UA, ANTIGRAVITY_SIGNATURE_BYPASS_SENTINEL, antigravitySessionId, isLikelyRealThoughtSignature, sanitizeAntigravityClaudeSignatures } from "./google-antigravity-wire";
 import { repairGoogleToolPairs, stripTrailingClaudePrefill } from "./google-antigravity-tools";
 import { canonicalAntigravityHttpsHost, isAntigravityHttpsHost } from "./google-antigravity-hosts";
 import { compileGoogleWireBody } from "./google-wire-compiler";
@@ -45,6 +47,16 @@ import {
 } from "../lib/translator-budget";
 import { buildNonOpenAIToolCatalogNudgeForTools } from "./tool-catalog-nudge";
 import { configuredReasoningEfforts, mapReasoningEffort } from "../reasoning-effort";
+import { normalizeAntigravityProviderError } from "../oauth/antigravity-routing";
+
+const INLINE_ERROR_URL_USERINFO = /https?:\/\/[^\s"'<>]*@/gi;
+
+function safeAntigravityInlineErrorMessage(value: unknown): string | undefined {
+  if (typeof value !== "string") return undefined;
+  return sanitizeUpstreamErrorText(value)
+    .replace(INLINE_ERROR_URL_USERINFO, "[REDACTED_URL]")
+    .slice(0, 500);
+}
 
 // Google-family models (Gemini/Vertex/Antigravity) tend to emit long running commentary between
 // tool calls. This steers them to keep the BETWEEN-STEP text to one line and reason internally
@@ -139,6 +151,19 @@ const GEMINI_EMPTY_PLACEHOLDER = "(empty)";
 const GEMINI_EMPTY_TOOL_OUTPUT_PLACEHOLDER = "(empty tool output)";
 const GEMINI_MISSING_TOOL_RESULT = "[missing tool_result for this tool_use in history]";
 
+function appendGeminiContent(
+  contents: unknown[],
+  next: { role: string; parts: unknown[] },
+  mergeAdjacentUsers = true,
+): void {
+  const previous = contents.at(-1) as { role?: unknown; parts?: unknown[] } | undefined;
+  if (mergeAdjacentUsers && previous?.role === "user" && next.role === "user" && Array.isArray(previous.parts)) {
+    previous.parts.push(...next.parts);
+  } else {
+    contents.push(next);
+  }
+}
+
 /** A Gemini text part, or undefined when the value cannot form a valid non-empty text block. */
 function geminiTextPart(text: unknown): { text: string } | undefined {
   return typeof text === "string" && text.length > 0 ? { text } : undefined;
@@ -208,6 +233,11 @@ function messagesToGeminiFormat(
   const systemInstruction = { parts: [{ text: systemText }] };
 
   const contents: unknown[] = [];
+  let userMergeBarrier = false;
+  const appendContent = (next: { role: string; parts: unknown[] }): void => {
+    appendGeminiContent(contents, next, !userMergeBarrier);
+    userMergeBarrier = false;
+  };
   const messages = repairGoogleToolPairs(parsed.context.messages, { dropUnmatchedCalls: repairToolPairs });
 
   const callIds = createToolCallIdAllocator();
@@ -226,7 +256,7 @@ function messagesToGeminiFormat(
       case "user":
       case "developer": {
         if (typeof msg.content === "string") {
-          contents.push({ role: "user", parts: [{ text: msg.content || GEMINI_EMPTY_PLACEHOLDER }] });
+          appendContent({ role: "user", parts: [{ text: msg.content || GEMINI_EMPTY_PLACEHOLDER }] });
         } else {
           const parts: unknown[] = [];
           for (const p of msg.content as OcxContentPart[]) {
@@ -241,7 +271,7 @@ function messagesToGeminiFormat(
             const textPart = geminiTextPart(p.text);
             if (textPart) parts.push(textPart);
           }
-          contents.push({ role: "user", parts: parts.length > 0 ? parts : [{ text: GEMINI_EMPTY_PLACEHOLDER }] });
+          appendContent({ role: "user", parts: parts.length > 0 ? parts : [{ text: GEMINI_EMPTY_PLACEHOLDER }] });
         }
         break;
       }
@@ -291,8 +321,11 @@ function messagesToGeminiFormat(
         // A turn with nothing Gemini can represent (e.g. thinking-only) would serialize as
         // `parts: []`, which the Anthropic translation rejects. Skip it, as the Anthropic
         // adapter does for its own empty assistant content.
-        if (parts.length === 0) break;
-        contents.push({ role: "model", parts });
+        if (parts.length === 0) {
+          userMergeBarrier = true;
+          break;
+        }
+        appendContent({ role: "model", parts });
         if (toolCalls.length > 0) {
           // Gemini/Claude-on-Antigravity requires one adjacent response batch for the whole
           // function-call turn. Replayed histories can be interrupted, reversed, duplicated, or
@@ -321,7 +354,7 @@ function messagesToGeminiFormat(
           for (const orphan of orphanResults) {
             responseParts.push(...geminiOrphanToolResultParts(orphan));
           }
-          contents.push({ role: "user", parts: responseParts });
+          appendContent({ role: "user", parts: responseParts });
           i = j - 1;
         }
         break;
@@ -332,7 +365,7 @@ function messagesToGeminiFormat(
         // batch never reach here (the assistant branch consumes them). Standalone or
         // barrier-delayed results still have to stay visible — especially image-bearing
         // screenshots — as explicit user text rather than vanishing or 400ing CCA.
-        contents.push({ role: "user", parts: geminiOrphanToolResultParts(msg as OcxToolResultMessage) });
+        appendContent({ role: "user", parts: geminiOrphanToolResultParts(msg as OcxToolResultMessage) });
         break;
       }
     }
@@ -395,6 +428,13 @@ function usageFromGemini(usage: Record<string, number> | undefined): OcxUsage |
   };
 }
 
+function googlePromptFeedbackError(root: Record<string, unknown>): Extract<AdapterEvent, { type: "error" }> | undefined {
+  const feedback = root.promptFeedback;
+  if (!isGoogleRecord(feedback) || typeof feedback.blockReason !== "string" || !feedback.blockReason.trim()) return undefined;
+  const reason = sanitizeUpstreamErrorText(feedback.blockReason).slice(0, 160);
+  return { type: "error", message: `google response blocked by prompt feedback: ${reason}` };
+}
+
 /**
  * Cap on the buffered non-streaming response body (100 MiB), matching
  * IMAGES_RESPONSE_MAX_BYTES in src/server/images.ts. Enforced by streaming the
@@ -672,6 +712,7 @@ function invalidGoogleShapeEvent(
 export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapter {
   // Per-request closure: resolveAdapter builds a fresh adapter per request (server.ts), so buildRequest
   // can stash the CCA model/session for parseStream's reasoning-replay observation.
+  let observeProviderError: IncomingMeta["onProviderError"];
   let antigravityModel: string | undefined;
   let antigravitySession: string | undefined;
   // Vertex returns the same opaque Gemini thought signatures as CCA, but its replay namespace
@@ -681,8 +722,23 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
   let vertexReplaySession: string | undefined;
   let restoreGoogleToolName = (name: string): string => name;
   const emitInTurnGroundingSourcesQueue: boolean[] = [];
+  const truncationErrorMessage = provider.googleMode === "vertex" || provider.googleMode === "cloud-code-assist"
+    ? vertexTruncationErrorMessage
+    : googleTruncationErrorMessage;
   return {
     name: "google",
+    validateRequest(parsed: OcxParsedRequest) {
+      if (provider.googleMode === "cloud-code-assist" && parsed.options.providerOptions?.google) {
+        throw new OcxRequestValidationError("provider_options.google is not supported on Google Cloud Code Assist routes");
+      }
+      const googleOptions = parsed.options.providerOptions?.google;
+      if (isImageCapableModel(parsed.modelId)
+        && (googleOptions?.thinkingBudget !== undefined || googleOptions?.includeThoughts !== undefined)) {
+        throw new OcxRequestValidationError(
+          "provider_options.google thinking_budget and include_thoughts are not supported for image-capable Gemini models",
+        );
+      }
+    },
 
     // Vertex + Antigravity get Kiro-style retry/timeout + classified, redacted errors.
     // Direct AI-Studio uses the canonical server transport (fetchWithTransientRetry), which
@@ -697,7 +753,8 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
         }
       : {}),
 
-    async buildRequest(parsed: OcxParsedRequest) {
+    async buildRequest(parsed: OcxParsedRequest, options?: IncomingMeta) {
+      observeProviderError = options?.onProviderError;
       const routedModelId = provider.googleMode === "cloud-code-assist"
         ? resolveAntigravityEffortWireModel(
             parsed.modelId,
@@ -723,6 +780,9 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
       // catalog is a guaranteed upstream 400.
       const toolConfig = tools ? toolChoiceToGeminiToolConfig(parsed) : undefined;
       if (toolConfig) body.toolConfig = toolConfig;
+      const googleOptions = parsed.options.providerOptions?.google;
+      if (googleOptions?.safetySettings) body.safetySettings = googleOptions.safetySettings;
+      if (googleOptions?.cachedContent) body.cachedContent = googleOptions.cachedContent;
 
       const generationConfig: Record<string, unknown> = {};
       if (parsed.options.maxOutputTokens) generationConfig.maxOutputTokens = parsed.options.maxOutputTokens;
@@ -744,7 +804,13 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
       const thinkingLevel = thinkingEligible
         ? mapReasoningEffort(provider, parsed.modelId, parsed.options.reasoning)
         : undefined;
-      if (thinkingLevel) generationConfig.thinkingConfig = { thinkingLevel };
+      if (!isImageCapableModel(parsed.modelId)) {
+        const thinkingConfig: Record<string, unknown> = {};
+        if (googleOptions?.thinkingBudget !== undefined) thinkingConfig.thinkingBudget = googleOptions.thinkingBudget;
+        else if (thinkingLevel) thinkingConfig.thinkingLevel = thinkingLevel;
+        if (googleOptions?.includeThoughts !== undefined) thinkingConfig.includeThoughts = googleOptions.includeThoughts;
+        if (Object.keys(thinkingConfig).length > 0) generationConfig.thinkingConfig = thinkingConfig;
+      }
       if (!generationConfig.thinkingConfig && isImageCapableModel(parsed.modelId)) {
         generationConfig.responseModalities = ["TEXT", "IMAGE"];
       }
@@ -816,6 +882,19 @@ 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;
+                  }
+                }
+              }
+            }
           } else {
             sanitizeAntigravityClaudeSignatures(contents);
           }
@@ -970,17 +1049,31 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
 
         // Inline provider error inside a 200 stream → terminal error (see openai-chat.ts).
         if (chunk.error) {
-          const err = chunk.error as { message?: string } | undefined;
+          const rawError = chunk.error as { code?: unknown; status?: unknown; message?: unknown };
+          const safeMessage = safeAntigravityInlineErrorMessage(rawError.message);
+          const error = normalizeAntigravityProviderError({
+            code: rawError.code,
+            status: rawError.status,
+            message: safeMessage,
+          });
+          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);
           }
-          yield { type: "error", message: err?.message ?? "upstream error" };
+          yield {
+            type: "error",
+            ...(error?.status !== undefined ? { status: error.status } : {}),
+            ...(error?.code ? { code: error.code } : {}),
+            message: err.message ?? "upstream error",
+          };
           return "terminate";
         }
 
@@ -1010,7 +1103,14 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
         // absent key and an empty array are already skipped here; `null` joins them. A non-null
         // non-array container is still claimed structure the parser cannot read, and stays
         // terminal.
-        if (rawCandidates === undefined || rawCandidates === null) return "continue";
+        if (rawCandidates === undefined || rawCandidates === null) {
+          const feedbackError = googlePromptFeedbackError(root);
+          if (feedbackError) {
+            yield feedbackError;
+            return "terminate";
+          }
+          return "continue";
+        }
         if (!Array.isArray(rawCandidates)) {
           yield invalidGoogleShapeEvent({
             reason: "candidates_not_array",
@@ -1018,7 +1118,14 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
           });
           return "terminate";
         }
-        if (rawCandidates.length === 0) return "continue";
+        if (rawCandidates.length === 0) {
+          const feedbackError = googlePromptFeedbackError(root);
+          if (feedbackError) {
+            yield feedbackError;
+            return "terminate";
+          }
+          return "continue";
+        }
         const rawCandidate = rawCandidates[0];
         if (!isGoogleRecord(rawCandidate)) {
           // Unlike a root `data: null` keepalive, this is a claimed response candidate. Treat it
@@ -1086,7 +1193,7 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
         if (parts) {
           for (const part of parts) {
             const sig = googlePartThoughtSignature(part);
-            if (part.thought === true && sig && isLikelyRealThoughtSignature(sig)) {
+            if (sig && isLikelyRealThoughtSignature(sig) && (part.thought === true || !part.functionCall)) {
               pendingStreamThoughtSig = sig;
             }
             const textEvent = googlePartTextEvent(part, filterCcaSearchSuggestionHtml);
@@ -1191,9 +1298,8 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
         }
         // Fail-closed: a turn cut off mid tool call (MAX_TOKENS / MALFORMED_FUNCTION_CALL) surfaces
         // an error instead of a silently-incomplete done. Mirrors kiro-truncation.
-        if ((provider.googleMode === "vertex" || provider.googleMode === "cloud-code-assist")
-          && isVertexTruncatedTurn(lastFinishReason, toolCallsStarted)) {
-          yield { type: "error", message: vertexTruncationErrorMessage(lastFinishReason) };
+        if (isVertexTruncatedTurn(lastFinishReason, toolCallsStarted)) {
+          yield { type: "error", message: truncationErrorMessage(lastFinishReason) };
           return;
         }
         if (!sawAnyFrame || !sawTerminalSignal) {
@@ -1237,7 +1343,8 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
       // Cloud Code Assist exposes only the SSE transport. Unary callers still use this
       // buffered adapter entry point, so collect the exact same events parseStream emits
       // instead of maintaining a second CCA JSON parser.
-      if (provider.googleMode === "cloud-code-assist") {
+      const isSse = response.headers.get("content-type")?.includes("text/event-stream") ?? false;
+      if (provider.googleMode === "cloud-code-assist" && isSse) {
         const events: AdapterEvent[] = [];
         let previousTail: AdapterEvent | undefined;
         try {
@@ -1326,10 +1433,24 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
         return events;
       };
       if (raw.error) {
-        const err = raw.error as { message?: string };
-        return finish([{ type: "error", message: err.message ?? "upstream error" }]);
+        const rawError = raw.error as { code?: unknown; status?: unknown; message?: unknown };
+        const safeMessage = safeAntigravityInlineErrorMessage(rawError.message);
+        const error = normalizeAntigravityProviderError({
+          code: rawError.code,
+          status: rawError.status,
+          message: safeMessage,
+        });
+        if (error) observeProviderError?.(error);
+        return finish([{
+          type: "error",
+          ...(error?.status !== undefined ? { status: error.status } : {}),
+          ...(error?.code ? { code: error.code } : {}),
+          message: error?.message ?? safeMessage ?? "upstream error",
+        }]);
       }
-      const json = raw;
+      const json = (provider.googleMode === "cloud-code-assist" && raw.response && typeof raw.response === "object" && !Array.isArray(raw.response))
+        ? (raw.response as Record<string, unknown>)
+        : raw;
       const events: AdapterEvent[] = [];
 
       const rawCandidates: unknown = json.candidates;
@@ -1345,6 +1466,8 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
       }
       const candidates = rawCandidates as { finishReason?: string }[] | undefined;
       if (!candidates?.length) {
+        const feedbackError = googlePromptFeedbackError(json);
+        if (feedbackError) return finish([feedbackError]);
         return finish([{ type: "error", message: "google response contained no candidates" }]);
       }
       const rawCandidate: unknown = candidates[0];
@@ -1417,9 +1540,8 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
 
       // Fail-closed truncation, same as the stream path: a non-stream turn cut off mid tool call
       // (MAX_TOKENS / MALFORMED_FUNCTION_CALL) surfaces an error instead of a silent done.
-      if (provider.googleMode === "vertex"
-        && isVertexTruncatedTurn(candidate.finishReason, toolCallsStarted)) {
-        return finish([{ type: "error", message: vertexTruncationErrorMessage(candidate.finishReason) }]);
+      if (isVertexTruncatedTurn(candidate.finishReason, toolCallsStarted)) {
+        return finish([{ type: "error", message: truncationErrorMessage(candidate.finishReason) }]);
       }
 
       const usage = json.usageMetadata as Record<string, number> | undefined;

package/src/adapters/kiro-tools.ts

@@ -172,6 +172,12 @@ function omittedToolCatalogNotice(kept: number, omitted: readonly OcxTool[], reg
   return `[opencodex] Kiro's outbound catalog budget allows ${kept} of ${kept + omitted.length} client tools this turn. Omitted and unavailable this turn: ${summary}.`;
 }
 
+function boundedCatalogPriority(tool: OcxTool): number {
+  if (tool.loadedFromToolSearch) return 0;
+  if (tool.toolSearch) return 1;
+  return 2;
+}
+
 export function convertKiroToolContext(
   parsed: OcxParsedRequest,
   registry: KiroToolNameRegistry = createKiroToolNameRegistry(),
@@ -181,9 +187,7 @@ export function convertKiroToolContext(
   // Validate every listed name even when tool_choice:none emulates a tool-free turn.
   for (const tool of tools) registry.alias(namespacedToolName(tool.namespace, tool.name));
   const effectiveTools = parsed.options.toolChoice === "none" ? [] : tools;
-  const convertedTools: unknown[] = [];
-  let omittedAt = effectiveTools.length;
-  for (const [index, tool] of effectiveTools.entries()) {
+  const convertedEntries = effectiveTools.map((tool, index) => {
     const description = tool.description || `Tool: ${tool.name}`;
     // Send the full namespaced wire name (e.g. mcp__chrome-devtools__navigate_page) so Kiro echoes
     // it back; the bridge's toolNsMap is keyed by this name and restores the MCP namespace Codex
@@ -198,19 +202,26 @@ export function convertKiroToolContext(
         inputSchema: { json: ensureRootObjectType(sanitizeKiroSchema(tool.parameters ?? {})) },
       },
     };
-    // Preserve declaration order and only omit a suffix. Ranking tools would make a catalog change
-    // silently alter which capability disappears; this deterministic policy is paired with a
-    // model-visible omission notice so unavailable tools are explicit rather than assumed absent.
+    return { tool, index, converted };
+  });
+  const exceedsBudget = convertedEntries.length > MAX_KIRO_TOOL_COUNT
+    || serializedToolCatalogBytes(convertedEntries.map(entry => entry.converted)) > MAX_KIRO_TOOL_CATALOG_BYTES;
+  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()) {
     if (
       convertedTools.length >= MAX_KIRO_TOOL_COUNT
-      || serializedToolCatalogBytes([...convertedTools, converted]) > MAX_KIRO_TOOL_CATALOG_BYTES
+      || serializedToolCatalogBytes([...convertedTools, entry.converted]) > MAX_KIRO_TOOL_CATALOG_BYTES
     ) {
       omittedAt = index;
       break;
     }
-    convertedTools.push(converted);
+    convertedTools.push(entry.converted);
   }
-  const omittedTools = effectiveTools.slice(omittedAt);
+  const omittedTools = candidates.slice(omittedAt).map(entry => entry.tool);
   return {
     tools: convertedTools,
     systemAdditions: omittedTools.length > 0 ? [omittedToolCatalogNotice(convertedTools.length, omittedTools, registry)] : [],

package/src/adapters/openai-chat.ts

@@ -1244,6 +1244,15 @@ function toolsToChatFormat(parsed: OcxParsedRequest, provider: OcxProviderConfig
       },
     }];
   });
+  if (xaiTarget) {
+    const omitted = tools.length - formatted.length;
+    debugProviderDiagnostic("openai-chat", "tool-catalog", {
+      declared: tools.length,
+      emitted: formatted.length,
+      omitted,
+      ...(omitted > 0 ? { omissionCause: "xai_schema_not_lossless" } : {}),
+    });
+  }
   return formatted.length > 0 ? formatted : undefined;
 }
 

package/src/adapters/openai-responses.ts

@@ -1686,7 +1686,7 @@ export function createResponsesPassthroughAdapter(provider: OcxProviderConfig):
       let convertedRoutedCustomToolNames: Set<string> | undefined;
       let routedCustomToolRepairNames: Set<string> | undefined;
       let convertedRoutedToolSearchNames: Set<string> | undefined;
-      let convertedRoutedNamespaceToolAliases: Map<string, { namespace: string; name: string }> | undefined;
+      let convertedRoutedNamespaceToolAliases: Map<string, { namespace: string; name: string; kind: "function" | "custom" }> | undefined;
       const unexpandedMiss = !!parsed.previousResponseId && parsed._previousResponseInputExpanded !== true;
       let outBody = stripPreviousResponseId(
         parsed._rawBody,