@remodex/rmx 1.0.2

package/src/adapters/google-errors.ts

@@ -0,0 +1,85 @@
+import { parseUpstreamJsonPayload, safeUpstreamErrorString, sanitizeUpstreamErrorText } from "./upstream-http-error";
+
+/** Pull the human detail out of the Google API error envelope `{error:{message,status,code}}`. */
+function googleErrorDetail(payloadText: string): { message?: string; status?: string } {
+  const trimmed = payloadText.trim();
+  if (!trimmed || (!trimmed.startsWith("{") && !trimmed.startsWith("["))) {
+    return { message: trimmed || undefined };
+  }
+  const parsed = parseUpstreamJsonPayload(trimmed);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+  const err = (parsed as { error?: { message?: unknown; status?: unknown } }).error;
+  return {
+    message: safeUpstreamErrorString(err?.message),
+    status: safeUpstreamErrorString(err?.status),
+  };
+}
+
+function classifyGoogle(label: string, status: number | undefined, enumStatus: string | undefined, text: string): string {
+  const lower = `${enumStatus ?? ""} ${text}`.toLowerCase();
+  const quotaExhausted =
+    lower.includes("quotafailure") ||
+    lower.includes("quota exceeded") ||
+    lower.includes("exceeded your current quota") ||
+    lower.includes("billing");
+  if (enumStatus === "RESOURCE_EXHAUSTED" && quotaExhausted) return `${label} quota exhausted`;
+  if (status === 429 || enumStatus === "RESOURCE_EXHAUSTED" || lower.includes("rate limit")) {
+    return `${label} rate limit exceeded`;
+  }
+  if (status === 401 || enumStatus === "UNAUTHENTICATED" || lower.includes("unauthenticated") || lower.includes("invalid authentication") || lower.includes("expired")) {
+    return `${label} authentication failed`;
+  }
+  if (status === 403 || enumStatus === "PERMISSION_DENIED" || lower.includes("permission denied") || lower.includes("access denied")) {
+    return `${label} access denied`;
+  }
+  if (status === 503 || enumStatus === "UNAVAILABLE" || lower.includes("overloaded") || lower.includes("unavailable")) {
+    return `${label} server overloaded`;
+  }
+  if (status === 400 || status === 404 || enumStatus === "INVALID_ARGUMENT" || enumStatus === "NOT_FOUND" || lower.includes("invalid") || lower.includes("not found") || lower.includes("malformed")) {
+    return `${label} invalid request`;
+  }
+  return `${label} upstream error`;
+}
+
+/**
+ * Normalize a Google/Vertex/Antigravity HTTP error body into a short, classified, secret-redacted
+ * message. Mirrors `kiro-errors.ts`. `label` is the provider-facing prefix ("Vertex AI",
+ * "Antigravity").
+ */
+export function safeGoogleHttpErrorMessage(label: string, status: number, payloadText: string): string {
+  const { message, status: enumStatus } = googleErrorDetail(payloadText);
+  const prefix = classifyGoogle(label, status, enumStatus, [message, enumStatus].filter(Boolean).join(" "));
+  const detail = message ? sanitizeUpstreamErrorText(message).slice(0, 500) : `HTTP ${status}`;
+  return `${prefix}: ${detail}`;
+}
+
+/** Vertex AI HTTP error message (label = "Vertex AI"). */
+export function safeVertexHttpErrorMessage(status: number, payloadText: string): string {
+  return safeGoogleHttpErrorMessage("Vertex AI", status, payloadText);
+}
+
+/** Antigravity (Cloud Code Assist) HTTP error message (label = "Antigravity"). */
+export function safeAntigravityHttpErrorMessage(status: number, payloadText: string): string {
+  return safeGoogleHttpErrorMessage("Antigravity", status, payloadText);
+}
+
+/** Google-family retryable HTTP set (mirrors Kiro). Quota-exhausted is classified above and not retried. */
+export function retryableGoogleStatus(status: number): boolean {
+  return status === 429 || status === 500 || status === 502 || status === 503 || status === 504;
+}
+
+/**
+ * True when a 429 body indicates hard quota exhaustion (not a transient rate limit). Quota
+ * exhaustion is generally not expected to recover for hours (AIP-194), so it must NOT be retried —
+ * unlike a plain rate limit. The HTTP status alone can't distinguish the two, so the retry layer
+ * inspects the body with this.
+ */
+export function isQuotaExhaustedBody(payloadText: string): boolean {
+  const { message, status } = googleErrorDetail(payloadText);
+  if (status !== "RESOURCE_EXHAUSTED") return false;
+  const lower = (message ?? "").toLowerCase();
+  return lower.includes("quotafailure")
+    || lower.includes("quota exceeded")
+    || lower.includes("exceeded your current quota")
+    || lower.includes("billing");
+}

