@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
247 lines (230 loc) • 13.7 kB
text/typescript
/**
* Anthropic OAuth on the managed native Messages lane (PF-10, behind
* `protocols.rollout.managedMessagesNativeOAuth`).
*
* Credential. Shared Anthropic routing chooses the account for the session and model;
* the same generation-fenced selection commit as the Responses transport admits it. A lost
* commit re-evaluates routing so a concurrent manual switch or policy edit wins. Selection,
* token resolution and affinity binding run at dispatch only, never during planning.
*
* Pools. Native Messages uses the OAuth owner's strategy, model allowlist, session affinity,
* pause and cooldown admission. Pre-output refusal recovery proposes a replacement account;
* this module admits and binds its exact generation before a rebuilt request may send.
* A lane-change 409 remains distinct from typed local authentication/pause/cooldown refusals.
*
* Tool names. An OAuth request carries client tool names under the Claude OAuth prefix, as the
* adapter sends them; the answer's `tool_use` names are mapped back here, for exactly the names
* the builder renamed.
*
* No token, account id or body content is logged or returned in an error message.
*/
import type { OAuthAccessSnapshot } from "../oauth";
import { anthropicRoutingFor } from "../oauth/anthropic-routing";
import { resolveAnthropicModelRouteForInstance, routeCandidates, type AnthropicRouteDecision } from "../oauth/anthropic-model-routes";
import { configuredAnthropicInstance, type AnthropicInstanceId } from "../providers/anthropic-instance";
import { resolveAnthropicMessagesUrl } from "../adapters/anthropic";
import { routedProviderConfig } from "../router";
import {
captureOAuthAccountSelection,
commitOAuthAccountSelection,
credentialGeneration,
getAccountCredentialWithStatus,
} from "../oauth/store";
import type { TranslatorBudget } from "../lib/translator-budget";
import type { OcxConfig } from "../types";
import { relaySseWithPayloadRewrite } from "./sse-payload-rewrite";
const MAX_SELECTION_ATTEMPTS = 3;
type Selection = NonNullable<ReturnType<typeof captureOAuthAccountSelection>>;
type Rec = Record<string, unknown>;
function isRec(value: unknown): value is Rec {
return value !== null && typeof value === "object" && !Array.isArray(value);
}
/** The committed selection and the credential snapshot one native request is served with. */
export interface NativeOAuthBinding {
readonly instance: AnthropicInstanceId;
/** Config-authorized physical destination, captured before any credential await. */
readonly routeTarget: string;
readonly selection: Selection;
readonly snapshot: OAuthAccessSnapshot;
/** Anthropic account UUID from the same stored generation, distinct from snapshot.accountId. */
readonly providerAccountUuid?: string;
readonly routeDecision: AnthropicRouteDecision | null;
readonly sessionKey: string | null;
readonly model?: string;
readonly config: OcxConfig;
readonly manualSelectionGeneration: number;
}
/** The selection moved or became ineligible while resolving. Maps to a 409 retry. */
export class NativeOAuthSelectionChangedError extends Error {
constructor() {
super("OAuth account selection changed; retry the request");
this.name = "NativeOAuthSelectionChangedError";
}
}
/** Invalid operator route configuration remains a request refusal, not an auth failure. */
export class NativeOAuthModelRouteError extends Error {}
/**
* Current configured ownership and target; a revoked B never resolves orphan credentials.
*
* Adapter, auth mode and destination are read from the routed provider, the same normalization the
* settled route used to compute its target. Routing canonicalizes the primary row's adapter and auth
* mode from the registry, so a raw-field comparison would refuse an existing Pool 1 row the route
* already accepted. B's own raw-row shape is still enforced through `configuredAnthropicInstance`.
*/
function nativeOAuthRouteTarget(instance: AnthropicInstanceId, config: OcxConfig): string {
const provider = config.providers[instance];
if (configuredAnthropicInstance(config, instance) !== instance || !provider || provider.disabled === true) {
throw new NativeOAuthSelectionChangedError();
}
let routed: ReturnType<typeof routedProviderConfig>;
try {
routed = routedProviderConfig(instance, provider);
} catch {
// A destination the router now refuses is a moved route, not a different failure class.
throw new NativeOAuthSelectionChangedError();
}
if (routed.authMode !== "oauth" || routed.adapter !== "anthropic") throw new NativeOAuthSelectionChangedError();
return resolveAnthropicMessagesUrl(routed);
}
function currentRoute(instance: AnthropicInstanceId, config: OcxConfig, model?: string): AnthropicRouteDecision | null {
const resolved = model ? resolveAnthropicModelRouteForInstance(instance, config, model) : { decision: null };
if (resolved.error) throw new NativeOAuthModelRouteError(`Invalid Anthropic model routes: ${resolved.error}`);
return resolved.decision ? { ...resolved.decision, accounts: [...resolved.decision.accounts] } : null;
}
function routeIsCurrent(instance: AnthropicInstanceId, config: OcxConfig, model: string | undefined, decision: AnthropicRouteDecision | null): boolean {
return JSON.stringify(currentRoute(instance, config, model)) === JSON.stringify(decision);
}
export interface NativeOAuthBindingOptions {
/** Settled route destination; retries may never authorize a replacement destination. */
routeTarget?: string;
sessionKey?: string | null;
model?: string;
/** An account proposed by the shared pre-output refusal recovery policy. */
candidateAccountId?: string;
/** Selection captured before asynchronous refusal classification or throttle wait. */
expectedRecoverySelection?: Selection | null;
expectedRecoveryRouteDecision?: AnthropicRouteDecision | null;
}
/** Compatibility entrypoint: the original instance only. */
export function resolveNativeOAuthBinding(config: OcxConfig, options: NativeOAuthBindingOptions = {}): Promise<NativeOAuthBinding> {
return resolveNativeOAuthBindingForInstance("anthropic", config, options);
}
/** Resolve the shared pool selector and commit its exact credential generation for dispatch. */
export async function resolveNativeOAuthBindingForInstance(
instance: AnthropicInstanceId,
config: OcxConfig,
options: NativeOAuthBindingOptions = {},
): Promise<NativeOAuthBinding> {
const routeTarget = options.routeTarget ?? nativeOAuthRouteTarget(instance, config);
const routing = anthropicRoutingFor(instance);
const assertOwner = () => {
if (nativeOAuthRouteTarget(instance, config) !== routeTarget) throw new NativeOAuthSelectionChangedError();
};
const sessionKey = options.sessionKey ?? null;
const model = options.model;
for (let attempt = 0; attempt < MAX_SELECTION_ATTEMPTS; attempt++) {
assertOwner();
const routeDecision = currentRoute(instance, config, model);
const manualSelectionGeneration = routing.captureAnthropicManualSelectionGeneration();
const selection = captureOAuthAccountSelection(instance);
// A recovery candidate may replace a terminal active credential, including pool-off.
// A newer committed selection or route discards the proposal and uses normal admission.
const recoverySelectionMatches = !!options.expectedRecoverySelection
&& selection?.accountId === options.expectedRecoverySelection.accountId
&& selection?.revision === options.expectedRecoverySelection.revision;
const recoveryRouteMatches = options.expectedRecoveryRouteDecision === undefined
|| JSON.stringify(options.expectedRecoveryRouteDecision) === JSON.stringify(routeDecision);
const recoveryAccountId = attempt === 0 && options.candidateAccountId && recoverySelectionMatches && recoveryRouteMatches
? options.candidateAccountId : undefined;
const accountId = recoveryAccountId
?? await routing.resolveAnthropicDispatchAccountId(config, sessionKey, routeDecision, model);
assertOwner();
if (!routeIsCurrent(instance, config, model, routeDecision)) continue;
const proposed = routing.resolveAnthropicAccountForSession(sessionKey, config, Date.now(), routeDecision, model);
if (!selection) continue;
if (!routeCandidates(routing.getEligibleAnthropicAccounts(Date.now(), model), routeDecision).includes(accountId)) {
throw new NativeOAuthSelectionChangedError();
}
const candidate = await routing.getAnthropicPoolAccessSnapshot(accountId);
assertOwner();
if (candidate.provider !== instance) throw new NativeOAuthSelectionChangedError();
if (!routeIsCurrent(instance, config, model, routeDecision)) continue;
const committed = await commitOAuthAccountSelection(instance, candidate.accountId, {
expectedSelection: selection,
expectedCredentialGeneration: candidate.generation,
requireUsableAccount: true,
});
assertOwner();
if (committed) {
if (!routeIsCurrent(instance, config, model, routeDecision)
|| manualSelectionGeneration !== routing.captureAnthropicManualSelectionGeneration()) continue;
if (!routing.commitAnthropicSelectionRouting(candidate.accountId, selection, committed, {
config, sessionKey, model, routeDecision,
reason: accountId === proposed.accountId ? proposed.reason : undefined,
expectedCredentialGeneration: candidate.generation,
})) continue;
const row = getAccountCredentialWithStatus(instance, candidate.accountId);
if (!row || row.credential.access !== candidate.accessToken || credentialGeneration(row.credential) !== candidate.generation) continue;
const binding: NativeOAuthBinding = { instance, routeTarget, selection: committed, snapshot: candidate, providerAccountUuid: row.credential.accountId, routeDecision, sessionKey, model, config, manualSelectionGeneration };
if (nativeOAuthBindingIsCurrent(binding)) return binding;
}
}
throw new NativeOAuthSelectionChangedError();
}
/**
* Whether a binding may still be sent: a live pooled session affinity or the same committed
* selection, plus the same usable credential generation. Checked before every physical send.
*/
export function nativeOAuthBindingIsCurrent(binding: NativeOAuthBinding): boolean {
const { instance } = binding;
const routing = anthropicRoutingFor(instance);
try {
if (nativeOAuthRouteTarget(instance, binding.config) !== binding.routeTarget) return false;
} catch { return false; }
if (binding.snapshot.provider !== instance) return false;
if (binding.manualSelectionGeneration !== routing.captureAnthropicManualSelectionGeneration()
|| !routeIsCurrent(instance, binding.config, binding.model, binding.routeDecision)) return false;
const selected = captureOAuthAccountSelection(instance);
const row = getAccountCredentialWithStatus(instance, binding.snapshot.accountId);
const sessionRoute = routing.isAnthropicAccountPoolEnabled(binding.config) && binding.sessionKey
? routing.resolveAnthropicAccountForSession(binding.sessionKey, binding.config, Date.now(), binding.routeDecision, binding.model) : null;
// Another conversation may move the automatic active pointer without revoking this
// session's affinity. Manual selection clears affinity and precedes it in the selector.
const selectionCurrent = sessionRoute?.reason === "affinity"
&& sessionRoute.accountId === binding.snapshot.accountId
|| (selected?.accountId === binding.selection.accountId && selected?.revision === binding.selection.revision);
return selectionCurrent
&& !!row && !row.paused && !row.needsReauth && row.credential.expires > Date.now()
&& !routing.getAnthropicAccountHealthSnapshot(binding.snapshot.accountId)
&& routeCandidates(routing.getEligibleAnthropicAccounts(Date.now(), binding.model), binding.routeDecision).includes(binding.snapshot.accountId)
&& row.credential.access === binding.snapshot.accessToken
&& credentialGeneration(row.credential) === binding.snapshot.generation
&& row.credential.accountId === binding.providerAccountUuid;
}
/** Map a `tool_use` block's wire name back to the caller's name; other blocks are untouched. */
function restoredBlock(block: unknown, names: ReadonlyMap<string, string>): unknown {
if (!isRec(block) || block.type !== "tool_use" || typeof block.name !== "string") return block;
const original = names.get(block.name);
return original === undefined ? block : { ...block, name: original };
}
/** A Messages result with renamed `tool_use` names mapped back. Returns the input when unchanged. */
export function restoreOAuthToolNamesInMessage(message: Rec, names: ReadonlyMap<string, string>): Rec {
if (names.size === 0 || !Array.isArray(message.content)) return message;
return { ...message, content: message.content.map(block => restoredBlock(block, names)) };
}
/** The upstream Messages stream with renamed `tool_use` names mapped back in `content_block_start`. */
export function restoreOAuthToolNamesInSse(
body: ReadableStream<Uint8Array>,
names: ReadonlyMap<string, string>,
translatorBudget: TranslatorBudget,
): ReadableStream<Uint8Array> {
if (names.size === 0) return body;
return relaySseWithPayloadRewrite(body, (payload) => {
if (!payload.includes("content_block_start")) return payload;
let parsed: unknown;
try { parsed = JSON.parse(payload); } catch { return payload; }
if (!isRec(parsed) || parsed.type !== "content_block_start") return payload;
const restored = restoredBlock(parsed.content_block, names);
return restored === parsed.content_block ? payload : JSON.stringify({ ...parsed, content_block: restored });
}, translatorBudget);
}