@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
text/typescript
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;
}