@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
192 lines (173 loc) • 6.87 kB
text/typescript
const MAX_CACHE_BYTES = 8 * 1024 * 1024;
const MAX_CONCURRENT_RECOVERIES = 32;
const CACHE_TTL_MS = 15 * 60 * 1000;
export type AgentTaskRecoveryResolutionFailureReason =
| "recovery_unavailable"
| "caller_cancelled"
| "recovery_http_rejected"
| "recovery_timeout"
| "recovery_aborted"
| "recovery_transport_error"
| "recovery_invalid_output";
/** Shared flights carry bounded failures; only successful plaintext enters the cache. */
export type AgentTaskRecoveryResolution =
| { readonly recovered: true; readonly assignment: string }
| { readonly recovered: false; readonly reason: AgentTaskRecoveryResolutionFailureReason };
interface RecoveryCacheEntry {
assignment: string;
bytes: number;
expiresAt: number;
expiryTimer: ReturnType<typeof setTimeout> | null;
}
interface RecoveryFlight {
controller: AbortController;
promise: Promise<AgentTaskRecoveryResolution>;
waiters: number;
settled: boolean;
}
const RECOVERY_CACHE = new Map<string, RecoveryCacheEntry>();
const RECOVERY_FLIGHTS = new Map<string, RecoveryFlight>();
let recoveryCacheBytes = 0;
function deleteRecoveryCacheEntry(key: string, expected?: RecoveryCacheEntry): void {
const entry = RECOVERY_CACHE.get(key);
if (!entry || (expected && entry !== expected)) return;
RECOVERY_CACHE.delete(key);
if (entry.expiryTimer) clearTimeout(entry.expiryTimer);
recoveryCacheBytes = Math.max(0, recoveryCacheBytes - entry.bytes);
}
function sweepRecoveryCache(now: number, maxEntries: number): void {
for (const [key, entry] of RECOVERY_CACHE) {
if (entry.expiresAt > now) continue;
deleteRecoveryCacheEntry(key, entry);
}
while (RECOVERY_CACHE.size > maxEntries || recoveryCacheBytes > MAX_CACHE_BYTES) {
const oldest = RECOVERY_CACHE.keys().next().value;
if (oldest === undefined) break;
deleteRecoveryCacheEntry(oldest);
}
}
function insertRecoveryCacheEntry(key: string, assignment: string, maxEntries: number): void {
const replaced = RECOVERY_CACHE.get(key);
if (replaced) deleteRecoveryCacheEntry(key, replaced);
const insertedAt = Date.now();
const entry: RecoveryCacheEntry = {
assignment,
bytes: Buffer.byteLength(assignment),
expiresAt: insertedAt + CACHE_TTL_MS,
expiryTimer: null,
};
entry.expiryTimer = setTimeout(
() => deleteRecoveryCacheEntry(key, entry),
CACHE_TTL_MS,
);
entry.expiryTimer.unref?.();
RECOVERY_CACHE.set(key, entry);
recoveryCacheBytes += entry.bytes;
sweepRecoveryCache(insertedAt, maxEntries);
}
function startRecoveryFlight(
key: string,
maxEntries: number,
request: (signal: AbortSignal) => Promise<AgentTaskRecoveryResolution>,
): RecoveryFlight | null {
const active = RECOVERY_FLIGHTS.get(key);
if (active) return active;
if (RECOVERY_FLIGHTS.size >= MAX_CONCURRENT_RECOVERIES) return null;
const controller = new AbortController();
const flight: RecoveryFlight = {
controller,
promise: Promise.resolve({ recovered: false, reason: "recovery_unavailable" }),
waiters: 0,
settled: false,
};
flight.promise = request(controller.signal)
.then((result): AgentTaskRecoveryResolution => {
if (controller.signal.aborted) return { recovered: false, reason: "recovery_aborted" };
if (result.recovered) insertRecoveryCacheEntry(key, result.assignment, maxEntries);
return result;
})
.finally(() => {
flight.settled = true;
if (RECOVERY_FLIGHTS.get(key) === flight) RECOVERY_FLIGHTS.delete(key);
});
RECOVERY_FLIGHTS.set(key, flight);
return flight;
}
async function waitForRecoveryFlight(
flight: RecoveryFlight,
abortSignal?: AbortSignal,
): Promise<AgentTaskRecoveryResolution> {
if (abortSignal?.aborted) return { recovered: false, reason: "caller_cancelled" };
flight.waiters += 1;
let onAbort: (() => void) | undefined;
try {
if (!abortSignal) return await flight.promise;
const cancelled = new Promise<AgentTaskRecoveryResolution>((resolve) => {
onAbort = () => resolve({ recovered: false, reason: "caller_cancelled" });
abortSignal.addEventListener("abort", onAbort, { once: true });
if (abortSignal.aborted) onAbort();
});
return await Promise.race([flight.promise, cancelled]);
} finally {
if (onAbort) abortSignal?.removeEventListener("abort", onAbort);
flight.waiters = Math.max(0, flight.waiters - 1);
if (flight.waiters === 0 && !flight.settled) {
flight.controller.abort(new DOMException("All recovery callers cancelled", "AbortError"));
}
}
}
export async function resolveCachedAgentTaskRecovery(
key: string,
maxEntries: number,
request: (signal: AbortSignal) => Promise<string | null>,
abortSignal?: AbortSignal,
): Promise<string | null> {
const result = await resolveCachedAgentTaskRecoveryWithResult(key, maxEntries, async signal => {
const assignment = await request(signal);
return assignment
? { recovered: true, assignment }
: { recovered: false, reason: "recovery_unavailable" };
}, abortSignal);
return result.recovered ? result.assignment : null;
}
export async function resolveCachedAgentTaskRecoveryWithResult(
key: string,
maxEntries: number,
request: (signal: AbortSignal) => Promise<AgentTaskRecoveryResolution>,
abortSignal?: AbortSignal,
): Promise<AgentTaskRecoveryResolution> {
if (abortSignal?.aborted) return { recovered: false, reason: "caller_cancelled" };
sweepRecoveryCache(Date.now(), maxEntries);
const cached = RECOVERY_CACHE.get(key)?.assignment;
if (cached) return { recovered: true, assignment: cached };
const flight = startRecoveryFlight(key, maxEntries, request);
return flight ? waitForRecoveryFlight(flight, abortSignal) : { recovered: false, reason: "recovery_unavailable" };
}
export function discardCachedAgentTaskRecovery(key: string): void {
deleteRecoveryCacheEntry(key);
}
export function resetAgentTaskRecoveryCache(): void {
for (const flight of RECOVERY_FLIGHTS.values()) {
flight.controller.abort(new DOMException("Recovery state reset", "AbortError"));
}
RECOVERY_FLIGHTS.clear();
for (const key of [...RECOVERY_CACHE.keys()]) deleteRecoveryCacheEntry(key);
}
export function agentTaskRecoveryWaiterCountForTests(): number {
let count = 0;
for (const flight of RECOVERY_FLIGHTS.values()) count += flight.waiters;
return count;
}
export function agentTaskRecoveryCacheSnapshotForTests(): { entries: number; bytes: number } {
return { entries: RECOVERY_CACHE.size, bytes: recoveryCacheBytes };
}
/** Read an existing recovery without starting a request or extending its lifetime. */
export function cachedAgentTaskRecovery(key: string): string | null {
const entry = RECOVERY_CACHE.get(key);
if (!entry) return null;
if (entry.expiresAt <= Date.now()) {
deleteRecoveryCacheEntry(key, entry);
return null;
}
return entry.assignment;
}