package/src/adapters/google-http.ts

@@ -0,0 +1,100 @@
+import type { AdapterFetchContext, AdapterRequest } from "./base";
+import { isQuotaExhaustedBody, retryableGoogleStatus, safeGoogleHttpErrorMessage } from "./google-errors";
+import { repairGoogleInvalidRequestBody } from "./google-wire-compiler";
+import { normalizeUpstreamHttpErrorResponse, readDisplaySafeErrorPayloadText } from "./upstream-http-error";
+import {
+  abortError,
+  cancelResponseBodyBestEffort,
+  fetchWithAttemptDeadline,
+  retryBackoffDelayMs,
+  sleepWithAbort,
+} from "../lib/upstream-retry";
+
+const GOOGLE_RETRY_ATTEMPTS = 3;
+const GOOGLE_RETRY_BASE_MS = 250;
+const GOOGLE_RETRY_MAX_MS = 2_000;
+
+async function normalizeFinalGoogleError(label: string, res: Response, signal?: AbortSignal): Promise<Response> {
+  return normalizeUpstreamHttpErrorResponse(res, {
+    signal,
+    formatMessage: payloadText => safeGoogleHttpErrorMessage(label, res.status, payloadText),
+  });
+}
+
+/**
+ * Fetch a Google-family upstream (Vertex / Antigravity) with Kiro-style hardening: per-attempt
+ * timeout (`AbortSignal.any([parent, timeout])`), bounded retry on transient status / network
+ * errors, `Retry-After` honoring, jittered exponential backoff, and a classified + redacted final
+ * error body. `label` is the provider-facing prefix used in error messages.
+ */
+export async function fetchGoogleWithRetry(label: string, request: AdapterRequest, ctx: AdapterFetchContext = {}): Promise<Response> {
+  const timeoutMs = ctx.timeoutMs ?? 200_000;
+  let lastError: unknown;
+  let activeRequest = request;
+  let compatibilityReplayUsed = false;
+  for (let attempt = 0; attempt < GOOGLE_RETRY_ATTEMPTS; attempt++) {
+    if (ctx.abortSignal?.aborted) throw abortError(ctx.abortSignal);
+    try {
+      const res = await fetchWithAttemptDeadline(activeRequest.url, {
+        method: activeRequest.method,
+        headers: activeRequest.headers,
+        body: activeRequest.body,
+      }, timeoutMs, ctx.abortSignal, ctx.stream);
+      if (res.status === 400 && !compatibilityReplayUsed) {
+        let payloadText = "";
+        try {
+          payloadText = await readDisplaySafeErrorPayloadText(res.clone(), ctx.abortSignal);
+        } catch (error) {
+          if (ctx.abortSignal?.aborted) throw error;
+        }
+        const repairedBody = repairGoogleInvalidRequestBody(activeRequest.body, payloadText);
+        if (repairedBody !== undefined) {
+          compatibilityReplayUsed = true;
+          activeRequest = { ...activeRequest, body: repairedBody };
+          cancelResponseBodyBestEffort(res);
+          attempt--; // The changed-request replay is separate from transient retry accounting.
+          continue;
+        }
+      }
+      if (!retryableGoogleStatus(res.status) || attempt === GOOGLE_RETRY_ATTEMPTS - 1) {
+        return ctx.returnRawErrors ? res : normalizeFinalGoogleError(label, res, ctx.abortSignal);
+      }
+      // A 429 may be a transient rate limit (retry) or hard quota exhaustion (do NOT retry —
+      // it won't recover for hours and burns retries). Peek the body to tell them apart.
+      if (res.status === 429 && !ctx.returnRawErrors) {
+        const peek = await readDisplaySafeErrorPayloadText(res, ctx.abortSignal);
+        if (isQuotaExhaustedBody(peek)) {
+          return normalizeUpstreamHttpErrorResponse(res, {
+            signal: ctx.abortSignal,
+            formatMessage: payloadText => safeGoogleHttpErrorMessage(label, res.status, payloadText || peek),
+          });
+        }
+      }
+      cancelResponseBodyBestEffort(res);
+      await sleepWithAbort(retryBackoffDelayMs(attempt, {
+        baseDelayMs: GOOGLE_RETRY_BASE_MS,
+        maxDelayMs: GOOGLE_RETRY_MAX_MS,
+        headers: res.headers,
+      }), ctx.abortSignal);
+    } catch (err) {
+      if (ctx.abortSignal?.aborted) throw err;
+      lastError = err;
+      if (attempt === GOOGLE_RETRY_ATTEMPTS - 1) throw err;
+      await sleepWithAbort(retryBackoffDelayMs(attempt, {
+        baseDelayMs: GOOGLE_RETRY_BASE_MS,
+        maxDelayMs: GOOGLE_RETRY_MAX_MS,
+      }), ctx.abortSignal);
+    }
+  }
+  throw lastError ?? new Error(`${label} fetch failed`);
+}
+
+/** Vertex AI retry wrapper. */
+export function fetchVertexWithRetry(request: AdapterRequest, ctx: AdapterFetchContext = {}): Promise<Response> {
+  return fetchGoogleWithRetry("Vertex AI", request, ctx);
+}
+
+/** Antigravity (Cloud Code Assist) retry wrapper. */
+export function fetchAntigravityWithRetry(request: AdapterRequest, ctx: AdapterFetchContext = {}): Promise<Response> {
+  return fetchGoogleWithRetry("Antigravity", request, ctx);
+}

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

