UNPKG

@bitkyc08/opencodex

Version:

Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code

187 lines (178 loc) • 9.35 kB
import { nativeResponseOutput } from "./native-response-output"; import { admitAppOwnedPinnedBytes, appOwnedBytesSnapshot, type RetainedStoreSnapshot, } from "../../lib/app-owned-memory"; /** * Connection-local replay journal. Only input committed by response.created enters * a successor's prefix. Uncommitted/rejected steering never enters the shared * continuation cache. Bodies are bounded and discarded at connection teardown. */ export const MAX_NATIVE_STEERING_REPLAY_BYTES = 32 * 1024 * 1024; /** * Aggregate ceiling across every live steering and injection journal. The operator * budget is an eviction target that can be raised to 4 GiB; pinned control journals * keep their own finite admission cap so the documented pin-capable aggregate stays * below the process-owned 512 MiB worst case. */ export const MAX_NATIVE_CONTROL_REPLAY_TOTAL_BYTES = 128 * 1024 * 1024; let aggregateCapBytes = MAX_NATIVE_CONTROL_REPLAY_TOTAL_BYTES; const activeReplays = new Set<{ readonly retainedBytes: number }>(); /** Account active journals as pinned state: protocol safety forbids evicting pending input. */ export function nativeControlReplayRetainedStoreSnapshot(): RetainedStoreSnapshot { let bytes = 0; for (const replay of activeReplays) bytes += replay.retainedBytes; return { count: activeReplays.size, bytes, evictableBytes: 0, pinnedBytes: bytes, oldestAt: null }; } /** Track one live control journal (steering or injection) and return its detach hook. */ export function registerNativeControlReplayJournal(journal: { readonly retainedBytes: number }): () => void { activeReplays.add(journal); return () => { activeReplays.delete(journal); }; } /** * Shared pinned-memory admission for one journal's current retained bytes. Bytes the * retained-store registry already sees are measured in place; a journal still in its * constructor is priced as a new proposal. Reclaimable owners are demoted before * refusal, so cache occupancy alone never fails a journal. */ export function admitNativeControlReplayJournal(journal: { readonly retainedBytes: number }): void { const replayBytes = nativeControlReplayRetainedStoreSnapshot().bytes + (activeReplays.has(journal) ? 0 : journal.retainedBytes); if (replayBytes > aggregateCapBytes) { throw new Error("Native control replay exceeded the pinned journal ceiling."); } const registeredBytes = appOwnedBytesSnapshot().stores.native_control_replay?.bytes ?? 0; if (!admitAppOwnedPinnedBytes(replayBytes - registeredBytes)) { throw new Error("Native control replay exceeded the application-owned memory budget."); } } type Frame = Record<string, unknown>; /** Accept JSON object envelopes without treating arrays as records. */ function record(value: unknown): value is Frame { return value !== null && typeof value === "object" && !Array.isArray(value); } /** Normalize string input to one user message while preserving array order. */ function inputItems(input: unknown): unknown[] { if (typeof input === "string") return [{ type: "message", role: "user", content: [{ type: "input_text", text: input }] }]; return Array.isArray(input) ? input : []; } export interface NativeSteeringReplayObserver { submitted(frame: Frame): () => void; observe(frame: Frame): void; dispose(): void; } /** Keep bounded, connection-local input until a validated successor commits it. */ export class NativeSteeringReplay implements NativeSteeringReplayObserver { private prefix: unknown[]; private bytes: number; private current?: string; private previousOutput: unknown[] = []; private outputItems = new Map<number, Frame>(); private submissions: Array<{ parent: string; input: unknown[]; id?: string; bytes: number }> = []; private explicitInput: unknown[] = []; private explicitBytes = 0; private disposed = false; private unregisterAccounting?: () => void; get retainedBytes(): number { return this.bytes; } /** Capture the initial prefix and reject over-budget history before dispatch. */ constructor(input: unknown, private readonly remember: (input: unknown[], response: Frame) => void) { this.prefix = [...inputItems(input)]; this.bytes = Buffer.byteLength(JSON.stringify(this.prefix)); this.check(); this.unregisterAccounting = registerNativeControlReplayJournal(this); } /** Reject overflow rather than silently truncating retained conversation input. */ private check(): void { if (this.bytes > MAX_NATIVE_STEERING_REPLAY_BYTES) throw new Error("Native steering replay exceeded its bounded history budget; input was not silently truncated."); admitNativeControlReplayJournal(this); } /** Reserve replay bytes before send and return a rollback for synchronous failure. */ submitted(frame: Frame): () => void { const input = inputItems(frame.input); const bytes = Buffer.byteLength(JSON.stringify(input)); this.bytes += bytes; try { this.check(); } catch (error) { this.bytes -= bytes; throw error; } if (frame.type === "response.steer") { const submission = { parent: String(frame.previous_response_id), input, bytes }; this.submissions.push(submission); return () => { const index = this.submissions.indexOf(submission); if (index >= 0) { this.submissions.splice(index, 1); this.bytes -= bytes; } }; } this.explicitInput = input; this.explicitBytes = bytes; return () => { this.explicitInput = []; this.bytes -= this.explicitBytes; this.explicitBytes = 0; }; } /** Apply ordered upstream events; only created successors commit queued input. */ observe(frame: Frame): void { const response = record(frame.response) ? frame.response : undefined; const steer = record(frame.steer) ? frame.steer : undefined; if (frame.type === "response.steer.accepted") { const first = this.submissions.find(item => item.parent === steer?.previous_response_id && item.id === undefined); if (!first || typeof steer?.id !== "string") throw new Error("Native steering replay acceptance does not match submitted input"); first.id = steer.id; } else if (frame.type === "response.steer.failed") { const index = this.submissions.findIndex(item => steer?.id !== undefined ? item.id === steer.id : item.parent === steer?.previous_response_id && item.id === undefined); if (index >= 0) { const [failed] = this.submissions.splice(index, 1); this.bytes -= failed.bytes; } } else if (frame.type === "response.created") { if (this.current) { const committed = this.submissions.filter(item => item.parent === this.current && item.id !== undefined); // Byte-valid histories may exceed the runtime's positional-argument limit. for (const item of this.previousOutput) this.prefix.push(item); for (const submission of committed) { for (const item of submission.input) this.prefix.push(item); } for (const item of this.explicitInput) this.prefix.push(item); this.submissions = this.submissions.filter(item => !committed.includes(item)); } this.explicitInput = []; this.explicitBytes = 0; this.previousOutput = []; this.outputItems.clear(); this.current = String(response?.id); } else if (frame.type === "response.output_item.done") { const index = frame.output_index as number; if (!Number.isSafeInteger(index) || index < 0 || index > 10_000 || !record(frame.item)) throw new Error("Native steering replay output identity is invalid"); const previous = this.outputItems.get(index); if (previous !== undefined) this.bytes -= Buffer.byteLength(JSON.stringify(previous)); this.bytes += Buffer.byteLength(JSON.stringify(frame.item)); this.check(); this.outputItems.set(index, frame.item); } else if (response && ["response.completed", "response.incomplete", "response.failed"].includes(String(frame.type))) { const doneItems = [...this.outputItems.entries()].sort((a, b) => a[0] - b[0]).map(([, item]) => item); const output = nativeResponseOutput(this.outputItems, response.output); for (const item of doneItems) this.bytes -= Buffer.byteLength(JSON.stringify(item)); this.bytes += Buffer.byteLength(JSON.stringify(output)); this.check(); this.outputItems.clear(); this.previousOutput = output; // Failed and steered parents are never presented to shared state as completed. // Their output is used only when a validated successor commits that prefix. if (frame.type === "response.completed") this.remember(this.prefix, { ...response, output }); } } /** Release retained input, output and queued submissions when the owner detaches. */ dispose(): void { if (this.disposed) return; this.disposed = true; this.unregisterAccounting?.(); this.unregisterAccounting = undefined; this.prefix = []; this.previousOutput = []; this.submissions = []; this.explicitInput = []; this.outputItems.clear(); this.bytes = 0; } } /** Test-only: shrink the aggregate pinned-journal ceiling (null restores the documented cap). */ export function setNativeControlReplayTotalCapForTests(capBytes: number | null): void { aggregateCapBytes = capBytes ?? MAX_NATIVE_CONTROL_REPLAY_TOTAL_BYTES; }