@cortexkit/pi-anthropic-auth 1.23.0 → 2.0.0

package/dist/stream.js

@@ -1,58 +1,16 @@
-import { applyClaudeCodeHeaders, applyCustomHeaders, CACHE_KEEP_EXTENDED_TTL_BETA, CacheKeepManager, CacheKeepSessionRegistry, ClaustrumScopedRuntime, connectClaustrumScopedClient, createStickyNoRouteResponse, decideStickyQuotaFailure, dumpDirectRequest, FAST_MODE_BETA, FallbackAccountManager, fetchOAuthQuotaSnapshot, getCache1hPersistentMode, getClaudeCodeIdentityForVerifiedAccount, getClaustrumMode, getDefaultCacheKeepRegistryDirectory, getFallbackReauthLabels, getHostClaustrumEnrollmentPaths, getOrCreateMainAccountId, getQuotaCheckIntervalMs, getRelayConfig, getRoutingMode, getScopedQuotaWindowForModel, getStickyRoutingStatePath, getThinkingPrefixMismatchBehavior, hasThinkingBindingControls, isApiKeyAccount, isCache1hPersistentlyEnabled, isCacheKeepHybridActive, isDumpPersistentlyEnabled, isFastModePersistentlyEnabled, isKillswitchEnabled, isOAuthAccount, isPermanentRefreshError, isValidApiBaseURL, killswitchPassesPolicy, loadAccounts, logger, MID_CONVERSATION_OUTPUT_CONFIG_BETA, mergeAnthropicBetas, QuotaManager, quotaSnapshotHasStandardWindows, quotaSnapshotModelScopeIsExhausted, quotaSnapshotPassesModelScope, quotaSnapshotPassesPolicy, refreshBackoffActive, resolveClaudeCodeIdentity, STICKY_ROUTING_MAIN_ACCOUNT_ID, StickySessionRouter, sendViaRelay, setDumpEnabled, shouldFallbackStatus, stickyQuotaSnapshotIsFresh, stickyRetryAfterWithJitter, stickyRouteFamilyForModel, THINKING_BINDING_CONTROLS_BETA, tokenFingerprint, usesMidConversationOutputConfig, } from '@cortexkit/anthropic-auth-core';
+import { applyClaudeCodeHeaders, applyCustomHeaders, CACHE_KEEP_EXTENDED_TTL_BETA, CacheKeepManager, CacheKeepSessionRegistry, createProviderErrorResponseScope, createSseFramer, createStickyNoRouteResponse, decideStickyQuotaFailure, decodeSseFrame, dumpDirectRequest, FAST_MODE_BETA, getCache1hPersistentMode, getClaudeCodeIdentityForVerifiedAccount, getDefaultCacheKeepRegistryDirectory, getFallbackReauthLabels, getQuotaCheckIntervalMs, getRoutingMode, getScopedQuotaWindowForModel, getThinkingPrefixMismatchBehavior, hasThinkingBindingControls, isCache1hPersistentlyEnabled, isCacheKeepHybridActive, isDumpPersistentlyEnabled, isFastModePersistentlyEnabled, isKillswitchEnabled, isNativeTransientAccountError, isOAuthAccount, isPermanentRefreshError, isValidApiBaseURL, killswitchPassesPolicy, logger, MID_CONVERSATION_OUTPUT_CONFIG_BETA, mergeAnthropicBetas, NativeVaultNoAccountError, parseSseFrame, QuotaManager, quotaBackoffActive, quotaSnapshotHasStandardWindows, quotaSnapshotModelScopeIsExhausted, quotaSnapshotPassesModelScope, quotaSnapshotPassesPolicy, STICKY_ROUTING_MAIN_ACCOUNT_ID, StickySessionRouter, sendViaRelay, setDumpEnabled, shouldFallbackStatus, stickyQuotaSnapshotIsFresh, stickyRetryAfterWithJitter, stickyRouteFamilyForModel, THINKING_BINDING_CONTROLS_BETA, usesMidConversationOutputConfig, } from '@cortexkit/anthropic-auth-core';
 import { calculateCost, createAssistantMessageEventStream, } from '@earendil-works/pi-ai';
 import { buildAnthropicRequest, fromClaudeCodeToolName } from './convert.js';
-import { requirePiEnrollment } from './custody.js';
-import { getPiAccountStoragePath, getPiClaustrumConnectionOptions, } from './paths.js';
-function errorText(error) {
-    return error instanceof Error ? error.message : String(error);
-}
+import { getPiNativeRuntime, piAttemptAccessToken, } from './native.js';
+import { getPiAccountStoragePath } from './paths.js';
+import { buildPiOAuthMessagesUrl, fetchPiOAuth, requirePiOAuthOrigin, } from './transport.js';
+/** Dump label for a physical send that failed before any response arrived. */
+const PHYSICAL_SEND_FAILED = 'physical send failed before a response';
 let cacheKeepRegistry;
 let cacheKeepRegistryDirectory;
 const stickyRouters = new Map();
 const quotaManagers = new Map();
-const fallbackManagers = new Map();
-const mainAccountIdInitializations = new Map();
 const PI_SERVICE_CACHE_LIMIT = 16;
-const scopedRuntimes = new Map();
-export function getPiScopedRuntime(storagePath = getPiAccountStoragePath(), overrides = {}) {
-    const existing = scopedRuntimes.get(storagePath);
-    if (existing)
-        return existing;
-    let warned = false;
-    const { connect, ...runtimeOverrides } = overrides;
-    const runtime = new ClaustrumScopedRuntime({
-        storagePath,
-        tokenPath: getHostClaustrumEnrollmentPaths('pi').tokenPath,
-        connect: async () => {
-            await requirePiEnrollment();
-            return connect
-                ? connect()
-                : connectClaustrumScopedClient(getPiClaustrumConnectionOptions(storagePath));
-        },
-        onRoster: () => {
-            warned = false;
-        },
-        onError: () => {
-            if (!warned)
-                logger.warn('claustrum', 'Pi scoped credential service unavailable');
-            warned = true;
-        },
-        ...runtimeOverrides,
-    });
-    while (scopedRuntimes.size >= PI_SERVICE_CACHE_LIMIT) {
-        const oldest = scopedRuntimes.keys().next().value;
-        if (oldest === undefined)
-            break;
-        scopedRuntimes.get(oldest)?.close();
-        scopedRuntimes.delete(oldest);
-    }
-    scopedRuntimes.set(storagePath, runtime);
-    return runtime;
-}
-export function closePiScopedRuntime(storagePath = getPiAccountStoragePath()) {
-    scopedRuntimes.get(storagePath)?.close();
-    scopedRuntimes.delete(storagePath);
-}
 function setBoundedService(map, key, value) {
     map.delete(key);
     map.set(key, value);
@@ -63,76 +21,92 @@ function setBoundedService(map, key, value) {
         map.delete(oldest);
     }
 }
