@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
235 lines (224 loc) • 9.93 kB
text/typescript
import {
compressedBodyDecodeLimit,
MAX_DECOMPRESSED_BODY_BYTES,
resolveInboundBodyLimitBytes,
} from "./request-decompress";
import { withCors, type RequestPolicyView } from "./auth-cors";
import { codexCompatibleUrl } from "../codex/context-compat";
import { addFinalRequestLog, markLocalRequestLogRefusal } from "./request-log";
import type { WorkflowRefusalLog } from "./workflow-refusal";
import { inboundBodyBudget, bindInboundBodyLease, type InboundBodyBudget } from "./inbound-body-budget";
import { isGeminiBodyPath } from "./gemini-native-paths";
import { OLLAMA_JSON_BODY_ROUTES } from "./ollama-native-paths";
export { configureInboundBodyBudget, MAX_CONCURRENT_INBOUND_BODY_BYTES } from "./inbound-body-budget";
// Match the HTTP routes whose JSON readers use maxInboundBodyBytes. Keep the
// current image/search/count_tokens support; management, audio, context relay,
// and WebSocket frames have separate limits and are not part of this gate.
// Exported so the contract tests classify the dispatcher's own route list
// instead of copying it: a new loopback route has to land in one of these two
// sets, or `tests/server/inbound-body-admission.test.ts` fails.
export const CONFIGURABLE_JSON_BODY_ROUTES: ReadonlySet<string> = new Set([
"/v1/responses",
"/v1/responses/compact",
"/v1/chat/completions",
"/v1/messages",
"/v1/messages/count_tokens",
"/v1/images/generations",
"/v1/images/edits",
"/v1/alpha/search",
]);
/**
* Loopback routes deliberately outside this gate. Audio uploads, realtime/live
* control and the model list do not read JSON under `maxInboundBodyBytes`, so
* reserving that allowance for them would refuse traffic the limit never covered.
*/
export const UNGATED_LOOPBACK_ROUTES: ReadonlySet<string> = new Set([
"/v1/audio/transcriptions",
"/v1/audio/transcriptions/stream",
"/v1/models",
"/v1/realtime",
"/v1/realtime/calls",
"/v1/live",
]);
export class InboundBodyCapacityError extends Error {
constructor() {
super("OpenCodex inbound request body capacity is temporarily exhausted. Retry after the current request completes.");
this.name = "InboundBodyCapacityError";
}
}
function cancelUnreadBody(req: Request, reason: unknown): void {
if (!req.body || req.body.locked) return;
try {
// A tee's cancellation can wait for the other branch. Refusal must not wait
// for a peer that has not finished uploading, or for an unconsumed clone.
void req.body.cancel(reason).catch(() => undefined);
} catch { /* Non-standard streams may throw synchronously. */ }
}
function capacityResponse(pathname: string, error: InboundBodyCapacityError): Response {
const anthropic = pathname === "/v1/messages" || pathname === "/v1/messages/count_tokens";
return Response.json({
...(anthropic ? { type: "error" } : {}),
error: {
type: anthropic ? "overloaded_error" : "server_error",
code: "server_busy",
message: error.message,
},
}, { status: 503, headers: { "Retry-After": "1" } });
}
function retainUntilResponseSettles(response: Response, signal: AbortSignal, release: () => void): Response {
if (!response.body) {
release();
return response;
}
const reader = response.body.getReader();
let cancelling = false;
let cancellation: Promise<void> | undefined;
let finalized = false;
let bodyController!: ReadableStreamDefaultController<Uint8Array>;
const onAbort = (): void => {
if (finalized) return;
bodyController.error(signal.reason);
void cancel(signal.reason).catch(() => undefined);
};
const finalize = (): void => {
if (finalized) return;
finalized = true;
signal.removeEventListener("abort", onAbort);
try { reader.releaseLock(); } finally { release(); }
};
const cancel = (reason: unknown): Promise<void> => {
if (cancellation) return cancellation;
if (finalized) return Promise.resolve();
cancelling = true;
// Share one settlement even if explicit cancellation races request abort.
cancellation = Promise.resolve().then(() => reader.cancel(reason)).finally(finalize);
return cancellation;
};
const body = new ReadableStream<Uint8Array>({
start(controller) { bodyController = controller; },
async pull(controller) {
try {
const result = await reader.read();
// cancel() can resolve a pending read as EOF before the producer's
// asynchronous cancellation completes. Only cancel owns release then.
if (cancelling) return;
if (result.done) {
finalize();
controller.close();
} else {
controller.enqueue(result.value);
}
} catch (error) {
if (cancelling) return;
finalize();
controller.error(error);
}
},
cancel,
}, { highWaterMark: 0 });
// This is the outermost HTTP wrapper, after protocol conversion, relay
// preflight and request logging; no internal relay marker is consumed later.
const wrapped = new Response(body, {
status: response.status,
statusText: response.statusText,
headers: response.headers,
});
signal.addEventListener("abort", onAbort, { once: true });
if (signal.aborted) onAbort();
return wrapped;
}
/** A body that will be decoded: any Content-Encoding other than identity. */
function encodedBody(req: Request): boolean {
const encoding = req.headers.get("content-encoding")?.trim().toLowerCase();
return encoding !== undefined && encoding !== "" && encoding !== "identity";
}
/**
* Own one raised-limit or encoded HTTP request from before body reading through response
* EOF/error or settled cancellation. An encoded body joins the shared budget at every limit
* (#3023): it reserves what it may decode to (`compressedBodyDecodeLimit` of its declared wire
* bytes, or the whole limit without a declaration) before a byte is read, and the reader shrinks
* that to the measured size, so the decoded bodies held at once stay within the budget however
* small their wire bytes are. An identity body at the default limit is not gated, as before. Call only at the admitted HTTP boundary,
* after auth/origin checks, not from readers or internal combo/translation hops.
* pathname is the same canonical pathname used by the server's dispatcher.
* The optional budget/wait override isolates lifecycle tests from the process-wide owner.
*/
export async function withRaisedInboundBodyAdmission(
req: Request,
pathname: string,
configuredLimit: number | undefined,
work: () => Promise<Response>,
onRefusal: (response: Response) => Response = response => response,
options?: { budget?: InboundBodyBudget; maxWaitMs?: number; onAdmissionError?: (error: unknown) => Response },
): Promise<Response> {
const maxBytes = resolveInboundBodyLimitBytes(configuredLimit);
// Native Ollama generation routes are served only on the authenticated listener, so they sit in
// their own set: the loopback oracle checks CONFIGURABLE_JSON_BODY_ROUTES against that allowlist.
const raised = maxBytes > MAX_DECOMPRESSED_BODY_BYTES;
if (req.method !== "POST" || !(CONFIGURABLE_JSON_BODY_ROUTES.has(pathname) || OLLAMA_JSON_BODY_ROUTES.has(pathname) || isGeminiBodyPath(pathname))
|| !(raised || encodedBody(req)) || req.signal.aborted) {
return work();
}
const declared = req.headers.get("content-length");
const declaredBytes = declared === null || declared.trim() === "" ? NaN : Number(declared);
if (Number.isFinite(declaredBytes) && declaredBytes > maxBytes) {
// The existing bounded reader rejects this before allocating. Let its
// protocol-specific 413 win over temporary capacity refusal, unchanged.
return work();
}
const reservation = raised || !Number.isFinite(declaredBytes) ? maxBytes : compressedBodyDecodeLimit(declaredBytes, maxBytes);
let lease;
try {
lease = await (options?.budget ?? inboundBodyBudget).acquire(reservation, req.signal, options?.maxWaitMs);
} catch (error) {
cancelUnreadBody(req, error);
if (options?.onAdmissionError) return options.onAdmissionError(error);
throw error;
}
if (!lease) {
const error = new InboundBodyCapacityError();
cancelUnreadBody(req, error);
return onRefusal(capacityResponse(pathname, error));
}
// An immediate grant can race a disconnect before this async function resumes.
if (req.signal.aborted) {
lease.release();
cancelUnreadBody(req, req.signal.reason);
if (options?.onAdmissionError) return options.onAdmissionError(req.signal.reason);
throw req.signal.reason;
}
const unbind = bindInboundBodyLease(req, lease);
const release = (): void => { unbind(); lease.release(); };
try {
return retainUntilResponseSettles(await work(), req.signal, release);
} catch (error) {
release();
throw error;
}
}
/**
* The admitted HTTP call site. Refusal is recorded as a local terminal and
* carries the receiving listener's CORS headers, so a browser dashboard can
* read it. No request content is read or logged on this path.
*/
export function runAdmittedBodyWork(
req: Request,
policy: RequestPolicyView,
configuredLimit: number | undefined,
work: () => Promise<Response>,
refusalLog?: WorkflowRefusalLog,
mapRefusal?: (response: Response) => Response,
onAdmissionError?: (error: unknown) => Response,
): Promise<Response> {
return withRaisedInboundBodyAdmission(req, codexCompatibleUrl(req.url).pathname, configuredLimit, work, refused => {
if (refusalLog) {
markLocalRequestLogRefusal(refusalLog.logCtx, "server_busy");
refusalLog.logCtx.errorCode = "server_busy";
addFinalRequestLog(refusalLog.requestId, refusalLog.start, refusalLog.logCtx, refused.status, {
closeReason: "terminal",
});
refusalLog.onLogged?.();
}
return withCors(mapRefusal ? mapRefusal(refused) : refused, req, policy);
}, onAdmissionError ? { onAdmissionError } : undefined);
}