@yansigit/opencodex 2.31.0

package/src/adapters/google-antigravity-tools.ts

@@ -0,0 +1,105 @@
+import type {
+  OcxAssistantMessage,
+  OcxMessage,
+  OcxToolCall,
+  OcxToolResultMessage,
+} from "../types";
+
+function isAssistantToolCall(message: OcxMessage): message is OcxAssistantMessage {
+  return message.role === "assistant";
+}
+
+function isToolResult(message: OcxMessage): message is OcxToolResultMessage {
+  return message.role === "toolResult";
+}
+
+/**
+ * Repair incomplete tool exchanges before assigning provider-visible ids.
+ *
+ * CCA translates Gemini function calls and responses into Anthropic tool blocks,
+ * which requires both sides of every exchange. A result is valid only when its
+ * call appeared earlier in the history, and a call is valid only when a result
+ * appears later. Filtering the history first also prevents orphan results from
+ * reserving ids in the request-scoped allocator.
+ *
+ * The allocator maps one raw id to one wire id, so a second complete exchange
+ * that reuses the same raw id would serialize as a colliding pair. Keep only
+ * the first matched occurrence per raw id.
+ *
+ * Direct Gemini and Vertex accept an unmatched trailing `functionCall`, so
+ * `dropUnmatchedCalls` is CCA-only. Orphan results are still dropped in every
+ * Google mode so they cannot reserve allocator slots or emit a lone
+ * `functionResponse`.
+ */
+export function repairGoogleToolPairs(
+  messages: readonly OcxMessage[],
+  opts: { dropUnmatchedCalls?: boolean } = {},
+): OcxMessage[] {
+  const dropUnmatchedCalls = opts.dropUnmatchedCalls ?? true;
+  const pendingCalls = new Map<string, Array<{ messageIndex: number; partIndex: number }>>();
+  const seenRawCallIds = new Set<string>();
+  const matchedCallParts = new Set<string>();
+  const matchedResultIndexes = new Set<number>();
+
+  const enqueueCall = (id: string, messageIndex: number, partIndex: number) => {
+    if (seenRawCallIds.has(id)) return;
+    seenRawCallIds.add(id);
+    const queue = pendingCalls.get(id) ?? [];
+    queue.push({ messageIndex, partIndex });
+    pendingCalls.set(id, queue);
+  };
+
+  for (let messageIndex = 0; messageIndex < messages.length; messageIndex++) {
+    const message = messages[messageIndex]!;
+    if (isAssistantToolCall(message)) {
+      message.content.forEach((part, partIndex) => {
+        if (part.type !== "toolCall") return;
+        enqueueCall((part as OcxToolCall).id, messageIndex, partIndex);
+      });
+      continue;
+    }
+    if (!isToolResult(message)) continue;
+    const queue = pendingCalls.get(message.toolCallId);
+    const slot = queue?.shift();
+    if (!slot) continue;
+    matchedCallParts.add(`${slot.messageIndex}:${slot.partIndex}`);
+    matchedResultIndexes.add(messageIndex);
+  }
+
+  const repaired: OcxMessage[] = [];
+  for (const [messageIndex, message] of messages.entries()) {
+    if (isToolResult(message)) {
+      if (matchedResultIndexes.has(messageIndex)) repaired.push(message);
+      continue;
+    }
+    if (!isAssistantToolCall(message)) {
+      repaired.push(message);
+      continue;
+    }
+
+    const content = message.content.filter((part, partIndex) =>
+      part.type !== "toolCall"
+      || matchedCallParts.has(`${messageIndex}:${partIndex}`)
+      || !dropUnmatchedCalls);
+    if (content.length > 0) {
+      repaired.push(content.length === message.content.length ? message : { ...message, content });
+    }
+  }
+  return repaired;
+}
+
+/**
+ * Claude interprets a final model turn as a prefilled assistant response.
+ * CCA expects the next turn to be generated instead, except when that model
+ * turn is the entire conversation and must remain as the initial context.
+ */
+export function stripTrailingClaudePrefill(contents: unknown[]): boolean {
+  let strippedModelTail = false;
+  while (contents.length >= 2) {
+    const last = contents[contents.length - 1];
+    if (typeof last !== "object" || last === null || (last as { role?: unknown }).role !== "model") break;
+    contents.pop();
+    strippedModelTail = true;
+  }
+  return strippedModelTail;
+}

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

