@bitkyc08/opencodex 2.7.34 → 2.7.35

package/src/adapters/google-tool-schema.ts

@@ -1,98 +1,173 @@
 type Schema = Record<string, unknown>;
 
-// Gemini / Antigravity (CCA) accept only an OpenAPI-3.0 subset for function `parameters`. Codex
-// emits full JSON-Schema (draft 2020-12) tool definitions, so passing them through verbatim makes
-// CCA reject the whole request with "Request contains an invalid argument" / "Unknown name ...".
-// Every keyword below was confirmed live against the Antigravity backend to trigger a 400.
-// `encrypted` is Codex's Responses-only marker (openai/codex 5f4d06ef, PR #26210) stamped on v2
-// collaboration tool schemas (spawn_agent/send_message/followup_task `message`); CCA rejects it
-// with 400 "Unknown name \"encrypted\"" (issue #85). It is an annotation for the ChatGPT backend
-// only, so dropping it never changes tool behavior.
-const DROPPED_SCHEMA_KEYS = new Set([
-  "$schema", "$id", "$comment", "$ref", "$defs", "definitions",
-  "examples", "patternProperties", "if", "then", "else",
-  "uniqueItems", "additionalItems", "unevaluatedProperties", "unevaluatedItems",
-  "dependentRequired", "dependentSchemas", "propertyNames", "contains",
-  "encrypted",
-]);
-
-const MAX_DEREF_DEPTH = 64;
+// Google documents this function-schema subset: type, nullable, required, format, description,
+// properties, items, enum, anyOf, $ref, and $defs. We inline local refs and normalize anyOf, so
+// only the eight scalar/container keywords below are ever emitted. Building from an allowlist
+// prevents new MCP/JSON-Schema annotations from turning into provider-wide 400 responses.
+const ALLOWED_TYPES = new Set(["string", "integer", "number", "boolean", "array", "object"]);
+const MAX_SCHEMA_DEPTH = 24; // Google's documented nesting limit is 32; leave headroom for CCA.
+const MAX_DEREF_DEPTH = 16;
+
+function isRecord(value: unknown): value is Schema {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
 
 function resolveRef(ref: string, defs: Map<string, unknown>): unknown {
-  // Only local pointers into the schema's own $defs/definitions are supported (e.g.
-  // "#/$defs/Foo"). Anything else cannot be inlined, so it collapses to an unconstrained object.
+  // Only local pointers into the schema's own $defs/definitions are safe to inline.
   const match = /^#\/(?:\$defs|definitions)\/(.+)$/.exec(ref);
   if (!match) return undefined;
-  return defs.get(decodeURIComponent(match[1].replace(/~1/g, "/").replace(/~0/g, "~")));
+  try {
+    return defs.get(decodeURIComponent(match[1].replace(/~1/g, "/").replace(/~0/g, "~")));
+  } catch {
+    return undefined;
+  }
 }
 
 function collectDefs(root: unknown, defs: Map<string, unknown>): void {
-  if (!root || typeof root !== "object") return;
+  if (!isRecord(root)) return;
   for (const bag of ["$defs", "definitions"] as const) {
-    const group = (root as Schema)[bag];
-    if (group && typeof group === "object" && !Array.isArray(group)) {
-      for (const [name, value] of Object.entries(group as Schema)) {
-        if (!defs.has(name)) defs.set(name, value);
-      }
+    const group = root[bag];
+    if (!isRecord(group)) continue;
+    for (const [name, value] of Object.entries(group)) {
+      if (!defs.has(name)) defs.set(name, value);
     }
   }
 }
 
-function normalizeType(value: unknown, out: Schema): void {
-  // JSON-Schema allows `type` to be an array (e.g. ["string","null"]); OpenAPI 3.0 does not.
-  // Collapse to the first non-null type and mark the field nullable when "null" was present.
-  if (!Array.isArray(value)) {
-    out.type = value;
-    return;
+function normalizeType(value: unknown, out: Schema, preserveNullType: boolean): void {
+  const candidates = Array.isArray(value) ? value : [value];
+  let sawNull = false;
+
+  for (const candidate of candidates) {
+    if (typeof candidate !== "string") continue;
+    const type = candidate.toLowerCase();
+    if (type === "null") {
+      sawNull = true;
+    } else if (out.type === undefined && ALLOWED_TYPES.has(type)) {
+      out.type = type;
+    }
+  }
+
+  if (!sawNull) return;
+  if (out.type !== undefined) out.nullable = true;
+  else if (preserveNullType) out.type = "null";
+  else out.nullable = true;
+}
+
+function sanitizeEnum(value: unknown): string[] | undefined {
+  if (!Array.isArray(value)) return undefined;
+  const values = [...new Set(value.filter((item): item is string => typeof item === "string"))];
+  return values.length > 0 ? values : undefined;
+}
+
+function normalizeAnyOf(
+  value: unknown,
+  defs: Map<string, unknown>,
+  depth: number,
+  refDepth: number,
+): Schema {
+  if (!Array.isArray(value) || value.length === 0) return {};
+  const schemas = value.map(item => sanitizeSchema(item, defs, depth + 1, refDepth, true));
+
+  const nonNullSchemas = schemas.filter(schema => schema.type !== "null");
+  const nullSchemas = schemas.filter(schema => schema.type === "null");
+  if (
+    nonNullSchemas.length === 1
+    && nullSchemas.length > 0
+    && nullSchemas.every(schema => Object.keys(schema).every(key => key === "type"))
+  ) {
+    return { ...nonNullSchemas[0], nullable: true };
+  }
+
+  const type = schemas[0]?.type;
+  const sameType = schemas.length > 0 && schemas.every(schema => schema.type === type);
+  const enumOnly = schemas.every(schema => {
+    const allowedKeys = type === undefined ? new Set(["enum"]) : new Set(["type", "enum"]);
+    return Array.isArray(schema.enum) && Object.keys(schema).every(key => allowedKeys.has(key));
+  });
+  if (sameType && enumOnly && type !== "null") {
+    const values = sanitizeEnum(schemas.flatMap(schema => schema.enum as unknown[]));
+    if (values) return { ...(typeof type === "string" ? { type } : {}), enum: values };
+  }
+
+  // CCA's Claude bridge turns typed anyOf branches into an invalid input_schema. Widen only this
+  // node when a union cannot be collapsed losslessly; parent annotations and structure survive.
+  return {};
+}
+
+function sanitizeProperties(
+  value: unknown,
+  defs: Map<string, unknown>,
+  depth: number,
+  refDepth: number,
+): Record<string, Schema> | undefined {
+  if (!isRecord(value)) return undefined;
+  const properties: Record<string, Schema> = Object.create(null) as Record<string, Schema>;
+  for (const [name, schema] of Object.entries(value)) {
+    // Property names form a name bag and must never be interpreted as schema keywords.
+    properties[name] = sanitizeSchema(schema, defs, depth + 1, refDepth, false);
   }
-  const nonNull = value.filter(t => t !== "null");
-  if (value.includes("null")) out.nullable = true;
-  if (nonNull.length > 0) out.type = nonNull[0];
+  return properties;
 }
 
-function sanitize(node: unknown, defs: Map<string, unknown>, depth: number): unknown {
-  if (Array.isArray(node)) return node.map(item => sanitize(item, defs, depth));
-  if (!node || typeof node !== "object") return node;
-  const input = node as Schema;
+function sanitizeSchema(
+  node: unknown,
+  defs: Map<string, unknown>,
+  depth: number,
+  refDepth: number,
+  preserveNullType: boolean,
+): Schema {
+  if (depth >= MAX_SCHEMA_DEPTH || !isRecord(node)) return {};
 
-  if (typeof input.$ref === "string" && depth < MAX_DEREF_DEPTH) {
-    const target = resolveRef(input.$ref, defs);
-    if (target && typeof target === "object") {
-      const merged: Schema = { ...(target as Schema) };
-      for (const [key, value] of Object.entries(input)) {
+  if (typeof node.$ref === "string" && refDepth < MAX_DEREF_DEPTH) {
+    const target = resolveRef(node.$ref, defs);
+    if (isRecord(target)) {
+      const merged: Schema = { ...target };
+      for (const [key, value] of Object.entries(node)) {
         if (key !== "$ref") merged[key] = value;
       }
-      return sanitize(merged, defs, depth + 1);
+      return sanitizeSchema(merged, defs, depth, refDepth + 1, preserveNullType);
     }
   }
 
   const out: Schema = {};
-  for (const [key, value] of Object.entries(input)) {
-    if (DROPPED_SCHEMA_KEYS.has(key)) continue;
-    if (key === "type") { normalizeType(value, out); continue; }
-    if (key === "const") { out.enum = [value]; continue; }
-    if (key === "exclusiveMinimum" && typeof value === "number") { out.minimum = value; continue; }
-    if (key === "exclusiveMaximum" && typeof value === "number") { out.maximum = value; continue; }
-    if (key === "required" && Array.isArray(value)) {
-      out.required = [...new Set(value.filter((item): item is string => typeof item === "string"))];
-      continue;
-    }
-    if (key === "additionalProperties") {
-      // A boolean additionalProperties is accepted, but a nested schema is only meaningful with
-      // its own sanitize pass.
-      out.additionalProperties = typeof value === "boolean" ? value : sanitize(value, defs, depth);
-      continue;
-    }
-    out[key] = sanitize(value, defs, depth);
+  normalizeType(node.type, out, preserveNullType);
+
+  if (typeof node.nullable === "boolean") out.nullable = node.nullable;
+  if (typeof node.description === "string") out.description = node.description;
+  if (typeof node.format === "string") out.format = node.format;
+
+  const enumValues = sanitizeEnum(node.enum ?? (typeof node.const === "string" ? [node.const] : undefined));
+  if (enumValues) out.enum = enumValues;
+
+  const properties = sanitizeProperties(node.properties, defs, depth, refDepth);
+  if (properties) out.properties = properties;
+
+  if (isRecord(node.items)) {
+    out.items = sanitizeSchema(node.items, defs, depth + 1, refDepth, false);
+  }
+
+  if (Array.isArray(node.required)) {
+    out.required = [...new Set(node.required.filter((item): item is string => typeof item === "string"))];
   }
+
+  if (node.anyOf !== undefined) Object.assign(out, normalizeAnyOf(node.anyOf, defs, depth, refDepth));
   return out;
 }
 
 export function sanitizeGeminiToolParameters(parameters: unknown): Record<string, unknown> {
-  const defs = new Map<string, unknown>();
-  collectDefs(parameters, defs);
-  const result = sanitize(parameters, defs, 0);
-  return result && typeof result === "object" && !Array.isArray(result)
-    ? result as Record<string, unknown>
-    : { type: "object" };
+  try {
+    const defs = new Map<string, unknown>();
+    collectDefs(parameters, defs);
+    const root = sanitizeSchema(parameters, defs, 0, 0, false);
+
+    // Function arguments are always an object. Claude additionally rejects root composition and a
+    // missing root type even when those forms are valid general-purpose JSON Schema.
+    root.type = "object";
+    if (!isRecord(root.properties)) root.properties = {};
+    return root;
+  } catch {
+    // Last-resort containment: no third-party schema may break every tool in the request.
+    return { type: "object", properties: {} };
+  }
 }

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

@@ -0,0 +1,228 @@
+import { createHash } from "node:crypto";
+import { sanitizeGeminiToolParameters } from "./google-tool-schema";
+
+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"]);
+
+function isObject(value: unknown): value is JsonObject {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+function toolNameCodec(names: readonly string[]): {
+  toWire: (name: string) => string;
+  fromWire: (name: string) => string;
+} {
+  const toWire = new Map<string, string>();
+  const fromWire = new Map<string, string>();
+  const used = new Set<string>();
+
+  for (const name of names) {
+    if (toWire.has(name)) continue;
+    if (GOOGLE_TOOL_NAME.test(name) && !used.has(name)) {
+      toWire.set(name, name);
+      fromWire.set(name, name);
+      used.add(name);
+      continue;
+    }
+
+    let cleaned = name.replace(/[^A-Za-z0-9_-]/g, "_");
+    if (!/^[A-Za-z_]/.test(cleaned)) cleaned = `_${cleaned}`;
+    const prefix = (cleaned || "tool").slice(0, 55);
+    for (let salt = 0; ; salt++) {
+      const hashInput = salt === 0 ? name : `${name}#${salt}`;
+      const suffix = createHash("sha256").update(hashInput).digest("hex").slice(0, 8);
+      const candidate = `${prefix}_${suffix}`;
+      if (used.has(candidate)) continue;
+      toWire.set(name, candidate);
+      fromWire.set(candidate, name);
+      used.add(candidate);
+      break;
+    }
+  }
+
+  return {
+    toWire: name => toWire.get(name) ?? name,
+    fromWire: name => fromWire.get(name) ?? name,
+  };
+}
+
+function collectToolNames(body: JsonObject): string[] {
+  const names: string[] = [];
+  if (Array.isArray(body.tools)) {
+    for (const rawTool of body.tools) {
+      if (!isObject(rawTool) || !Array.isArray(rawTool.functionDeclarations)) continue;
+      for (const rawDeclaration of rawTool.functionDeclarations) {
+        if (isObject(rawDeclaration) && typeof rawDeclaration.name === "string") names.push(rawDeclaration.name);
+      }
+    }
+  }
+  if (Array.isArray(body.contents)) {
+    for (const rawContent of body.contents) {
+      if (!isObject(rawContent) || !Array.isArray(rawContent.parts)) continue;
+      for (const rawPart of rawContent.parts) {
+        if (!isObject(rawPart)) continue;
+        for (const key of ["functionCall", "functionResponse"]) {
+          const call = rawPart[key];
+          if (isObject(call) && typeof call.name === "string") names.push(call.name);
+        }
+      }
+    }
+  }
+  return names;
+}
+
+function compileContents(value: unknown, toWireName: (name: string) => string): unknown[] | undefined {
+  if (!Array.isArray(value)) return undefined;
+  return value.map(rawContent => {
+    if (!isObject(rawContent)) return {};
+    const content = { ...rawContent };
+    if (!Array.isArray(rawContent.parts)) return content;
+    content.parts = rawContent.parts.map(rawPart => {
+      if (!isObject(rawPart)) return {};
+      const part = { ...rawPart };
+      for (const key of ["functionCall", "functionResponse"]) {
+        const call = rawPart[key];
+        if (isObject(call) && typeof call.name === "string") {
+          part[key] = { ...call, name: toWireName(call.name) };
+        }
+      }
+      return part;
+    });
+    return content;
+  });
+}
+
+function compileTools(value: unknown, toWireName: (name: string) => string): unknown[] | undefined {
+  if (!Array.isArray(value)) return undefined;
+  const tools = value.flatMap(rawTool => {
+    if (!isObject(rawTool) || !Array.isArray(rawTool.functionDeclarations)) return [];
+    const functionDeclarations = rawTool.functionDeclarations.flatMap(rawDeclaration => {
+      if (!isObject(rawDeclaration) || typeof rawDeclaration.name !== "string") return [];
+      return [{
+        name: toWireName(rawDeclaration.name),
+        ...(typeof rawDeclaration.description === "string" ? { description: rawDeclaration.description } : {}),
+        parameters: sanitizeGeminiToolParameters(rawDeclaration.parameters),
+      }];
+    });
+    return functionDeclarations.length > 0 ? [{ functionDeclarations }] : [];
+  });
+  return tools.length > 0 ? tools : undefined;
+}
+
+function finiteNumber(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
+function compileGenerationConfig(value: unknown): JsonObject | undefined {
+  if (!isObject(value)) return undefined;
+  const out: JsonObject = {};
+  const maxOutputTokens = finiteNumber(value.maxOutputTokens);
+  if (maxOutputTokens !== undefined && maxOutputTokens > 0) out.maxOutputTokens = Math.floor(maxOutputTokens);
+  const temperature = finiteNumber(value.temperature);
+  if (temperature !== undefined && temperature >= 0) out.temperature = Math.min(2, temperature);
+  const topP = finiteNumber(value.topP);
+  if (topP !== undefined && topP >= 0) out.topP = Math.min(1, topP);
+  if (Array.isArray(value.stopSequences)) {
+    const stopSequences = [...new Set(value.stopSequences.filter(
+      (item): item is string => typeof item === "string" && item.length > 0,
+    ))].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 };
+  }
+  return Object.keys(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;
+  const out: JsonObject = {};
+  if (typeof raw.mode === "string" && ["AUTO", "ANY", "NONE", "VALIDATED"].includes(raw.mode.toUpperCase())) {
+    out.mode = raw.mode.toUpperCase();
+  }
+  if (Array.isArray(raw.allowedFunctionNames)) {
+    const names = raw.allowedFunctionNames
+      .filter((name): name is string => typeof name === "string")
+      .map(toWireName);
+    if (names.length > 0) out.allowedFunctionNames = names;
+  }
+  return Object.keys(out).length > 0 ? { functionCallingConfig: out } : undefined;
+}
+
+/**
+ * Final trust boundary for every Google-family request. The adapter may build a convenient
+ * Gemini-shaped object; only this compiler is allowed to decide what reaches the wire.
+ */
+export function compileGoogleWireBody(input: unknown): {
+  body: JsonObject;
+  restoreToolName: (name: string) => string;
+} {
+  const source = isObject(input) ? input : {};
+  const names = toolNameCodec(collectToolNames(source));
+  const body: JsonObject = {};
+  const contents = compileContents(source.contents, names.toWire);
+  if (contents) body.contents = contents;
+  if (isObject(source.systemInstruction)) body.systemInstruction = source.systemInstruction;
+  const tools = compileTools(source.tools, names.toWire);
+  if (tools) body.tools = tools;
+  const generationConfig = compileGenerationConfig(source.generationConfig);
+  if (generationConfig) body.generationConfig = generationConfig;
+  const toolConfig = compileToolConfig(source.toolConfig, names.toWire);
+  if (toolConfig) body.toolConfig = toolConfig;
+  if (typeof source.sessionId === "string" && source.sessionId.length > 0) body.sessionId = source.sessionId;
+  return { body, restoreToolName: names.fromWire };
+}
+
+function functionDeclarations(root: JsonObject): JsonObject[] {
+  if (!Array.isArray(root.tools)) return [];
+  return root.tools.flatMap(rawTool => {
+    if (!isObject(rawTool) || !Array.isArray(rawTool.functionDeclarations)) return [];
+    return rawTool.functionDeclarations.filter(isObject);
+  });
+}
+
+/** Build a changed request for one known-safe replay of an INVALID_ARGUMENT response. */
+export function repairGoogleInvalidRequestBody(body: string, errorPayload: string): string | undefined {
+  const schemaError = /(?:input[_ ]schema|json schema|function[_ ]declarations?|x-mcp-header)/i.test(errorPayload);
+  const thinkingError = /thinking[_ ]?(?:config|level)/i.test(errorPayload);
+  if (!schemaError && !thinkingError) return undefined;
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(body) as unknown;
+  } catch {
+    return undefined;
+  }
+  if (!isObject(parsed)) return undefined;
+  const root = isObject(parsed.request) ? parsed.request : parsed;
+  let changed = false;
+
+  if (thinkingError && isObject(root.generationConfig) && "thinkingConfig" in root.generationConfig) {
+    delete root.generationConfig.thinkingConfig;
+    if (Object.keys(root.generationConfig).length === 0) delete root.generationConfig;
+    changed = true;
+  }
+
+  if (schemaError) {
+    const declarations = functionDeclarations(root);
+    if (declarations.length > 0) {
+      const indexed = /tools(?:\.|\[)(\d+)(?:\])?\.custom\.input_schema/i.exec(errorPayload)?.[1]
+        ?? /function[_]?declarations(?:\.|\[)(\d+)/i.exec(errorPayload)?.[1];
+      const index = indexed === undefined ? -1 : Number.parseInt(indexed, 10);
+      const rejected = declarations[index];
+      const targets = rejected ? [rejected] : declarations;
+      for (const declaration of targets) {
+        declaration.parameters = { type: "object", properties: {} };
+        delete declaration.parametersJsonSchema;
+      }
+      changed = true;
+    }
+  }
+  return changed ? JSON.stringify(parsed) : undefined;
+}

package/src/adapters/google.ts

@@ -18,7 +18,7 @@ import { fetchAntigravityWithRetry, fetchVertexWithRetry } from "./google-http";
 import { safeAntigravityHttpErrorMessage, safeVertexHttpErrorMessage } from "./google-errors";
 import { isVertexTruncationReason, vertexTruncationErrorMessage } from "./google-truncation";
 import { ANTIGRAVITY_REQUEST_UA, antigravitySessionId, isLikelyRealThoughtSignature, sanitizeAntigravityClaudeSignatures } from "./google-antigravity-wire";
-import { sanitizeGeminiToolParameters } from "./google-tool-schema";
+import { compileGoogleWireBody } from "./google-wire-compiler";
 import { neutralizeIdentity } from "./identity";
 import { antigravityUsesReplayCache, applyAntigravityReplay, clearAntigravityReplay, observeAntigravityReplay } from "./google-antigravity-replay";
 import { resolveAntigravityEffortWireModel } from "../providers/antigravity-models";
@@ -179,7 +179,7 @@ function toolsToGeminiFormat(parsed: OcxParsedRequest): unknown[] | undefined {
     functionDeclarations: tools.map(t => ({
       name: namespacedToolName(t.namespace, t.name),
       description: t.description,
-      parameters: sanitizeGeminiToolParameters(t.parameters),
+      parameters: t.parameters,
     })),
   }];
 }
@@ -199,6 +199,7 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
   // can stash the CCA model/session for parseStream's reasoning-replay observation.
   let antigravityModel: string | undefined;
   let antigravitySession: string | undefined;
+  let restoreGoogleToolName = (name: string): string => name;
   return {
     name: "google",
 
@@ -262,23 +263,27 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
         }
         // Reasoning continuity: Gemini models re-inject cached thoughtSignatures; Claude-on-Antigravity
         // sanitizes signatures inline (no cache). Both guard against the upstream 400 on bad signatures.
-        if (Array.isArray((body as { contents?: unknown[] }).contents)) {
-          const contents = (body as { contents: unknown[] }).contents;
-          if (antigravityUsesReplayCache(wireModelId)) {
-            applyAntigravityReplay(wireModelId, sessionId, contents);
-          } else {
-            sanitizeAntigravityClaudeSignatures(contents);
-          }
-        }
         // The real Antigravity client puts the session id ONLY at `request.sessionId` (camelCase,
         // nested) — matching CLIProxyAPI `generateStableSessionID`. An extra top-level/snake_case
         // spelling is a non-first-party key, so we send the single canonical location.
-        const request: Record<string, unknown> = { ...body, sessionId };
+        const draftRequest: Record<string, unknown> = { ...body, sessionId };
         // Claude-on-Antigravity forces VALIDATED function calling (the real client always sets it).
         if (/claude/i.test(wireModelId)) {
-          const existing = (request.toolConfig ?? {}) as Record<string, unknown>;
+          const existing = (draftRequest.toolConfig ?? {}) as Record<string, unknown>;
           const fcc = (existing.functionCallingConfig ?? {}) as Record<string, unknown>;
-          request.toolConfig = { ...existing, functionCallingConfig: { ...fcc, mode: "VALIDATED" } };
+          draftRequest.toolConfig = { ...existing, functionCallingConfig: { ...fcc, mode: "VALIDATED" } };
+        }
+        const compiled = compileGoogleWireBody(draftRequest);
+        const request = compiled.body;
+        restoreGoogleToolName = compiled.restoreToolName;
+        // Compile names before replay: signatures are keyed by the exact provider-visible name.
+        if (Array.isArray((request as { contents?: unknown[] }).contents)) {
+          const contents = (request as { contents: unknown[] }).contents;
+          if (antigravityUsesReplayCache(wireModelId)) {
+            applyAntigravityReplay(wireModelId, sessionId, contents);
+          } else {
+            sanitizeAntigravityClaudeSignatures(contents);
+          }
         }
         const envelope = {
           model: wireModelId,
@@ -297,12 +302,14 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
       }
 
       if (provider.googleMode === "vertex") {
+        const compiled = compileGoogleWireBody(body);
+        restoreGoogleToolName = compiled.restoreToolName;
         // Vertex AI: project/location endpoint with GCP ADC, or x-goog-api-key fast path.
         const apiKey = resolveVertexApiKey(provider.apiKey);
         if (apiKey) {
           const url = `https://aiplatform.googleapis.com/v1/publishers/google/models/${parsed.modelId}:${method}${streamParam}`;
           headers["x-goog-api-key"] = apiKey;
-          return { url, method: "POST", headers, body: JSON.stringify(body) };
+          return { url, method: "POST", headers, body: JSON.stringify(compiled.body) };
         }
         const project = provider.project || process.env.GOOGLE_CLOUD_PROJECT || process.env.GCLOUD_PROJECT;
         if (!project) throw new Error("Vertex AI requires a project id (provider.project or GOOGLE_CLOUD_PROJECT/GCLOUD_PROJECT).");
@@ -312,7 +319,7 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
         const url = `https://${host}/v1/projects/${project}/locations/${location}/publishers/google/models/${parsed.modelId}:${method}${streamParam}`;
         const token = await getVertexAccessToken();
         headers["Authorization"] = `Bearer ${token}`;
-        return { url, method: "POST", headers, body: JSON.stringify(body) };
+        return { url, method: "POST", headers, body: JSON.stringify(compiled.body) };
       }
 
       // ai-studio (default): Generative Language API + x-goog-api-key.
@@ -321,7 +328,9 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
       if (!apiKey) throw new Error("google (AI Studio) requires a non-empty API key");
       headers["x-goog-api-key"] = apiKey;
 
-      return { url, method: "POST", headers, body: JSON.stringify(body) };
+      const compiled = compileGoogleWireBody(body);
+      restoreGoogleToolName = compiled.restoreToolName;
+      return { url, method: "POST", headers, body: JSON.stringify(compiled.body) };
     },
 
     async *parseStream(response: Response): AsyncGenerator<AdapterEvent> {
@@ -403,7 +412,7 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
                 if (part.functionCall) {
                   const id = `call_${crypto.randomUUID().slice(0, 8)}`;
                   toolCallsStarted++;
-                  yield { type: "tool_call_start", id, name: part.functionCall.name };
+                  yield { type: "tool_call_start", id, name: restoreGoogleToolName(part.functionCall.name) };
                   yield { type: "tool_call_delta", arguments: JSON.stringify(part.functionCall.args ?? {}) };
                   yield { type: "tool_call_end" };
                 }
@@ -456,7 +465,7 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
           if (part.functionCall) {
             const id = `call_${crypto.randomUUID().slice(0, 8)}`;
             toolCallsStarted++;
-            events.push({ type: "tool_call_start", id, name: part.functionCall.name });
+            events.push({ type: "tool_call_start", id, name: restoreGoogleToolName(part.functionCall.name) });
             events.push({ type: "tool_call_delta", arguments: JSON.stringify(part.functionCall.args ?? {}) });
             events.push({ type: "tool_call_end" });
           }

package/src/adapters/kiro.ts

@@ -846,6 +846,14 @@ async function* parseKiroAttempt(
         ...(contextWindow ? { configuredContextWindow: contextWindow } : {}),
       });
     }
+    debugProviderDiagnostic("kiro", "attempt_complete", {
+      mode,
+      sawText,
+      sawReasoning,
+      sawRealTool,
+      completionCalls,
+      assistantChars: assistantText.length,
+    });
 
     if (mode === "text_fallback") {
       if (completionAnswer !== undefined) {
@@ -909,7 +917,23 @@ async function* parseKiroAttempt(
         terminal: { type: "done", usage: finalUsage, endTurn: false, ...(finalProviderState ? { providerState: finalProviderState } : {}) },
       };
     }
-    if (mode === "required" && (sawText || sawReasoning)) {
+    // A clean Smithy EOF after ordinary assistant text is a complete answer even when the
+    // private completion tool was advertised. Replaying that answer through a second Kiro
+    // request adds latency and can hang an otherwise-finished Codex turn if the retry stalls.
+    // Reasoning-only output still needs the bounded fallback because it has no user-facing text.
+    if (mode === "required" && sawText) {
+      return {
+        assistantText,
+        sawReasoning,
+        terminal: {
+          type: "done",
+          usage: finalUsage,
+          endTurn: true,
+          ...(finalProviderState ? { providerState: finalProviderState } : {}),
+        },
+      };
+    }
+    if (mode === "required" && sawReasoning) {
       return { assistantText, sawReasoning, needsFallback: true, usage: finalUsage, providerState: finalProviderState };
     }
     if (!sawText && !sawReasoning) {