@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
188 lines (178 loc) • 6.99 kB
text/typescript
import {
MAX_CONFIGURABLE_INBOUND_BODY_BYTES,
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";
/** Admission units, not a bound on process RSS or the size of parsed object graphs. */
export const MAX_CONCURRENT_INBOUND_BODY_BYTES = MAX_CONFIGURABLE_INBOUND_BODY_BYTES;
let reservedInboundBodyBytes = 0;
// 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/server-request-body-size.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, release: () => void): Response {
if (!response.body) {
release();
return response;
}
const reader = response.body.getReader();
let cancelling = false;
let finalized = false;
const finalize = (): void => {
if (finalized) return;
finalized = true;
try { reader.releaseLock(); } finally { release(); }
};
const body = new ReadableStream<Uint8Array>({
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);
}
},
async cancel(reason) {
cancelling = true;
try { await reader.cancel(reason); } finally { finalize(); }
},
}, { highWaterMark: 0 });
// This is the outermost HTTP wrapper, after protocol conversion, relay
// preflight and request logging; no internal relay marker is consumed later.
return new Response(body, {
status: response.status,
statusText: response.statusText,
headers: response.headers,
});
}
/**
* Own one raised-limit HTTP request from before body reading through response
* EOF/error or settled cancellation. 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.
*/
export async function withRaisedInboundBodyAdmission(
req: Request,
pathname: string,
configuredLimit: number | undefined,
work: () => Promise<Response>,
onRefusal: (response: Response) => Response = response => response,
): Promise<Response> {
const maxBytes = resolveInboundBodyLimitBytes(configuredLimit);
if (req.method !== "POST" || !CONFIGURABLE_JSON_BODY_ROUTES.has(pathname)
|| maxBytes <= MAX_DECOMPRESSED_BODY_BYTES || 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();
}
if (maxBytes > MAX_CONCURRENT_INBOUND_BODY_BYTES - reservedInboundBodyBytes) {
const error = new InboundBodyCapacityError();
cancelUnreadBody(req, error);
return onRefusal(capacityResponse(pathname, error));
}
reservedInboundBodyBytes += maxBytes;
let released = false;
const release = (): void => {
if (released) return;
released = true;
reservedInboundBodyBytes -= maxBytes;
};
try {
return retainUntilResponseSettles(await work(), 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,
): 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",
});
}
return withCors(refused, req, policy);
});
}