@cortexkit/pi-anthropic-auth 1.20.0 → 1.21.0

package/dist/convert.js

@@ -3,6 +3,10 @@ import { applyClaudeCodeMetadata, buildBillingHeaderValue, CLAUDE_CODE_ENTRYPOIN
 // that Anthropic currently rejects in system[]. Unknown prompt shapes take the
 // service-preserving fallback below instead of returning the full prompt there.
 const PI_DOCS_ANCHOR = 'Pi documentation';
+const ANTHROPIC_REPLAY_APIS = new Set([
+    'anthropic-messages',
+    'cortexkit-anthropic-messages',
+]);
 const CLAUDE_CODE_TOOLS = new Map([
     'Read',
     'Write',
@@ -105,7 +109,7 @@ function convertTextAndImages(content) {
     }
     return blocks;
 }
-function convertMessages(messages) {
+function convertMessages(messages, targetModelId) {
     const result = [];
     for (let index = 0; index < messages.length; index++) {
         const message = messages[index];
@@ -140,33 +144,63 @@ function convertMessages(messages) {
                 if (block.type === 'text' && block.text.trim()) {
                     blocks.push({ type: 'text', text: sanitize(block.text) });
                 }
-                else if (block.type === 'thinking' && block.thinking.trim()) {
+                else if (block.type === 'thinking') {
                     const thinking = block;
-                    if (isOpenAIReasoningSignature(thinking.thinkingSignature)) {
-                        // OpenAI reasoningEncryptedContent is also opaque encrypted state,
-                        // but it is not an Anthropic thinking signature. Sending it as
-                        // `thinking.signature` makes Anthropic reject the request.
+                    const signature = thinking.thinkingSignature;
+                    const hasSignature = typeof signature === 'string' && signature.trim().length > 0;
+                    const signatureBelongsToTarget = message.provider === 'anthropic' &&
+                        ANTHROPIC_REPLAY_APIS.has(message.api) &&
+                        message.model === targetModelId &&
+                        !isOpenAIReasoningSignature(signature);
+                    // Match Pi's built-in origin check: only replay signatures from the
+                    // same Anthropic API/model. Preserve visible foreign reasoning as
+                    // ordinary text, but drop opaque redacted/OpenAI encrypted state.
+                    if (hasSignature && !signatureBelongsToTarget) {
+                        if (!thinking.redacted &&
+                            !isOpenAIReasoningSignature(signature) &&
+                            thinking.thinking.trim()) {
+                            blocks.push({ type: 'text', text: sanitize(thinking.thinking) });
+                        }
                         continue;
                     }
-                    if (thinking.thinkingSignature &&
-                        !hasLoneSurrogate(thinking.thinking)) {
-                        // Signed thinking blocks must be sent back verbatim — the signature
-                        // is computed over the original text. Sanitizing would alter it and
-                        // Anthropic rejects the block as "modified". Anthropic-origin
-                        // thinking is valid UTF-8, so this is the normal path.
+                    if (thinking.redacted) {
+                        if (hasSignature) {
+                            blocks.push({
+                                type: 'redacted_thinking',
+                                data: signature,
+                            });
+                        }
+                        continue;
+                    }
+                    if (!hasSignature) {
+                        // Anthropic rejects unsigned thinking blocks. Preserve readable
+                        // output from interrupted streams as ordinary assistant text.
+                        if (thinking.thinking.trim()) {
+                            blocks.push({
+                                type: 'text',
+                                text: sanitize(thinking.thinking),
+                            });
+                        }
+                        continue;
+                    }
+                    if (hasLoneSurrogate(thinking.thinking)) {
+                        // Signature authenticates the thinking bytes exactly. Sanitizing the
+                        // text would invalidate it, so downgrade malformed signed thinking
+                        // to plain text and omit the signature instead.
+                        if (thinking.thinking.trim()) {
+                            blocks.push({
+                                type: 'text',
+                                text: sanitize(thinking.thinking),
+                            });
+                        }
+                    }
+                    else {
                         blocks.push({
                             type: 'thinking',
                             thinking: thinking.thinking,
-                            signature: thinking.thinkingSignature,
+                            signature,
                         });
                     }
-                    else {
-                        // Either unsigned, or signed-but-contains a lone surrogate. In the
-                        // latter case we cannot keep the signature: sanitizing breaks it and
-                        // sending the raw lone surrogate is an invalid-UTF8 400. Drop the
-                        // signature and downgrade to sanitized text.
-                        blocks.push({ type: 'text', text: sanitize(thinking.thinking) });
-                    }
                 }
                 else if (block.type === 'toolCall') {
                     blocks.push({
@@ -318,7 +352,7 @@ function applyCacheMode(body, enabled, mode) {
     addTtl(body);
 }
 export async function buildAnthropicRequest(modelId, context, options, cache, fastModeEnabled = false, identity) {
-    const messages = convertMessages(context.messages);
+    const messages = convertMessages(context.messages, modelId);
     // Strip trailing assistant messages — Anthropic rejects prefill on some models
     while (messages.length &&
         messages[messages.length - 1]?.role === 'assistant') {

package/dist/stream.js

@@ -1,4 +1,4 @@
-import { applyClaudeCodeHeaders, CACHE_KEEP_EXTENDED_TTL_BETA, CacheKeepManager, CacheKeepSessionRegistry, createStickyNoRouteResponse, decideStickyQuotaFailure, dumpDirectRequest, FAST_MODE_BETA, FallbackAccountManager, getCache1hPersistentMode, getDefaultCacheKeepRegistryDirectory, getFallbackReauthLabels, getRelayConfig, getRoutingMode, getStickyRoutingStatePath, isApiKeyAccount, isCache1hPersistentlyEnabled, isCacheKeepHybridActive, isDumpPersistentlyEnabled, isFastModePersistentlyEnabled, isKillswitchEnabled, isOAuthAccount, isPermanentRefreshError, isValidApiBaseURL, killswitchPassesPolicy, loadAccounts, mergeAnthropicBetas, QuotaManager, quotaSnapshotModelScopeIsExhausted, quotaSnapshotPassesModelScope, quotaSnapshotPassesPolicy, resolveClaudeCodeIdentity, STICKY_ROUTING_MAIN_ACCOUNT_ID, StickySessionRouter, sendViaRelay, setDumpEnabled, shouldFallbackStatus, stickyQuotaSnapshotIsFresh, stickyRetryAfterWithJitter, stickyRouteFamilyForModel, } from '@cortexkit/anthropic-auth-core';
+import { applyClaudeCodeHeaders, CACHE_KEEP_EXTENDED_TTL_BETA, CacheKeepManager, CacheKeepSessionRegistry, createStickyNoRouteResponse, decideStickyQuotaFailure, dumpDirectRequest, FAST_MODE_BETA, FallbackAccountManager, getCache1hPersistentMode, getDefaultCacheKeepRegistryDirectory, getFallbackReauthLabels, getOrCreateMainAccountId, getRelayConfig, getRoutingMode, getStickyRoutingStatePath, isApiKeyAccount, isCache1hPersistentlyEnabled, isCacheKeepHybridActive, isDumpPersistentlyEnabled, isFastModePersistentlyEnabled, isKillswitchEnabled, isOAuthAccount, isPermanentRefreshError, isValidApiBaseURL, killswitchPassesPolicy, loadAccounts, mergeAnthropicBetas, QuotaManager, quotaSnapshotHasStandardWindows, quotaSnapshotModelScopeIsExhausted, quotaSnapshotPassesModelScope, quotaSnapshotPassesPolicy, refreshBackoffActive, resolveClaudeCodeIdentity, STICKY_ROUTING_MAIN_ACCOUNT_ID, StickySessionRouter, sendViaRelay, setDumpEnabled, shouldFallbackStatus, stickyQuotaSnapshotIsFresh, stickyRetryAfterWithJitter, stickyRouteFamilyForModel, } from '@cortexkit/anthropic-auth-core';
 import { calculateCost, createAssistantMessageEventStream, } from '@earendil-works/pi-ai';
 import { buildAnthropicRequest, fromClaudeCodeToolName } from './convert.js';
 import { getPiAccountStoragePath } from './paths.js';
@@ -10,6 +10,7 @@ let cacheKeepRegistryDirectory;
 const stickyRouters = new Map();
 const quotaManagers = new Map();
 const fallbackManagers = new Map();
+const mainAccountIdInitializations = new Map();
 const PI_SERVICE_CACHE_LIMIT = 16;
 function setBoundedService(map, key, value) {
     map.delete(key);
@@ -21,6 +22,19 @@ 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);
@@ -71,7 +85,10 @@ const cacheKeepManager = new CacheKeepManager({
             return headers;
         try {
             const body = JSON.parse(target.bodyText);
-            const identity = await resolveClaudeCodeIdentity(accessToken, typeof body.model === 'string' ? body.model : undefined);
+            const storagePath = getPiAccountStoragePath();
+            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 });
             headers.set('anthropic-beta', mergeAnthropicBetas(headers.get('anthropic-beta'), [
@@ -201,10 +218,14 @@ export async function* parseSse(response) {
     }
 }
 async function sendAnthropicRequest(options) {
+    await ensurePiMainAccountId(options.storagePath);
     const storage = await loadAccounts(options.storagePath);
     setDumpEnabled(isDumpPersistentlyEnabled(storage));
+    const accountIdentity = options.oauthAccountId === STICKY_ROUTING_MAIN_ACCOUNT_ID
+        ? storage?.mainAccountId
+        : options.oauthAccountId;
     const identity = options.accessToken
-        ? await resolveClaudeCodeIdentity(options.accessToken, options.model.id)
+        ? await resolveClaudeCodeIdentity(options.accessToken, options.model.id, accountIdentity)
         : undefined;
     const { body, bodyText } = await buildAnthropicRequest(options.model.id, options.context, options.streamOptions, {
         enabled: isCache1hPersistentlyEnabled(storage),
@@ -307,16 +328,18 @@ async function firstStreamingError(response) {
     return response;
 }
 async function executeWithFallback(options) {
+    await ensurePiMainAccountId(options.storagePath);
     const storage = await loadAccounts(options.storagePath);
     const { quotaManager, fallbackManager: manager } = getPiRoutingServices(options.storagePath, storage);
-    quotaManager.seedMainFromStorage(storage, options.primaryAccessToken);
+    const mainAccountId = storage?.mainAccountId;
+    quotaManager.seedMainFromStorage(storage, mainAccountId);
     quotaManager.seedFallbacksFromAccounts((storage?.accounts ?? []).filter(isOAuthAccount));
     async function buildStickyRoutes(modelId) {
-        const mainEntry = quotaManager.getMain(options.primaryAccessToken);
+        const mainEntry = quotaManager.getMain(mainAccountId);
         let mainQuota = mainEntry?.quota;
         if (!stickyQuotaSnapshotIsFresh(mainEntry?.quota, storage, Date.now(), modelId)) {
             try {
-                mainQuota = await quotaManager.refreshMain(options.primaryAccessToken);
+                mainQuota = await quotaManager.refreshMain(mainAccountId, options.primaryAccessToken);
             }
             catch { }
         }
@@ -339,11 +362,10 @@ async function executeWithFallback(options) {
             const account = usableById.get(configured.id) ?? configured;
             if (!account.access || isPermanentRefreshError(account.lastRefreshError))
                 continue;
-            let accountQuota = quotaManager.getFallback(account.id, account.access)?.quota ??
-                account.quota;
+            let accountQuota = quotaManager.getFallback(account.id, account)?.quota ?? account.quota;
             if (!stickyQuotaSnapshotIsFresh(accountQuota, storage, Date.now(), modelId)) {
                 try {
-                    accountQuota = await quotaManager.refreshFallback(account.id, account.access);
+                    accountQuota = await quotaManager.refreshFallback(account.id, account.access, account);
                 }
                 catch { }
             }
@@ -374,19 +396,26 @@ async function executeWithFallback(options) {
         }));
         const usableIds = new Set(usableFallbacks.map((account) => account.id));
         const candidates = allRoutes.flatMap((route) => {
-            if (!route.quota)
-                return [];
+            const quota = quotaSnapshotHasStandardWindows(route.quota)
+                ? route.quota
+                : undefined;
             const accountId = route.id === STICKY_ROUTING_MAIN_ACCOUNT_ID ? undefined : route.id;
-            const passes = quotaSnapshotPassesPolicy(route.quota, storage) &&
-                quotaSnapshotPassesModelScope(route.quota, modelId) &&
-                (!isKillswitchEnabled(storage) ||
-                    killswitchPassesPolicy(route.quota, storage, accountId, modelId)) &&
-                (route.id === STICKY_ROUTING_MAIN_ACCOUNT_ID || usableIds.has(route.id));
+            const quotaState = quota
+                ? { kind: 'known', quota }
+                : { kind: 'unknown' };
+            const passesKillswitch = !isKillswitchEnabled(storage) ||
+                killswitchPassesPolicy(quotaState.kind === 'known' ? quotaState.quota : undefined, storage, accountId, modelId);
+            const passes = passesKillswitch &&
+                (quotaState.kind === 'unknown' ||
+                    (quotaSnapshotPassesPolicy(quotaState.quota, storage) &&
+                        quotaSnapshotPassesModelScope(quotaState.quota, modelId) &&
+                        (route.id === STICKY_ROUTING_MAIN_ACCOUNT_ID ||
+                            usableIds.has(route.id))));
             return passes
                 ? [
                     {
                         accountId: route.id,
-                        quota: route.quota,
+                        quota: quotaState,
                         order: route.order,
                     },
                 ]
@@ -396,8 +425,8 @@ async function executeWithFallback(options) {
     }
     async function primaryQuotaRefreshConfirmsExhausted() {
         try {
-            const quota = await quotaManager.refreshMain(options.primaryAccessToken);
-            const entry = quotaManager.getMain(options.primaryAccessToken);
+            const quota = await quotaManager.refreshMain(mainAccountId, options.primaryAccessToken);
+            const entry = quotaManager.getMain(mainAccountId);
             return Boolean(entry &&
                 entry.refreshAfter > Date.now() &&
                 quotaSnapshotIsExhausted(quota));
@@ -408,8 +437,8 @@ async function executeWithFallback(options) {
     }
     async function primaryQuotaRefreshConfirmsModelScopeExhausted() {
         try {
-            const quota = await quotaManager.refreshMain(options.primaryAccessToken);
-            const entry = quotaManager.getMain(options.primaryAccessToken);
+            const quota = await quotaManager.refreshMain(mainAccountId, options.primaryAccessToken);
+            const entry = quotaManager.getMain(mainAccountId);
             return Boolean(entry &&
                 entry.refreshAfter > Date.now() &&
                 quotaSnapshotModelScopeIsExhausted(quota, options.model.id));
@@ -419,12 +448,12 @@ async function executeWithFallback(options) {
         }
     }
     function primaryCachedModelScopeExhausted() {
-        const entry = quotaManager.getMain(options.primaryAccessToken);
+        const entry = quotaManager.getMain(mainAccountId);
         return Boolean(entry &&
             quotaSnapshotModelScopeIsExhausted(entry.quota, options.model.id));
     }
     function primaryFreshModelScopeExhausted() {
-        const entry = quotaManager.getMain(options.primaryAccessToken);
+        const entry = quotaManager.getMain(mainAccountId);
         return Boolean(entry &&
             !quotaManager.isMainStale(options.model.id) &&
             quotaSnapshotModelScopeIsExhausted(entry.quota, options.model.id));
@@ -436,17 +465,38 @@ async function executeWithFallback(options) {
         const usableOAuthById = new Map(usableOAuth.map((account) => [account.id, account]));
         for (const configured of storage?.accounts ?? []) {
             let response = null;
-            const account = isOAuthAccount(configured)
+            let account = isOAuthAccount(configured)
                 ? usableOAuthById.get(configured.id)
                 : configured;
-            if (!account)
+            if (!account) {
+                if (!isOAuthAccount(configured) ||
+                    !configured.access ||
+                    (configured.expires !== undefined &&
+                        configured.expires <= Date.now()) ||
+                    isPermanentRefreshError(configured.lastRefreshError) ||
+                    refreshBackoffActive(configured.lastRefreshError, configured.id, Date.now()))
+                    continue;
+                account = configured;
+                const quota = quotaManager.getFallback(configured.id, configured)?.quota ??
+                    configured.quota;
+                if (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 || !account.access)
                     continue;
                 response = await sendAnthropicRequest({
                     ...options,
                     accessToken: account.access,
+                    oauthAccountId: account.id,
                 });
             }
             else if (routeOptions.includeApiRoutes === true &&
@@ -587,8 +637,8 @@ async function executeWithFallback(options) {
                 try {
                     quota =
                         route.id === STICKY_ROUTING_MAIN_ACCOUNT_ID
-                            ? await quotaManager.refreshMain(route.access)
-                            : await quotaManager.refreshFallback(route.id, route.access);
+                            ? await quotaManager.refreshMain(mainAccountId, route.access)
+                            : await quotaManager.refreshFallback(route.id, route.access, route.account);
                 }
                 catch {
                     // Retain affinity when the quota probe itself is unavailable.
@@ -680,9 +730,39 @@ async function executeWithFallback(options) {
         if (fallback)
             return fallback;
     }
+    if (isKillswitchEnabled(storage)) {
+        let mainQuota = quotaManager.getMain(mainAccountId)?.quota;
+        if (!mainQuota || quotaManager.isMainStale(options.model.id)) {
+            try {
+                mainQuota = await quotaManager.refreshMain(mainAccountId, options.primaryAccessToken);
+            }
+            catch { }
+        }
+        if (!killswitchPassesPolicy(mainQuota, storage, undefined, options.model.id)) {
+            if (!fallbackFirst) {
+                const fallback = await tryFallbackAccounts();
+                if (fallback)
+                    return fallback;
+            }
+            return new Response(JSON.stringify({
+                type: 'error',
+                error: {
+                    type: 'rate_limit_error',
+                    message: 'Killswitch blocked all OAuth routes',
+                },
+            }), {
+                status: 429,
+                headers: {
+                    'content-type': 'application/json',
+                    'retry-after': '60',
+                },
+            });
+        }
+    }
     const primary = await sendAnthropicRequest({
         ...options,
         accessToken: options.primaryAccessToken,
+        oauthAccountId: STICKY_ROUTING_MAIN_ACCOUNT_ID,
     });
     const primaryPreflight = await firstStreamingError(primary);
     if (primaryPreflight instanceof Response) {
@@ -758,6 +838,20 @@ export function streamCortexKitAnthropic(model, context, options) {
                             partial: output,
                         });
                     }
+                    else if (block?.type === 'redacted_thinking') {
+                        output.content.push({
+                            type: 'thinking',
+                            thinking: '[Reasoning redacted]',
+                            thinkingSignature: String(block.data ?? ''),
+                            redacted: true,
+                            index: event.index,
+                        });
+                        stream.push({
+                            type: 'thinking_start',
+                            contentIndex: output.content.length - 1,
+                            partial: output,
+                        });
+                    }
                     else if (block?.type === 'tool_use') {
                         output.content.push({
                             type: 'toolCall',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cortexkit/pi-anthropic-auth",
-  "version": "1.20.0",
+  "version": "1.21.0",
   "type": "module",
   "repository": {
     "type": "git",
@@ -36,7 +36,7 @@
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@cortexkit/anthropic-auth-core": "1.20.0"
+    "@cortexkit/anthropic-auth-core": "1.21.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "*",