@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
145 lines (138 loc) • 5.59 kB
text/typescript
import { carryPacedStream, isPacedStream, PACED_READ_AHEAD_BYTES } from "../lib/paced-stream";
/** Read-ahead allowance, not a lifetime limit on SSE inspection or delivery. */
export const MAX_INSPECTION_READ_AHEAD_BYTES = 32 * 1024 * 1024;
/**
* Relay a body in slices of at most `maxChunkBytes`, reading the source only when the last slice was taken.
*
* Every relay stage with a queue of one chunk then holds one slice instead of one source chunk, and the slices are
* views of the chunk the source handed over, never copies. Bytes, order and errors pass through unchanged; a cancel
* reaches the source.
*/
export function sliceChunks(source: ReadableStream<Uint8Array>, maxChunkBytes: number): ReadableStream<Uint8Array> {
if (!Number.isSafeInteger(maxChunkBytes) || maxChunkBytes <= 0) throw new RangeError("Slice size must be a positive safe integer");
const reader = source.getReader();
let pending: Uint8Array | undefined;
return new ReadableStream<Uint8Array>({
async pull(controller) {
try {
while (pending === undefined) {
const next = await reader.read();
if (next.done) { controller.close(); return; }
if (next.value.byteLength > 0) pending = next.value;
}
const slice = pending.subarray(0, maxChunkBytes);
pending = pending.byteLength > maxChunkBytes ? pending.subarray(maxChunkBytes) : undefined;
controller.enqueue(slice);
} catch (error) {
pending = undefined;
controller.error(error);
}
},
cancel(reason) {
pending = undefined;
return reader.cancel(reason);
},
}, { highWaterMark: 0 });
}
export interface InspectionTeeOptions {
/** Release pacing so the inspection owner's existing bounded drain can run. */
clientGoneSignal?: AbortSignal;
/** Internal test seam; callers must not take this value from upstream data. */
maxReadAheadBytes?: number;
}
/**
* Keep native tee cancellation semantics while pacing the inspection branch.
*
* Inspection may lead raw client consumption by the allowance plus one source
* chunk (and native tee prefetch). It never stops merely because the whole turn
* crossed that size: terminal, usage and continuation observers retain ownership.
* Count raw client bytes BEFORE rewrites, which may shrink, drop or expand them.
* Push sources still need their own producer-side bound; this is not an RSS cap.
*/
export function teeWithBoundedInspection(
source: ReadableStream<Uint8Array>,
options: InspectionTeeOptions = {},
): [ReadableStream<Uint8Array>, ReadableStream<Uint8Array>] {
// A paced source (#8601) lets inspection lead its client by one chunk instead of the allowance.
const limit = options.maxReadAheadBytes ?? (isPacedStream(source) ? PACED_READ_AHEAD_BYTES : MAX_INSPECTION_READ_AHEAD_BYTES);
if (!Number.isSafeInteger(limit) || limit <= 0) {
throw new RangeError("Inspection read-ahead limit must be a positive safe integer");
}
const [client, inspection] = source.tee();
let leadBytes = 0;
let pacingReleased = false;
let credit: Promise<void> | undefined;
let wake: (() => void) | undefined;
const wakeReader = () => {
const resolve = wake;
wake = undefined;
credit = undefined;
resolve?.();
};
const releasePacing = () => {
pacingReleased = true;
wakeReader();
};
const signal = options.clientGoneSignal;
if (signal?.aborted) releasePacing();
else signal?.addEventListener("abort", releasePacing, { once: true });
const wrap = (
body: ReadableStream<Uint8Array>,
isClient: boolean,
): ReadableStream<Uint8Array> => {
const reader = body.getReader();
let ended = false;
// An upstream error must wake an inspector waiting for credit, not remain
// hidden until the client happens to issue another read. One observer per
// reader, not a permanent Promise.race reaction attached on every chunk.
void reader.closed.catch(releasePacing);
const releaseLock = () => {
try { reader.releaseLock(); } catch { /* a pending read owns the lock */ }
};
const finish = () => {
ended = true;
releasePacing();
if (!isClient) signal?.removeEventListener("abort", releasePacing);
};
return new ReadableStream<Uint8Array>({
async pull(controller) {
if (ended) return;
if (!isClient && !pacingReleased && leadBytes >= limit) {
credit ??= new Promise<void>(resolve => { wake = resolve; });
await credit;
if (ended) return;
}
try {
const result = await reader.read();
if (ended) return;
if (result.done) {
finish();
releaseLock();
controller.close();
return;
}
if (isClient) {
leadBytes -= result.value.byteLength;
if (leadBytes < limit) wakeReader();
} else {
leadBytes += result.value.byteLength;
}
controller.enqueue(result.value);
} catch (error) {
if (ended) return;
finish();
releaseLock();
controller.error(error);
}
},
cancel(reason) {
finish();
// Awaiting one tee branch's cancellation waits for the sibling. The
// owner must be free to finish cleanup and cancel/read that sibling.
void reader.cancel(reason).catch(() => undefined);
releaseLock();
},
}, { highWaterMark: 0 });
};
return [carryPacedStream(source, wrap(client, true)), wrap(inspection, false)];
}