UNPKG

@bitkyc08/opencodex

Version:

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

667 lines (617 loc) • 29.3 kB
import { isCodexAccountGenerationLive, readCodexAccountRecord } from "../account-store"; import { MAIN_CODEX_ACCOUNT_ID } from "../account-id"; import { retainedUtf8Bytes } from "../../lib/admission"; import { clearAllCodexPoolRefreshFailures } from "../pool-refresh-backoff"; import type { CodexThreadLineage } from "../lineage"; import type { CodexQuotaScope } from "./health-store"; import type { TransientProbeLease } from "../../routing/probe-lease"; import { clearPoolRecoveryState } from "../../routing/probe-lease"; import { identityFence, adoptStoredThreadRows, adoptStoredIssuer, CODEX_UNKNOWN_CONVERSATION_STATE_ISSUER, registerCodexAffinityLiveState, recordThreadBind, recordThreadTouch, recordThreadDelete, recordThreadAccountDeleted, recordAccountPinsCleared, recordAllCleared, recordThreadsCleared, recordIssuerSet, recordIssuerTouch, recordIssuerDelete, recordIssuersCleared } from "./thread-affinity-store"; export { CODEX_UNKNOWN_CONVERSATION_STATE_ISSUER } from "./thread-affinity-store"; export type ThreadAffinityEntry = { accountId: string; generation: number; identityFence?: string; createdAt: number; lastUsedAt: number; // Last time the bound account's quota threshold was re-evaluated for this // thread (interval-gated to avoid per-request flapping). See REEVAL_INTERVAL_MS. lastReevalAt: number; // When a transient failure streak first forced this thread onto another account // while the binding was HELD (#4546). Cleared the moment the bound account serves // again; once it ages past CODEX_TRANSIENT_AFFINITY_HOLD_MS the binding is // released through the ordinary path instead of detouring forever. transientHoldSince?: number; // Which account is serving this thread while its own is held under a transient hold. // Remembered rather than re-picked per request: under round-robin a fresh pick each turn // would walk the ring and start cold on every hop, which is the behaviour the hold exists // to prevent. Cleared with transientHoldSince when the bound account serves again. transientDetourAccountId?: string; }; /** * The half-open trial this request was granted against its own held account (#4701). * * The lease alone is not enough to settle safely. Its generation is an account-local PROBE * epoch, while {@link ThreadAffinityEntry.generation} is the selected CREDENTIAL generation, * and the two move independently: a credential replaced while the probe is in flight leaves * the probe epoch untouched, so a settle that checked only the lease would write an answer * about a credential that no longer exists. Capturing the affinity generation here is what * lets the settle refuse that case. */ export interface TransientProbeGrant { readonly lease: TransientProbeLease; /** Credential generation the binding held when the probe was granted. */ readonly affinityGeneration: number; } export type CodexThreadResolution = | { status: "selected"; accountId: string; affinity?: CodexAffinityDecision; /** * Present only when this request is the single admitted probe of a held account. The * holder owes the lease a settle or a release; nothing else may act on it. */ transientProbe?: TransientProbeGrant; } | { status: "none"; affinity?: CodexAffinityDecision } | { status: "expired"; accountId: string; affinity?: CodexAffinityDecision } /** * Every candidate for this binding is held and no detour is left, so there is no account * this request may be sent to. Distinct from `none`: the binding is REMEMBERED and the * caller is told when to come back, rather than being handed the account already known to * be failing. Returning `selected` here is the "must not send, sends anyway" defect * (#4701); the caller must refuse before any upstream I/O. */ | { status: "withheld"; accountId: string; /** Earliest moment a recovery dispatch could be admitted. Always strictly in the future. */ retryAt: number; /** The remembered detour, when one exists but is itself unusable right now. */ detourAccountId?: string; affinity?: CodexAffinityDecision; }; /** What happened to this thread's binding on this request (#4546). */ export type CodexAffinityMove = /** Served by its own bound account, which was healthy. */ | "reused" /** Served by its own bound account while something transient was wrong with it. */ | "held" /** Served by another account while the binding stayed put. */ | "detour" /** The binding was released and a different account took the thread. */ | "rebound" /** There was no live binding; this request established one. */ | "new_bind" /** The binding was released without a replacement on this request. */ | "cleared" /** No binding was established for this selection. */ | "unbound"; /** * Why. A move is the expensive event -- it discards the prompt-cache prefix warmed on the old * account -- so the operator should not have to infer it from account labels across log lines, * which is how #4546 had to be diagnosed. */ export type CodexAffinityReason = | "healthy" /** The request had no usable conversation key. */ | "no_conversation" /** A caller-owned credential did not opt into affinity. */ | "request_owned" | "quota_headroom" | "quota_refusal" | "transient" | "transient_hold_expired" | "unusable" | "paused" | "plan_excluded" /** Credits are off for the account and one of its usage windows is full (#6334). */ | "credits_off" | "cooldown" | "quota_avoided" | "generation" | "expired" | "model_lane" /** First placement followed the parent's CURRENT serving account (#4546, wp8). */ | "lineage_parent" /** First placement followed a compatible sibling's current serving account. */ | "lineage_sibling"; export interface CodexAffinityDecision { move: CodexAffinityMove; reason: CodexAffinityReason; } /** The decision to report once a binding has been released and selection starts over. */ export function affinityAfterRelease( threadId: string | null, releaseReason: CodexAffinityReason | undefined, ): CodexAffinityDecision { // Reported now, so it must not be reported again by the next request. clearPendingReleaseReason(threadId); return releaseReason === undefined ? { move: "new_bind", reason: "healthy" } : { move: "rebound", reason: releaseReason }; } /** * What to report when selection produced no account at all. The binding is gone and nothing took * it, which is a `cleared`, and the pending reason is deliberately NOT consumed: a no-account * result reaches no auth context and therefore no usage entry, so the next resolve that does * produce one is the first place this release can actually be seen. */ export function affinityOnNoAccount( threadId: string | null, releaseReason: CodexAffinityReason | undefined, ): CodexAffinityDecision | undefined { if (releaseReason === undefined) return undefined; // Hand it forward as well as reporting it. A reason derived from the entry this request just // released lives only in a local, so without this the next resolve finds no entry and no // pending reason and calls the rebind a fresh healthy bind. notePendingReleaseReason(threadId, releaseReason); return { move: "cleared", reason: releaseReason }; } export const CODEX_THREAD_AFFINITY_IDLE_TTL_MS = 24 * 60 * 60_000; export const CODEX_THREAD_AFFINITY_MAX_ENTRIES = 2048; const MAX_AFFINITY_COMPONENT_BYTES = 512; // Min interval between quota threshold re-evaluations for a single bound thread. // Well under the 5h/weekly quota windows, but enough to stop per-request flapping. export const CODEX_THREAD_AFFINITY_REEVAL_INTERVAL_MS = 60_000; /** * How long a live binding outlives a TRANSIENT failure streak on its own account (#4546). * * Being unable to send right now is not the same as losing ownership of the conversation. * A 5xx streak is frequently provider-wide rather than account-specific, and deleting the * binding for it discards a prompt-cache prefix that the next turn then pays for again -- * the same cost the quota threshold used to impose, arriving through a different door. * So the request detours to another account while the binding is held here. * * Bounded, because an unbounded hold is its own defect: an account that never recovers * would keep a thread detouring indefinitely while the conversation's real warm prefix * accumulates somewhere else. Ten minutes is longer than the whole soft-avoid escalation * ladder up to its final step, so an ordinary outage resolves inside the hold and a * genuine one converts to a real rebind instead of a permanent detour. */ export const CODEX_TRANSIENT_AFFINITY_HOLD_MS = 10 * 60_000; /** * Requests without a resolved native model retain the historic one-account-per- * thread behavior. Requests with a known quota scope get an independent * affinity so a Reserve failover cannot displace the same thread's Terra/Luna * account (and vice versa). */ type BaseThreadAffinityScope = CodexQuotaScope | "legacy"; type ModelDetourAffinityScope = `model-detour:${BaseThreadAffinityScope}:${string}`; type ThreadAffinityScope = BaseThreadAffinityScope | ModelDetourAffinityScope; function isModelDetourAffinityScope(scope: ThreadAffinityScope): scope is ModelDetourAffinityScope { return scope.startsWith("model-detour:"); } const LEGACY_THREAD_AFFINITY_SCOPE = "legacy" as const; const threadAccountMap = new Map<string, Map<ThreadAffinityScope, ThreadAffinityEntry>>(); let threadAffinityEntryTotal = 0; /** * Which pool account minted the conversation's carried OpenAI state * (`previous_response_id`, encrypted reasoning, provider conversation/file ids). * Keyed by the same affinity key as {@link threadAccountMap}, bounded the same * way. Durable rows use a separate keyed digest; raw account ids never reach a log. */ type ConversationStateIssuerEntry = { accountId: string; lastUsedAt: number; fence?: string; storedAccountId?: string; storedFence?: string | null; }; const conversationStateIssuerMap = new Map<string, ConversationStateIssuerEntry>(); export function registerThreadAffinityLiveState(): void { registerCodexAffinityLiveState({ thread: (key, scope) => threadAccountMap.get(key)?.get(scope as ThreadAffinityScope), issuer: key => { const entry = conversationStateIssuerMap.get(key); return entry && { accountId: entry.storedAccountId ?? entry.accountId, fence: entry.storedAccountId ? entry.storedFence ?? undefined : entry.fence, lastUsedAt: entry.lastUsedAt }; }, clearLive: () => { threadAccountMap.clear(); threadAffinityEntryTotal = 0; conversationStateIssuerMap.clear(); }, }); } registerThreadAffinityLiveState(); export function clearThreadAccountMap(options: { preserveConversationStateIssuers?: boolean } = {}): void { if (options.preserveConversationStateIssuers) recordThreadsCleared(); else recordAllCleared(); threadAccountMap.clear(); threadAffinityEntryTotal = 0; // A refresh cooldown is per-account runtime state learned alongside these bindings. Leaving it // behind here keeps an account out of selection after the roster it belonged to is gone. clearAllCodexPoolRefreshFailures(); // Same argument for recovery state (#4701): probe pacing is keyed on account ids this reset // may have just retired, and the recovery window counts sends made by the roster that is // going away. A held account nobody may probe because of a lease issued against the previous // roster is a recovery that never starts. clearPoolRecoveryState(); // A manual account switch clears routing affinity, not the issuer of carried state. The next // account needs that record to scrub or refuse account-bound continuation. if (!options.preserveConversationStateIssuers) conversationStateIssuerMap.clear(); } export function clearConversationStateIssuerMap(): void { recordIssuersCleared(); conversationStateIssuerMap.clear(); } export function clearThreadAccountMapForAccount( accountId: string, reason: CodexAffinityReason = "unusable", ): void { recordAccountPinsCleared(accountId); for (const [threadId, affinities] of threadAccountMap) { for (const [scope, entry] of affinities) { if (entry.accountId === accountId && affinities.delete(scope)) { threadAffinityEntryTotal = Math.max(0, threadAffinityEntryTotal - 1); notePendingReleaseReason(threadId, reason); } } if (affinities.size === 0) threadAccountMap.delete(threadId); } } function pruneConversationStateIssuers(now: number): void { for (const [key, entry] of conversationStateIssuerMap) { if (now - entry.lastUsedAt > CODEX_THREAD_AFFINITY_IDLE_TTL_MS) { conversationStateIssuerMap.delete(key); recordIssuerDelete(key); } } while (conversationStateIssuerMap.size > CODEX_THREAD_AFFINITY_MAX_ENTRIES) { let oldestKey: string | null = null; let oldestAt = Number.POSITIVE_INFINITY; for (const [key, entry] of conversationStateIssuerMap) { if (entry.lastUsedAt < oldestAt) { oldestAt = entry.lastUsedAt; oldestKey = key; } } if (!oldestKey) break; conversationStateIssuerMap.delete(oldestKey); recordIssuerDelete(oldestKey); } } /** * Record the pool account that just issued carried conversation state for this * binding key. Persisted when an anchor is available; the id is never logged. */ export function rememberConversationStateIssuer( bindingKey: string, accountId: string, now = Date.now(), credential?: { generation: number; chatgptAccountId: string }, ): void { if (!bindingKey.trim() || !accountId.trim()) return; if (!admissibleAffinityComponent(bindingKey) || !admissibleAffinityComponent(accountId)) return; pruneConversationStateIssuers(now); const record = accountId === MAIN_CODEX_ACCOUNT_ID ? undefined : readCodexAccountRecord(accountId); const fence = record?.credential && record.deletedAt == null && credential && record.generation === credential.generation && record.credential.chatgptAccountId === credential.chatgptAccountId ? identityFence(record.quotaHistoryIdentity) : undefined; if (accountId === MAIN_CODEX_ACCOUNT_ID) recordIssuerDelete(bindingKey); else if (accountId !== CODEX_UNKNOWN_CONVERSATION_STATE_ISSUER) recordIssuerSet(bindingKey, accountId, fence ?? null, now); conversationStateIssuerMap.set(bindingKey, { accountId, lastUsedAt: now, fence }); pruneConversationStateIssuers(now); } /** Last account that minted carried state for this binding, if still in the TTL window. */ export function peekConversationStateIssuer( bindingKey: string, now = Date.now(), ): string | undefined { if (!bindingKey.trim() || !admissibleAffinityComponent(bindingKey)) return undefined; pruneConversationStateIssuers(now); recordIssuerTouch(bindingKey); let entry = conversationStateIssuerMap.get(bindingKey); if (!entry) { const stored = adoptStoredIssuer(bindingKey, now); if (stored !== undefined) { entry = { accountId: stored.issuer, lastUsedAt: now, storedAccountId: stored.storedAccountId, storedFence: stored.storedFence }; conversationStateIssuerMap.set(bindingKey, entry); pruneConversationStateIssuers(now); } } if (!entry) return undefined; entry.lastUsedAt = now; return entry.accountId; } export function peekConversationStateStoredIssuerAccount(bindingKey: string): string | undefined { return conversationStateIssuerMap.get(bindingKey)?.storedAccountId; } /** * Why a binding was released, held until that thread's next resolve can report it (#4546). * * A release and the request that pays for it are two different moments: a 429 clears the pin * inside the outcome recorder, and the next request arrives with nothing left to explain why it * is starting cold. Bounded, because it is a diagnostic and must not become a leak. */ const pendingReleaseReasons = new Map<string, CodexAffinityReason>(); const MAX_PENDING_RELEASE_REASONS = 4096; export function notePendingReleaseReason(threadId: string | null, reason: CodexAffinityReason): void { if (threadId === null) return; if (!pendingReleaseReasons.has(threadId) && pendingReleaseReasons.size >= MAX_PENDING_RELEASE_REASONS) { const oldest = pendingReleaseReasons.keys().next(); if (!oldest.done) pendingReleaseReasons.delete(oldest.value); } pendingReleaseReasons.set(threadId, reason); } export function peekPendingReleaseReason(threadId: string | null): CodexAffinityReason | undefined { if (threadId === null) return undefined; return pendingReleaseReasons.get(threadId); } /** * Forget a release only once it has actually been reported. * * Consuming it at derivation time lost it whenever selection then failed to produce an account: * a no-account return carries no payload, so the release went unrecorded and the next successful * resolve claimed a fresh healthy bind (#4598). A release survives until some resolve reports it. */ function clearPendingReleaseReason(threadId: string | null): void { if (threadId !== null) pendingReleaseReasons.delete(threadId); } function threadAffinityScope(quotaScope?: CodexQuotaScope): BaseThreadAffinityScope { return quotaScope ?? LEGACY_THREAD_AFFINITY_SCOPE; } function admissibleAffinityComponent(value: string): boolean { return retainedUtf8Bytes(value) <= MAX_AFFINITY_COMPONENT_BYTES; } function modelDetourAffinityScope( modelId: string | undefined, quotaScope?: CodexQuotaScope, ): ModelDetourAffinityScope | undefined { const canonicalModelId = modelId?.trim().toLowerCase(); if (!canonicalModelId || !admissibleAffinityComponent(canonicalModelId)) return undefined; return `model-detour:${threadAffinityScope(quotaScope)}:${canonicalModelId}`; } function getThreadAffinityForScope( threadId: string, scope: ThreadAffinityScope, ): ThreadAffinityEntry | undefined { if (!admissibleAffinityComponent(threadId)) return undefined; recordThreadTouch(threadId, scope); if (!threadAccountMap.get(threadId)?.get(scope)) adoptThreadAffinities(threadId, Date.now(), scope); return threadAccountMap.get(threadId)?.get(scope); } function adoptThreadAffinities(threadId: string, now: number, scopeName?: ThreadAffinityScope): void { for (const row of adoptStoredThreadRows(threadId, now, scopeName)) { const record = readCodexAccountRecord(row.accountId); if (!record?.credential || record.deletedAt != null || identityFence(record.quotaHistoryIdentity) !== row.fence) continue; const scope = row.scope as ThreadAffinityScope; const affinities = threadAccountMap.get(threadId) ?? new Map<ThreadAffinityScope, ThreadAffinityEntry>(); if (affinities.has(scope)) continue; affinities.set(scope, { accountId: row.accountId, generation: record.generation, identityFence: row.fence, createdAt: row.createdAt, lastUsedAt: row.lastUsedAt, lastReevalAt: now }); threadAccountMap.set(threadId, affinities); threadAffinityEntryTotal += 1; } pruneLruThreadAffinities(); } export function getThreadAffinity(threadId: string, quotaScope?: CodexQuotaScope): ThreadAffinityEntry | undefined { return getThreadAffinityForScope(threadId, threadAffinityScope(quotaScope)); } export function getModelDetourAffinity( threadId: string, modelId: string | undefined, quotaScope?: CodexQuotaScope, ): ThreadAffinityEntry | undefined { const scope = modelDetourAffinityScope(modelId, quotaScope); return scope ? getThreadAffinityForScope(threadId, scope) : undefined; } function deleteThreadAffinityForScope(threadId: string, scope: ThreadAffinityScope): void { if (!admissibleAffinityComponent(threadId)) return; recordThreadDelete(threadId, scope); const affinities = threadAccountMap.get(threadId); if (!affinities) return; if (affinities.delete(scope)) { threadAffinityEntryTotal = Math.max(0, threadAffinityEntryTotal - 1); } if (affinities.size === 0) threadAccountMap.delete(threadId); } export function deleteThreadAffinity(threadId: string, quotaScope?: CodexQuotaScope): void { deleteThreadAffinityForScope(threadId, threadAffinityScope(quotaScope)); } export function deleteModelDetourAffinity( threadId: string, modelId: string | undefined, quotaScope?: CodexQuotaScope, ): void { const scope = modelDetourAffinityScope(modelId, quotaScope); if (scope) deleteThreadAffinityForScope(threadId, scope); } /** Remove only the matching failed account's affinities for one thread. */ export function deleteThreadAffinitiesForAccount(threadId: string, accountId: string): void { if (!admissibleAffinityComponent(threadId) || !admissibleAffinityComponent(accountId)) return; recordThreadAccountDeleted(threadId, accountId); const affinities = threadAccountMap.get(threadId); if (!affinities) return; for (const [scope, entry] of affinities) { if (entry.accountId === accountId && affinities.delete(scope)) { recordThreadDelete(threadId, scope); threadAffinityEntryTotal = Math.max(0, threadAffinityEntryTotal - 1); } } if (affinities.size === 0) threadAccountMap.delete(threadId); } function threadAffinityEntryCount(): number { return threadAffinityEntryTotal; } export function isThreadAffinityExpired(entry: ThreadAffinityEntry, now: number): boolean { return now - entry.lastUsedAt > CODEX_THREAD_AFFINITY_IDLE_TTL_MS; } export function isThreadAffinityGenerationLive(entry: ThreadAffinityEntry): boolean { if (entry.accountId === MAIN_CODEX_ACCOUNT_ID) return entry.generation === 0; return isCodexAccountGenerationLive(entry.accountId, entry.generation); } /** Generations this account's affinity entries are bound at. Test observability only. */ export function debugCodexAffinityGenerations(accountId: string): number[] { const generations: number[] = []; for (const affinities of threadAccountMap.values()) { for (const entry of affinities.values()) { if (entry.accountId === accountId) generations.push(entry.generation); } } return generations; } /** * Advance this account's affinity entries from the generation a rejected credential * was bound under to the generation its own refresh produced. * * A 401 refresh-and-replay keeps the request on the same account, but the CAS write * moves the credential from G to G+1, and {@link isThreadAffinityGenerationLive} * demands exact equality — so without this the entry the replay just preserved is * dead on the next request. Not quarantining an account is not the same as keeping * its affinity. * * Lineage is proven by the CALLER, which must pass only a generation its own refresh * produced. Re-deriving it here from `replacedAt` cannot work: the caller reads that * field after the refresh and this function would re-read the same record, so the * comparison is tautological and an external replacement passes it. An external * replacement must retire the affinity, because that credential may belong to a * different upstream identity. */ export function handOffThreadAffinityGeneration( accountId: string, fromGeneration: number, toGeneration: number, ): boolean { if (accountId === MAIN_CODEX_ACCOUNT_ID) return false; if (toGeneration !== fromGeneration + 1) return false; const record = readCodexAccountRecord(accountId); if (!record?.credential || record.deletedAt != null) return false; if (record.generation !== toGeneration) return false; let handedOff = false; for (const affinities of threadAccountMap.values()) { for (const entry of affinities.values()) { if (entry.accountId !== accountId || entry.generation !== fromGeneration) continue; entry.generation = toGeneration; handedOff = true; } } return handedOff; } function pruneExpiredThreadAffinities(now: number): void { for (const [threadId, affinities] of threadAccountMap) { for (const [scope, entry] of affinities) { if (isThreadAffinityExpired(entry, now) && affinities.delete(scope)) { recordThreadDelete(threadId, scope); threadAffinityEntryTotal = Math.max(0, threadAffinityEntryTotal - 1); } } if (affinities.size === 0) threadAccountMap.delete(threadId); } } function pruneLruThreadAffinities(): void { if (threadAffinityEntryCount() <= CODEX_THREAD_AFFINITY_MAX_ENTRIES) return; while (threadAffinityEntryCount() > CODEX_THREAD_AFFINITY_MAX_ENTRIES) { let oldestThreadId: string | null = null; let oldestScope: ThreadAffinityScope | null = null; let oldestLastUsedAt = Number.POSITIVE_INFINITY; let oldestIsDetour = false; for (const [threadId, affinities] of threadAccountMap) { for (const [scope, entry] of affinities) { const candidateIsDetour = isModelDetourAffinityScope(scope); if ( (candidateIsDetour && !oldestIsDetour) || (candidateIsDetour === oldestIsDetour && entry.lastUsedAt < oldestLastUsedAt) ) { oldestThreadId = threadId; oldestScope = scope; oldestLastUsedAt = entry.lastUsedAt; oldestIsDetour = candidateIsDetour; } } } if (!oldestThreadId || !oldestScope) return; deleteThreadAffinityForScope(oldestThreadId, oldestScope); } } function bindThreadAffinityForScope( threadId: string, accountId: string, now: number, scope: ThreadAffinityScope, ): void { if (!admissibleAffinityComponent(threadId) || !admissibleAffinityComponent(accountId)) return; const record = accountId === MAIN_CODEX_ACCOUNT_ID ? undefined : readCodexAccountRecord(accountId); if (accountId !== MAIN_CODEX_ACCOUNT_ID && (!record?.credential || record.deletedAt != null)) return; pruneExpiredThreadAffinities(now); recordThreadTouch(threadId, scope); const affinities = threadAccountMap.get(threadId) ?? new Map<ThreadAffinityScope, ThreadAffinityEntry>(); const previous = affinities.get(scope); const fence = identityFence(record?.quotaHistoryIdentity); const entry: ThreadAffinityEntry = { accountId, generation: accountId === MAIN_CODEX_ACCOUNT_ID ? 0 : record!.generation, identityFence: fence, createdAt: previous?.createdAt ?? now, lastUsedAt: now, lastReevalAt: now, }; if (fence) recordThreadBind(threadId, scope, { scope, accountId, fence, createdAt: entry.createdAt, lastUsedAt: now }); else recordThreadDelete(threadId, scope); affinities.set(scope, entry); if (!previous) threadAffinityEntryTotal += 1; threadAccountMap.set(threadId, affinities); pruneLruThreadAffinities(); } export function bindThreadAffinity( threadId: string, accountId: string, now: number, quotaScope?: CodexQuotaScope, ): void { bindThreadAffinityForScope(threadId, accountId, now, threadAffinityScope(quotaScope)); } export function bindModelDetourAffinity( threadId: string, accountId: string, now: number, modelId: string | undefined, quotaScope?: CodexQuotaScope, ): void { const scope = modelDetourAffinityScope(modelId, quotaScope); if (scope) bindThreadAffinityForScope(threadId, accountId, now, scope); } /** Read-only view of one thread's scope-keyed affinity entries. */ export function getThreadAffinityScopes( threadId: string, ): ReadonlyMap<ThreadAffinityScope, ThreadAffinityEntry> | undefined { adoptThreadAffinities(threadId, Date.now()); return threadAccountMap.get(threadId); } /** * Move one scope's binding from the pre-#4546 RAW parent key onto the key this thread uses now. * * Legacy raw-parent keys are process-local and are not persisted. The case this exists for is the * narrow one: a code swap under a live conversation, where the map still holds entries made by * the old rule. Rebinding those cold is precisely the defect the lineage work exists to prevent, * so the conversation keeps its account and the legacy entry is retired in the same step. * * One way, once. The legacy entry is deleted even when it was dead on arrival, because nothing * can reach it again under the new rule and an orphan only spends an LRU slot a live * conversation needs. Only the account moves: a transient hold describes a failure happening * right now, and the ordinary path re-derives it on this very request. */ function adoptLegacyAffinityForScope( threadId: string, legacyKey: string, now: number, scope: ThreadAffinityScope, ): void { if (getThreadAffinityForScope(threadId, scope) !== undefined) return; const legacy = getThreadAffinityForScope(legacyKey, scope); if (legacy === undefined) return; if (!isThreadAffinityExpired(legacy, now) && isThreadAffinityGenerationLive(legacy)) { bindThreadAffinityForScope(threadId, legacy.accountId, now, scope); } deleteThreadAffinityForScope(legacyKey, scope); } /** Both lanes of the legacy migration: the ordinary binding and this request's model detour. */ export function adoptLegacyLineageAffinity( threadId: string, lineage: CodexThreadLineage | undefined, now: number, quotaScope?: CodexQuotaScope, modelId?: string, ): void { const legacyKey = lineage?.legacyConversationKey; if (legacyKey === undefined || legacyKey === threadId) return; adoptLegacyAffinityForScope(threadId, legacyKey, now, threadAffinityScope(quotaScope)); const detourScope = modelDetourAffinityScope(modelId, quotaScope); if (detourScope) adoptLegacyAffinityForScope(threadId, legacyKey, now, detourScope); }