UNPKG

@bitkyc08/opencodex

Version:

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

408 lines (378 loc) • 17.4 kB
import { bindAnthropicRejectionPolicy } from "../../adapters/anthropic-rejection-memo"; import { getReasoningReplayOpaqueBlobRejection } from "../../responses/reasoning-replay-cache"; import type { OcxProviderContinuationOwner, OcxProviderContinuationState, OcxParsedRequest, OcxProviderConfig, OcxReasoningReplayIdentity, AdapterEvent, } from "../../types"; import { isValidProviderContinuationOwner, sameProviderContinuationOwner, providerContinuationOwnerFromReplayIdentity, providerContinuationRouteScope, } from "../../responses/provider-continuation"; import { reasoningReplayDestinationIdentity, reasoningReplayOAuthCredentialIdentity, durableReplayCredentialIdentity, reasoningReplayCodexCredentialIdentity, reasoningReplayKeyCredentialIdentity, durableReplayDestinationIdentity, nativeReasoningTag, nativeReasoningTagMatches, type NativeReasoningOwner, bindReasoningReplayScope, reasoningReplayServingIdentityChanged, reasoningReplayServingIdentityChange, reasoningReplayItemStoreChanged, reasoningReplayOpaqueBlobRejectionMemoized, } from "../../responses/reasoning-replay-cache"; import type { OAuthAccessSnapshot } from "../../oauth"; import type { CodexAuthContext } from "../../codex/auth-context"; import { thoughtSignatureReplaySalt } from "../../responses/thought-signature-replay"; import { randomUUID } from "node:crypto"; import { requiresPlaintextReasoningReplay } from "../../adapters/openai-responses/passthrough"; import { isCanonicalOpenAiForwardProvider } from "../../providers/openai-tiers"; /** * Adapters whose continuation state must survive Codex's store:false requests. */ export function adapterNeedsForcedContinuation(name: string): boolean { return name === "kiro" || name === "cursor"; } /** Adapters opting into restricted store:false replay for pending client function calls. */ export function adapterNeedsToolCallContinuation(name: string): boolean { return name === "qoder"; } export type ContinuationOwnerRead = | { kind: "missing" } | { kind: "invalid" } | { kind: "valid"; owner: OcxProviderContinuationOwner }; export function readProviderContinuationOwner( state: OcxProviderContinuationState | undefined, ): ContinuationOwnerRead { if (!state || state.__ocxOwner === undefined) return { kind: "missing" }; const owner = state.__ocxOwner; if (!isValidProviderContinuationOwner(owner)) return { kind: "invalid" }; return { kind: "valid", owner: { ...owner } }; } export function providerContinuationPayload( state: OcxProviderContinuationState | undefined, ): OcxProviderContinuationState | undefined { if (!state) return undefined; const cloned = structuredClone(state); delete cloned.__ocxOwner; return Object.keys(cloned).length > 0 ? cloned : undefined; } export function bindProviderContinuationForRoute( parsed: OcxParsedRequest, currentOwner: OcxProviderContinuationOwner | undefined, ): void { const candidate = parsed._providerContinuationCandidate; const storedOwner = readProviderContinuationOwner(candidate); const mayRestore = storedOwner.kind === "valid" && !!currentOwner && sameProviderContinuationOwner(storedOwner.owner, currentOwner); const restored = mayRestore ? providerContinuationPayload(candidate) : undefined; if (restored) parsed._providerContinuation = restored; else delete parsed._providerContinuation; const cursorConversationId = restored?.cursor?.conversationId; if (cursorConversationId) parsed._cursorConversationId = cursorConversationId; else delete parsed._cursorConversationId; if (currentOwner) parsed._providerContinuationOwner = { ...currentOwner }; else delete parsed._providerContinuationOwner; } export function providerContinuationDestinationIdentity( parsed: OcxParsedRequest, provider: OcxProviderConfig, ): string | undefined { const kiroContext = parsed._kiroAuthContext; return reasoningReplayDestinationIdentity(JSON.stringify([ provider.baseUrl.trim().replace(/\/+$/, ""), provider.responsesPath ?? "", kiroContext?.profileArn ?? "", kiroContext?.apiRegion ?? "", kiroContext?.ssoRegion ?? "", ])); } export function bindRouteReasoningReplayScope(args: { parsed: OcxParsedRequest; providerName: string; provider: OcxProviderConfig; adapterName: string; oauthCredentialSnapshot?: Pick<OAuthAccessSnapshot, "accountId" | "generation">; codexAuthContext?: CodexAuthContext; forwardHeaders?: Headers; }): void { const { parsed, providerName, provider, adapterName } = args; const replayIdentity = routeReasoningReplayIdentity({ ...args, modelId: parsed.modelId, }); const owner = nativeReasoningOwnerForRoute(args); if (owner) parsed._nativeReasoningBoundOwner = owner; else delete parsed._nativeReasoningBoundOwner; if (parsed._nativeReasoningReplay?.size) { const rejected = new Set<string>(); for (const [blob, tag] of parsed._nativeReasoningReplay) { if (!nativeReasoningTagMatches(nativeReasoningTag(owner, blob), tag)) { rejected.add(blob); } } if (rejected.size) stripNativeReasoningBlobs(parsed, rejected); } const continuationDestinationIdentity = providerContinuationDestinationIdentity(parsed, provider); const continuationOwner = providerContinuationOwnerFromReplayIdentity( replayIdentity && continuationDestinationIdentity ? { ...replayIdentity, providerDestinationIdentity: continuationDestinationIdentity } : undefined, ); if (adapterName === "cursor") { // The final route owner is authoritative for Cursor and supersedes the account-derived // seed assigned before route binding. A Cursor conversation must be scoped to the exact // provider/destination/adapter/model/credential that serves it. if (continuationOwner) parsed._cursorIdentityScope = providerContinuationRouteScope(continuationOwner); else if (!parsed._cursorIdentityScope?.startsWith("cursor-unowned:")) { // Prevent the adapter's token-only fallback from recreating a provider-private id after the // route owner failed closed. The sentinel is per parsed request and contains no credential. parsed._cursorIdentityScope = `cursor-unowned:${randomUUID()}`; } } bindReasoningReplayScope( parsed._reasoningReplayScope, replayIdentity, ); // Keep this sticky for the whole outbound request: a later auth/key rebind may compare equal // after the first mismatch, but it cannot make history minted by the prior route decodable. const identityChange = reasoningReplayServingIdentityChange(parsed._reasoningReplayScope); if (identityChange) { // Reasoning retention does not establish portability of native compacted history. parsed._stripNativeCompactionEncryptedContent = true; const retention = parsed._nativeReasoningRetention; const mayRetainReasoning = isCanonicalOpenAiForwardProvider(provider) && !identityChange.providerChanged && !identityChange.destinationChanged && !identityChange.adapterChanged && (!identityChange.modelChanged || retention?.modelSwitch === true) && (!identityChange.credentialChanged || retention?.accountSwitch === true); if (!mayRetainReasoning) parsed._stripReasoningEncryptedContent = true; else if (parsed._stripReasoningEncryptedContent !== true) parsed._nativeReasoningRetainedAcrossRoute = true; // Only a different destination or credential makes the replayed item ids unresolvable; a // model change on the same store keeps them. if (reasoningReplayItemStoreChanged(parsed._reasoningReplayScope)) { parsed._dropForeignReasoningItemIds = true; } } const rejectionMemo = getReasoningReplayOpaqueBlobRejection(parsed._reasoningReplayScope); bindAnthropicRejectionPolicy(parsed, adapterName === "anthropic" ? rejectionMemo : undefined); if (reasoningReplayOpaqueBlobRejectionMemoized(parsed._reasoningReplayScope)) { if (adapterName !== "anthropic" || rejectionMemo?.mode !== "selective") parsed._stripReasoningEncryptedContent = true; parsed._stripNativeCompactionEncryptedContent = true; parsed._dropForeignReasoningItemIds = true; } // Stripping is authoritative: nothing retained remains to be refused. if (parsed._stripReasoningEncryptedContent === true) delete parsed._nativeReasoningRetainedAcrossRoute; bindProviderContinuationForRoute(parsed, continuationOwner); } function stripNativeReasoningBlobs(parsed: OcxParsedRequest, rejected: ReadonlySet<string>): void { const input = (parsed._rawBody as { input?: unknown } | undefined)?.input; if (Array.isArray(input)) { for (const item of input) { if (item && typeof item === "object" && item.type === "reasoning" && rejected.has(item.encrypted_content)) { delete item.encrypted_content; delete item.id; } } } for (const message of parsed.context.messages) { if (message.role !== "assistant" || !Array.isArray(message.content)) continue; for (const part of message.content) { if (part.type !== "thinking" || typeof part.signature !== "string") continue; try { const item: unknown = JSON.parse(part.signature); if (!item || typeof item !== "object" || Array.isArray(item)) continue; const reasoning = item as Record<string, unknown>; if (reasoning.type !== "reasoning" || typeof reasoning.encrypted_content !== "string" || !rejected.has(reasoning.encrypted_content)) continue; delete reasoning.encrypted_content; delete reasoning.id; part.signature = JSON.stringify(reasoning); delete part.itemId; } catch { /* A provider signature is not the parser's JSON carrier. */ } } } } export function nativeReasoningOwnerForRoute(args: { provider: OcxProviderConfig; oauthCredentialSnapshot?: Pick<OAuthAccessSnapshot, "accountId" | "generation">; codexAuthContext?: CodexAuthContext; }): NativeReasoningOwner | undefined { const { provider } = args; const salt = thoughtSignatureReplaySalt(); if (!salt || salt.length < 16) return undefined; const destination = durableReplayDestinationIdentity(JSON.stringify([ provider.baseUrl.trim().replace(/\/+$/, ""), provider.responsesPath ?? "", ])); let credential: string | undefined; if (provider.authMode === "oauth") { const snapshot = args.oauthCredentialSnapshot; if (snapshot?.accountId && snapshot.generation !== undefined) credential = durableReplayCredentialIdentity( "oauth", `${snapshot.accountId}\0${snapshot.generation}`, provider.headers, salt, ); } else if (provider.authMode === "forward") { const context = args.codexAuthContext; if (context && (context.kind === "pool" || context.kind === "main-pool") && context.accountId && context.writerGeneration !== undefined && (context.kind !== "pool" || context.generation !== undefined)) { credential = durableReplayCredentialIdentity("codex", JSON.stringify([ context.accountId, context.kind === "pool" ? context.generation : null, context.writerGeneration, ]), provider.headers, salt); } } else if (provider.authMode !== "local") { credential = durableReplayCredentialIdentity("key", nonEmptyProviderApiKey(provider), provider.headers, salt); } return destination && credential ? { destination, credential } : undefined; } function routeReasoningReplayIdentity(args: { providerName: string; provider: OcxProviderConfig; adapterName: string; modelId: string; oauthCredentialSnapshot?: Pick<OAuthAccessSnapshot, "accountId" | "generation">; codexAuthContext?: CodexAuthContext; forwardHeaders?: Headers; }): OcxReasoningReplayIdentity | undefined { const { providerName, provider, adapterName, modelId } = args; let credentialIdentity: string | undefined; let credentialDurableIdentity: string | undefined; const durableSalt = thoughtSignatureReplaySalt(); if (provider.authMode === "oauth") { credentialIdentity = reasoningReplayOAuthCredentialIdentity( args.oauthCredentialSnapshot, provider.headers, ); // The persisted account-slot id survives token refresh and restarts; the rotating // generation deliberately does NOT participate (#1926 design: rotation-safe). credentialDurableIdentity = durableReplayCredentialIdentity( "oauth", args.oauthCredentialSnapshot?.accountId, provider.headers, durableSalt, ); } else if (provider.authMode === "forward") { const poolContext = args.codexAuthContext?.kind === "pool" || args.codexAuthContext?.kind === "main-pool" ? args.codexAuthContext : undefined; credentialIdentity = reasoningReplayCodexCredentialIdentity({ authorization: poolContext ? `Bearer ${poolContext.accessToken}` : args.forwardHeaders?.get("authorization"), chatgptAccountId: poolContext?.chatgptAccountId ?? args.forwardHeaders?.get("chatgpt-account-id"), accountId: poolContext?.accountId, credentialGeneration: poolContext?.kind === "pool" ? poolContext.generation : undefined, writerGeneration: poolContext?.writerGeneration, headers: provider.headers, }); // Durable identity requires a STABLE, TRUSTED account handle. Pool context comes from // our own account store; a client-supplied chatgpt-account-id header is attacker // -influenceable bucket selection and a bearer alone is rotating material — both are // refused, so direct-forward turns get no durable scope (fail closed; the in-process // cache still covers same-process replay). const codexDurableHandle = poolContext?.accountId ?? poolContext?.chatgptAccountId ?? undefined; credentialDurableIdentity = durableReplayCredentialIdentity( "codex", codexDurableHandle ?? undefined, provider.headers, durableSalt, ); } else if (provider.authMode !== "local") { credentialIdentity = reasoningReplayKeyCredentialIdentity(provider); credentialDurableIdentity = durableReplayCredentialIdentity( "key", nonEmptyProviderApiKey(provider), provider.headers, durableSalt, ); } const providerDestinationIdentity = reasoningReplayDestinationIdentity(provider.baseUrl); return credentialIdentity && providerDestinationIdentity ? { providerName, providerDestinationIdentity, providerDestinationDurableIdentity: durableReplayDestinationIdentity(provider.baseUrl), adapterName, modelId, credentialIdentity, ...(credentialDurableIdentity ? { credentialDurableIdentity } : {}), } : undefined; } /** * Whether this exact route cannot satisfy its documented plaintext reasoning replay contract. * * A generic plaintext-preserving gateway is not made ineligible. Unknown serving provenance also * stays eligible; only a proven route mismatch may suppress a combo candidate. */ export function mandatoryResponsesReasoningReplayUnavailable(args: { body: unknown; clientThreadId: string | undefined; clientPrincipalId?: string; providerName: string; provider: OcxProviderConfig; adapterName: string; modelId: string; }): boolean { const { body, clientThreadId, provider, adapterName } = args; if ( adapterName !== "openai-responses" || !requiresPlaintextReasoningReplay(provider) || !clientThreadId || !requestCarriesTools(body) || !hasOpaqueOnlyReasoningItem(body) ) return false; const current = routeReasoningReplayIdentity(args); return reasoningReplayServingIdentityChanged({ clientThreadId, clientPrincipalId: args.clientPrincipalId, current }); } function requestCarriesTools(body: unknown): boolean { if (!body || typeof body !== "object" || Array.isArray(body)) return false; return Array.isArray((body as { tools?: unknown }).tools) && (body as { tools: unknown[] }).tools.length > 0; } function hasOpaqueOnlyReasoningItem(body: unknown): boolean { if (!body || typeof body !== "object" || Array.isArray(body)) return false; const input = (body as { input?: unknown }).input; if (!Array.isArray(input)) return false; return input.some(item => { if (!item || typeof item !== "object" || Array.isArray(item)) return false; const reasoning = item as Record<string, unknown>; if (reasoning.type !== "reasoning" || typeof reasoning.encrypted_content !== "string") return false; const content = reasoning.content; const hasPlaintext = Array.isArray(content) && content.some(part => !!part && typeof part === "object" && !Array.isArray(part) && (part as Record<string, unknown>).type === "reasoning_text" && typeof (part as Record<string, unknown>).text === "string" && ((part as Record<string, unknown>).text as string).length > 0 ); return !hasPlaintext; }); } export function adapterResponseReachedServingTerminal( events: readonly AdapterEvent[], response: Readonly<Record<string, unknown>>, ): boolean { return (response.status === "completed" || response.status === "incomplete") && events.some(event => event.type === "done" || event.type === "incomplete"); } export function nonEmptyProviderApiKey(provider: OcxProviderConfig): string | undefined { return typeof provider.apiKey === "string" && provider.apiKey.trim().length > 0 ? provider.apiKey : undefined; }