@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
260 lines (243 loc) • 12.2 kB
text/typescript
/**
* Shared plumbing for native ingresses that translate onto the internal Chat Completions path
* (the Ollama-compatible and Gemini-compatible routes). It holds what is identical across them:
* the identity-only internal request, Retry-After and refusal vocabulary, fixed error text by
* status, and the SSE-to-native stream pump with its settlement and cancellation rules. The
* protocol-specific parts (frame shapes, error bodies) stay in each ingress.
*/
import { isUnattendedAgyAcpHttpTurn } from "../adapters/agy-acp/policy";
import { parseRetryAfterMs } from "../combos";
import type { AdmissionLease } from "../lib/admission";
import { WORKFLOW_LOCAL_REFUSAL_HEADER } from "../lib/workflow-budget";
import type { OcxConfig } from "../types";
import type { CapturedAdmissionPolicy } from "../types/admission-policy";
import type { DataPlaneAdmission } from "./auth-cors";
import { handleChatCompletions } from "./chat-completions";
import type { NativeFinalLog } from "./native-final-log";
import type { RequestLogContext } from "./request-log";
import { linkRequestSessionLane } from "./request-log-conversation";
// Session and workflow identity only: lineage, session lanes and the workflow root's spend
// ceiling read these from the request Chat sees. Never authorization, cookies or admission keys.
const IDENTITY_HEADERS = ["session_id", "session-id", "thread-id", "x-session-id", "x-codex-parent-thread-id"] as const;
/** Dispatch translated Chat while keeping the original turn label in process-local policy state. */
export function handleNativeChat(
req: Request,
originalBody: unknown,
chatJson: string,
config: OcxConfig,
logCtx: RequestLogContext,
ids: NativeLogIds,
): Promise<Response> {
const agyAcpUnattendedHttpTurn = isUnattendedAgyAcpHttpTurn(req.headers, originalBody);
const headers = new Headers({ "content-type": "application/json" });
for (const name of IDENTITY_HEADERS) {
const value = req.headers.get(name);
if (value !== null) headers.set(name, value);
}
const internal = new Request(new URL("/v1/chat/completions", req.url), { method: "POST", headers, body: chatJson, signal: req.signal });
linkRequestSessionLane(req, internal);
return handleChatCompletions(internal, config, logCtx, {
...ids, suppressProtocolTrace: true, agyAcpUnattendedHttpTurn,
});
}
/** The request-log and admission identity a native handler passes to the inner Chat path. */
export interface NativeLogIds {
requestId: string;
start: number;
turnAdmissionLease?: AdmissionLease;
admission?: DataPlaneAdmission;
advisorAdmissionPolicy?: CapturedAdmissionPolicy;
}
/** Upper bound for the retry advice a native surface passes on. */
export const NATIVE_MAX_RETRY_AFTER_SECONDS = 3600;
/**
* Retry-After as an integer we format ourselves. The incoming value may come from an upstream,
* so only the parsed delay crosses this boundary, never its bytes; unparseable values are dropped.
*/
export function nativeRetryAfter(value: string | null | undefined, now = Date.now()): string | undefined {
if (value?.trim() === "0") return "0";
const ms = parseRetryAfterMs(value, now);
if (ms === undefined) return undefined;
return String(Math.min(NATIVE_MAX_RETRY_AFTER_SECONDS, Math.max(0, Math.ceil(ms / 1000))));
}
/**
* The local refusal codes native surfaces pass on, each mapped to a constant defined here. The
* emitted header value is always the constant; an incoming value only selects it, and any value
* not in this table is dropped.
*/
const LOCAL_REFUSAL_CODES: ReadonlyMap<string, string> = new Map([
["workflow_sends_exhausted", "workflow_sends_exhausted"],
["workflow_children_exhausted", "workflow_children_exhausted"],
["workflow_concurrency_exhausted", "workflow_concurrency_exhausted"],
["workflow_spend_exhausted", "workflow_spend_exhausted"],
["workflow_tracking_exhausted", "workflow_tracking_exhausted"],
["workflow_send_replayed", "workflow_send_replayed"],
["workflow_pool_history_unresolved", "workflow_pool_history_unresolved"],
["workflow_spend_undurable", "workflow_spend_undurable"],
]);
export interface NativeRefusalParts {
status: number;
message: string;
retryAfter: string | null;
/** A constant from the known workflow refusal codes, never the incoming header value. */
localRefusalCode?: string;
}
/** Reduce an existing proxy refusal (capacity, workflow, drain) to its status, fixed text and retry advice. */
export function nativeRefusalParts(response: Response): NativeRefusalParts {
try { void response.body?.cancel().catch(() => {}); } catch { /* already consumed */ }
const message = response.status === 429 ? "request budget exhausted; retry later"
: response.status === 499 ? "request cancelled"
: response.status === 503 ? "server temporarily unavailable; retry later" : "request refused";
const code = LOCAL_REFUSAL_CODES.get(response.headers.get(WORKFLOW_LOCAL_REFUSAL_HEADER) ?? "");
return { status: response.status, message, retryAfter: response.headers.get("retry-after"), ...(code !== undefined ? { localRefusalCode: code } : {}) };
}
/** Put the workflow refusal constant on a native refusal and expose it to browsers. */
export function applyLocalRefusalCode(native: Response, code: string | undefined): Response {
if (code === undefined) return native;
native.headers.set(WORKFLOW_LOCAL_REFUSAL_HEADER, code);
native.headers.set("Access-Control-Expose-Headers", WORKFLOW_LOCAL_REFUSAL_HEADER);
return native;
}
/**
* Native error text is chosen by status only. The inner body can carry upstream-authored text,
* which may echo a credential no pattern recognizes, so it is drained and never forwarded.
*/
const INNER_ERROR_MESSAGES: Readonly<Record<number, string>> = {
400: "request rejected",
401: "upstream authentication failed",
402: "upstream payment required",
403: "request not permitted",
404: "model not found",
408: "upstream request timed out",
409: "request conflict",
413: "request too large",
422: "request rejected",
429: "rate limited; retry later",
499: "request cancelled",
500: "upstream request failed",
502: "upstream request failed",
503: "upstream unavailable; retry later",
504: "upstream request timed out",
};
export function nativeInnerErrorMessage(status: number): string {
return INNER_ERROR_MESSAGES[status] ?? (status >= 500 ? "upstream request failed" : "request failed");
}
export async function drainedInnerErrorMessage(response: Response): Promise<string> {
await response.body?.cancel().catch(() => {});
return nativeInnerErrorMessage(response.ok ? 502 : response.status);
}
/** A client that left before the outer outcome was committed owns a 499 row, whatever the inner path reported. */
export function commitCancelled(finalLog: NativeFinalLog): void {
finalLog.commit({ status: 499, closeReason: "client_cancel" });
}
export type NativeStreamTerminal = { ok: true; frames(): Uint8Array[] } | { ok: false; error: string };
/** The protocol-specific half of a native stream: how Chat chunks become frames. */
export interface NativeStreamTranslator {
contentType: string;
/** One parsed Chat chunk to zero or more encoded frames. Throwing marks the stream failed. */
chunk(parsed: unknown): Uint8Array[];
/** Evaluated once at end of stream, before settlement is known; frames are produced only on success. */
terminal(): NativeStreamTerminal;
/** Encoded frames that end a stream that failed or did not settle. */
failure(message: string): Uint8Array[];
/** Release translator-owned buffers after success, failure, or cancellation. */
dispose?(): void;
}
/**
* Pump an inner Chat SSE body through a translator. A stream's terminal frames are emitted only
* after the Chat stream reached EOF and the inner path settled, so trailing usage is included and
* a later error never follows a success terminal. The row is committed exactly once through
* the final log; a client that cancels, even while settlement is pending, owns a 499 row.
*/
export function streamNativeFromChat(translator: NativeStreamTranslator, body: ReadableStream<Uint8Array>, finalLog: NativeFinalLog, signal: AbortSignal): Response {
const reader = body.getReader();
const decoder = new TextDecoder();
let pending = "";
// ended: no further reads or frames. cancelled: the client went away, possibly while end() waits.
let ended = false;
let cancelled = false;
// The inner Chat path can finalize on EOF after [DONE], so keep draining to EOF before ending.
let sawDone = false;
const cancelInner = () => { try { void reader.cancel().catch(() => {}); } catch { /* released */ } };
const end = async (controller: ReadableStreamDefaultController<Uint8Array>, failure?: string) => {
if (ended) return;
ended = true;
if (failure !== undefined) {
cancelInner();
translator.dispose?.();
}
const terminal = failure === undefined ? translator.terminal() : undefined;
const settled = await finalLog.waitForInner();
try {
if (cancelled || signal.aborted) {
commitCancelled(finalLog);
try { controller.close(); } catch { /* already cancelled by the client */ }
return;
}
if (terminal?.ok === true && settled) {
for (const frame of terminal.frames()) controller.enqueue(frame);
finalLog.commit({ status: 200, terminalStatus: "completed", closeReason: "terminal" });
} else {
const message = failure ?? (terminal?.ok === false ? terminal.error : "request did not complete");
for (const frame of translator.failure(message)) controller.enqueue(frame);
finalLog.commit({ status: 502, terminalStatus: "failed", closeReason: "terminal" });
}
controller.close();
} catch {
// The client cancelled between settlement and the terminal frames; the row still lands once.
commitCancelled(finalLog);
} finally {
if (failure === undefined) translator.dispose?.();
}
};
// Returns how many frames were enqueued. Finish and usage chunks may enqueue nothing.
const consume = (controller: ReadableStreamDefaultController<Uint8Array>, block: string): number => {
let emitted = 0;
for (const raw of block.split("\n")) {
const text = raw.trimEnd();
if (!text.startsWith("data:")) continue;
// Chat ends at [DONE]; any later data (an error frame, say) means the stream did not settle cleanly.
if (sawDone) throw new Error("data after the Chat stream terminator");
const payload = text.slice(5).trim();
if (payload === "[DONE]") { sawDone = true; continue; }
for (const frame of translator.chunk(JSON.parse(payload))) { controller.enqueue(frame); emitted++; }
}
return emitted;
};
return new Response(new ReadableStream<Uint8Array>({
// A pull that resolves without enqueueing is not called again, so keep reading until this
// pull has produced a frame or ended the stream.
async pull(controller) {
try {
while (!ended) {
const { done, value } = await reader.read();
if (done) {
pending += decoder.decode();
if (pending) consume(controller, pending);
pending = "";
await end(controller);
return;
}
pending += decoder.decode(value, { stream: true });
const boundary = pending.lastIndexOf("\n");
if (boundary < 0) continue;
const complete = pending.slice(0, boundary);
pending = pending.slice(boundary + 1);
if (consume(controller, complete) > 0) return;
}
} catch {
await end(controller, signal.aborted ? "request cancelled" : "upstream stream failed");
}
},
async cancel() {
cancelled = true;
// When end() is already waiting for settlement it sees the flag and writes the 499 row.
if (ended) return;
ended = true;
cancelInner();
translator.dispose?.();
await finalLog.waitForInner();
commitCancelled(finalLog);
},
}, { highWaterMark: 0 }), { status: 200, headers: { "content-type": translator.contentType } });
}