@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
216 lines (202 loc) • 7.51 kB
text/typescript
/** A response-body guard owns one reader, never the request-wide abort controller. */
export interface ResponseBodyInactivityGuard {
response: Response;
/** Stop an abandoned parser without waiting for a broken source's cancel promise. */
dispose: () => void;
}
export class ResponseBodyInactivityError extends DOMException {
constructor(timeoutMs: number) {
super(`Upstream response body stalled for ${timeoutMs}ms`, "TimeoutError");
}
}
/**
* The same expiry from a guard armed by the operator's explicit `stallTimeoutSec` (#8206). Only this
* one reaches clients as `upstream_stall_timeout`; a guard on a default budget keeps its old terminal.
*/
export class ExplicitBodyStallError extends ResponseBodyInactivityError {}
// Published responses whose upstream reads already run under a positive inactivity guard.
const guardedResponses = new WeakSet<Response>();
/** Record that `response` relays bytes from guarded upstream reads, so no second clock is armed. */
export function markResponseBodyInactivityGuarded(response: Response): Response {
guardedResponses.add(response);
return response;
}
export function isResponseBodyInactivityGuarded(response: Response): boolean {
return guardedResponses.has(response);
}
/**
* Bound silence only while the consumer is waiting for upstream bytes.
*
* A zero high-water mark prevents this wrapper from speculatively reading while
* the consumer is paused. Empty chunks neither count as progress nor reset the
* deadline. Cancellation is local to this body: aborting a shared request signal
* here would suppress the failure terminal in the enclosing Responses bridge.
*/
export function guardResponseBodyInactivity(
response: Response,
signal: AbortSignal | undefined,
timeoutMs: number,
options: { explicitBudget?: boolean } = {},
): ResponseBodyInactivityGuard {
const source = response.body;
if (!source) return { response, dispose: () => {} };
const reader = source.getReader();
const timeoutEnabled = Number.isFinite(timeoutMs) && timeoutMs > 0;
const timeoutError = options.explicitBudget === true
? new ExplicitBodyStallError(timeoutMs)
: new ResponseBodyInactivityError(timeoutMs);
let output!: ReadableStreamDefaultController<Uint8Array>;
let settled = false;
let timer: ReturnType<typeof setTimeout> | undefined;
let deadline: number | undefined;
const pause = (): void => {
if (timer !== undefined) clearTimeout(timer);
timer = undefined;
deadline = undefined;
};
const release = (): void => {
try { reader.releaseLock(); } catch { /* a source may already have torn down */ }
};
const settle = (): boolean => {
if (settled) return false;
settled = true;
pause();
signal?.removeEventListener("abort", onAbort);
return true;
};
const cancelSource = (reason?: unknown): void => {
// reader.cancel settles outstanding reads before its source cleanup completes.
// Never await that cleanup; custom transports can leave it pending forever.
try { void reader.cancel(reason).catch(() => {}); } catch { /* already released */ }
release();
};
const fail = (reason: unknown): void => {
if (!settle()) return;
// Publish the failure before cancellation can synchronously tear down relays.
try { output.error(reason); } catch { /* downstream is already closed */ }
cancelSource(reason);
};
const onAbort = (): void => {
fail(signal?.reason ?? new DOMException("The operation was aborted", "AbortError"));
};
const arm = (): void => {
if (settled || deadline === undefined) return;
// Avoid the platform's signed-32-bit setTimeout overflow for large settings.
const remaining = deadline - performance.now();
if (remaining <= 0) {
fail(timeoutError);
return;
}
timer = setTimeout(() => {
timer = undefined;
arm();
}, Math.min(2_147_483_647, Math.max(1, remaining)));
};
const body = new ReadableStream<Uint8Array>({
start(controller) {
output = controller;
signal?.addEventListener("abort", onAbort, { once: true });
if (signal?.aborted) onAbort();
},
async pull(controller) {
if (settled) return;
if (timeoutEnabled) {
deadline = performance.now() + timeoutMs;
arm();
}
try {
let emptyReads = 0;
for (;;) {
// A producer of immediately resolved empty chunks can starve timers.
// The monotonic deadline check also bounds that microtask-only loop.
if (deadline !== undefined && performance.now() >= deadline) {
fail(timeoutError);
return;
}
const { done, value } = await reader.read();
if (settled) return;
if (done) {
settle();
release();
controller.close();
return;
}
if (value.byteLength === 0) {
// Empty chunks are not progress, so the deadline keeps running. Hand the
// macrotask queue a turn periodically: otherwise a long configured timeout
// lets this microtask chain hold timers and unrelated requests.
emptyReads += 1;
if (emptyReads % 64 === 0) {
await new Promise<void>(resolve => { setTimeout(resolve, 0); });
if (settled) return;
}
continue;
}
emptyReads = 0;
pause();
controller.enqueue(value);
return;
}
} catch (error) {
fail(error);
}
},
cancel(reason) {
if (!settle()) return;
cancelSource(reason);
},
}, { highWaterMark: 0 });
return {
response: new Response(body, {
status: response.status,
statusText: response.statusText,
headers: response.headers,
}),
dispose: () => {
if (!settle()) return;
try { output.close(); } catch { /* parser already settled */ }
cancelSource();
},
};
}
/** Native SSE and bounded JSON/error readers retain their existing ownership. */
export function guardDirectPassthroughBodyInactivity(
response: Response,
signal: AbortSignal | undefined,
timeoutMs: number,
): Response {
const redirect = response.status >= 300 && response.status < 400;
const contentType = response.headers.get("content-type")?.toLowerCase();
if (!redirect && (!response.ok
|| contentType?.includes("text/event-stream")
|| contentType?.includes("application/json"))) return response;
return guardResponseBodyInactivity(response, signal, timeoutMs).response;
}
/** Scope a buffered adapter parser, including throws and early successful returns. */
export async function readResponseBodyWithInactivity<T>(
response: Response,
signal: AbortSignal | undefined,
timeoutMs: number,
parse: (response: Response) => Promise<T>,
): Promise<T> {
const guarded = guardResponseBodyInactivity(response, signal, timeoutMs);
try {
return await parse(guarded.response);
} finally {
guarded.dispose();
}
}
/** Scope an adapter stream, including continuation legs and iterator abandonment. */
export async function* readResponseStreamWithInactivity<T>(
response: Response,
signal: AbortSignal | undefined,
timeoutMs: number,
parse: (response: Response) => AsyncIterable<T>,
): AsyncGenerator<T> {
const guarded = guardResponseBodyInactivity(response, signal, timeoutMs);
try {
yield* parse(guarded.response);
} finally {
guarded.dispose();
}
}