UNPKG

@bitkyc08/opencodex

Version:

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

191 lines (187 loc) • 11.7 kB
import { comboFailureDecision } from "../combos"; import { isProviderIntakeRefusalBody, isProviderModerationRefusal } from "../combos/failover"; import { attachComboFailureEvidence } from "../lib/client-error-body"; import { explicitErrorEventStatus } from "./responses/combo-stream-preflight"; import { httpStatusFromTerminalError } from "../lib/errors"; import { redactSecretString } from "../lib/redact"; import { sseFieldValue } from "../lib/sse-decoder"; import type { TranslatorBudget } from "../lib/translator-budget"; import { anthropicUsageToOcx } from "./messages-shared"; import type { RequestLogContext } from "./request-log"; import { BoundedSseFrameBuffer, MAX_CLIENT_SSE_FRAME_BYTES, SseFrameCountLimitError, SseFrameTooLargeError } from "./sse-frame-buffer"; import { UNDECLARED_TOOL_CALL_ERROR_CODE } from "./responses-undeclared-tool-guard"; type Rec = Record<string, unknown>; const isRec = (value: unknown): value is Rec => value !== null && typeof value === "object" && !Array.isArray(value); /** Capture replay evidence before any relay can split a physical upstream read into frames. */ export function observeNativeMessagesReplayBoundary(body: ReadableStream<Uint8Array>, logCtx: RequestLogContext, replay: { committed: boolean; pending: boolean }): ReadableStream<Uint8Array> { const reader = body.getReader(); const inspector = new BoundedSseFrameBuffer(); const decoder = new TextDecoder(); let active = true; return new ReadableStream<Uint8Array>({ async pull(controller) { try { const next = await reader.read(); if (next.done) { inspector.dispose(); controller.close(); return; } if (active) { let errorSeen = false; let finished = false; try { for (const frame of inspector.feed(next.value)) { if (frame.continuation) continue; const lines = decoder.decode(frame.block).split(/\r\n|\r|\n/); const event = lines.map(line => sseFieldValue(line, "event")).findLast(value => value !== null) ?? null; const dataFields = lines.map(line => sseFieldValue(line, "data")).filter(value => value !== null); const data = dataFields.join("\n"); let payload: unknown; try { payload = JSON.parse(data); } catch { payload = undefined; } const type = isRec(payload) && (event === null || event === payload.type) ? payload.type : undefined; if (errorSeen && (event !== null || dataFields.length > 0) && type !== "ping") logCtx.streamErrorFollowed = true; if (type === "error" && isRec(payload) && isRec(payload.error)) errorSeen = true; else if ((event !== null || dataFields.length > 0) && type !== "ping" && !(type === "message_start" && isRec(payload) && isRec(payload.message) && Array.isArray(payload.message.content) && payload.message.content.length === 0)) { replay.committed = true; finished = true; } } replay.pending = inspector.pendingBytes > 0; // An unfinished event can still acquire a different name or payload on the next read. if (errorSeen && inspector.pendingBytes > 0) logCtx.streamErrorFollowed = true; if (errorSeen || finished) { active = false; inspector.dispose(); } } catch (error) { if (!(error instanceof SseFrameTooLargeError || error instanceof SseFrameCountLimitError)) throw error; logCtx.streamErrorFollowed = true; replay.committed = true; active = false; inspector.dispose(); } } controller.enqueue(next.value); } catch (error) { inspector.dispose(); controller.error(error); } }, cancel(reason) { inspector.dispose(); return reader.cancel(reason); }, }, { highWaterMark: 0 }); } /** Inspect only the bounded protocol prelude. Any block, unknown payload or cap commits. */ export async function preflightNativeMessagesResponse( response: Response, logCtx: RequestLogContext, budget: TranslatorBudget, replay?: { committed: boolean }, ): Promise<{ kind: "accepted" | "failed"; response: Response }> { if (!response.ok || !response.body || !response.headers.get("content-type")?.toLowerCase().includes("text/event-stream")) { return { kind: "accepted", response }; } let committed = false; let terminal = false; let failure: Rec | undefined; let failureStatus = 502; /** The whole error event, kept when a moderation verdict decided the hop. */ let failureEvidence: string | undefined; let usage: Rec = {}; const inspector = new BoundedSseFrameBuffer(); const decoder = new TextDecoder(); const inspectFrame = (block: Uint8Array) => { // A retryable failure keeps reading its chunk: later output in it still commits. if (committed || terminal) return; const lines = decoder.decode(block).split(/\r\n|\r|\n/); const event = lines.map(line => sseFieldValue(line, "event")).findLast(value => value !== null) ?? null; const data = lines.map(line => sseFieldValue(line, "data")).filter(value => value !== null).join("\n"); // A named event without a payload is malformed and commits; a comment-only block is skipped. if (!data) { if (event !== null) committed = true; return; } let payload: unknown; try { payload = JSON.parse(data); } catch { committed = true; return; } // Match the native log tap: the last, untrimmed event field is authoritative. A payload // under another event name is unknown output, never a replayable refusal or prelude. if (!isRec(payload) || (event !== null && event !== payload.type)) { committed = true; return; } if (payload.type === "message_start" && isRec(payload.message)) { if (isRec(payload.message.usage)) usage = { ...usage, ...payload.message.usage }; if (!Array.isArray(payload.message.content) || payload.message.content.length !== 0) committed = true; } else if (payload.type === "ping") { // Protocol liveness is not output. } else if (payload.type === "error" && isRec(payload.error)) { const error = payload.error; const wholeEvent = JSON.stringify(payload); // A status the event states for itself (any spelling the responses preflight reads) is // evidence of its own: a framed 429 or 503 is never read as a moderation refusal. const framed = explicitErrorEventStatus(payload); const framedAllowsModeration = framed === undefined || framed === 400 || framed === 422; // Otherwise a structured moderation verdict on the whole event is a request-level refusal, // whatever status the terminal mapping infers for its code; judge it like the HTTP reader. const moderation = framedAllowsModeration && isProviderModerationRefusal(400, wholeEvent, undefined, true); const mapped = httpStatusFromTerminalError({ type: typeof error.type === "string" ? error.type : undefined, code: typeof error.code === "string" ? error.code : undefined, message: typeof error.message === "string" ? error.message : undefined }) ?? 502; const status = moderation && mapped !== 400 && mapped !== 422 ? 400 : mapped; if (logCtx.terminalSource !== "synthetic" && logCtx.errorCode !== UNDECLARED_TOOL_CALL_ERROR_CODE && comboFailureDecision(status, typeof error.message === "string" ? error.message : "", { code: typeof error.code === "string" ? error.code : undefined, rootCode: typeof payload.code === "string" ? payload.code : undefined, // The whole event, as the HTTP and stream readers judge it, so transports cannot disagree. providerModerationRefusal: status === 400 || status === 422 ? framedAllowsModeration && isProviderModerationRefusal(status, wholeEvent, undefined, true) : undefined, providerIntakeRefusal: status === 413 ? isProviderIntakeRefusalBody(wholeEvent) : undefined, }) === "hop") { failure = error; failureStatus = status; failureEvidence = moderation && (status === 400 || status === 422) ? wholeEvent : undefined; } else committed = true; } else if (payload.type === "message_stop") terminal = true; else committed = true; }; const reader = response.body.getReader(); const chunks: Uint8Array[] = []; let retained = 0; const release = () => { budget.releaseRetained(retained, { kind: "retained_collectors" }); retained = 0; }; try { for (;;) { const next = await reader.read(); if (next.done) { terminal = true; break; } // The one upstream chunk already exists; retain it without a copy if the cap commits. if (retained + next.value.byteLength > MAX_CLIENT_SSE_FRAME_BYTES || chunks.length >= 1024) { chunks.push(next.value); committed = true; break; } // Classify before retaining: a chunk that commits is held like the cap's, so a budget // refusal can only meet a prelude that is still safe to replay. try { for (const frame of inspector.feed(next.value)) if (!frame.continuation) inspectFrame(frame.block); } catch (error) { if (!(error instanceof SseFrameTooLargeError || error instanceof SseFrameCountLimitError)) throw error; committed = true; } if (!committed) { budget.chargeRetained(next.value.byteLength, { kind: "retained_collectors" }); retained += next.value.byteLength; } chunks.push(next.value); if (committed || terminal || failure) break; } // The tap read the original upstream chunk; output after the error there commits too. if (failure && !committed && !replay?.committed && !logCtx.streamErrorFollowed) { logCtx.usage = anthropicUsageToOcx(usage); const message = redactSecretString(typeof failure.message === "string" ? failure.message : "Provider stream failed before output"); logCtx.upstreamError = `Provider stream failed (${failureStatus})`; void reader.cancel("retrying native Messages pre-output refusal").catch(() => {}); release(); const headers = new Headers(response.headers); headers.set("content-type", "application/json"); headers.delete("content-length"); headers.delete("content-encoding"); const failed = Response.json({ error: { ...(typeof failure.type === "string" ? { type: failure.type } : {}), ...(typeof failure.code === "string" ? { code: failure.code } : {}), message, } }, { status: failureStatus, headers }); // The rebuilt envelope drops the evidence (root code, innererror) the verdict was judged on. return { kind: "failed", response: failureEvidence === undefined ? failed : attachComboFailureEvidence(failed, failureEvidence) }; } let index = 0; const body = new ReadableStream<Uint8Array>({ async pull(controller) { try { if (index < chunks.length) { controller.enqueue(chunks[index++]!); return; } chunks.length = 0; release(); const next = await reader.read(); if (next.done) controller.close(); else controller.enqueue(next.value); } catch (error) { release(); controller.error(error); } }, cancel(reason) { release(); void reader.cancel(reason).catch(() => {}); }, }, { highWaterMark: 0 }); return { kind: "accepted", response: new Response(body, { status: response.status, headers: response.headers }) }; } catch (error) { release(); void reader.cancel(error).catch(() => {}); throw error; } finally { inspector.dispose(); } }