UNPKG

@bitkyc08/opencodex

Version:

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

355 lines (311 loc) • 12.7 kB
/** * Bounded in-memory overrides for Cursor conversation continuity. * * When an invalid_argument recovery mints a fresh conversation id for a store:false * thread-identified client, later turns without previous_response_id must reuse that * recovered id instead of recomputing the stale deterministic thread hash. */ import { createHash } from "node:crypto"; const OVERRIDE_TTL_MS = 60 * 60 * 1000; const OVERRIDE_MAX_ENTRIES = 2048; const overrides = new Map<string, { conversationId: string; updatedAt: number }>(); const conversationRewrites = new Map<string, { to: string; root: string; updatedAt: number }>(); function rewriteKey(conversationId: string, identityScope?: string): string { const identity = createHash("sha256").update(identityScope?.trim() || "local").digest("hex"); return `${identity}\0${conversationId}`; } function pruneRewrites(at: number): void { for (const [key, entry] of conversationRewrites) { if (at - entry.updatedAt > OVERRIDE_TTL_MS) conversationRewrites.delete(key); } while (conversationRewrites.size > OVERRIDE_MAX_ENTRIES) { const oldest = conversationRewrites.keys().next().value; if (oldest === undefined) break; conversationRewrites.delete(oldest); } } export function rememberCursorConversationRewrite(from: string, to: string, identityScope?: string): void { if (!from || !to || from === to) return; const at = now(); pruneRewrites(at); const scope = rewriteKey("", identityScope); const root = conversationRewrites.get(rewriteKey(from, identityScope))?.root ?? from; const redirects = [...conversationRewrites].filter(([key, entry]) => key.startsWith(scope) && entry.root === root); for (const [key] of redirects) { conversationRewrites.delete(key); conversationRewrites.set(key, { to, root, updatedAt: at }); } conversationRewrites.set(rewriteKey(from, identityScope), { to, root, updatedAt: at }); conversationRewrites.set(rewriteKey(to, identityScope), { to, root, updatedAt: at }); pruneRewrites(at); } export function resolveCursorConversationRewrite(conversationId: string, identityScope?: string): string { const at = now(); pruneRewrites(at); const key = rewriteKey(conversationId, identityScope); const entry = conversationRewrites.get(key); if (!entry) return conversationId; conversationRewrites.delete(key); conversationRewrites.set(key, { ...entry, updatedAt: at }); return entry.to; } function now(): number { return Date.now(); } function prune(at: number): void { for (const [key, entry] of overrides) { if (at - entry.updatedAt > OVERRIDE_TTL_MS) overrides.delete(key); else break; // Map iterates insertion order; refreshed entries are moved to the end } while (overrides.size > OVERRIDE_MAX_ENTRIES) { const oldest = overrides.keys().next().value; if (oldest === undefined) break; overrides.delete(oldest); } } /** Scope key for a client thread, optionally namespaced by authenticated tenant/operator identity. */ export function cursorThreadScopeKey(threadId: string, identityScope?: string): string { const scope = identityScope?.trim() || "local"; return `${scope}\0${threadId}`; } export function rememberCursorThreadConversation( threadId: string, conversationId: string, identityScope?: string, ): void { const key = cursorThreadScopeKey(threadId, identityScope); const at = now(); overrides.delete(key); overrides.set(key, { conversationId, updatedAt: at }); prune(at); } export function lookupCursorThreadConversation( threadId: string, identityScope?: string, ): string | undefined { const key = cursorThreadScopeKey(threadId, identityScope); const entry = overrides.get(key); if (!entry) return undefined; const at = now(); if (at - entry.updatedAt > OVERRIDE_TTL_MS) { overrides.delete(key); return undefined; } overrides.delete(key); overrides.set(key, { conversationId: entry.conversationId, updatedAt: at }); return entry.conversationId; } export function clearCursorThreadContinuityForTests(): void { overrides.clear(); conversationRewrites.clear(); } /** Max conversation-id remints after the first surfaced overflow per retained scope. */ export const CURSOR_OVERFLOW_REMINT_MAX = 3; export const CURSOR_OVERFLOW_REMINT_TTL_MS = 60 * 60 * 1000; export const CURSOR_OVERFLOW_REMINT_MAX_ENTRIES = 2_048; type OverflowRemintState = { surfaced: boolean; remintCount: number; skip: boolean; updatedAt: number; }; const overflowRemintByScope = new Map<string, OverflowRemintState>(); function pruneOverflowRemints(at: number): void { for (const [scopeKey, entry] of overflowRemintByScope) { if (at - entry.updatedAt > CURSOR_OVERFLOW_REMINT_TTL_MS) overflowRemintByScope.delete(scopeKey); } while (overflowRemintByScope.size > CURSOR_OVERFLOW_REMINT_MAX_ENTRIES) { const oldest = overflowRemintByScope.keys().next().value; if (oldest === undefined) break; overflowRemintByScope.delete(oldest); } } function overflowRemintEntry(scopeKey: string): OverflowRemintState { const at = now(); pruneOverflowRemints(at); const existing = overflowRemintByScope.get(scopeKey); if (existing) { existing.updatedAt = at; overflowRemintByScope.delete(scopeKey); overflowRemintByScope.set(scopeKey, existing); return existing; } const fresh: OverflowRemintState = { surfaced: false, remintCount: 0, skip: false, updatedAt: at }; overflowRemintByScope.set(scopeKey, fresh); pruneOverflowRemints(at); return fresh; } /** Stable client-thread ownership survives conversation remints; wire ids alone do not. */ export function cursorOverflowRemintScopeKey( threadOwner: string | undefined, identityScope?: string, ): string | null { if (!threadOwner) return null; return `overflow\0${cursorThreadScopeKey(threadOwner, identityScope)}`; } /** True until the first overflow for this scope has been surfaced for Codex compact. */ export function shouldSurfaceCursorOverflowFirst(scopeKey: string): boolean { pruneOverflowRemints(now()); return overflowRemintByScope.get(scopeKey)?.surfaced !== true; } export function markCursorOverflowSurfaced(scopeKey: string): void { const entry = overflowRemintEntry(scopeKey); entry.surfaced = true; } export function shouldSkipCursorOverflowRemint(scopeKey: string): boolean { const at = now(); pruneOverflowRemints(at); const entry = overflowRemintByScope.get(scopeKey); if (entry) { entry.updatedAt = at; overflowRemintByScope.delete(scopeKey); overflowRemintByScope.set(scopeKey, entry); } return entry?.skip === true || (entry?.remintCount ?? 0) >= CURSOR_OVERFLOW_REMINT_MAX; } /** Record one overflow remint; returns false when the cap is exhausted. */ export function recordCursorOverflowRemint(scopeKey: string): boolean { const entry = overflowRemintEntry(scopeKey); if (entry.skip || entry.remintCount >= CURSOR_OVERFLOW_REMINT_MAX) { entry.skip = true; return false; } entry.remintCount += 1; return true; } export function clearCursorOverflowRemintForTests(): void { overflowRemintByScope.clear(); } export function cursorOverflowRemintCountForTests(): number { pruneOverflowRemints(now()); return overflowRemintByScope.size; } /** Max next-turn conversation-id rotations after incomplete client-tool streams per retained scope. */ export const CURSOR_INCOMPLETE_TOOL_REMINT_MAX = 3; export const CURSOR_INCOMPLETE_TOOL_REMINT_TTL_MS = CURSOR_OVERFLOW_REMINT_TTL_MS; export const CURSOR_INCOMPLETE_TOOL_REMINT_MAX_ENTRIES = CURSOR_OVERFLOW_REMINT_MAX_ENTRIES; type IncompleteToolRemintState = { remintCount: number; updatedAt: number; }; /** * One bounded next-turn remint allowance, keyed by retained thread scope. * * Each recovery reason owns its own instance. Sharing one budget would let a cheap, frequent * failure spend the allowance that a rarer, more expensive recovery depends on. */ function createCursorRemintBudget(max: number, ttlMs: number, maxEntries: number) { const byScope = new Map<string, IncompleteToolRemintState>(); const prune = (at: number): void => { for (const [scopeKey, entry] of byScope) { if (at - entry.updatedAt > ttlMs) byScope.delete(scopeKey); } while (byScope.size > maxEntries) { const oldest = byScope.keys().next().value; if (oldest === undefined) break; byScope.delete(oldest); } }; return { /** Record one remint; returns false when this budget is exhausted. */ record(scopeKey: string): boolean { const at = now(); prune(at); const existing = byScope.get(scopeKey); if (existing && existing.remintCount >= max) { existing.updatedAt = at; byScope.delete(scopeKey); byScope.set(scopeKey, existing); return false; } const entry = existing ?? { remintCount: 0, updatedAt: at }; entry.remintCount += 1; entry.updatedAt = at; byScope.delete(scopeKey); byScope.set(scopeKey, entry); prune(at); return true; }, clear(scopeKey: string): void { byScope.delete(scopeKey); }, clearForTests(): void { byScope.clear(); }, countForTests(): number { prune(now()); return byScope.size; }, }; } const incompleteToolRemintBudget = createCursorRemintBudget( CURSOR_INCOMPLETE_TOOL_REMINT_MAX, CURSOR_INCOMPLETE_TOOL_REMINT_TTL_MS, CURSOR_INCOMPLETE_TOOL_REMINT_MAX_ENTRIES, ); /** Incomplete-tool and overflow recovery share ownership scope, but keep independent budgets. */ export function cursorIncompleteToolRemintScopeKey( threadOwner: string | undefined, identityScope?: string, ): string | null { return cursorOverflowRemintScopeKey(threadOwner, identityScope); } /** Record one incomplete-tool remint; returns false when the independent cap is exhausted. */ export function recordCursorIncompleteToolRemint(scopeKey: string): boolean { return incompleteToolRemintBudget.record(scopeKey); } /** A clean turn replenishes this recovery without changing the overflow retry budget. */ export function clearCursorIncompleteToolRemint(scopeKey: string): void { incompleteToolRemintBudget.clear(scopeKey); } export function clearCursorIncompleteToolRemintForTests(): void { incompleteToolRemintBudget.clearForTests(); } export function cursorIncompleteToolRemintCountForTests(): number { return incompleteToolRemintBudget.countForTests(); } /** * Max next-turn rotations after a MID-STREAM envelope echo, per retained scope. * * Deliberately a separate budget from the incomplete-tool allowance. A mid-stream echo is a * cheap, repeatable formatting failure, while an incomplete client-tool stream is a rarer * structural one; on a shared counter a model that echoes every turn would spend the budget * that incomplete-tool recovery depends on. Bounding it at all is the point: the echo has * already reached the client and cannot be quarantined, so without a cap a persistently * echoing model would remint the conversation on every single turn, forever. */ export const CURSOR_ENVELOPE_ECHO_REMINT_MAX = 3; export const CURSOR_ENVELOPE_ECHO_REMINT_TTL_MS = CURSOR_OVERFLOW_REMINT_TTL_MS; export const CURSOR_ENVELOPE_ECHO_REMINT_MAX_ENTRIES = CURSOR_OVERFLOW_REMINT_MAX_ENTRIES; const envelopeEchoRemintBudget = createCursorRemintBudget( CURSOR_ENVELOPE_ECHO_REMINT_MAX, CURSOR_ENVELOPE_ECHO_REMINT_TTL_MS, CURSOR_ENVELOPE_ECHO_REMINT_MAX_ENTRIES, ); /** Echo recovery shares ownership scope with overflow and incomplete-tool, budget apart. */ export function cursorEnvelopeEchoRemintScopeKey( threadOwner: string | undefined, identityScope?: string, conversationId?: string, ): string | null { if (conversationId) { pruneRewrites(now()); const root = conversationRewrites.get(rewriteKey(conversationId, identityScope))?.root ?? conversationId; return `echo\0${rewriteKey(root, identityScope)}`; } return cursorOverflowRemintScopeKey(threadOwner, identityScope); } /** Record one envelope-echo remint; returns false when the independent cap is exhausted. */ export function recordCursorEnvelopeEchoRemint(scopeKey: string): boolean { return envelopeEchoRemintBudget.record(scopeKey); } /** A turn that completed without an echo replenishes only this budget. */ export function clearCursorEnvelopeEchoRemint(scopeKey: string): void { envelopeEchoRemintBudget.clear(scopeKey); } export function clearCursorEnvelopeEchoRemintForTests(): void { envelopeEchoRemintBudget.clearForTests(); } export function cursorEnvelopeEchoRemintCountForTests(): number { return envelopeEchoRemintBudget.countForTests(); }