@cortexkit/pi-anthropic-auth 1.20.0 → 1.22.0

package/README.md

@@ -2,7 +2,7 @@
 
 Pi package for CortexKit Anthropic OAuth support. It overrides Pi's built-in `anthropic` provider with a CortexKit provider extension backed by the shared `@cortexkit/anthropic-auth-core` package.
 
-The Pi provider catalog includes Claude Fable 5 (`claude-fable-5`), limited-access Claude Mythos 5 (`claude-mythos-5`), Claude Opus 5 (`claude-opus-5`), Claude Opus 4.8, Claude Opus 4.5, Claude Sonnet 4.5, and Claude Sonnet 5 (`claude-sonnet-5`). Fable/Mythos reasoning uses Anthropic adaptive thinking with `thinking.display: "summarized"` and `output_config.effort`; the package does not send rejected manual `thinking.budget_tokens` for those models.
+The Pi provider catalog includes Claude Fable 5 (`claude-fable-5`) and 5.1 (`claude-fable-5-1`), limited-access Claude Mythos 5 (`claude-mythos-5`) and 5.1 (`claude-mythos-5-1`), Claude Opus 5 (`claude-opus-5`), Claude Opus 4.8, Claude Opus 4.5, Claude Sonnet 4.5, and Claude Sonnet 5 (`claude-sonnet-5`). Fable/Mythos reasoning uses Anthropic adaptive thinking with `thinking.display: "summarized"` and `output_config.effort`; the package does not send rejected manual `thinking.budget_tokens` for those models. OAuth Fable 5.1 sessions preserve Pi thinking-level changes as mid-conversation effort markers, so switching effort does not rewrite the cached prefix. Replayed signed/redacted thinking follows the configured prefix-mismatch behavior.
 
 This package is part of the CortexKit Anthropic Auth monorepo, which supports both OpenCode (`@cortexkit/opencode-anthropic-auth`) and Pi (`@cortexkit/pi-anthropic-auth`) through the same shared core logic.
 
@@ -42,7 +42,7 @@ Pi state is stored separately from OpenCode at:
 
 Override the path with `PI_ANTHROPIC_AUTH_FILE`. The package also respects `PI_AGENT_DIR` when deriving the default sidecar path.
 
-The sidecar uses the same JSON shape as the OpenCode package, including `routing`, `claudeCache`, `cacheKeep`, `prime`, `claudeFast`, `dump`, `relay`, and fallback `accounts` blocks. Runtime OAuth/quota state is stored in `anthropic-auth-state.json`; sticky session assignments are stored separately in `anthropic-auth-routing-state.json` with SHA-256-hashed session IDs.
+The sidecar uses the same JSON shape as the OpenCode package, including `routing`, `claudeCache`, `cacheKeep`, `prime`, `claudeFast`, `thinkingBinding`, `dump`, `relay`, and fallback `accounts` blocks. `thinkingBinding.prefixMismatchBehavior` accepts `account-default` (default), `error`, or `drop_block` for OAuth Fable 5.1 replay. Runtime OAuth/quota state is stored in `anthropic-auth-state.json`; sticky session assignments are stored separately in `anthropic-auth-routing-state.json` with SHA-256-hashed session IDs.
 
 ## Commands
 
@@ -77,10 +77,13 @@ The sidecar uses the same JSON shape as the OpenCode package, including `routing
 /claude-routing sticky-balanced
 /claude-routing reset
 
+/claude-account
+/claude-account reset-backoff
+
 /claude-quota
 ```
 
