@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
119 lines (108 loc) • 7.58 kB
text/typescript
/**
* Caller-owned affinity is scoped to the exact Authorization value and conversation key under a
* process-random HMAC key. It is process-local and must never be anchored or persisted, as required
* by the structure contract. Decisions describe the binding at selection time.
*/
import { createHmac, randomBytes } from "node:crypto";
import { MAIN_CODEX_ACCOUNT_ID } from "./account-id";
import { codexConversationIdentity } from "./lineage";
import { getThreadAffinity, getModelDetourAffinity, deleteThreadAffinity, deleteModelDetourAffinity, notePendingReleaseReason, type CodexAffinityDecision, type CodexAffinityReason, type ThreadAffinityEntry } from "./routing/thread-affinity";
import type { CodexQuotaScope } from "./routing/health-store";
import { classifyCodexUpstreamOutcome } from "./routing/cooldown-math";
import type { CodexAuthContext } from "./auth-context";
import { isRequestOwnedAffinityKey, REQUEST_OWNED_AFFINITY_KEY_PREFIX } from "./request-owned-affinity-key";
export { isRequestOwnedAffinityKey } from "./request-owned-affinity-key";
const key = randomBytes(32);
const prefix = REQUEST_OWNED_AFFINITY_KEY_PREFIX;
/** Derive the opaque key for this caller and conversation, if both exist. */
export function requestOwnedAffinityKey(headers: Headers): string | undefined {
const authorization = headers.get("authorization");
const conversation = codexConversationIdentity(headers)?.conversationKey;
if (!authorization || !conversation) return undefined;
return prefix + createHmac("sha256", key)
.update("opencodex-request-owned-affinity-v1\0").update(authorization).update("\0").update(conversation)
.digest("base64url");
}
/** Report a bind only when the selection-time entry names the selected account. */
export function honestAffinityDecision(
decision: CodexAffinityDecision | undefined,
affinityKey: string | undefined,
accountId: string,
quotaScope?: CodexQuotaScope,
modelId?: string,
requestOwnedKeyWithheld = false,
): CodexAffinityDecision | undefined {
if (!decision || (decision.move !== "new_bind" && decision.move !== "rebound")) return decision;
// This is a selection-time snapshot, immediately after the synchronous selector returns.
if (affinityKey && (getThreadAffinity(affinityKey, quotaScope)?.accountId === accountId
|| getModelDetourAffinity(affinityKey, modelId, quotaScope)?.accountId === accountId)) return decision;
if (decision.move === "rebound") return { move: "cleared", reason: decision.reason };
return { move: "unbound", reason: affinityKey ? decision.reason : requestOwnedKeyWithheld ? "request_owned" : "no_conversation" };
}
/** Identify the issuer for a Pool or keyed caller-main context. */
export function conversationStateAccountId(ctx: { kind: "main" | "pool" | "main-pool"; accountId: string | null; affinityKey?: string; conversationStateKey?: string }): string | undefined {
return ctx.kind === "main" ? (ctx.affinityKey || ctx.conversationStateKey ? MAIN_CODEX_ACCOUNT_ID : undefined) : ctx.accountId ?? undefined;
}
/** Describe the account actually serving a caller-owned fallback. */
export function callerOwnedFallbackAffinityDecision(
decision: CodexAffinityDecision | undefined, affinityKey: string | undefined, quotaScope: CodexQuotaScope | undefined,
modelId: string | undefined, requestOwnedKeyWithheld: boolean, reason: "cooldown" | "unusable",
): CodexAffinityDecision {
const ordinary = affinityKey ? getThreadAffinity(affinityKey, quotaScope) : undefined;
const detour = affinityKey ? getModelDetourAffinity(affinityKey, modelId, quotaScope) : undefined;
if (ordinary?.accountId === MAIN_CODEX_ACCOUNT_ID || detour?.accountId === MAIN_CODEX_ACCOUNT_ID)
return honestAffinityDecision(decision ?? { move: "reused", reason: "healthy" }, affinityKey, MAIN_CODEX_ACCOUNT_ID, quotaScope, modelId, requestOwnedKeyWithheld)!;
if (ordinary || detour) return { move: "detour", reason };
return { move: "unbound", reason: affinityKey ? decision?.reason ?? "healthy" : requestOwnedKeyWithheld ? "request_owned" : "no_conversation" };
}
/** Opaque process-local identity for the bindings present when main was selected. */
export type RequestOwnedBindingSnapshot = object;
type EntryIdentity = { entry: ThreadAffinityEntry; accountId: string; generation: number; createdAt: number };
const bindingSnapshots = new WeakMap<RequestOwnedBindingSnapshot, { key: string; scope?: CodexQuotaScope; modelId?: string; ordinary?: EntryIdentity; detour?: EntryIdentity }>();
function identity(entry: ThreadAffinityEntry | undefined): EntryIdentity | undefined {
return entry && { entry, accountId: entry.accountId, generation: entry.generation, createdAt: entry.createdAt };
}
function matches(captured: EntryIdentity | undefined, current: ThreadAffinityEntry | undefined): boolean {
return !!captured && captured.entry === current && captured.accountId === current.accountId
&& captured.generation === current.generation && captured.createdAt === current.createdAt;
}
/** Capture the exact entries that a request is authorized to release after selection. */
export function captureRequestOwnedAffinityBindings(key: string | undefined, scope?: CodexQuotaScope, modelId?: string): RequestOwnedBindingSnapshot | undefined {
if (!key || !isRequestOwnedAffinityKey(key)) return undefined;
const snapshot = {};
bindingSnapshots.set(snapshot, { key, scope, modelId, ordinary: identity(getThreadAffinity(key, scope)), detour: identity(getModelDetourAffinity(key, modelId, scope)) });
return snapshot;
}
/** Whether a context carries a caller-owned routing key. */
export function isKeyedRequestOwnedMain(ctx: CodexAuthContext): ctx is Extract<CodexAuthContext, { kind: "main" }> & { affinityKey: string } {
return ctx.kind === "main" && !!ctx.affinityKey && isRequestOwnedAffinityKey(ctx.affinityKey);
}
/** Release this caller’s scoped binding after its own main credential is refused. */
export function releaseRequestOwnedMainOnOutcome(ctx: CodexAuthContext, outcome: number, _modelId?: string): void {
if (!isKeyedRequestOwnedMain(ctx) || !ctx.affinityBindingSnapshot) return;
const snapshot = bindingSnapshots.get(ctx.affinityBindingSnapshot);
if (!snapshot || snapshot.key !== ctx.affinityKey) return;
const outcomeClass = classifyCodexUpstreamOutcome(outcome);
const reason: CodexAffinityReason | undefined = outcomeClass === "quota" ? "quota_refusal"
: outcomeClass === "credential" ? "unusable" : outcomeClass === "transient" ? "transient" : undefined;
if (!reason) return;
const key = ctx.affinityKey;
const { scope, modelId: selectedModelId } = snapshot;
let released = false;
const ordinary = getThreadAffinity(key, scope);
const detour = getModelDetourAffinity(key, selectedModelId, scope);
const mainDetour = matches(snapshot.detour, detour) && detour?.accountId === MAIN_CODEX_ACCOUNT_ID;
// A caller-main fallback or model detour can leave an ordinary binding on a different
// account. Retire it too so the next placement reports the release rather than reuse. If
// main was itself bound and another turn has since rebound elsewhere, keep that newer entry.
const callerMainDetour = ctx.affinityDecision?.move === "detour";
if (matches(snapshot.ordinary, ordinary) && (ordinary?.accountId === MAIN_CODEX_ACCOUNT_ID || mainDetour || callerMainDetour)) {
deleteThreadAffinity(key, scope);
released = true;
}
if (mainDetour) {
deleteModelDetourAffinity(key, selectedModelId, scope);
released = true;
}
if (released) notePendingReleaseReason(key, reason);
}