@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
129 lines (122 loc) • 5.69 kB
text/typescript
import { DEFAULT_CONCURRENT_INBOUND_BODY_BYTES, resolveConcurrentInboundBodyLimitBytes } from "../lib/inbound-body-policy";
export { DEFAULT_CONCURRENT_INBOUND_BODY_BYTES, MAX_CONCURRENT_INBOUND_BODY_BYTES } from "../lib/inbound-body-policy";
export const MAX_QUEUED_INBOUND_BODIES = 32;
export const INBOUND_BODY_QUEUE_TIMEOUT_MS = 120_000;
export interface InboundBodyLease {
/** Return unused allowance after the bounded reader measures the accepted body. */
shrink(bytes: number): void;
/** Return the remaining charge exactly once when the HTTP owner settles. */
release(): void;
}
/** FIFO admission whose bounded waiters neither read uploads nor own reservations. */
export function createInboundBodyBudget(capacity: number, maxQueued = MAX_QUEUED_INBOUND_BODIES) {
if (!Number.isSafeInteger(capacity) || capacity <= 0
|| !Number.isSafeInteger(maxQueued) || maxQueued < 0) {
throw new RangeError("Invalid inbound body budget");
}
let reservedBytes = 0;
let activeLeases = 0;
const pending: Array<{ bytes: number; admit(): void }> = [];
/** Only the FIFO head may consume newly available capacity. */
const drain = (): void => {
while (pending.length && pending[0]!.bytes <= capacity - reservedBytes) pending[0]!.admit();
};
/** Charge an allowance and give its HTTP owner an idempotent release handle. */
const grant = (bytes: number): InboundBodyLease => {
let held = bytes;
let released = false;
reservedBytes += held;
activeLeases++;
return {
/** Never increase a reservation or accept an invalid measurement. */
shrink(measured) {
if (released || !Number.isFinite(measured) || measured < 0) return;
const next = Math.min(held, Math.max(1, Math.ceil(measured)));
reservedBytes -= held - next;
held = next;
drain();
},
/** Free only this lease, including when EOF and cancellation race. */
release() {
if (released) return;
released = true;
reservedBytes -= held;
activeLeases--;
drain();
},
};
};
return {
/** Report the current shared allowance without confusing it with measured charges. */
capacity: () => capacity,
/** Startup configuration changes the same owner; existing leases and FIFO waiters survive. */
setCapacity(bytes: number): void {
if (!Number.isSafeInteger(bytes) || bytes <= 0) throw new RangeError("Invalid inbound body capacity");
capacity = bytes;
drain();
},
/** Observe counters without exposing request bodies or identities. */
snapshot: () => ({ reservedBytes, activeLeases, queuedRequests: pending.length }),
/** Wait for an entire upload allowance; null preserves the caller's overload response. */
acquire(bytes: number, signal: AbortSignal, waitMs = INBOUND_BODY_QUEUE_TIMEOUT_MS): Promise<InboundBodyLease | null> {
if (!Number.isSafeInteger(bytes) || bytes <= 0 || bytes > capacity) {
return Promise.reject(new RangeError("Invalid inbound body reservation"));
}
if (signal.aborted) return Promise.reject(signal.reason);
if (!pending.length && bytes <= capacity - reservedBytes) return Promise.resolve(grant(bytes));
if (pending.length >= maxQueued || !Number.isFinite(waitMs) || waitMs <= 0) return Promise.resolve(null);
return new Promise<InboundBodyLease | null>((resolve, reject) => {
let settled = false;
let timer: ReturnType<typeof setTimeout>;
/** Detach every waiter resource before admitting, timing out, or rejecting it. */
const cleanup = (): void => {
settled = true;
clearTimeout(timer);
signal.removeEventListener("abort", onAbort);
const index = pending.indexOf(entry);
if (index >= 0) pending.splice(index, 1);
};
/** A cancelled head must not strand a smaller eligible follower. */
const onAbort = (): void => {
if (settled) return;
cleanup();
reject(signal.reason);
drain();
};
const entry = { bytes,
/** Transfer a queued caller to a charged lease once, before resolving it. */
admit() {
if (settled) return;
cleanup();
resolve(grant(bytes));
},
};
pending.push(entry);
signal.addEventListener("abort", onAbort, { once: true });
timer = setTimeout(() => {
if (settled) return;
cleanup();
resolve(null);
drain();
}, Math.min(waitMs, INBOUND_BODY_QUEUE_TIMEOUT_MS));
if (signal.aborted) onAbort();
});
},
};
}
export type InboundBodyBudget = ReturnType<typeof createInboundBodyBudget>;
export const inboundBodyBudget = createInboundBodyBudget(DEFAULT_CONCURRENT_INBOUND_BODY_BYTES);
const requestLeases = new WeakMap<Request, InboundBodyLease>();
/** Adopt one startup policy for every listener without resetting live accounting. */
export function configureInboundBodyBudget(configured?: number): void {
inboundBodyBudget.setCapacity(resolveConcurrentInboundBodyLimitBytes(configured));
}
/** Connect only the admitted HTTP request to its bounded reader; internal reads own no lease. */
export function bindInboundBodyLease(req: Request, lease: InboundBodyLease): () => void {
requestLeases.set(req, lease);
return () => { if (requestLeases.get(req) === lease) requestLeases.delete(req); };
}
/** Only an accepted, measured body can replace an HTTP owner's upload allowance. */
export function updateInboundBodyReservation(req: Request, bytes: number): void {
requestLeases.get(req)?.shrink(bytes);
}