-`/claude-quota` reports sidecar OAuth fallback quota state from `~/.pi/agent/anthropic-auth.json`. `/claude-routing fallback-first` prefers usable OAuth fallback accounts before the main account; `/claude-routing main-first` restores the default. `/claude-routing sticky-balanced` assigns each Pi session to an OAuth account according to current 5-hour, 7-day, and matching model-scoped quota headroom, then persists that assignment across transient failures and process restarts. `/claude-routing reset` clears the current Pi session's assignment. Direct Opus sessions prefer usable accounts whose Fable quota is exhausted. API-key routes use the same sidecar shape as OpenCode and are sent directly to their configured Anthropic-compatible base URL, such as Kie's `https://api.kie.ai/claude`, but Pi only uses them after the main OAuth model response reports HTTP 429 or a streaming rate-limit error and a live quota check confirms 0% remaining. `/claude-cachekeep always` keeps active hybrid caches warm while Pi remains open; `/claude-cachekeep HH-HH` limits prewarms to a local time window. Both send `max_tokens: 0` pre-warm requests about five minutes before the 1-hour TTL expires. Running `/claude-cachekeep` without arguments lists live tracked sessions across Pi processes through a temporary lease registry that stores only session IDs and cache timing. `/claude-fast on` adds Anthropic `speed: "fast"` plus the `fast-mode-2026-02-01` beta header for supported Opus models (`claude-opus-4-6`, `claude-opus-4-7`, `claude-opus-4-8`, and `claude-opus-5`).
+`/claude-account reset-backoff` clears the main OAuth refresh backoff and its matching quota backoff. Persisted refresh backoffs are bound to the refresh token that produced them, so replacing a rejected credential immediately escapes its stale latch. `/claude-quota` reports sidecar OAuth fallback quota state from `~/.pi/agent/anthropic-auth.json`. `/claude-routing fallback-first` prefers usable OAuth fallback accounts before the main account; `/claude-routing main-first` restores the default. `/claude-routing sticky-balanced` assigns each Pi session to an OAuth account according to current 5-hour, 7-day, and matching model-scoped quota headroom, then persists that assignment across transient failures and process restarts. `/claude-routing reset` clears the current Pi session's assignment. Direct Opus sessions prefer usable accounts whose Fable quota is exhausted. API-key routes use the same sidecar shape as OpenCode and are sent directly to their configured Anthropic-compatible base URL, such as Kie's `https://api.kie.ai/claude`, but Pi only uses them after the main OAuth model response reports HTTP 429 or a streaming rate-limit error and a live quota check confirms 0% remaining. `/claude-cachekeep always` keeps active hybrid caches warm while Pi remains open; `/claude-cachekeep HH-HH` limits prewarms to a local time window. Both send `max_tokens: 0` pre-warm requests about five minutes before the 1-hour TTL expires. Running `/claude-cachekeep` without arguments lists live tracked sessions across Pi processes through a temporary lease registry that stores only session IDs and cache timing. `/claude-fast on` adds Anthropic `speed: "fast"` plus the `fast-mode-2026-02-01` beta header for supported Opus models (`claude-opus-4-6`, `claude-opus-4-7`, `claude-opus-4-8`, and `claude-opus-5`).
 
 ### Claude quota window priming
 

package/dist/commands.js

