@yansigit/opencodex 2.31.0

package/src/adapters/google-http.ts

@@ -0,0 +1,460 @@
+import type { AdapterFetchContext, AdapterRequest } from "./base";
+import {
+  isAntigravityGeoBlockedBody,
+  isQuotaExhaustedBody,
+  retryableGoogleStatus,
+  safeGoogleHttpErrorMessage,
+} from "./google-errors";
+import { repairGoogleInvalidRequestBody } from "./google-wire-compiler";
+import { normalizeUpstreamHttpErrorResponse, readDisplaySafeErrorPayloadText } from "./upstream-http-error";
+import { recordAntigravityCooldown } from "../oauth/antigravity-routing";
+import {
+  antigravityHostCandidates,
+  canonicalAntigravityHttpsHost,
+  isAntigravityHttpsHost,
+} from "./google-antigravity-hosts";
+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;
+export const CCA_STREAM_CLASSIFY_MAX_BYTES = 256 * 1024;
+export const CCA_STREAM_PROBE_MAX_BYTES = CCA_STREAM_CLASSIFY_MAX_BYTES;
+
+function isAntigravitySseRequest(request: AdapterRequest): boolean {
+  return request.url.includes("/v1internal:streamGenerateContent?alt=sse");
+}
+
+function requestForHost(request: AdapterRequest, host: string): AdapterRequest {
+  const current = new URL(request.url);
+  const target = new URL(host);
+  target.pathname = current.pathname;
+  target.search = current.search;
+  return { ...request, url: target.toString() };
+}
+
+type CcaSseProbe = "empty" | "candidate" | "unavailable" | "quota_exhausted" | "geo_blocked" | "terminal";
+
+function probeCcaSseEvent(bytes: Uint8Array): CcaSseProbe {
+  const text = new TextDecoder().decode(bytes);
+  for (const line of text.split(/\r?\n/)) {
+    if (!line.startsWith("data:")) continue;
+    const payload = line.slice(5).trim();
+    if (!payload) continue;
+    let frame: unknown;
+    try {
+      frame = JSON.parse(payload);
+    } catch {
+      return "terminal";
+    }
+    if (!frame || typeof frame !== "object" || Array.isArray(frame)) return "terminal";
+    const record = frame as Record<string, unknown>;
+    if (record.error) {
+      const error = record.error;
+      const errorRecord = error && typeof error === "object" && !Array.isArray(error)
+        ? error as Record<string, unknown>
+        : {};
+      const status = String(errorRecord.status ?? "").toUpperCase();
+      const code = errorRecord.code;
+      if (status === "UNAVAILABLE" || status === "503" || code === 503 || code === "503") {
+        return "unavailable";
+      }
+      const serialized = JSON.stringify(frame);
+      if (isQuotaExhaustedBody(serialized)) return "quota_exhausted";
+      if (isAntigravityGeoBlockedBody(serialized)) return "geo_blocked";
+      return "terminal";
+    }
+    const response = record.response;
+    if (!response || typeof response !== "object" || Array.isArray(response)) return "terminal";
+    const root = response as Record<string, unknown>;
+    if (Array.isArray(root.candidates) && root.candidates.length > 0) return "candidate";
+  }
+  return "empty";
+}
+
+export class CcaProbeBuffer {
+  private storage: Uint8Array;
+  length = 0;
+
+  constructor(private readonly maxBytes = CCA_STREAM_PROBE_MAX_BYTES) {
+    this.storage = new Uint8Array(Math.min(64 * 1024, maxBytes));
+  }
+
+  append(next: Uint8Array): boolean {
+    if (next.byteLength === 0) return true;
+    const required = this.length + next.byteLength;
+    if (required > this.maxBytes) return false;
+    if (required > this.storage.byteLength) {
+      let capacity = Math.max(this.storage.byteLength, 1);
+      while (capacity < required) {
+        const grownCapacity = Math.min(this.maxBytes, capacity * 2);
+        capacity = grownCapacity <= capacity ? this.maxBytes : grownCapacity;
+      }
+      const grown = new Uint8Array(capacity);
+      grown.set(this.storage.subarray(0, this.length));
+      this.storage = grown;
+    }
+    this.storage.set(next, this.length);
+    this.length = required;
+    return true;
+  }
+
+  view(): Uint8Array {
+    return this.storage.subarray(0, this.length);
+  }
+}
+
+function firstSseEventEnd(bytes: Uint8Array, from: number): number | undefined {
+  for (let index = from; index + 1 < bytes.byteLength; index++) {
+    if (bytes[index] === 10 && bytes[index + 1] === 10) return index + 2;
+    if (index + 3 < bytes.byteLength
+      && bytes[index] === 13 && bytes[index + 1] === 10
+      && bytes[index + 2] === 13 && bytes[index + 3] === 10) {
+      return index + 4;
+    }
+  }
+  return undefined;
+}
+
+function responseWithBufferedBody(
+  response: Response,
+  buffered: Uint8Array,
+  reader: ReadableStreamDefaultReader<Uint8Array>,
+  pending?: Uint8Array,
+  status = response.status,
+): Response {
+  let bufferedBody = buffered;
+  let pendingBody = pending;
+  let readerReleased = false;
+  const releaseReader = () => {
+    if (readerReleased) return;
+    readerReleased = true;
+    reader.releaseLock();
+  };
+  const body = new ReadableStream<Uint8Array>({
+    async pull(controller) {
+      try {
+        if (bufferedBody.byteLength > 0 || pendingBody?.byteLength) {
+          if (bufferedBody.byteLength > 0) {
+            controller.enqueue(bufferedBody);
+            bufferedBody = new Uint8Array();
+          }
+          if (pendingBody?.byteLength) {
+            controller.enqueue(pendingBody);
+            pendingBody = undefined;
+          }
+          return;
+        }
+
+        const { done, value } = await reader.read();
+        if (done) {
+          controller.close();
+          releaseReader();
+          return;
+        }
+        if (value?.byteLength) controller.enqueue(value);
+      } catch (error) {
+        controller.error(error);
+        releaseReader();
+      }
+    },
+    cancel(reason) {
+      void reader.cancel(reason).catch(() => {}).finally(releaseReader);
+    },
+  });
+  return new Response(body, {
+    status,
+    statusText: response.statusText,
+    headers: response.headers,
+  });
+}
+
+async function prepareCcaSseResponse(
+  response: Response,
+  fetchPeer: (() => Promise<Response>) | undefined,
+): Promise<Response> {
+  if (!response.body) return fetchPeer ? fetchPeer() : response;
+  const reader = response.body.getReader();
+  const probeBuffer = new CcaProbeBuffer();
+  let scanned = 0;
+  const passthrough = (pending?: Uint8Array, status = response.status) =>
+    responseWithBufferedBody(response, probeBuffer.view(), reader, pending, status);
+  const failoverOrPassthrough = async (): Promise<Response> => {
+    if (!fetchPeer) return passthrough();
+    await reader.cancel().catch(() => {});
+    reader.releaseLock();
+    return fetchPeer();
+  };
+  try {
+    while (probeBuffer.length < CCA_STREAM_CLASSIFY_MAX_BYTES) {
+      if (scanned >= CCA_STREAM_CLASSIFY_MAX_BYTES || probeBuffer.length >= CCA_STREAM_CLASSIFY_MAX_BYTES) {
+        return passthrough();
+      }
+      const { done, value } = await reader.read();
+      if (done) {
+        const buffered = probeBuffer.view();
+        const residual = buffered.subarray(scanned);
+        if (residual.byteLength > 0) {
+          const probe = probeCcaSseEvent(residual);
+          if (probe === "candidate" || probe === "terminal") {
+            return passthrough();
+          }
+          if (probe === "unavailable") {
+            return failoverOrPassthrough();
+          }
+          if (probe === "quota_exhausted" || probe === "geo_blocked") {
+            const status = probe === "quota_exhausted" ? 429 : 403;
+            return passthrough(undefined, status);
+          }
+        }
+        return failoverOrPassthrough();
+      }
+      if (!value?.byteLength) continue;
+      const classifyRemaining = CCA_STREAM_CLASSIFY_MAX_BYTES - probeBuffer.length;
+      const copyBytes = Math.min(value.byteLength, classifyRemaining);
+      const overflow = value.byteLength > copyBytes ? value.subarray(copyBytes) : undefined;
+      if (copyBytes > 0) {
+        probeBuffer.append(value.subarray(0, copyBytes));
+      }
+      const buffered = probeBuffer.view();
+      while (true) {
+        if (scanned >= CCA_STREAM_CLASSIFY_MAX_BYTES) return passthrough(overflow);
+        const eventEnd = firstSseEventEnd(buffered, scanned);
+        if (eventEnd === undefined) break;
+        const probe = probeCcaSseEvent(buffered.subarray(scanned, eventEnd));
+        scanned = eventEnd;
+        if (probe === "candidate") return passthrough(overflow);
+        if (probe === "unavailable") {
+          if (overflow?.byteLength) {
+            return passthrough(overflow);
+          }
+          return failoverOrPassthrough();
+        }
+        if (probe === "quota_exhausted" || probe === "geo_blocked") {
+          const status = probe === "quota_exhausted" ? 429 : 403;
+          return passthrough(overflow, status);
+        }
+        if (probe === "terminal") return passthrough(overflow);
+      }
+      if (overflow?.byteLength) return passthrough(overflow);
+      if (scanned >= CCA_STREAM_CLASSIFY_MAX_BYTES || probeBuffer.length >= CCA_STREAM_CLASSIFY_MAX_BYTES) {
+        return passthrough();
+      }
+    }
+    return passthrough();
+  } catch (error) {
+    try { await reader.cancel(error); } catch { /* cleanup only */ }
+    reader.releaseLock();
+    throw error;
+  }
+}
+
+function isUnavailableResponse(response: Response): boolean {
+  return response.status === 503;
+}
+
+export interface GoogleRetryOptions {
+  /** Repair-and-replay structurally invalid 400 bodies (Vertex/Antigravity behavior). */
+  repairInvalid400?: boolean;
+}
+
+async function normalizeFinalGoogleError(label: string, res: Response, signal?: AbortSignal): Promise<Response> {
+  return normalizeUpstreamHttpErrorResponse(res, {
+    signal,
+    formatMessage: payloadText => safeGoogleHttpErrorMessage(label, res.status, payloadText),
+  });
+}
+
+function retryAfterMs(value: string | null, now = Date.now()): number | undefined {
+  const text = value?.trim();
+  if (!text) return undefined;
+  if (/^\d+(?:\.\d+)?$/.test(text)) {
+    const seconds = Number(text);
+    return Number.isFinite(seconds) && seconds > 0 ? Math.ceil(seconds * 1000) : undefined;
+  }
+  const timestamp = Date.parse(text);
+  return Number.isFinite(timestamp) && timestamp > now ? timestamp - now : undefined;
+}
+
+async function recordAntigravityHttpCooldown(
+  response: Response,
+  accountId: string | undefined,
+): Promise<boolean> {
+  if (!accountId || (response.status !== 429 && response.status !== 403)) return false;
+  const payloadText = await readDisplaySafeErrorPayloadText(response.clone());
+  if (response.status === 429) {
+    recordAntigravityCooldown(
+      accountId,
+      isQuotaExhaustedBody(payloadText) ? "quota_exhausted" : "rate_limited",
+      retryAfterMs(response.headers.get("retry-after")),
+    );
+    return true;
+  }
+  if (isAntigravityGeoBlockedBody(payloadText)) {
+    recordAntigravityCooldown(accountId, "geo_blocked");
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Fetch a Google-family upstream 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 (unless raw mode is used) a
+ * classified + redacted final error body. `label` is the provider-facing prefix used in error
+ * messages.
+ */
+async function fetchGoogleWithRetryInternal(
+  label: string,
+  request: AdapterRequest,
+  ctx: AdapterFetchContext,
+  allowAntigravityHostFailover: boolean,
+  opts: GoogleRetryOptions = {},
+): Promise<Response> {
+  const repairInvalid400 = opts.repairInvalid400 ?? true;
+  const timeoutMs = ctx.timeoutMs ?? 200_000;
+  const executor = ctx.executor ?? globalThis.fetch;
+  let activeRequest = request;
+  if (label === "Antigravity" && isAntigravitySseRequest(activeRequest)) {
+    const origin = new URL(activeRequest.url).origin;
+    const canonicalHttps = canonicalAntigravityHttpsHost(origin);
+    if (canonicalHttps) {
+      activeRequest = requestForHost(activeRequest, canonicalHttps);
+    } else if (!isAntigravityHttpsHost(origin)) {
+      throw new Error("Antigravity OAuth bearer requests must use HTTPS");
+    }
+  }
+  const antigravityHosts = allowAntigravityHostFailover && label === "Antigravity" && isAntigravitySseRequest(activeRequest)
+    ? antigravityHostCandidates(new URL(activeRequest.url).origin).filter(isAntigravityHttpsHost)
+    : [];
+  let antigravityHostIndex = 0;
+  let lastError: unknown;
+  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, executor);
+      if (label === "Antigravity") {
+        const cooldownRecorded = await recordAntigravityHttpCooldown(res, ctx.accountId);
+        if (cooldownRecorded) {
+          return ctx.returnRawErrors ? res : normalizeFinalGoogleError(label, res, ctx.abortSignal);
+        }
+      }
+      if (antigravityHosts.length > 1 && antigravityHostIndex === 0) {
+        const shouldTryPeer = res.status === 404 || isUnavailableResponse(res);
+        if (shouldTryPeer) {
+          cancelResponseBodyBestEffort(res);
+          antigravityHostIndex = 1;
+          activeRequest = requestForHost(activeRequest, antigravityHosts[antigravityHostIndex]!);
+          continue;
+        }
+      }
+      if (label === "Antigravity" && isAntigravitySseRequest(activeRequest) && res.ok) {
+        const fetchPeer = antigravityHosts.length > 1 && antigravityHostIndex === 0
+          ? () => fetchGoogleWithRetryInternal(
+            label,
+            requestForHost(activeRequest, antigravityHosts[1]!),
+            ctx,
+            false,
+            opts,
+          )
+          : undefined;
+        return prepareCcaSseResponse(res, fetchPeer);
+      }
+      if (res.status === 400 && repairInvalid400 && !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) {
+        const peekTarget = ctx.returnRawErrors ? res.clone() : res;
+        const peek = await readDisplaySafeErrorPayloadText(peekTarget, ctx.abortSignal);
+        if (isQuotaExhaustedBody(peek)) {
+          return ctx.returnRawErrors ? res : 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 (antigravityHosts.length > 1 && antigravityHostIndex === 0) {
+        antigravityHostIndex = 1;
+        activeRequest = requestForHost(activeRequest, antigravityHosts[antigravityHostIndex]!);
+        continue;
+      }
+      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`);
+}
+
+export function fetchGoogleWithRetry(
+  label: string,
+  request: AdapterRequest,
+  ctx: AdapterFetchContext = {},
+  opts: GoogleRetryOptions = {},
+): Promise<Response> {
+  return fetchGoogleWithRetryInternal(label, request, ctx, true, opts);
+}
+
+/**
+ * AI Studio direct (`generativelanguage.googleapis.com`) retry wrapper.
+ *
+ * Direct requests keep the default server error surface — the raw `Provider error <status>:
+ * <body>` text the shared Responses path formats — and keep single-shot 400 semantics (no
+ * request-shape compatibility replay). The wrapper exists for the failure mode observed in
+ * production: AI Studio's transient `503 UNAVAILABLE` "model is currently experiencing high
+ * demand" spikes, plus plain rate-limit 429s, both of which previously failed immediately
+ * because the default server fetch path only retries connection resets.
+ */
+export function fetchDirectGeminiWithRetry(request: AdapterRequest, ctx: AdapterFetchContext = {}): Promise<Response> {
+  return fetchGoogleWithRetry("Gemini", request, { ...ctx, returnRawErrors: true }, { repairInvalid400: false });
+}
+
+/** 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,238 @@
+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;
+const MAX_SCHEMA_NODES = 1_024;
+const BUDGET_EXHAUSTED = Symbol("schema-budget-exhausted");
+const MERGED_SCHEMA_KEYS = [
+  "type",
+  "nullable",
+  "description",
+  "format",
+  "enum",
+  "const",
+  "properties",
+  "items",
+  "required",
+  "anyOf",
+] as const;
+
+type SanitizeResult = Schema | typeof BUDGET_EXHAUSTED;
+
+interface SanitizeState {
+  activeRefs: Set<string>;
+  remainingNodes: number;
+}
+
+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 mergeRefTarget(target: Schema, overlay: Schema): Schema {
+  const merged: Schema = {};
+  if (Object.hasOwn(target, "$ref")) merged.$ref = target.$ref;
+  for (const key of MERGED_SCHEMA_KEYS) {
+    if (Object.hasOwn(overlay, key)) merged[key] = overlay[key];
+    else if (Object.hasOwn(target, key)) merged[key] = target[key];
+  }
+  return merged;
+}
+
+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,
+  state: SanitizeState,
+): Schema {
+  if (!Array.isArray(value) || value.length === 0) return {};
+  const schemas: Schema[] = [];
+  for (let index = 0; index < value.length; index++) {
+    if (state.remainingNodes <= 0) return {};
+    const schema = sanitizeSchema(value[index], defs, depth + 1, refDepth, true, state);
+    if (schema === BUDGET_EXHAUSTED) return {};
+    schemas.push(schema);
+  }
+
+  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,
+  state: SanitizeState,
+): Record<string, Schema> | undefined {
+  if (!isRecord(value)) return undefined;
+  const properties: Record<string, Schema> = Object.create(null) as Record<string, Schema>;
+  for (const name in value) {
+    if (!Object.hasOwn(value, name)) continue;
+    if (state.remainingNodes <= 0) break;
+    // Property names form a name bag and must never be interpreted as schema keywords.
+    const schema = sanitizeSchema(value[name], defs, depth + 1, refDepth, false, state);
+    if (schema === BUDGET_EXHAUSTED) break;
+    properties[name] = schema;
+  }
+  return properties;
+}
+
+function sanitizeSchema(
+  node: unknown,
+  defs: Map<string, unknown>,
+  depth: number,
+  refDepth: number,
+  preserveNullType: boolean,
+  state: SanitizeState,
+): SanitizeResult {
+  if (state.remainingNodes <= 0) return BUDGET_EXHAUSTED;
+  state.remainingNodes -= 1;
+  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)) {
+      if (state.activeRefs.has(node.$ref)) return {};
+      state.activeRefs.add(node.$ref);
+      // Select only inputs the sanitizer can consume. Spreading an untrusted definition here would
+      // enumerate and allocate every unsupported annotation before the node budget can stop work.
+      const merged = mergeRefTarget(target, node);
+      try {
+        return sanitizeSchema(merged, defs, depth, refDepth + 1, preserveNullType, state);
+      } finally {
+        state.activeRefs.delete(node.$ref);
+      }
+    }
+  }
+
+  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, state);
+  if (properties) out.properties = properties;
+
+  if (properties && Array.isArray(node.required)) {
+    const required = [...new Set(node.required.filter((item): item is string => (
+      typeof item === "string" && Object.hasOwn(properties, item)
+    )))];
+    if (required.length > 0) out.required = required;
+  }
+
+  if (state.remainingNodes <= 0) return out;
+
+  if (isRecord(node.items)) {
+    const items = sanitizeSchema(node.items, defs, depth + 1, refDepth, false, state);
+    if (items !== BUDGET_EXHAUSTED) out.items = items;
+  }
+
+  if (state.remainingNodes <= 0) return out;
+  if (node.anyOf !== undefined) {
+    Object.assign(out, normalizeAnyOf(node.anyOf, defs, depth, refDepth, state));
+  }
+  return out;
+}
+
+export function sanitizeGeminiToolParameters(parameters: unknown): Record<string, unknown> {
+  try {
+    const defs = new Map<string, unknown>();
+    collectDefs(parameters, defs);
+    const state: SanitizeState = {
+      activeRefs: new Set(),
+      remainingNodes: MAX_SCHEMA_NODES,
+    };
+    const sanitized = sanitizeSchema(parameters, defs, 0, 0, false, state);
+    const root = sanitized === BUDGET_EXHAUSTED ? {} : sanitized;
+
+    // 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: {} };
+  }
+}