UNPKG

@bitkyc08/opencodex

Version:

Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code

236 lines (221 loc) • 13.2 kB
import { createHash } from "node:crypto"; import type { OcxContentPart, OcxParsedRequest } from "../types"; import { antigravityCliUserAgent, 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(); /** * Antigravity CLI User-Agent. CCA serves the Gemini 4 codename models (Argon, Carbon) only to the * CLI client family, and it 404s other agent models (`gemini-3.7-flash-tiered`, * `gemini-3.1-pro-low`) under it, so the choice is per wire model: see * `antigravityUserAgentForWireModel`. */ export const ANTIGRAVITY_CLI_REQUEST_UA = antigravityCliUserAgent(); /** * Model discovery (`:fetchAvailableModels`) uses the CLI UA so the Gemini 4 wire ids are listed; * under the IDE UA they are absent. */ export const ANTIGRAVITY_DISCOVERY_UA = ANTIGRAVITY_CLI_REQUEST_UA; /** * Wire ids sent with the CLI User-Agent: every Gemini 4 codename, bare or with a low, medium, high * or xhigh tier suffix. Observed on CCA: Argon was verified 2026-10-14, and on 2026-11-11 the CLI * discovery list was exactly the IDE list plus the Argon and Carbon tiers, with * `gemini-4-carbon-medium` answering 404 under the IDE UA and 200 under the CLI UA. Hydrogen * (low/medium/high/xhigh, verified on Vertex AI by #8583's author on 2026-11-13) was listed by CCA * discovery on 2026-11-12, and `gemini-4-hydrogen-xhigh` answered 200 under the CLI UA. Matching the generation keeps a newly discovered codename * callable instead of listing it in the picker and 404ing every request. */ const ANTIGRAVITY_CLI_ONLY_WIRE_MODEL = /^gemini-4-[a-z][a-z0-9]*(?:-(?:low|medium|high|xhigh))?$/; /** The User-Agent an Antigravity inference request for `wireModelId` must carry. */ export function antigravityUserAgentForWireModel(wireModelId: string): string { return ANTIGRAVITY_CLI_ONLY_WIRE_MODEL.test(wireModelId) ? ANTIGRAVITY_CLI_REQUEST_UA : ANTIGRAVITY_REQUEST_UA; } /** * 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; // The validator-bypass sentinel is something WE fabricate for outbound requests when no real // signature exists. It is alphanumeric with underscores, so it would otherwise satisfy every // check below and be re-ingested as genuine — cached, replayed, and eventually treated as // evidence that a turn was signed. It is never a real signature. if (sig === "skip_thought_signature_validator" || sig === "context_engineering_is_the_way_to_go") 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; // A document part carries text too: ignoring it left a document-only opening turn with no // anchor, which silently downgrades the deterministic session id to a random one. const first = (msg.content as OcxContentPart[]) .find(p => (p.type === "text" || p.type === "document") && typeof p.text === "string"); if (first && (first.type === "text" || first.type === "document")) 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, accountScope?: string): 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 = codexThreadAnchor(parsed).preimage ?? firstUserText(parsed); if (!text) return `-${Math.floor(Math.random() * 9e18).toString()}`; const scope = parsed._reasoningReplayScope?.current?.credentialDurableIdentity?.trim() || parsed._reasoningReplayScope?.current?.credentialIdentity?.trim() || accountScope?.trim() || ""; const preimage = scope ? `acct:${scope}\0${text}` : text; const digest = createHash("sha256").update(preimage, "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 codexThreadAnchor(parsed: OcxParsedRequest): { kind: "parent-and-own" | "parent-only" | "absent"; preimage?: string; } { // `_clientThreadId` carries `x-codex-parent-thread-id`, which every parallel child of one // parent presents identically, so anchoring on it alone collapsed concurrent children onto a // single upstream Cloud Code Assist session (#5033). // // A thread id is only unique WITHIN its parent, which is why `codexConversationIdentity` keys // on both. #5054 anchored on the child alone and therefore only moved the collision: two // parents can each have a child of the same id (#5058). The pair is the identity, joined by a // NUL so the encoding is injective: no Codex id contains one, so a pair cannot be re-read as a // different pair, nor as the parent-only anchor below. // // Deliberately NOT the general lane key: `codexConversationKeyFor` is an HMAC under a // process-random secret, so it changes across a proxy restart — and instability, not sharing, // is the failure mode this derivation has to avoid. These ids are Codex's own values and // survive both compaction and restart. const own = parsed._codexOwnThreadId?.trim(); const parent = parsed._clientThreadId?.trim(); if (own && parent) return { kind: "parent-and-own", preimage: `codex-thread:${parent}\u0000${own}` }; // Parent-only clients keep the anchor they already had. if (parent) return { kind: "parent-only", preimage: `codex-thread:${parent}` }; // A parentless ROOT deliberately omits the parent header. `src/server/context-history.ts` says // so in as many words: root model requests use (session-id=root, thread-id=root) and do not // fabricate a parent key. It has no pair to key on, and #5054's claim that a root presents // `thread-id` equal to its parent was simply wrong. // // So it keeps the pre-#5054 anchor rather than gaining an own-thread one. That is not a // preference: durable Antigravity replay state is keyed by model plus session id, and moving a // root's anchor on upgrade strands every signature stored under the old session — the exact // instability this derivation exists to avoid, introduced while fixing sharing. return { kind: "absent" }; } /** * Which class of anchor {@link antigravitySessionId} derives this request's session id from. * * The id itself identifies a live conversation and is a Google-visible wire value, so it is not * something a user can paste into a public bug report. The class is: it distinguishes the four * stability regimes above — a Codex parent/child pair, a parent-only client, the content-derived * text anchor that compaction can move, and the random fallback that changes every turn — while * carrying no identity at all. * * It reads the SAME decision the id derivation reads, so the two cannot disagree about which * regime a request is in. What it does not do is change how the id itself is derived: nothing * about a Google-visible wire value moves because a diagnostic wants to describe it. */ export type AntigravitySessionAnchor = "parent-and-own" | "parent-only" | "text" | "none"; export function antigravitySessionAnchor(parsed: OcxParsedRequest): AntigravitySessionAnchor { const anchor = codexThreadAnchor(parsed); if (anchor.kind !== "absent") return anchor.kind; return firstUserText(parsed) ? "text" : "none"; } /** 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; }