@@ -0,0 +1,141 @@
+import { createHash } from "node:crypto";
+import type { OcxContentPart, OcxParsedRequest } from "../types";
+import { antigravityUserAgent } from "./client-fingerprint";
+
+/**
+ * Antigravity request User-Agent. Mirrors the real Antigravity IDE UA
+ * (`antigravity/ide/{ver} (aidev_client; os_type=windows; arch=amd64)`) so the request fingerprint
+ * matches the OAuth credential — the prior literal `"antigravity"` was a giveaway no real client
+ * sends. The IDE client family is also required to unlock newer agent models (the backend 404s
+ * CLI-shaped UAs for `gemini-3.7-*`). A `GOOGLE_ANTIGRAVITY_USER_AGENT` override still wins.
+ */
+export const ANTIGRAVITY_REQUEST_UA = antigravityUserAgent();
+
+/**
+ * Whether a stored `OcxToolCall.thoughtSignature` is a REAL upstream Gemini signature versus a
+ * foreign id that must not be forwarded to Gemini/Antigravity.
+ *
+ * Foreign ids that have 400'd Antigravity (`TYPE_BYTES` / Base64 decoding failed) include:
+ * - Responses/bridge item ids: `fc_...`, `ctc_...` (custom_tool_call), `tsc_...` (tool_search_call),
+ *   `call_...`, `rs_...`, …
+ * - Anthropic tool-use ids: `toolu_...`
+ *
+ * Only real signatures may be forwarded — sending a foreign id as `thoughtSignature` breaks
+ * multi-turn reasoning continuity. Real signatures are opaque base64-ish blobs with no
+ * Responses/Anthropic id prefix.
+ *
+ * Note: do NOT reject a bare `sig_` / `sig-` prefix — existing Gemini replay fixtures and some
+ * upstream blobs use that shape; a deny-list entry for `sig` would drop valid continuity tokens.
+ */
+export function isLikelyRealThoughtSignature(sig: string | undefined): boolean {
+  if (typeof sig !== "string" || sig.length < 16) return false;
+  // Reject synthetic Responses/tool-call ids and Anthropic tool-use ids (`_` or `-` separators).
+  if (/^(fc|ctc|tsc|call|msg|rs|resp|reasoning|item|ws|toolu|tool|func|function)[-_]/i.test(sig)) return false;
+  // Real Gemini thought signatures are opaque base64/base64url blobs: only [A-Za-z0-9+/_=-].
+  // Anything containing other characters (or whitespace) is not a real signature.
+  return /^[A-Za-z0-9+/_=-]+$/.test(sig);
+}
+
+function firstUserText(parsed: OcxParsedRequest): string | undefined {
+  for (const msg of parsed.context.messages) {
+    if (msg.role !== "user") continue;
+    if (typeof msg.content === "string") return msg.content;
+    const first = (msg.content as OcxContentPart[]).find(p => p.type === "text" && typeof p.text === "string");
+    if (first && first.type === "text") return first.text;
+  }
+  return undefined;
+}
+
+/**
+ * Deterministic Cloud Code Assist session id from the first user message text. Mirrors
+ * CLIProxyAPI `generateStableSessionID`: sha256(firstUserText) → BigEndian uint64 masked with
+ * 0x7FFFFFFFFFFFFFFF, prefixed with "-". Falls back to a random "-<digits>" id when there is no text.
+ */
+export function antigravitySessionId(parsed: OcxParsedRequest): string {
+  // The id must be IDENTICAL on turn N and turn N+1: the replay cache observes thought signatures
+  // on turn N's response and re-injects them on turn N+1's request, so a changing id loses the
+  // association entirely. (A *shared* id does not — signatures are keyed on functionCall identity,
+  // name+args, so cross-conversation collisions stay harmless. Instability is the failure mode.)
+  //
+  // First-user text does not guarantee that. It is stable only while the first user message
+  // survives verbatim in what this adapter sees, and Codex compacts, summarises, and trims long
+  // histories — at which point the anchor changes mid-conversation (#1295's sibling, #1297).
+  //
+  // `_clientThreadId` is Codex's own thread identity from `x-codex-parent-thread-id`. It survives
+  // compaction because it does not depend on message content, which is the property first-user
+  // text fails to provide. Deliberately NOT `promptCacheKey`: that is arbitrary Responses input
+  // and is explicitly shared across conversations for some clients
+  // (`adapters/cursor/request-builder.ts`), so it identifies a cache cohort, not a conversation.
+  //
+  // What is NOT claimed: that Google treats this id as anything but opaque, or that upstream
+  // signatures are not session-bound. Only the local association is verified here.
+  //
+  // Clients that send no thread header keep the text anchor and its instability; this is a scoped
+  // repair, not a universal one.
+  const text = clientThreadAnchor(parsed) ?? firstUserText(parsed);
+  if (!text) return `-${Math.floor(Math.random() * 9e18).toString()}`;
+  const digest = createHash("sha256").update(text, "utf8").digest();
+  const masked = digest.readBigUInt64BE(0) & 0x7fffffffffffffffn;
+  return `-${masked.toString()}`;
+}
+
+/**
+ * Codex's stable client thread id, prefixed before hashing so it does not collide with a first
+ * user message equal to the bare thread id.
+ *
+ * This is a prefix, not full domain separation: a textless-anchor request whose first message is
+ * literally `codex-thread:<id>` still hashes the same preimage. Tagging BOTH anchor classes would
+ * separate them completely, but it would also change every existing text-derived id — a
+ * Google-visible wire value for live conversations — which is a larger blast radius than the
+ * collision it removes. A collision is harmless here anyway: the replay cache keys signatures on
+ * functionCall identity (name+args), so a shared id does not misattribute them. Instability, not
+ * collision, is the failure mode this function exists to prevent.
+ */
+function clientThreadAnchor(parsed: OcxParsedRequest): string | undefined {
+  const threadId = parsed._clientThreadId?.trim();
+  return threadId ? `codex-thread:${threadId}` : undefined;
+}
+
+/** A Gemini content part as it appears in an Antigravity request body. */
+interface GeminiPart {
+  thought?: boolean;
+  thoughtSignature?: string;
+  thought_signature?: string;
+  text?: string;
+  [key: string]: unknown;
+}
+interface GeminiContent {
+  role?: string;
+  parts?: GeminiPart[];
+  [key: string]: unknown;
+}
+
+function hasSignature(part: GeminiPart): boolean {
+  return typeof part.thoughtSignature === "string" && part.thoughtSignature.length > 0
+    || typeof part.thought_signature === "string" && part.thought_signature.length > 0;
+}
+
+/**
+ * Claude-on-Antigravity signature sanitization (the no-cache path). Mirrors CLIProxyAPI's
+ * `StripEmptySignatureThinkingBlocks` + non-model signature stripping: drop thinking parts that
+ * carry no valid signature (they would 400 upstream), and strip signature fields from non-model
+ * (user) content. Mutates and returns `contents`.
+ */
+export function sanitizeAntigravityClaudeSignatures(contents: unknown[]): unknown[] {
+  if (!Array.isArray(contents)) return contents;
+  for (const raw of contents as GeminiContent[]) {
+    if (!raw || typeof raw !== "object" || !Array.isArray(raw.parts)) continue;
+    const isModel = raw.role === "model";
+    if (!isModel) {
+      // Non-model parts must not carry thought signatures.
+      for (const part of raw.parts) {
+        delete part.thoughtSignature;
+        delete part.thought_signature;
+      }
+      continue;
+    }
+    // Model turn: drop thinking blocks lacking a valid signature.
+    raw.parts = raw.parts.filter(part => !(part.thought === true && !hasSignature(part)));
+  }
+  return contents;
+}

package/src/adapters/google-errors.ts

@@ -0,0 +1,92 @@
+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),
+  };
+}
+
+const ANTIGRAVITY_GEO_BLOCKED_MARKER = "user location is not supported for the api use";
+
+export function isAntigravityGeoBlockedBody(payloadText: string): boolean {
+  return payloadText.toLowerCase().includes(ANTIGRAVITY_GEO_BLOCKED_MARKER);
+}
+
+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 (isAntigravityGeoBlockedBody(lower)) return `${label} location not supported`;
+  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");
+}