@@ -0,0 +1,173 @@
+type Schema = Record<string, unknown>;
+
+// 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 safe to inline.
+  const match = /^#\/(?:\$defs|definitions)\/(.+)$/.exec(ref);
+  if (!match) return undefined;
+  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 (!isRecord(root)) return;
+  for (const bag of ["$defs", "definitions"] as const) {
+    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, 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);
+  }
+  return properties;
+}
+
+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 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 sanitizeSchema(merged, defs, depth, refDepth + 1, preserveNullType);
+    }
+  }
+
+  const out: Schema = {};
+  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> {
+  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-truncation.ts

@@ -0,0 +1,24 @@
+import { redactSecretString } from "../lib/redact";
+
+/** Gemini/Vertex finishReason values that mean the turn was cut off, not cleanly stopped. */
+const TRUNCATION_REASONS = new Set(["MAX_TOKENS", "MALFORMED_FUNCTION_CALL"]);
+
+export function isVertexTruncationReason(finishReason: string | undefined): boolean {
+  return finishReason !== undefined && TRUNCATION_REASONS.has(finishReason);
+}
+
+export function vertexTruncationErrorMessage(reason?: string): string {
+  const suffix = reason ? ` (${redactSecretString(reason).slice(0, 160)})` : "";
+  return `Vertex AI 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
+ * is dropped upstream and usually never materializes as a part, so the turn is incomplete
+ * despite looking empty. MAX_TOKENS with no started call stays a plain token-limit stop.
+ */
+export function isVertexTruncatedTurn(finishReason: string | undefined, toolCallsStarted: number): boolean {
+  if (!isVertexTruncationReason(finishReason)) return false;
+  return toolCallsStarted > 0 || finishReason === "MALFORMED_FUNCTION_CALL";
+}

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

@@ -0,0 +1,232 @@
+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 };
+  }
+  if (Array.isArray(value.responseModalities)) {
+    const valid = value.responseModalities.filter((m): m is string => typeof m === "string" && ["TEXT", "IMAGE", "AUDIO"].includes(m));
+    if (valid.length > 0) out.responseModalities = valid;
+  }
+  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;
+}