@@ -1,4 +1,4 @@
-import { buildClaudeQuotaSummary, buildFallbackQuotaSummaries, buildPrimeAccountStatuses, CLAUDE_ACCOUNT_COMMAND_NAME, CLAUDE_CACHE_KEEP_COMMAND_NAME, CLAUDE_PRIME_COMMAND_NAME, CLAUDE_ROUTING_COMMAND_NAME, createEmptyStorage, executeAccountCommand, executeCache1hCommand, executeCacheKeepCommand, executeDumpCommand, executeFastModeCommand, executeLoggingCommand, executePrimeCommand, executeRoutingCommand, getCache1hPersistentMode, getCacheKeepWindow, getPersistedLogLevel, getRoutingMode, isCache1hPersistentlyEnabled, isCacheKeepAlways, isCacheKeepHybridActive, isCacheKeepPersistentlyEnabled, isDumpPersistentlyEnabled, isFastModePersistentlyEnabled, isPrimePersistentlyEnabled, loadAccounts, parseCache1hCommandAction, parseCacheKeepCommandAction, parseDumpCommandAction, parseFastModeCommandAction, parseLoggingCommandAction, parseRoutingCommandAction, removeAccountPersistent, reorderAccountsPersistent, setAccountEnabledPersistent, setCache1hPersistentEnabled, setCache1hPersistentMode, setCacheKeepPersistentAlways, setCacheKeepPersistentEnabled, setCacheKeepPersistentWindow, setCacheKeepSubagentsEnabled, setDumpEnabled, setDumpPersistentEnabled, setFastModePersistentEnabled, setLogLevelPersistent, setRoutingMode, } from '@cortexkit/anthropic-auth-core';
+import { buildClaudeQuotaSummary, buildFallbackQuotaSummaries, buildPrimeAccountStatuses, CLAUDE_ACCOUNT_COMMAND_NAME, CLAUDE_CACHE_KEEP_COMMAND_NAME, CLAUDE_PRIME_COMMAND_NAME, CLAUDE_ROUTING_COMMAND_NAME, createEmptyStorage, detectClaustrumConnection, executeAccountCommand, executeCache1hCommand, executeCacheKeepCommand, executeDumpCommand, executeFastModeCommand, executeLoggingCommand, executePrimeCommand, executeRoutingCommand, getCache1hPersistentMode, getCacheKeepWindow, getPersistedLogLevel, getRoutingMode, isCache1hPersistentlyEnabled, isCacheKeepAlways, isCacheKeepHybridActive, isCacheKeepPersistentlyEnabled, isDumpPersistentlyEnabled, isFastModePersistentlyEnabled, isPrimePersistentlyEnabled, loadAccounts, mergeMainQuotaErrorClearedAt, mergeMainRefreshErrorClearedAt, parseAccountCommandAction, parseCache1hCommandAction, parseCacheKeepCommandAction, parseDumpCommandAction, parseFastModeCommandAction, parseLoggingCommandAction, parseRoutingCommandAction, removeAccountPersistent, reorderAccountsPersistent, saveAccountState, setAccountEnabledPersistent, setCache1hPersistentEnabled, setCache1hPersistentMode, setCacheKeepPersistentAlways, setCacheKeepPersistentEnabled, setCacheKeepPersistentWindow, setCacheKeepSubagentsEnabled, setDumpEnabled, setDumpPersistentEnabled, setFastModePersistentEnabled, setLogLevelPersistent, setRoutingMode, } from '@cortexkit/anthropic-auth-core';
 import { getPiAccountStoragePath } from './paths.js';
 import { clearPiStickyRoutingSession, getPiTrackedCacheKeepSessions, } from './stream.js';
 function notify(ctx, message, kind = 'info') {
@@ -152,9 +152,13 @@ export function registerCommands(pi) {
         handler: async (args, ctx) => {
             const path = getPiAccountStoragePath();
             const storage = await loadAccounts(path);
+            const action = parseAccountCommandAction(args ?? '');
             const result = executeAccountCommand({
                 argumentsText: args ?? '',
                 storage: storage ?? createEmptyStorage(),
+                claustrum: action.type === 'status'
+                    ? await detectClaustrumConnection()
+                    : undefined,
             });
             if (!result.updated) {
                 notify(ctx, result.text);
@@ -181,6 +185,29 @@ export function registerCommands(pi) {
                     await reorderAccountsPersistent(newOrder, path);
                 }
             }
+            else if (mutationAction === 'reset-backoff') {
+                const nextStorage = storage ?? createEmptyStorage();
+                nextStorage.refresh = nextStorage.refresh ?? {};
+                nextStorage.refresh.mainLastRefreshError = undefined;
+                nextStorage.refresh.mainRefreshErrorClearedAt =
+                    mergeMainRefreshErrorClearedAt(nextStorage.refresh.mainRefreshErrorClearedAt, Date.now());
+                const mainIdentity = nextStorage.mainAccountId;
+                const quotaError = nextStorage.quota?.mainLastQuotaApiError;
+                if (!quotaError?.accountIdentity ||
+                    !mainIdentity ||
+                    quotaError.accountIdentity === mainIdentity) {
+                    nextStorage.quota = nextStorage.quota ?? {};
+                    nextStorage.quota.mainLastQuotaApiError = undefined;
+                    const nextQuotaErrorGeneration = (nextStorage.quota.mainQuotaErrorGeneration ?? 0) + 1;
+                    nextStorage.quota.mainQuotaErrorGeneration = Math.max(nextStorage.quota.mainQuotaErrorGeneration ?? 0, nextQuotaErrorGeneration);
+                    nextStorage.quota.mainQuotaErrorClearedAt =
+                        mergeMainQuotaErrorClearedAt(nextStorage.quota.mainQuotaErrorClearedAt, Date.now());
+                }
+                await saveAccountState(nextStorage, path, {
+                    mainRefresh: true,
+                    mainQuota: true,
+                });
+            }
             notify(ctx, result.text);
         },
     });

package/dist/convert.d.ts

