UNPKG

@bitkyc08/opencodex

Version:

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

142 lines (133 loc) • 8.11 kB
import type { AdapterRequest } from "../../adapters/base"; import { formatErrorResponse } from "../../bridge"; import type { MainQuotaDispatch } from "../../codex/main-account-cache"; import { isLocalUpstream } from "../../lib/local-upstream"; import { guardResponseBodyInactivity, markResponseBodyInactivityGuarded } from "../../lib/response-body-inactivity"; import { explicitStallTimeoutMs, resolveStallTimeoutMs } from "../../stall-timeout"; import type { OcxConfig } from "../../types"; import { recordKeyWireAttemptUsage, usageFromResponsesPayload, type RequestLogContext } from "../request-log"; import { selectProtocolSafeResetResponse, type ProtocolSafeResetRecovery } from "./combo-stream-preflight"; import { bindPublishedMainQuotaDispatch } from "./core-codex-account"; import type { ResponsesAdmissionState } from "./core-options"; import { guardOpenGatewayCompletion } from "./opengateway-completion-guard"; import { parseOutboundRequestBody } from "./outbound-request-body"; import { carryResponseToolOwnership } from "./response-tool-ownership"; export { parseOutboundRequestBody } from "./outbound-request-body"; // A guarded published reset response, mapped to when its selection began holding the head. const guardedResetResponses = new WeakMap<Response, number>(); // A canonical JSON turn's published head, mapped to the wall-clock time its selection began (#8343). const bufferedSelectionStarts = new WeakMap<Response, number>(); /** * When reset selection began holding this canonical JSON turn's head, if it ran. The collector's * whole-turn deadline starts there, so the time selection held the head counts against it. */ export function bufferedResetSelectionStartedAt(response: Response): number | undefined { return bufferedSelectionStarts.get(response); } /** * How long a direct stream's head may wait on the original's own inspection. * * Returning the response is the latest point this code can still choose a head, but it does not * send one: Bun's server writes the head together with the first body bytes, so a window commit * also gives the client a comment at once. A healthy slow upstream and a dying one look the same * until the source fails, so a direct client gets the original head promptly instead of after a * heartbeat interval. A failure observed inside this window may still publish the replacement's * own head, as a pre-header reset does. */ export const DIRECT_RESET_INSPECTION_WINDOW_MS = 200; /** Who consumes the selected head: the client directly, the canonical JSON collector, or a combo parent. */ export type ResetSelectionDelivery = "direct-stream" | "buffered-json" | "combo-child"; /** A replacement must still be the stream the upstream request asked for; refetch requires 2xx. */ export function isResetReplacementStream(candidate: Response, upstreamRequestsStream: boolean): boolean { const type = candidate.headers.get("content-type")?.toLowerCase() ?? ""; return type.includes("text/event-stream") || (!type && upstreamRequestsStream); } /** * Select the native response a reset preflight publishes. * * A direct stream's head waits on the original's inspection for at most * `DIRECT_RESET_INSPECTION_WINDOW_MS`. The canonical JSON collector and a combo parent publish no * head before their own inspection ends, so their selection may wait one heartbeat interval. No * selection waits longer than the stall budget; see `selectProtocolSafeResetResponse`. A consumer that measures silence on the bytes it * receives cannot tell a held prelude, its later replay or a generated comment from an upstream * read, and it starts after selection already waited. Both bodies are guarded before preflight, so each physical * attempt's stall budget runs on its own upstream reads from its own head. The guard's failure is * a timeout, which the reset gate never treats as replayable. The published head carries the main * quota proof of the physical attempt that produced it, because the replacement send renews the * context's proof. */ export function selectPassthroughResetResponse( response: Response, admission: Pick<ResponsesAdmissionState, "authCtx">, logCtx: RequestLogContext, recover: ProtocolSafeResetRecovery, options: { request: AdapterRequest; config: Pick<OcxConfig, "stallTimeoutSec">; signal: AbortSignal; allowMissingContentType: boolean; delivery: ResetSelectionDelivery; }, ): Promise<Response> { const openGateway = options.request.url === "https://apis.opengateway.ai/v1/responses" && response.status === 200 && response.body !== null; const stallMs = resolveStallTimeoutMs(options.config.stallTimeoutSec, { localUpstream: isLocalUpstream(options.request.url) }); // The same budget, but reported as a stall only when the operator set it explicitly (#8206). const explicitBudget = explicitStallTimeoutMs(options.config.stallTimeoutSec) > 0; const protect = (source: Response): Response => carryResponseToolOwnership(source, guardResponseBodyInactivity(source, options.signal, stallMs, { explicitBudget }).response); const quotaOwner = (): MainQuotaDispatch | undefined => admission.authCtx.kind === "main" ? admission.authCtx.mainQuotaDispatch : undefined; const originalOwner = quotaOwner(); let replacementOwner: MainQuotaDispatch | undefined; const heldSince = performance.now(); const selectionStartedAt = Date.now(); return selectProtocolSafeResetResponse(protect(response), logCtx, async (error, stage, signal, accepts) => { // Recover returns only a validated, fresh body; wrapping earlier would hide its lock state. const replacement = await recover(error, stage, signal, accepts); if (!replacement) return null; replacementOwner = quotaOwner(); return protect(replacement); }, { allowMissingContentType: options.allowMissingContentType, // The collector's silence clock sees only delivered bytes; a combo parent holds the head itself. keepalive: options.delivery === "buffered-json" ? "upstream-activity" : options.delivery === "combo-child" ? "none" : "periodic", inspectionWindowMs: options.delivery === "direct-stream" ? DIRECT_RESET_INSPECTION_WINDOW_MS : undefined, signal: options.signal, maxSelectionMs: stallMs > 0 ? stallMs : undefined, onCommit: (published, owner) => { if (stallMs > 0) markResponseBodyInactivityGuarded(published); if (openGateway) guardedResetResponses.set(published, heldSince); if (options.delivery === "buffered-json") bufferedSelectionStarts.set(published, selectionStartedAt); bindPublishedMainQuotaDispatch(published, owner === "replacement" ? replacementOwner : originalOwner); }, }); } export function guardPassthroughCompletion( response: Response, request: AdapterRequest, config: Pick<OcxConfig, "emptyCompletionRetry" | "stallTimeoutSec">, signal: AbortSignal, logCtx: RequestLogContext, rebuildAndRefetch: (kind: "empty-completion") => Promise<Response | { failed: Response | { kind: "adapter-handoff" } }>, ): Promise<Response> { if (request.url !== "https://apis.opengateway.ai/v1/responses") return Promise.resolve(response); const heldSince = guardedResetResponses.get(response); return guardOpenGatewayCompletion(response, { url: request.url, body: parseOutboundRequestBody(request.body), signal, retryEnabled: config.emptyCompletionRetry, stallTimeoutMs: resolveStallTimeoutMs(config.stallTimeoutSec), initialBodyInactivityGuarded: heldSince !== undefined, // The completion hold and reset selection share one bound on how long the head waits. initialHoldSpentMs: heldSince === undefined ? 0 : performance.now() - heldSince, recordUsage: usage => { recordKeyWireAttemptUsage(logCtx, usageFromResponsesPayload(usage)); }, retry: async () => { const result = await rebuildAndRefetch("empty-completion"); if (!("failed" in result)) return result; return result.failed instanceof Response ? result.failed : formatErrorResponse(502, "upstream_error", "Native recovery changed the provider wire"); }, }); }