UNPKG

@bitkyc08/opencodex

Version:

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

158 lines (149 loc) • 8.48 kB
import { proxyErrorPresentation, isProxyError, rememberProxyErrorMessage } from "../../lib/client-error-body"; import { anthropicRejectionPolicy, bindAnthropicRejectionPolicy, rejectedAnthropicPayloads } from "../../adapters/anthropic-rejection-memo"; import { normalizeUpstreamErrorText, readDisplaySafeErrorText } from "./core-errors"; import { sanitizeNonReplayableUpstreamError } from "./non-replayable-error"; import { isLikelyRealAnthropicThinkingSignature } from "../../adapters/anthropic"; import type { AdapterEvent, OcxParsedRequest } from "../../types"; import { upstreamErrorMessageFromPayload } from "../../lib/errors"; import { readBoundedResponseBody } from "../../lib/bounded-body"; import { isNonReplayableResponse } from "../../lib/upstream-retry"; import { rememberReasoningReplayOpaqueBlobRejection } from "../../responses/reasoning-replay-cache"; import { prepareOpaqueBlobRecovery, type OpaqueBlobRecoveryGuard } from "./core-opaque-recovery"; /** Only the explicit conversation-binding refusal authorizes removing signed history. */ export function isAnthropicThinkingSignatureBindingRejectionMessage(message: string): boolean { return message.includes("Invalid `signature` in `thinking` block") && message.includes("The block is bound to a different conversation"); } function carriesThinkingState(parsed: OcxParsedRequest): boolean { return parsed.context.messages.some(message => message.role === "assistant" && message.content.some(part => part.type === "thinking" && (isLikelyRealAnthropicThinkingSignature(part.signature) || part.redacted?.some(data => typeof data === "string" && data.length > 0)))); } /** One request owns both the HTTP refusal and initial-event recovery, never a fresh retry guard. */ export function createAnthropicThinkingRecovery( parsed: OcxParsedRequest, signal: AbortSignal, guard: OpaqueBlobRecoveryGuard, canRetry: () => boolean, proxyErrorContext?: object, ) { let rejectedScope: OcxParsedRequest["_reasoningReplayScope"]; let rejectedPayloads: ReadonlySet<string> | undefined; let armed = false; let outputSeen = false; let completed = false; let failed = false; let remembered = false; const prepare = (message: string, adapterName: string, attempt = parsed, response?: Response): boolean => { if (signal.aborted || !canRetry() || adapterName !== "anthropic" || guard.attempted || parsed._stripReasoningEncryptedContent === true || !carriesThinkingState(attempt) || !isAnthropicThinkingSignatureBindingRejectionMessage(message)) return false; rejectedPayloads = rejectedAnthropicPayloads(response); // A real send must prove that it serialized opaque history; otherwise rebuilding could // repeat the same request. Direct event-policy callers have no HTTP body to identify. if (response && !rejectedPayloads?.size) return false; const previous = anthropicRejectionPolicy(parsed); if (rejectedPayloads && previous?.mode === "selective") { const merged = new Set(previous.fingerprints); for (const payload of rejectedPayloads) merged.add(payload); rejectedPayloads = merged.size <= 256 ? merged : undefined; } guard.attempted = true; armed = true; const scope = parsed._reasoningReplayScope; rejectedScope = scope ? { ...scope, current: scope.current ? { ...scope.current } : undefined } : undefined; if (!rejectedPayloads) { prepareOpaqueBlobRecovery(parsed); if (attempt !== parsed) prepareOpaqueBlobRecovery(attempt); } const policy = rejectedPayloads ? { mode: "selective" as const, fingerprints: rejectedPayloads } : { mode: "blanket" as const }; bindAnthropicRejectionPolicy(parsed, policy); bindAnthropicRejectionPolicy(attempt, policy); return true; }; const prepareHttp = async (response: Response, adapterName: string, attempt = parsed): Promise<boolean> => { if (signal.aborted || !canRetry() || response.status !== 400 || isNonReplayableResponse(response) || adapterName !== "anthropic" || guard.attempted || parsed._stripReasoningEncryptedContent === true || !carriesThinkingState(attempt)) return false; try { const body = await readBoundedResponseBody(response.clone(), { signal }); if (!body.displaySafe || body.truncated) return false; const message = upstreamErrorMessageFromPayload(JSON.parse(body.text) as unknown); return typeof message === "string" && prepare(message, adapterName, attempt, response); } catch { return false; } }; const observe = (event: AdapterEvent): void => { if (!armed) return; if (event.type === "error" || event.type === "incomplete") failed = true; if (event.type === "done") completed = true; if ((event.type === "text_delta" && event.text.length > 0) || event.type === "tool_call_end") outputSeen = true; }; async function* wrap( events: AsyncIterable<AdapterEvent>, retry: () => AsyncIterable<AdapterEvent>, adapterName: () => string, replayAllowed = true, response?: Response, attempt = parsed, ): AsyncGenerator<AdapterEvent> { let source = events; let replaySafe = replayAllowed; while (true) { const iterator = source[Symbol.asyncIterator](); let recovered = false; try { while (true) { const next = await iterator.next(); if (next.done) return; const event = next.value; if (replaySafe && event.type === "error" && prepare(event.message, adapterName(), attempt, response)) { // Close the rejected body before acquiring another dispatch/pacing slot. await iterator.return?.(); source = retry(); recovered = true; break; } // Even hidden reasoning, boundaries, and tool activity fence a replay. A heartbeat // carrying a side-effect latch is never evidence that a turn is safe to repeat. replaySafe &&= event.type === "heartbeat" && event.replayUnsafe !== true; observe(event); yield event; } } finally { if (!recovered) await iterator.return?.(); } } } const rememberSuccess = (response: Readonly<Record<string, unknown>>): void => { // HTTP 200, EOF, or a guard-generated completion alone cannot prove the stripped send worked. // The delivery owner calls this only after its bridge/fold validated a successful terminal. if (!armed || remembered || signal.aborted || failed || !completed || !outputSeen || response.status !== "completed" || !Array.isArray(response.output) || response.output.length === 0 || !rejectedScope || rejectedScope.clientThreadId !== parsed._reasoningReplayScope?.clientThreadId || rejectedScope.clientPrincipalId !== parsed._reasoningReplayScope?.clientPrincipalId || JSON.stringify(rejectedScope.current) !== JSON.stringify(parsed._reasoningReplayScope?.current)) return; remembered = true; rememberReasoningReplayOpaqueBlobRejection(rejectedScope, rejectedPayloads); }; // The search owner supplies only a fully validated current iteration, never search-card output. const observeIteration = (events: readonly AdapterEvent[]): void => { outputSeen = false; completed = false; for (const event of events) observe(event); }; const projectHttpFailure = async (response: Response, abortSignal: AbortSignal): Promise<Extract<AdapterEvent, { type: "error" }>> => { const nonReplayable = isNonReplayableResponse(response); if (nonReplayable) response = await sanitizeNonReplayableUpstreamError(response, abortSignal); const text = await readDisplaySafeErrorText(response, abortSignal, `Provider error ${response.status}`); const error = normalizeUpstreamErrorText(text, `Provider error ${response.status}`); if (proxyErrorContext && isProxyError(response)) rememberProxyErrorMessage(proxyErrorContext, error.message ?? error.safeText, { status: response.status, type: error.type ?? "upstream_error", code: error.code, presentation: proxyErrorPresentation(response) }); return { type: "error", status: response.status, message: error.message ?? error.safeText, errorType: error.type ?? "upstream_error", ...(error.code ? { code: error.code } : {}), ...(nonReplayable ? { retryable: false } : {}) }; }; return { prepareHttp, prepareEvent: prepare, observeIteration, projectHttpFailure, wrap, rememberSuccess }; }