@@ -1,4 +1,4 @@
-import { type Cache1hMode, type ClaudeCodeIdentity } from '@cortexkit/anthropic-auth-core';
+import { type Cache1hMode, type ClaudeCodeIdentity, type MidConversationEffortTransition, type ThinkingPrefixMismatchBehavior } from '@cortexkit/anthropic-auth-core';
 import type { Context, SimpleStreamOptions, Tool } from '@earendil-works/pi-ai';
 export type AnthropicRequestBody = {
     model: string;
@@ -26,7 +26,10 @@ export declare function fromClaudeCodeToolName(name: string, tools?: Tool[]): st
 export declare function buildAnthropicRequest(modelId: string, context: Context, options: SimpleStreamOptions | undefined, cache: {
     enabled: boolean;
     mode: Cache1hMode;
-}, fastModeEnabled?: boolean, identity?: ClaudeCodeIdentity): Promise<{
+}, fastModeEnabled?: boolean, identity?: ClaudeCodeIdentity, controls?: {
+    effortTransitions?: readonly MidConversationEffortTransition[];
+    thinkingPrefixMismatchBehavior?: ThinkingPrefixMismatchBehavior;
+}): Promise<{
     body: AnthropicRequestBody;
     bodyText: string;
 }>;

package/dist/convert.js

@@ -1,8 +1,13 @@
-import { applyClaudeCodeMetadata, buildBillingHeaderValue, CLAUDE_CODE_ENTRYPOINT, CLAUDE_CODE_IDENTITY, CLAUDE_FABLE_MYTHOS_5_SUMMARIZED_THINKING, CLAUDE_OPUS_5_ADAPTIVE_THINKING, CLAUDE_SONNET_5_ADAPTIVE_THINKING, isClaudeFableOrMythos5Model, isClaudeOpus5Model, isClaudeSonnet5Model, isFastModeSupportedModel, isOpenAIReasoningSignature, orderClaudeCodeBody, signRequestBody, } from '@cortexkit/anthropic-auth-core';
+import { applyClaudeCodeMetadata, applyMidConversationOutputConfig, applyThinkingBindingControls, buildBillingHeaderValue, CLAUDE_CODE_ENTRYPOINT, CLAUDE_CODE_IDENTITY, CLAUDE_FABLE_MYTHOS_5_SUMMARIZED_THINKING, CLAUDE_OPUS_5_ADAPTIVE_THINKING, CLAUDE_SONNET_5_ADAPTIVE_THINKING, ClaudeCodeFirstUserTextTracker, isClaudeFableOrMythos5Model, isClaudeOpus5Model, isClaudeSonnet5Model, isFastModeSupportedModel, isOpenAIReasoningSignature, orderClaudeCodeBody, signRequestBody, } from '@cortexkit/anthropic-auth-core';
 // Anchor identifying Pi's documentation paragraph — the only part of the prompt
 // 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 firstUserTextTracker = new ClaudeCodeFirstUserTextTracker();