-function ensurePiMainAccountId(storagePath) {
-    let initialization = mainAccountIdInitializations.get(storagePath);
-    if (!initialization) {
-        initialization = getOrCreateMainAccountId(storagePath).catch((error) => {
-            if (mainAccountIdInitializations.get(storagePath) === initialization) {
-                mainAccountIdInitializations.delete(storagePath);
-            }
-            throw error;
-        });
-        setBoundedService(mainAccountIdInitializations, storagePath, initialization);
-    }
-    return initialization;
-}
-function getPiRoutingServices(storagePath, storage) {
-    let quotaManager = quotaManagers.get(storagePath);
-    let fallbackManager = fallbackManagers.get(storagePath);
-    if (!quotaManager || !fallbackManager) {
+function getPiRoutingServices(storagePath, snapshot) {
+    const storage = snapshot.policyStorage;
+    const native = getPiNativeRuntime(storagePath);
+    const identityKey = JSON.stringify(snapshot.accounts.map((account) => [
+        account.id,
+        account.accountIdentity,
+        account.source,
+        account.credentialId,
+        account.binding?.rowId,
+        account.binding?.credentialEpoch,
+    ]));
+    const existing = quotaManagers.get(storagePath);
+    let quotaManager = existing?.identityKey === identityKey ? existing.manager : undefined;
+    if (!quotaManager) {
         quotaManager = new QuotaManager({
             storage,
-            fetchQuotaSnapshot: async (request) => {
-                const current = await loadAccounts(storagePath);
-                if (getClaustrumMode(current) === 'claustrum') {
-                    const id = request.kind === 'main' ? 'main' : request.accountId;
-                    if (!id)
-                        throw new Error('Claustrum quota request has no account identity');
-                    return getPiScopedRuntime(storagePath).fetchQuota(id);
-                }
-                if (!request.accessToken)
-                    throw new Error('Missing local OAuth quota credential');
-                return fetchOAuthQuotaSnapshot({ accessToken: request.accessToken });
+            fetchQuotaSnapshot: async (request, dispatch) => {
+                const id = request.kind === 'main' ? 'main' : request.accountId;
+                if (!id)
+                    throw new Error('Native quota request has no account identity');
+                return (await native.service()).fetchQuota(id, fetchPiOAuth, undefined, dispatch);
             },
         });
-        fallbackManager = new FallbackAccountManager({
-            configPath: storagePath,
-            quotaManager,
-            isFallbackAccountVaultEnabled: (_id, current) => getClaustrumMode(current) === 'claustrum',
-            isFallbackAccountVaultServed: (id, current) => {
-                const account = current.accounts.find((candidate) => candidate.id === id);
-                return (getClaustrumMode(current) === 'claustrum' &&
-                    Boolean(account &&
-                        isOAuthAccount(account) &&
-                        account.claustrumScopedCredentialId &&
-                        account.claustrumScopedState === 'active'));
-            },
-            resolveFallbackAccessToken: (account, current) => getClaustrumMode(current) === 'claustrum'
-                ? undefined
-                : account.access
-                    ? { token: account.access, source: 'sidecar' }
-                    : undefined,
+        setBoundedService(quotaManagers, storagePath, {
+            identityKey,
+            manager: quotaManager,
         });
-        setBoundedService(quotaManagers, storagePath, quotaManager);
-        setBoundedService(fallbackManagers, storagePath, fallbackManager);
     }
     else {
         quotaManager.updateStorage(storage);
     }
-    return { quotaManager, fallbackManager };
+    const quotas = quotaManager;
+    const getUsableFallbackAccounts = async (current, options = {}) => {
+        const snapshot = await native.view();
+        const accounts = new Map(snapshot.accounts.map((account) => [account.id, account]));
+        const usable = [];
+        for (const account of current.accounts) {
+            const view = accounts.get(account.id);
+            if (!isOAuthAccount(account) || !view?.enabled || view.type !== 'oauth')
+                continue;
+            if (view.source === 'vault' && view.state !== 'active')
+                continue;
+            if (isPermanentRefreshError(view.lastRefreshError) ||
+                (view.source === 'local' &&
+                    (view.lastRefreshError?.nextRetryAt ?? 0) > Date.now()))
+                continue;
+            const needsProbe = view.source !== 'vault' ||
+                Boolean(current.quota?.minimumRemaining) ||
+                isKillswitchEnabled(current);
+            if (needsProbe &&
+                quotas.isFallbackStale(account.id, undefined, options.modelId, account) &&
+                !quotaBackoffActive(account.lastQuotaRefreshError, Date.now())) {
+                try {
+                    await quotas.refreshFallback(account.id, '', account);
+                }
+                catch (error) {
+                    // A transient account error means another writer is still saving
+                    // this fallback. Rethrow it: swallowing it would leave the fallback
+                    // without a quota reading, which can exclude it below and send the
+                    // request through a different account. Other probe errors are
+                    // ignored.
+                    if (isNativeTransientAccountError(error))
+                        throw error;
+                }
+            }
+            const quota = quotas.getFallback(account.id, account)?.quota ?? account.quota;
+            if ((!needsProbe || quotaSnapshotPassesPolicy(quota, current)) &&
+                quotaSnapshotPassesModelScope(quota, options.modelId))
+                usable.push({ ...account, quota });
+        }
+        return usable;
+    };
+    return { quotaManager, getUsableFallbackAccounts };
 }
-function getPiStickyRouter(storagePath) {
-    const path = process.env.PI_ANTHROPIC_AUTH_ROUTING_STATE_FILE ||
-        getStickyRoutingStatePath(storagePath);
+async function getPiStickyRouter(storagePath) {
+    const { path, vaultSeed } = await getPiNativeRuntime(storagePath).routingStorage();
     let router = stickyRouters.get(path);
     if (!router) {
-        router = new StickySessionRouter({ path });
+        router = new StickySessionRouter({ path, vaultSeed });
         setBoundedService(stickyRouters, path, router);
     }
+    router.setVaultSeed(vaultSeed);
     return router;
 }
 export async function clearPiStickyRoutingSession(storagePath, sessionId) {
-    await getPiStickyRouter(storagePath).clear(sessionId);
+    await (await getPiStickyRouter(storagePath)).clear(sessionId);
 }
 function getPiCacheKeepRegistry() {
     const directory = process.env.PI_ANTHROPIC_AUTH_CACHEKEEP_REGISTRY_DIR ||
@@ -143,85 +117,81 @@ function getPiCacheKeepRegistry() {
     }
     return cacheKeepRegistry;
 }
-const scopedPrewarmAttempts = new Map();
+const nativePrewarmAttempts = new Map();
 const cacheKeepManager = new CacheKeepManager({
-    loadStorage: () => loadAccounts(getPiAccountStoragePath()),
+    fetchImpl: fetchPiOAuth,
+    loadStorage: async () => (await getPiNativeRuntime().view()).policyStorage,
     onTrackedSessionsChanged: (sessions) => getPiCacheKeepRegistry().publish(sessions),
     prepareHeaders: async (headers, target, attempt) => {
-        const storagePath = target.accountStoragePath ?? getPiAccountStoragePath();
-        const current = await loadAccounts(storagePath);
-        if (target.accountStoragePath && !current)
+        requirePiOAuthOrigin(target.url);
+        const runtime = getPiNativeRuntime(target.accountStoragePath ?? getPiAccountStoragePath());
+        const id = target.oauthAccountId ?? STICKY_ROUTING_MAIN_ACCOUNT_ID;
+        const current = await runtime.view();
+        const body = JSON.parse(target.bodyText);
+        const served = await runtime.authorize(id, attempt.signal, typeof body.model === 'string' ? body.model : undefined);
+        if (!target.oauthAccountIdentity ||
+            served.accountIdentity !== target.oauthAccountIdentity)
+            throw new Error('CacheKeep account identity changed');
+        const identity = getClaudeCodeIdentityForVerifiedAccount(id === STICKY_ROUTING_MAIN_ACCOUNT_ID
+            ? (current.policyStorage.mainAccountId ?? id)
+            : id, served.accountIdentity);
+        headers.delete('anthropic-beta');
+        applyClaudeCodeHeaders(headers, piAttemptAccessToken(served), {
+            body,
+            identity,
+            extraBetas: [
+                CACHE_KEEP_EXTENDED_TTL_BETA,
+                ...(hasThinkingBindingControls(body)
+                    ? [THINKING_BINDING_CONTROLS_BETA]
+                    : []),
+            ],
+        });
+        if (body.speed === 'fast')
+            headers.set('anthropic-beta', mergeAnthropicBetas(headers.get('anthropic-beta'), [FAST_MODE_BETA]));
+        nativePrewarmAttempts.set(attempt.id, { runtime, served, reported: false });
+        return headers;
+    },
+    retryOnUnauthorized: async ({ target, headers, attempt }) => {
+        const entry = nativePrewarmAttempts.get(attempt.id);
+        if (!entry)
             return undefined;
-        if (getClaustrumMode(current) === 'claustrum') {
-            const runtime = getPiScopedRuntime(storagePath);
-            const id = target.oauthAccountId ?? STICKY_ROUTING_MAIN_ACCOUNT_ID;
-            const receipt = await runtime.authorize(id, attempt.signal);
-            if (!target.oauthAccountIdentity ||
-                receipt.accountId !== target.oauthAccountIdentity) {
-                throw new Error('CacheKeep account identity changed');
-            }
-            const body = JSON.parse(target.bodyText);
-            const identity = getClaudeCodeIdentityForVerifiedAccount(id === STICKY_ROUTING_MAIN_ACCOUNT_ID
-                ? (current?.mainAccountId ?? id)
-                : id, receipt.accountId);
-            headers.delete('anthropic-beta');
-            applyClaudeCodeHeaders(headers, receipt.accessToken, {
-                body,
-                identity,
-                extraBetas: [
-                    CACHE_KEEP_EXTENDED_TTL_BETA,
-                    ...(hasThinkingBindingControls(body)
-                        ? [THINKING_BINDING_CONTROLS_BETA]
-                        : []),
-                ],
-            });
-            if (body.speed === 'fast')
-                headers.set('anthropic-beta', mergeAnthropicBetas(headers.get('anthropic-beta'), [FAST_MODE_BETA]));
-            scopedPrewarmAttempts.set(attempt.id, { runtime, receipt });
-            return headers;
-        }
-        const authorization = headers.get('authorization') ?? '';
-        const match = /^Bearer\s+(.+)$/i.exec(authorization);
-        const accessToken = match?.[1];
-        if (!accessToken)
+        await entry.runtime.report(entry.served, 401, 'direct').catch(() => {
+            logger.warn('native-auth', 'Pi CacheKeep auth-failure report unavailable');
+        });
+        entry.reported = true;
+        const retryBody = JSON.parse(target.bodyText);
+        const rotated = await entry.runtime
+            .retry(target.oauthAccountId ?? STICKY_ROUTING_MAIN_ACCOUNT_ID, entry.served, attempt.signal, typeof retryBody.model === 'string' ? retryBody.model : undefined)
+            .catch(() => undefined);
+        if (!rotated)
             return undefined;
-        try {
-            const body = JSON.parse(target.bodyText);
-            await ensurePiMainAccountId(storagePath);
-            const storage = await loadAccounts(storagePath);
-            const identity = await resolveClaudeCodeIdentity(accessToken, typeof body.model === 'string' ? body.model : undefined, target.oauthAccountId ?? storage?.mainAccountId);
-            headers.delete('anthropic-beta');
-            applyClaudeCodeHeaders(headers, accessToken, {
-                body,
-                identity,
-                extraBetas: [
-                    CACHE_KEEP_EXTENDED_TTL_BETA,
-                    ...(hasThinkingBindingControls(body)
-                        ? [THINKING_BINDING_CONTROLS_BETA]
-                        : []),
-                ],
-            });
-            if (body.speed === 'fast') {
-                headers.set('anthropic-beta', mergeAnthropicBetas(headers.get('anthropic-beta'), [FAST_MODE_BETA]));
-            }
-        }
-        catch {
-            applyClaudeCodeHeaders(headers, accessToken);
-        }
-        return headers;
+        const rotatedHeaders = new Headers(headers);
+        rotatedHeaders.set('authorization', `Bearer ${piAttemptAccessToken(rotated)}`);
+        nativePrewarmAttempts.set(attempt.id, {
+            runtime: entry.runtime,
+            served: rotated,
+            reported: false,
+        });
+        return rotatedHeaders;
     },
     onResponse: async ({ attempt, status }) => {
-        const entry = scopedPrewarmAttempts.get(attempt.id);
-        if (entry)
-            await entry.runtime.reportFailure(entry.receipt, status, 'direct');
+        const entry = nativePrewarmAttempts.get(attempt.id);
+        if (entry && status === 401 && !entry.reported)
+            await entry.runtime.report(entry.served, status, 'direct').catch(() => {
+                logger.warn('native-auth', 'Pi CacheKeep auth-failure report unavailable');
+            });
     },
     onComplete: ({ attempt }) => {
-        scopedPrewarmAttempts.delete(attempt.id);
+        nativePrewarmAttempts.delete(attempt.id);
     },
 });
 export async function getPiTrackedCacheKeepSessions() {
     return getPiCacheKeepRegistry().list(cacheKeepManager.trackedSessions());
 }
+/** Call prewarmNow directly to exercise its provider request without clock or timer mocks. */
+export function __prewarmPiCacheKeepForTest(input) {
+    return cacheKeepManager.prewarmNow(input);
+}
 function mapStopReason(reason) {
     switch (reason) {
         case 'end_turn':
@@ -308,66 +278,59 @@ export async function* parseSse(response) {
     if (!response.body)
         return;
     const reader = response.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = '';
+    // Core's byte framer ends frames at blank lines with CRLF, LF or CR line
+    // endings and keeps a multibyte character split across reads in one frame,
+    // so each frame is decoded once, whole. A frame without its closing blank
+    // line at end of stream is incomplete and dispatches nothing, as in
+    // EventSource.
+    const framer = createSseFramer();
+    // Only the stream's first frame may drop a leading byte-order mark.
+    let streamStart = true;
     try {
         while (true) {
             const { done, value } = await reader.read();
             if (done)
                 break;
-            buffer += decoder.decode(value, { stream: true });
-            let boundary = buffer.indexOf('\n\n');
-            while (boundary !== -1) {
-                const frame = buffer.slice(0, boundary);
-                buffer = buffer.slice(boundary + 2);
-                boundary = buffer.indexOf('\n\n');
-                for (const line of frame.split('\n')) {
-                    if (!line.startsWith('data:'))
-                        continue;
-                    const data = line.slice(5).trim();
-                    if (!data || data === '[DONE]')
-                        continue;
-                    yield JSON.parse(data);
-                }
+            for (const frame of framer.push(value)) {
+                const data = parseSseFrame(decodeSseFrame(frame, { streamStart })).data;
+                streamStart = false;
+                if (!data || data === '[DONE]')
+                    continue;
+                yield JSON.parse(data);
             }
         }
     }
     finally {
-        // Do not cancel the reader on early abandon. `firstStreamingError()` peeks
-        // the first SSE event from a `response.clone()` and then abandons this
-        // generator; cancelling the cloned (tee'd) reader tears down the shared
-        // underlying body, so the real `parseSse(response)` that streams the reply
-        // reads zero events and the assistant message comes back empty. Releasing
-        // the lock is enough — the abandoned clone branch is garbage-collected.
+        // Only the lock is released when the consumer stops early: cancelling the
+        // body on abandonment is the consumer's decision, not the parser's.
         reader.releaseLock();
     }
 }
 async function sendAnthropicRequest(options) {
-    await ensurePiMainAccountId(options.storagePath);
-    const storage = await loadAccounts(options.storagePath);
+    const native = getPiNativeRuntime(options.storagePath);
+    // Capture the serving service while authorization is open. Shutdown rejects
+    // new serving work immediately but drains writes for already-served attempts.
+    const servingRuntime = await native.service();
+    const snapshot = await native.view();
+    const storage = snapshot.policyStorage;
     setDumpEnabled(isDumpPersistentlyEnabled(storage));
-    const accountIdentity = options.oauthAccountId === STICKY_ROUTING_MAIN_ACCOUNT_ID
-        ? storage?.mainAccountId
-        : options.oauthAccountId;
-    const scoped = !options.apiAccount && getClaustrumMode(storage) === 'claustrum'
-        ? getPiScopedRuntime(options.storagePath)
-        : undefined;
     const routeId = options.oauthAccountId ?? STICKY_ROUTING_MAIN_ACCOUNT_ID;
-    const roster = scoped
-        ? (scoped.snapshot() ?? (await scoped.refresh()))
+    const selected = snapshot.accounts.find((account) => account.id === routeId);
+    let verifiedUuid = options.apiAccount ? undefined : selected?.accountIdentity;
+    if (!options.apiAccount && !verifiedUuid) {
+        if (selected?.source === 'vault')
+            throw new Error('Pi vault route identity is unasserted');
+        // Validation can learn the UUID of an account that has no verified identity.
+        // This lookup returns only that UUID; the model send authorizes the credential again.
+        verifiedUuid = (await native.authorize(routeId, options.streamOptions?.signal, options.model.id)).accountIdentity;
+    }
+    let nextAttempt;
+    const identity = verifiedUuid
+        ? getClaudeCodeIdentityForVerifiedAccount(routeId === STICKY_ROUTING_MAIN_ACCOUNT_ID
+            ? (storage.mainAccountId ?? routeId)
+            : routeId, verifiedUuid)
         : undefined;
-    const verifiedUuid = routeId === STICKY_ROUTING_MAIN_ACCOUNT_ID
-        ? roster?.primary?.accountId
-        : roster?.accounts.find((account) => account.id === routeId)
-            ?.anthropicAccountUuid;
-    if (scoped && !verifiedUuid)
-        throw new Error('Claustrum route has no verified provider identity');
-    const identity = scoped && verifiedUuid
-        ? getClaudeCodeIdentityForVerifiedAccount(accountIdentity ?? routeId, verifiedUuid)
-        : options.accessToken
-            ? await resolveClaudeCodeIdentity(options.accessToken, options.model.id, accountIdentity)
-            : undefined;
-    const { body, bodyText } = await buildAnthropicRequest(options.model.id, options.context, options.streamOptions, {
+    const { body, bodyText, hostTools } = await buildAnthropicRequest(options.model.id, options.context, options.streamOptions, {
         enabled: isCache1hPersistentlyEnabled(storage),
         mode: getCache1hPersistentMode(storage),
     }, isFastModePersistentlyEnabled(storage), identity, {
@@ -376,10 +339,11 @@ async function sendAnthropicRequest(options) {
             ? 'account-default'
             : getThinkingPrefixMismatchBehavior(storage),
     });
+    options.onResolvedTools?.(hostTools);
     const fastMode = body.speed === 'fast';
     const headers = options.apiAccount
-        ? configureApiRouteHeaders(options.apiAccount, fastMode)
-        : applyClaudeCodeHeaders(new Headers(), scoped ? '' : (options.accessToken ?? ''), {
+        ? new Headers()
+        : applyClaudeCodeHeaders(new Headers(), '', {
             body,
             identity,
             extraBetas: [
@@ -391,48 +355,120 @@ async function sendAnthropicRequest(options) {
                     : []),
             ],
         });
-    if (!options.apiAccount && fastMode) {
+    if (!options.apiAccount && fastMode)
         headers.set('anthropic-beta', mergeAnthropicBetas(headers.get('anthropic-beta'), [FAST_MODE_BETA]));
-    }
     const relayAffinity = options.streamOptions?.sessionId ?? null;
-    const input = options.apiAccount
-        ? buildExplicitBaseMessagesUrl(options.apiAccount.baseURL)
-        : new URL('/v1/messages?beta=true', options.model.baseUrl);
+    let input = options.apiAccount
+        ? new URL('https://api.anthropic.com/v1/messages')
+        : buildPiOAuthMessagesUrl(options.model.baseUrl);
     const init = {
         method: 'POST',
         headers,
         body: bodyText,
         signal: options.streamOptions?.signal,
+        ...(!options.apiAccount && { redirect: 'error' }),
     };
-    await cacheKeepManager.track({
-        sessionId: relayAffinity,
-        url: input.toString(),
-        headers,
-        bodyText,
-        storage,
-        cacheMode: !options.apiAccount && isCacheKeepHybridActive(storage)
-            ? 'hybrid'
-            : 'disabled',
-        oauthAccountId: options.oauthAccountId,
-        oauthAccountIdentity: verifiedUuid ?? identity?.accountUuid,
-        accountStoragePath: options.storagePath,
-    });
+    if (!options.apiAccount)
+        await cacheKeepManager.track({
+            sessionId: relayAffinity,
+            url: input.toString(),
+            headers,
+            bodyText,
+            storage,
+            cacheMode: isCacheKeepHybridActive(storage) ? 'hybrid' : 'disabled',
+            oauthAccountId: routeId,
+            oauthAccountIdentity: verifiedUuid,
+            accountStoragePath: options.storagePath,
+        });
+    const reported = new Set();
+    let retried401 = false;
+    let lastTransport;
+    const used = new Set();
     const report = async (attempt, status, source) => {
-        if (!scoped || status !== 401)
+        if (status !== 401 || reported.has(attempt))
             return;
-        await scoped.reportFailure(attempt, status, source).catch(() => {
-            logger.warn('claustrum', 'Pi scoped auth-failure report unavailable');
+        reported.add(attempt);
+        await native.report(attempt, status, source).catch(() => {
+            logger.warn('native-auth', 'Pi auth-failure report unavailable');
         });
     };
+    const markServed = (attempt) => {
+        if (used.has(attempt))
+            return;
+        used.add(attempt);
+        native.usagePublications.publish(() => native.markUsed(attempt, servingRuntime));
+    };
+    const takeAttempt = async () => {
+        const attempt = nextAttempt ??
+            (await native.authorize(routeId, init.signal ?? undefined, options.model.id));
+        nextAttempt = undefined;
+        if (attempt.accountIdentity !== verifiedUuid)
+            throw new Error('Pi native OAuth route identity changed');
+        return attempt;
+    };
     const directFetch = async () => {
-        // Every physical attempt, including relay-to-direct fallback, is authorized.
-        const attempt = scoped
-            ? await scoped.authorize(routeId, options.streamOptions?.signal)
-            : undefined;
-        if (attempt)
-            headers.set('authorization', `Bearer ${attempt.accessToken}`);
+        let attempt;
+        let apiSubject;
+        // The secret this physical send goes out with; a provider error may repeat it.
+        let secret = '';
+        if (options.apiAccount) {
+            const credential = await (await native.service()).authorizeApi(options.apiAccount.id, init.signal ?? undefined);
+            apiSubject = credential.subject;
+            secret = credential.apiKey ?? '';
+            input = buildExplicitBaseMessagesUrl(credential.baseURL);
+            const authorized = configureApiRouteHeaders({
+                ...credential,
+                id: options.apiAccount.id,
+            }, fastMode);
+            init.headers = authorized;
+        }
+        else {
+            attempt = await takeAttempt();
+            secret = piAttemptAccessToken(attempt);
+            headers.set('authorization', `Bearer ${secret}`);
+        }
+        lastTransport = 'direct';
+        // The response scope of the latest physical send. Each send gets its own
+        // before the request leaves, so a rejected 401 is already scrubbed when
+        // it is reported, dumped or cancelled.
+        const physical = {};
+        const send = async () => {
+            const scope = createProviderErrorResponseScope([secret], 'event-stream');
+            physical.scope = scope;
+            return scope.redactResponse(await fetch(input, init));
+        };
+        let response;
         try {
-            const response = await fetch(input, init);
+            response = await send();
+            if (attempt && response.status === 401) {
+                // Report the rejected credential version before retrying, even if its replacement later succeeds.
+                await report(attempt, response.status, 'direct');
+                const rotated = !retried401 && !init.signal?.aborted
+                    ? await native
+                        .retry(routeId, attempt, init.signal ?? undefined, options.model.id)
+                        .catch(() => undefined)
+                    : undefined;
+                if (rotated) {
+                    retried401 = true;
+                    await dumpDirectRequest({
+                        affinity: relayAffinity,
+                        route: options.route ?? 'oauth',
+                        status: response.status,
+                        bodyText,
+                        url: input.toString(),
+                        method: init.method,
+                        headers,
+                    });
+                    // Retire the rejected send's credentials before cancelling its
+                    // body, since that cancellation may never settle.
+                    physical.scope?.dispose();
+                    await response.body?.cancel().catch(() => { });
+                    attempt = rotated;
+                    secret = piAttemptAccessToken(rotated);
+                    headers.set('authorization', `Bearer ${secret}`);
+                    response = await send();
+                }
+            }
             if (attempt)
                 await report(attempt, response.status, 'direct');
             await dumpDirectRequest({
@@ -443,48 +479,95 @@ async function sendAnthropicRequest(options) {
                 bodyText,
                 url: input.toString(),
                 method: init.method,
-                headers,
+                headers: init.headers,
             });
-            return response;
         }
-        catch (error) {
+        catch (caught) {
+            // No response leaves this send, so its credentials retire here.
+            physical.scope?.dispose();
+            const scope = createProviderErrorResponseScope([secret], 'event-stream');
+            const error = scope.redactError(caught);
+            scope.dispose();
             await dumpDirectRequest({
                 affinity: relayAffinity,
                 route: options.route ??
                     (options.apiAccount ? `api:${options.apiAccount.id}` : 'oauth'),
-                error: errorText(error),
+                // A fixed label: the error text can repeat provider output or a credential.
+                error: PHYSICAL_SEND_FAILED,
                 bodyText,
                 url: input.toString(),
                 method: init.method,
-                headers,
+                headers: init.headers,
             });
             throw error;
         }
+        if (apiSubject && response.ok) {
+            const subject = apiSubject;
+            native.usagePublications.publish(() => servingRuntime.publishApi(subject, { lastUsed: Date.now() }));
+        }
+        if (attempt && response.ok)
+            markServed(attempt);
+        return response;
     };
     if (options.apiAccount)
         return directFetch();
-    return sendViaRelay({
-        config: getRelayConfig(storage),
+    let relay401Attempt;
+    let relayAttempt;
+    const relayReports = [];
+    // The relay scrubs each physical relay attempt's responses and errors with
+    // that attempt's own credentials and the relay token; a direct fallback is
+    // scrubbed by directFetch.
+    const sendRelayAttempt = async () => sendViaRelay({
+        config: await (await native.service()).getRelayConfig(),
         input,
         init,
         headers,
         body: bodyText,
         fallback: directFetch,
         affinity: relayAffinity,
-        authorizeAttempt: scoped
-            ? async () => {
-                const attempt = await scoped.authorize(routeId, options.streamOptions?.signal);
-                const authorizedHeaders = new Headers(headers);
-                authorizedHeaders.set('authorization', `Bearer ${attempt.accessToken}`);
-                return {
-                    headers: authorizedHeaders,
-                    onUpstreamStatus: (status) => {
-                        void report(attempt, status, 'relay_status_field');
-                    },
-                };
-            }
-            : undefined,
+        authorizeAttempt: async () => {
+            const attempt = await takeAttempt();
+            relayAttempt = attempt;
+            lastTransport = 'relay';
+            const authorizedHeaders = new Headers(headers);
+            const access = piAttemptAccessToken(attempt);
+            authorizedHeaders.set('authorization', `Bearer ${access}`);
+            return {
+                headers: authorizedHeaders,
+                errorSecrets: [access],
+                onUpstreamStatus: (status) => {
+                    if (status === 401) {
+                        relay401Attempt = attempt;
+                        // The relay can report an upstream 401 after returning the streaming response.
+                        relayReports.push(report(attempt, status, 'relay_status_field'));
+                    }
+                },
+            };
+        },
     });
+    let response = await sendRelayAttempt();
+    await Promise.all(relayReports);
+    if (relay401Attempt &&
+        response.status === 401 &&
+        !retried401 &&
+        !init.signal?.aborted) {
+        const rotated = await native
+            .retry(routeId, relay401Attempt, init.signal ?? undefined, options.model.id)
+            .catch(() => undefined);
+        if (rotated) {
+            retried401 = true;
+            await response.body?.cancel().catch(() => { });
+            // Use the replacement credential only for the retried relay request.
+            // A direct request after relay failure obtains its own authorization.
+            nextAttempt = rotated;
+            relay401Attempt = undefined;
+            response = await sendRelayAttempt();
+            await Promise.all(relayReports);
+        }
+    }
+    if (response.ok && lastTransport === 'relay' && relayAttempt)
+        markServed(relayAttempt);
+    return response;
 }
 function quotaSnapshotIsExhausted(quota) {
     return ['five_hour', 'seven_day'].some((key) => (quota?.[key]?.remainingPercent ?? 1) <= 0);
@@ -493,55 +576,154 @@ export function primaryResponseAllowsApiFallback(preflight) {
     return (preflight === 'rate_limit_error' ||
         (preflight instanceof Response && preflight.status === 429));
 }
-async function firstStreamingError(response) {
-    if (!response.ok)
-        return response;
-    const clone = response.clone();
+/**
+ * Bytes read while looking for a successful stream's first event. Comments
+ * and heartbeats carry no event, so a stream of them alone must not keep the
+ * inspection reading (and buffering) without end.
+ */
+const FIRST_EVENT_INSPECTION_BYTES = 65_536;
+/**
+ * Classify a successful stream by its first event without a tee: the bytes
+ * read are replayed in front of the rest of the body, so cancelling the
+ * returned response cancels the provider body itself. `preflight` is
+ * `rate_limit_error` for a streamed rate limit (the provider body is then
+ * cancelled and only the bytes read are replayed), else the returned
+ * response. A stream whose first event does not arrive within the budget, or
+ * cannot be read, is returned unclassified.
+ */
+export async function firstStreamingError(response) {
+    if (!response.ok || !response.body)
+        return { response, preflight: response };
+    const reader = response.body.getReader();
+    const chunks = [];
+    const framer = createSseFramer({
+        maxFrameBytes: FIRST_EVENT_INSPECTION_BYTES,
+    });
+    let bytes = 0;
+    let rateLimited = false;
+    let decided = false;
+    // Only the stream's first frame may drop a leading byte-order mark.
+    let streamStart = true;
     try {
-        for await (const event of parseSse(clone)) {
-            if (event.type === 'error' &&
-                typeof event.delta?.type === 'string' &&
-                event.delta.type === 'rate_limit_error') {
-                return 'rate_limit_error';
+        while (!decided && bytes < FIRST_EVENT_INSPECTION_BYTES) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            chunks.push(value);
+            bytes += value.byteLength;
+            for (const frame of framer.push(value)) {
+                const data = parseSseFrame(decodeSseFrame(frame, { streamStart })).data;
+                streamStart = false;
+                if (!data || data === '[DONE]')
+                    continue;
+                const event = JSON.parse(data);
+                // Anthropic reports a streamed rate limit as an `error` event whose
+                // `error.type` is `rate_limit_error`; only that event is a rate limit.
+                rateLimited =
+                    event.type === 'error' && event.error?.type === 'rate_limit_error';
+                decided = true;
+                break;
             }
-            return response;
         }
     }
     catch {
-        return response;
+        // An unreadable body, an oversized first frame or a first event that is
+        // not JSON is not treated as a rate limit: the response is returned for
+        // the consumer to read, and an unreadable body fails that read too.
     }
-    return response;
+    // The provider reader is released as soon as nothing will read it again:
+    // at end of stream, after a read failure, or once a cancellation settles.
+    const release = () => {
+        try {
+            reader.releaseLock();
+        }
+        catch {
+            // Already released.
+        }
+    };
+    const replay = (rest) => new Response(new ReadableStream({
+        start(controller) {
+            for (const chunk of chunks)
+                controller.enqueue(chunk);
+            if (!rest)
+                controller.close();
+        },
+        async pull(controller) {
+            let next;
+            try {
+                next = await reader.read();
+            }
+            catch (error) {
+                release();
+                throw error;
+            }
+            if (next.done) {
+                release();
+                controller.close();
+            }
+            else
+                controller.enqueue(next.value);
+        },
+        async cancel(reason) {
+            if (!rest)
+                return;
+            try {
+                await reader.cancel(reason);
+            }
+            finally {
+                release();
+            }
+        },
+    }), {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+    });
+    if (rateLimited) {
+        // Routing replaces this response. Cancel the provider body and clear its
+        // copied redaction material; retain the inspected error event for callers
+        // that still return the replay response.
+        await reader.cancel().catch(() => { });
+        release();
+        return { response: replay(false), preflight: 'rate_limit_error' };
+    }
+    const inspected = replay(true);
+    return { response: inspected, preflight: inspected };
 }
 async function executeWithFallback(options) {
-    await ensurePiMainAccountId(options.storagePath);
-    let storage = await loadAccounts(options.storagePath);
-    const scoped = getClaustrumMode(storage) === 'claustrum'
-        ? getPiScopedRuntime(options.storagePath)
-        : undefined;
-    let roster = scoped ? await scoped.refresh() : undefined;
-    if (scoped && !roster)
-        throw new Error('Claustrum custody changed during request preparation');
-    if (roster)
-        storage = roster.storage;
-    const primaryCredential = scoped ? '' : options.primaryAccessToken;
-    const scopedReady = (account) => Boolean(scoped &&
-        account.enabled !== false &&
-        account.claustrumScopedCredentialId &&
-        account.claustrumScopedState === 'active');
-    const primaryAvailable = () => !scoped ||
-        (roster?.primary?.state === 'active' &&
-            !storage?.claustrum?.disabledAccountIdentities?.includes(roster.primary.accountId));
-    const { quotaManager, fallbackManager: manager } = getPiRoutingServices(options.storagePath, storage);
-    let mainAccountId = scoped
-        ? roster?.primary?.accountId
-        : storage?.mainAccountId;
+    const native = getPiNativeRuntime(options.storagePath);
+    let snapshot = await native.requestView(options.streamOptions?.signal);
+    let storage = snapshot.policyStorage;
+    const accountView = (id) => snapshot.accounts.find((account) => account.id === id);
+    const vaultAccountIdentities = () => {
+        if (snapshot.mode !== 'claustrum')
+            return undefined;
+        const identities = new Map();
+        for (const account of snapshot.accounts) {
+            if (account.source === 'vault' && account.accountIdentity)
+                identities.set(account.id, account.accountIdentity);
+        }
+        return identities;
+    };
+    const nativeReady = (id) => {
+        const account = accountView(id);
+        return Boolean(account?.type === 'oauth' &&
+            account.enabled &&
+            (account.source !== 'vault' || account.state === 'active') &&
+            !isPermanentRefreshError(account.lastRefreshError) &&
+            (account.source !== 'local' ||
+                (account.lastRefreshError?.nextRetryAt ?? 0) <= Date.now()));
+    };
+    const primaryAvailable = () => nativeReady(STICKY_ROUTING_MAIN_ACCOUNT_ID);
+    let { quotaManager, getUsableFallbackAccounts } = getPiRoutingServices(options.storagePath, snapshot);
+    let mainAccountId = accountView(STICKY_ROUTING_MAIN_ACCOUNT_ID)?.accountIdentity;
     quotaManager.seedMainFromStorage(storage, mainAccountId);
     quotaManager.seedFallbacksFromAccounts((storage?.accounts ?? []).filter(isOAuthAccount));
     function quotaObservationIsFresh(quota, modelId) {
         if (stickyQuotaSnapshotIsFresh(quota, storage, Date.now(), modelId))
             return true;
-        // A successful windowless usage response is not the same as a failed
-        // probe. Pi intentionally admits the former as unknown-capacity OAuth.
+        // A successful usage response without quota windows is not a failed poll.
+        // Pi can serve that OAuth account without a known remaining capacity.
         if (!quota ||
             quota.five_hour ||
             quota.seven_day ||
@@ -553,37 +735,33 @@ async function executeWithFallback(options) {
         return (Date.now() - quota.checkedAt < age &&
             (!scopedWindow || Date.now() - scopedWindow.checkedAt < age));
     }
+    async function refreshRoutingSnapshot() {
+        snapshot = await native.view();
+        storage = snapshot.policyStorage;
+        mainAccountId = accountView(STICKY_ROUTING_MAIN_ACCOUNT_ID)?.accountIdentity;
+        ({ quotaManager, getUsableFallbackAccounts } = getPiRoutingServices(options.storagePath, snapshot));
+        quotaManager.seedMainFromStorage(storage, mainAccountId);
+        quotaManager.seedFallbacksFromAccounts(storage.accounts.filter(isOAuthAccount));
+    }
     async function buildStickyRoutes(modelId) {
-        if (scoped) {
-            roster = await scoped.refresh();
-            if (!roster)
-                throw new Error('Claustrum custody changed during routing');
-            storage = roster.storage;
-            mainAccountId = roster.primary?.accountId;
-            quotaManager.updateStorage(storage);
-            quotaManager.seedMainFromStorage(storage, mainAccountId);
-            quotaManager.seedFallbacksFromAccounts(storage.accounts.filter(isOAuthAccount));
-        }
+        await refreshRoutingSnapshot();
         const mainEntry = quotaManager.getMain(mainAccountId);
         let mainQuota = mainEntry?.quota;
         if (primaryAvailable() &&
             !stickyQuotaSnapshotIsFresh(mainEntry?.quota, storage, Date.now(), modelId)) {
             try {
-                mainQuota = await quotaManager.refreshMain(mainAccountId, primaryCredential);
+                mainQuota = await quotaManager.refreshMain(mainAccountId, '');
             }
             catch { }
         }
-        const usableFallbacks = await manager.getUsableFallbackAccounts(storage, {
+        const usableFallbacks = await getUsableFallbackAccounts(storage, {
             modelId,
         });
         const usableById = new Map(usableFallbacks.map((account) => [account.id, account]));
         const allRoutes = [];
-        if (primaryAvailable() &&
-            (scoped ||
-                !isPermanentRefreshError(storage?.refresh?.mainLastRefreshError))) {
+        if (primaryAvailable()) {
             allRoutes.push({
                 id: STICKY_ROUTING_MAIN_ACCOUNT_ID,
-                access: primaryCredential,
                 quota: mainQuota,
                 order: 0,
             });
@@ -592,20 +770,17 @@ async function executeWithFallback(options) {
             if (configured.enabled === false || !isOAuthAccount(configured))
                 continue;
             const account = usableById.get(configured.id) ?? configured;
-            if (scoped
-                ? !scopedReady(account)
-                : !account.access || isPermanentRefreshError(account.lastRefreshError))
+            if (!nativeReady(account.id))
                 continue;
             let accountQuota = quotaManager.getFallback(account.id, account)?.quota ?? account.quota;
             if (!stickyQuotaSnapshotIsFresh(accountQuota, storage, Date.now(), modelId)) {
                 try {
-                    accountQuota = await quotaManager.refreshFallback(account.id, scoped ? '' : (account.access ?? ''), account);
+                    accountQuota = await quotaManager.refreshFallback(account.id, '', account);
                 }
                 catch { }
             }
             allRoutes.push({
                 id: account.id,
-                access: scoped ? '' : (account.access ?? ''),
                 quota: accountQuota,
                 order: index + 1,
                 account,
@@ -615,7 +790,7 @@ async function executeWithFallback(options) {
             const refreshError = route.id === STICKY_ROUTING_MAIN_ACCOUNT_ID
                 ? storage?.refresh?.mainLastRefreshError
                 : route.account?.lastRefreshError;
-            if (!scoped && isPermanentRefreshError(refreshError))
+            if (isPermanentRefreshError(refreshError))
                 return [];
             if (stickyQuotaSnapshotIsFresh(route.quota, storage, Date.now(), modelId) &&
                 decideStickyQuotaFailure({ quota: route.quota, modelId }).action ===
@@ -658,10 +833,11 @@ async function executeWithFallback(options) {
         return { allRoutes, candidates, retainAccountIds };
     }
     async function primaryQuotaRefreshConfirmsExhausted() {
-        if (!primaryAvailable())
+        await refreshRoutingSnapshot();
+        if (!primaryAvailable() || !mainAccountId)
             return false;
         try {
-            const quota = await quotaManager.refreshMain(mainAccountId, primaryCredential);
+            const quota = await quotaManager.refreshMain(mainAccountId, '');
             const entry = quotaManager.getMain(mainAccountId);
             return Boolean(entry &&
                 entry.refreshAfter > Date.now() &&
@@ -672,10 +848,11 @@ async function executeWithFallback(options) {
         }
     }
     async function primaryQuotaRefreshConfirmsModelScopeExhausted() {
+        await refreshRoutingSnapshot();
         if (!primaryAvailable())
             return false;
         try {
-            const quota = await quotaManager.refreshMain(mainAccountId, primaryCredential);
+            const quota = await quotaManager.refreshMain(mainAccountId, '');
             const entry = quotaManager.getMain(mainAccountId);
             return Boolean(entry &&
                 entry.refreshAfter > Date.now() &&
@@ -701,56 +878,36 @@ async function executeWithFallback(options) {
             quotaSnapshotModelScopeIsExhausted(entry.quota, options.model.id));
     }
     async function tryFallbackAccounts(routeOptions = {}) {
-        const usableOAuth = await manager.getUsableFallbackAccounts(storage, {
+        const usableOAuth = await getUsableFallbackAccounts(storage, {
             modelId: options.model.id,
         });
         const usableOAuthById = new Map(usableOAuth.map((account) => [account.id, account]));
-        for (const configured of storage?.accounts ?? []) {
+        for (const configured of storage.accounts) {
             if (configured.enabled === false)
                 continue;
-            let response = null;
-            let account = isOAuthAccount(configured)
-                ? usableOAuthById.get(configured.id)
-                : configured;
-            if (!account) {
-                if (!isOAuthAccount(configured) ||
-                    (scoped
-                        ? !scopedReady(configured)
-                        : !configured.access ||
-                            (configured.expires !== undefined &&
-                                configured.expires <= Date.now()) ||
-                            isPermanentRefreshError(configured.lastRefreshError) ||
-                            refreshBackoffActive(configured.lastRefreshError, configured.id, Date.now(), tokenFingerprint(configured.refresh))))
+            let response;
+            if (isOAuthAccount(configured)) {
+                if (routeOptions.apiOnly || !nativeReady(configured.id))
                     continue;
-                account = configured;
-                const quota = quotaManager.getFallback(configured.id, configured)?.quota ??
-                    configured.quota;
-                if (quotaSnapshotHasStandardWindows(quota))
+                const account = usableOAuthById.get(configured.id) ?? configured;
+                const quota = quotaManager.getFallback(account.id, account)?.quota ?? account.quota;
+                if (!usableOAuthById.has(account.id) &&
+                    quotaSnapshotHasStandardWindows(quota))
                     continue;
                 if (isKillswitchEnabled(storage) &&
-                    !killswitchPassesPolicy(quota, storage, configured.id, options.model.id))
-                    continue;
-            }
-            else if (isOAuthAccount(account) &&
-                isKillswitchEnabled(storage) &&
-                !killswitchPassesPolicy(quotaManager.getFallback(account.id, account)?.quota ?? account.quota, storage, account.id, options.model.id)) {
-                continue;
-            }
-            if (isOAuthAccount(account)) {
-                if (routeOptions.apiOnly === true ||
-                    (scoped ? !scopedReady(account) : !account.access))
+                    !killswitchPassesPolicy(quota, storage, account.id, options.model.id))
                     continue;
                 response = await sendAnthropicRequest({
                     ...options,
-                    accessToken: scoped ? undefined : account.access,
                     oauthAccountId: account.id,
                 });
             }
-            else if (routeOptions.includeApiRoutes === true &&
-                isApiKeyAccount(account) &&
-                account.enabled !== false &&
-                account.apiKey &&
-                isValidApiBaseURL(account.baseURL)) {
+            else if (routeOptions.includeApiRoutes) {
+                const account = accountView(configured.id);
+                if (!account?.enabled ||
+                    account.type !== 'api' ||
+                    !isValidApiBaseURL(account.baseURL))
+                    continue;
                 response = await sendAnthropicRequest({
                     ...options,
                     apiAccount: account,
@@ -758,28 +915,24 @@ async function executeWithFallback(options) {
             }
             if (!response)
                 continue;
-            const preflight = await firstStreamingError(response);
-            if (preflight instanceof Response && preflight.ok) {
-                await manager.markUsed(account);
+            const inspected = await firstStreamingError(response);
+            const preflight = inspected.preflight;
+            if (preflight instanceof Response && preflight.ok)
                 return preflight;
-            }
             if (preflight instanceof Response &&
-                !shouldFallbackStatus(preflight.status, storage)) {
+                !shouldFallbackStatus(preflight.status, storage))
                 return preflight;
-            }
-            await response.body?.cancel().catch(() => { });
+            await inspected.response.body?.cancel().catch(() => { });
         }
         return null;
     }
     const routingMode = getRoutingMode(storage);
     if (routingMode === 'sticky-balanced' && options.streamOptions?.sessionId) {
         const sessionId = options.streamOptions.sessionId;
-        const router = getPiStickyRouter(options.storagePath);
+        const router = await getPiStickyRouter(options.storagePath);
         const initialInputBytes = Math.max(1, Buffer.byteLength(JSON.stringify(options.context)));
         let routes = await buildStickyRoutes(options.model.id);
-        const mainPermanentlyUnavailable = scoped
-            ? !primaryAvailable()
-            : isPermanentRefreshError(storage?.refresh?.mainLastRefreshError);
+        const mainPermanentlyUnavailable = !primaryAvailable();
         const incompleteQuotaPool = (routes.allRoutes.length === 0 && !mainPermanentlyUnavailable) ||
             routes.allRoutes.some((candidate) => !quotaObservationIsFresh(candidate.quota, options.model.id));
         let resolution = await router.resolve({
@@ -787,10 +940,11 @@ async function executeWithFallback(options) {
             family: stickyRouteFamilyForModel(options.model.id),
             modelId: options.model.id,
             affinityModelId: options.model.id,
-            // Existing affinity can survive a transient probe failure, but an
-            // incomplete pool cannot create a new balanced assignment.
+            // Keep an existing route after a temporary quota poll failure, but do not
+            // choose a new balanced route until the account pool has current quota data.
             candidates: incompleteQuotaPool ? [] : routes.candidates,
             retainAccountIds: routes.retainAccountIds,
+            accountIdentities: vaultAccountIdentities(),
             storage,
             inputBytes: initialInputBytes,
         });
@@ -803,10 +957,10 @@ async function executeWithFallback(options) {
             throw error;
         }
         if (!resolution) {
+            if (snapshot.mode === 'claustrum')
+                throw new NativeVaultNoAccountError();
             return createStickyNoRouteResponse({
-                mainRefreshError: scoped
-                    ? undefined
-                    : storage?.refresh?.mainLastRefreshError,
+                mainRefreshError: storage?.refresh?.mainLastRefreshError,
                 fallbackReauthLabels: getFallbackReauthLabels(storage),
                 routeQuotas: routes.allRoutes.flatMap((route) => route.quota ? [route.quota] : []),
                 modelId: options.model.id,
@@ -816,15 +970,10 @@ async function executeWithFallback(options) {
         if (resolution && route) {
             const sendRoute = (selected) => sendAnthropicRequest({
                 ...options,
-                accessToken: selected.access,
                 oauthAccountId: selected.id,
                 route: `sticky:${selected.id}`,
             });
-            const completeRoute = async (selected, response, markUsed = true) => {
-                if (markUsed && selected.account)
-                    await manager.markUsed(selected.account);
-                return response;
-            };
+            const completeRoute = async (_selected, response, _markUsed = true) => response;
             const proactiveQuotaDecision = stickyQuotaSnapshotIsFresh(route.quota, storage, Date.now(), options.model.id)
                 ? decideStickyQuotaFailure({
                     quota: route.quota,
@@ -846,44 +995,11 @@ async function executeWithFallback(options) {
                     },
                 }), false);
             }
-            let response = await sendRoute(route);
-            let preflight = await firstStreamingError(response);
+            const { response, preflight } = await firstStreamingError(await sendRoute(route));
             if (preflight instanceof Response && preflight.ok) {
                 return completeRoute(route, preflight);
             }
-            let permanentAuthFailure = preflight instanceof Response &&
-                preflight.status === 401 &&
-                (Boolean(scoped) || route.id === STICKY_ROUTING_MAIN_ACCOUNT_ID);
-            if (preflight instanceof Response &&
-                preflight.status === 401 &&
-                route.account &&
-                storage &&
-                !scoped) {
-                const authRouteId = route.id;
-                try {
-                    const refreshed = await manager.refreshAccount(route.account, storage, {
-                        force: true,
-                    });
-                    if (refreshed.access) {
-                        route = { ...route, access: refreshed.access, account: refreshed };
-                    }
-                    await preflight.body?.cancel().catch(() => { });
-                    response = await sendRoute(route);
-                    preflight = await firstStreamingError(response);
-                    if (preflight instanceof Response && preflight.ok) {
-                        return completeRoute(route, preflight);
-                    }
-                    permanentAuthFailure =
-                        preflight instanceof Response && preflight.status === 401;
-                }
-                catch (error) {
-                    const latest = await loadAccounts(options.storagePath);
-                    const refreshError = latest?.accounts.find((account) => account.id === authRouteId && isOAuthAccount(account))?.lastRefreshError;
-                    if (!isPermanentRefreshError(refreshError))
-                        throw error;
-                    permanentAuthFailure = true;
-                }
-            }
+            const permanentAuthFailure = preflight instanceof Response && preflight.status === 401;
             let migrate = (preflight instanceof Response && preflight.status === 403) ||
                 permanentAuthFailure;
             if (primaryResponseAllowsApiFallback(preflight)) {
@@ -891,8 +1007,8 @@ async function executeWithFallback(options) {
                 try {
                     quota =
                         route.id === STICKY_ROUTING_MAIN_ACCOUNT_ID
-                            ? await quotaManager.refreshMain(mainAccountId, route.access)
-                            : await quotaManager.refreshFallback(route.id, route.access, route.account);
+                            ? await quotaManager.refreshMain(mainAccountId, '')
+                            : await quotaManager.refreshFallback(route.id, '', route.account);
                 }
                 catch {
                     // Retain affinity when the quota probe itself is unavailable.
@@ -942,6 +1058,7 @@ async function executeWithFallback(options) {
                         modelId: options.model.id,
                         candidates: routes.candidates,
                         retainAccountIds: routes.retainAccountIds,
+                        accountIdentities: vaultAccountIdentities(),
                         storage,
                         inputBytes: initialInputBytes,
                         excludeAccountIds: new Set([failedRouteId]),
@@ -990,6 +1107,8 @@ async function executeWithFallback(options) {
             if (fallback)
                 return fallback;
         }
+        if (snapshot.mode === 'claustrum')
+            throw new NativeVaultNoAccountError();
         return createStickyNoRouteResponse({
             routeQuotas: (storage?.accounts ?? [])
                 .filter(isOAuthAccount)
@@ -1001,7 +1120,7 @@ async function executeWithFallback(options) {
         let mainQuota = quotaManager.getMain(mainAccountId)?.quota;
         if (!mainQuota || quotaManager.isMainStale(options.model.id)) {
             try {
-                mainQuota = await quotaManager.refreshMain(mainAccountId, primaryCredential);
+                mainQuota = await quotaManager.refreshMain(mainAccountId, '');
             }
             catch { }
         }
@@ -1026,12 +1145,10 @@ async function executeWithFallback(options) {
             });
         }
     }
-    const primary = await sendAnthropicRequest({
+    const { response: primary, preflight: primaryPreflight } = await firstStreamingError(await sendAnthropicRequest({
         ...options,
-        accessToken: primaryCredential,
         oauthAccountId: STICKY_ROUTING_MAIN_ACCOUNT_ID,
-    });
-    const primaryPreflight = await firstStreamingError(primary);
+    }));
     if (primaryPreflight instanceof Response) {
         if (!shouldFallbackStatus(primaryPreflight.status, storage))
             return primaryPreflight;
@@ -1059,18 +1176,18 @@ export function streamCortexKitAnthropic(model, context, options, effortTransiti
         const output = createOutput(model);
         stream.push({ type: 'start', partial: output });
         try {
-            const accessToken = options?.apiKey ?? '';
+            buildPiOAuthMessagesUrl(model.baseUrl);
             const storagePath = getPiAccountStoragePath();
-            if (!accessToken &&
-                getClaustrumMode(await loadAccounts(storagePath)) !== 'claustrum')
-                throw new Error('Missing Anthropic OAuth access token');
+            let hostTools = [];
             const response = await executeWithFallback({
                 model,
                 context,
                 streamOptions: options,
-                primaryAccessToken: accessToken,
                 storagePath,
                 effortTransitions,
+                onResolvedTools: (tools) => {
+                    hostTools = tools;
+                },
             });
             if (!response.ok) {
                 throw new Error(`Anthropic request failed: HTTP ${response.status} ${await response.text()}`);
@@ -1125,7 +1242,7 @@ export function streamCortexKitAnthropic(model, context, options, effortTransiti
                         output.content.push({
                             type: 'toolCall',
                             id: String(block.id),
-                            name: fromClaudeCodeToolName(String(block.name), context.tools),
+                            name: fromClaudeCodeToolName(String(block.name), hostTools),
                             arguments: {},
                             partialJson: '',
                             index: event.index,