+const ANTHROPIC_REPLAY_APIS = new Set([
+    'anthropic-messages',
+    'cortexkit-anthropic-messages',
+]);
 const CLAUDE_CODE_TOOLS = new Map([
     'Read',
     'Write',
@@ -105,7 +110,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 +145,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({
@@ -317,8 +352,8 @@ function applyCacheMode(body, enabled, mode) {
         body.cache_control = { type: 'ephemeral' };
     addTtl(body);
 }
-export async function buildAnthropicRequest(modelId, context, options, cache, fastModeEnabled = false, identity) {
-    const messages = convertMessages(context.messages);
+export async function buildAnthropicRequest(modelId, context, options, cache, fastModeEnabled = false, identity, controls = {}) {
+    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') {
@@ -327,7 +362,9 @@ export async function buildAnthropicRequest(modelId, context, options, cache, fa
     const system = [
         {
             type: 'text',
-            text: buildBillingHeaderValue(messages, undefined, CLAUDE_CODE_ENTRYPOINT),
+            text: buildBillingHeaderValue(messages, undefined, CLAUDE_CODE_ENTRYPOINT, options?.sessionId
+                ? firstUserTextTracker.resolve(options.sessionId, messages)
+                : undefined),
         },
         { type: 'text', text: CLAUDE_CODE_IDENTITY },
     ];
@@ -414,10 +451,13 @@ export async function buildAnthropicRequest(modelId, context, options, cache, fa
             };
         }
     }
+    applyMidConversationOutputConfig(body, controls.effortTransitions ?? []);
     addEphemeralCacheControl(body);
     applyCacheMode(body, cache.enabled, cache.mode);
-    if (identity)
+    if (identity) {
+        applyThinkingBindingControls(body, controls.thinkingPrefixMismatchBehavior ?? 'account-default');
         applyClaudeCodeMetadata(body, identity);
+    }
     const unsigned = JSON.stringify(orderClaudeCodeBody(body));
     const bodyText = await signRequestBody(unsigned);
     return { body, bodyText };

package/dist/effort-history.d.ts

@@ -0,0 +1,12 @@
+import { type MidConversationEffortTransition } from '@cortexkit/anthropic-auth-core';
+type SessionEntryLike = {
+    id?: unknown;
+    type?: unknown;
+    thinkingLevel?: unknown;
+    message?: {
+        role?: unknown;
+    };
+};
+/** Build Pi's active, compaction-aware Fable 5.1 effort timeline. */
+export declare function collectPiEffortHistory(contextEntries: readonly SessionEntryLike[], fullBranch: readonly SessionEntryLike[]): MidConversationEffortTransition[];
+export {};

package/dist/effort-history.js

@@ -0,0 +1,63 @@
+import { normalizeAdaptiveEffort, } from '@cortexkit/anthropic-auth-core';
+function entryRole(entry) {
+    if (entry.type === 'compaction' || entry.type === 'branch_summary') {
+        return 'user';
+    }
+    if (entry.type === 'custom_message')
+        return 'user';
+    return entry.type === 'message' ? entry.message?.role : undefined;
+}
+function appendTransition(transitions, afterAssistantMessages, effort) {
+    const previous = transitions.at(-1);
+    if (previous?.effort === effort)
+        return;
+    if (previous?.afterAssistantMessages === afterAssistantMessages) {
+        previous.effort = effort;
+        return;
+    }
+    transitions.push({ afterAssistantMessages, effort });
+}
+/** Build Pi's active, compaction-aware Fable 5.1 effort timeline. */
+export function collectPiEffortHistory(contextEntries, fullBranch) {
+    let activeEffort = 'high';
+    let assistantMessages = 0;
+    const transitions = [];
+    const first = contextEntries[0];
+    const compactionIndex = first?.type === 'compaction'
+        ? fullBranch.findIndex((entry) => entry.id === first.id)
+        : -1;
+    if (compactionIndex >= 0) {
+        for (let index = 0; index <= compactionIndex; index++) {
+            const entry = fullBranch[index];
+            if (entry?.type !== 'thinking_level_change')
+                continue;
+            activeEffort = normalizeAdaptiveEffort(entry.thinkingLevel) ?? 'high';
+        }
+        appendTransition(transitions, 0, activeEffort);
+    }
+    const branchIndexById = new Map(fullBranch.map((entry, index) => [entry.id, index]));
+    for (const entry of contextEntries) {
+        if (entry === first && entry.type === 'compaction')
+            continue;
+        const branchIndex = branchIndexById.get(entry.id);
+        const retainedBeforeCompaction = compactionIndex >= 0 &&
+            typeof branchIndex === 'number' &&
+            branchIndex < compactionIndex;
+        if (entry.type === 'thinking_level_change') {
+            if (!retainedBeforeCompaction) {
+                activeEffort = normalizeAdaptiveEffort(entry.thinkingLevel) ?? 'high';
+            }
+            continue;
+        }
+        const role = entryRole(entry);
+        if (role === 'assistant') {
+            assistantMessages++;
+        }
+        else if (role === 'user' ||
+            role === 'toolResult' ||
+            role === 'tool_result') {
+            appendTransition(transitions, assistantMessages, activeEffort);
+        }
+    }
+    return transitions;
+}

package/dist/index.js

@@ -1,5 +1,6 @@
-import { authorize, CLAUDE_FABLE_MYTHOS_5_CONTEXT_WINDOW, CLAUDE_FABLE_MYTHOS_5_MAX_OUTPUT_TOKENS, CLAUDE_FABLE_MYTHOS_5_MODEL_SPECS, CLAUDE_FABLE_MYTHOS_5_PRICING, exchange, refreshClaudeOAuthToken, } from '@cortexkit/anthropic-auth-core';
+import { authorize, CLAUDE_FABLE_MYTHOS_5_1_PRICING, CLAUDE_FABLE_MYTHOS_5_CONTEXT_WINDOW, CLAUDE_FABLE_MYTHOS_5_MAX_OUTPUT_TOKENS, CLAUDE_FABLE_MYTHOS_5_MODEL_SPECS, CLAUDE_FABLE_MYTHOS_5_PRICING, exchange, isClaudeFableOrMythos51Model, refreshClaudeOAuthToken, } from '@cortexkit/anthropic-auth-core';
 import { registerCommands } from './commands.js';
+import { collectPiEffortHistory } from './effort-history.js';
 import { streamCortexKitAnthropic } from './stream.js';
 async function loginAnthropic(callbacks) {
     const auth = await authorize('max');
@@ -32,25 +33,51 @@ async function refreshAnthropicToken(credentials) {
 }
 export default function cortexKitPiAnthropicAuth(pi) {
     registerCommands(pi);
+    const effortHistoryBySession = new Map();
+    pi.on('turn_start', async (_event, ctx) => {
+        const sessionId = ctx.sessionManager.getSessionId();
+        if (!sessionId)
+            return;
+        const transitions = collectPiEffortHistory(ctx.sessionManager.buildContextEntries(), ctx.sessionManager.getBranch());
+        effortHistoryBySession.delete(sessionId);
+        effortHistoryBySession.set(sessionId, transitions);
+        while (effortHistoryBySession.size > 128) {
+            const oldest = effortHistoryBySession.keys().next().value;
+            if (oldest)
+                effortHistoryBySession.delete(oldest);
+            else
+                break;
+        }
+    });
+    pi.on('session_shutdown', async (_event, ctx) => {
+        const sessionId = ctx.sessionManager.getSessionId();
+        if (sessionId)
+            effortHistoryBySession.delete(sessionId);
+    });
     pi.registerProvider('anthropic', {
         name: 'Anthropic (CortexKit OAuth)',
         baseUrl: 'https://api.anthropic.com',
         api: 'cortexkit-anthropic-messages',
         models: [
-            ...Object.values(CLAUDE_FABLE_MYTHOS_5_MODEL_SPECS).map((model) => ({
-                id: model.id,
-                name: model.name,
-                reasoning: true,
-                input: textImageInput(),
-                cost: {
-                    input: CLAUDE_FABLE_MYTHOS_5_PRICING.input,
-                    output: CLAUDE_FABLE_MYTHOS_5_PRICING.output,
-                    cacheRead: CLAUDE_FABLE_MYTHOS_5_PRICING.cacheRead,
-                    cacheWrite: CLAUDE_FABLE_MYTHOS_5_PRICING.cacheWrite5m,
-                },
-                contextWindow: CLAUDE_FABLE_MYTHOS_5_CONTEXT_WINDOW,
-                maxTokens: CLAUDE_FABLE_MYTHOS_5_MAX_OUTPUT_TOKENS,
-            })),
+            ...Object.values(CLAUDE_FABLE_MYTHOS_5_MODEL_SPECS).map((model) => {
+                const pricing = isClaudeFableOrMythos51Model(model.id)
+                    ? CLAUDE_FABLE_MYTHOS_5_1_PRICING
+                    : CLAUDE_FABLE_MYTHOS_5_PRICING;
+                return {
+                    id: model.id,
+                    name: model.name,
+                    reasoning: true,
+                    input: textImageInput(),
+                    cost: {
+                        input: pricing.input,
+                        output: pricing.output,
+                        cacheRead: pricing.cacheRead,
+                        cacheWrite: pricing.cacheWrite5m,
+                    },
+                    contextWindow: CLAUDE_FABLE_MYTHOS_5_CONTEXT_WINDOW,
+                    maxTokens: CLAUDE_FABLE_MYTHOS_5_MAX_OUTPUT_TOKENS,
+                };
+            }),
             {
                 id: 'claude-opus-5',
                 name: 'Claude Opus 5',
@@ -103,6 +130,8 @@ export default function cortexKitPiAnthropicAuth(pi) {
             refreshToken: refreshAnthropicToken,
             getApiKey: (credentials) => credentials.access,
         },
-        streamSimple: streamCortexKitAnthropic,
+        streamSimple: (model, context, options) => streamCortexKitAnthropic(model, context, options, options?.sessionId
+            ? effortHistoryBySession.get(options.sessionId)
+            : undefined),
     });
 }

package/dist/stream.d.ts

@@ -1,4 +1,4 @@
-import { type ApiKeyAccount } from '@cortexkit/anthropic-auth-core';
+import { type ApiKeyAccount, type MidConversationEffortTransition } from '@cortexkit/anthropic-auth-core';
 import { type Api, type AssistantMessageEventStream, type Context, type Model, type SimpleStreamOptions } from '@earendil-works/pi-ai';
 export declare function clearPiStickyRoutingSession(storagePath: string, sessionId: string): Promise<void>;
 export declare function getPiTrackedCacheKeepSessions(): Promise<import("@cortexkit/anthropic-auth-core").CacheKeepTrackedSession[]>;
@@ -16,5 +16,5 @@ export declare function buildExplicitBaseMessagesUrl(baseURL: string): URL;
 export declare function configureApiRouteHeaders(account: ApiKeyAccount, fastMode: boolean): Headers;
 export declare function parseSse(response: Response): AsyncGenerator<AnthropicEvent>;
 export declare function primaryResponseAllowsApiFallback(preflight: Response | string): boolean;
-export declare function streamCortexKitAnthropic(model: Model<Api>, context: Context, options?: SimpleStreamOptions): AssistantMessageEventStream;
+export declare function streamCortexKitAnthropic(model: Model<Api>, context: Context, options?: SimpleStreamOptions, effortTransitions?: readonly MidConversationEffortTransition[]): AssistantMessageEventStream;
 export {};

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, getThinkingPrefixMismatchBehavior, hasThinkingBindingControls, isApiKeyAccount, isCache1hPersistentlyEnabled, isCacheKeepHybridActive, isDumpPersistentlyEnabled, isFastModePersistentlyEnabled, isKillswitchEnabled, isOAuthAccount, isPermanentRefreshError, isValidApiBaseURL, killswitchPassesPolicy, loadAccounts, 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 { 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,12 +85,21 @@ 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'), [
-                CACHE_KEEP_EXTENDED_TTL_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]));
             }
@@ -201,21 +224,38 @@ 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),
         mode: getCache1hPersistentMode(storage),
-    }, isFastModePersistentlyEnabled(storage), identity);
+    }, isFastModePersistentlyEnabled(storage), identity, {
+        effortTransitions: options.apiAccount ? [] : options.effortTransitions,
+        thinkingPrefixMismatchBehavior: options.apiAccount
+            ? 'account-default'
+            : getThinkingPrefixMismatchBehavior(storage),
+    });
     const fastMode = body.speed === 'fast';
     const headers = options.apiAccount
         ? configureApiRouteHeaders(options.apiAccount, fastMode)
         : applyClaudeCodeHeaders(new Headers(), options.accessToken ?? '', {
             body,
             identity,
+            extraBetas: [
+                ...(hasThinkingBindingControls(body)
+                    ? [THINKING_BINDING_CONTROLS_BETA]
+                    : []),
+                ...(usesMidConversationOutputConfig(body)
+                    ? [MID_CONVERSATION_OUTPUT_CONFIG_BETA]
+                    : []),
+            ],
         });
     if (!options.apiAccount && fastMode) {
         headers.set('anthropic-beta', mergeAnthropicBetas(headers.get('anthropic-beta'), [FAST_MODE_BETA]));
@@ -307,16 +347,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 +381,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 +415,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 +444,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 +456,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 +467,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 +484,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(), tokenFingerprint(configured.refresh)))
+                    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 +656,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 +749,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) {
@@ -706,7 +805,7 @@ async function executeWithFallback(options) {
     }
     return primaryPreflight instanceof Response ? primaryPreflight : primary;
 }
-export function streamCortexKitAnthropic(model, context, options) {
+export function streamCortexKitAnthropic(model, context, options, effortTransitions) {
     const stream = createAssistantMessageEventStream();
     void (async () => {
         const output = createOutput(model);
@@ -722,6 +821,7 @@ export function streamCortexKitAnthropic(model, context, options) {
                 streamOptions: options,
                 primaryAccessToken: accessToken,
                 storagePath,
+                effortTransitions,
             });
             if (!response.ok) {
                 throw new Error(`Anthropic request failed: HTTP ${response.status} ${await response.text()}`);
@@ -758,6 +858,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.22.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.22.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "*",