@cortexkit/pi-anthropic-auth 1.21.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,9 @@
-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',
@@ -351,7 +352,7 @@ function applyCacheMode(body, enabled, mode) {
         body.cache_control = { type: 'ephemeral' };
     addTtl(body);
 }
-export async function buildAnthropicRequest(modelId, context, options, cache, fastModeEnabled = false, identity) {
+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 &&
@@ -361,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 },
     ];
@@ -448,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, 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 { 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';
@@ -90,10 +90,16 @@ const cacheKeepManager = new CacheKeepManager({
             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]));
             }
@@ -230,13 +236,26 @@ async function sendAnthropicRequest(options) {
     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]));
@@ -474,7 +493,7 @@ async function executeWithFallback(options) {
                     (configured.expires !== undefined &&
                         configured.expires <= Date.now()) ||
                     isPermanentRefreshError(configured.lastRefreshError) ||
-                    refreshBackoffActive(configured.lastRefreshError, configured.id, Date.now()))
+                    refreshBackoffActive(configured.lastRefreshError, configured.id, Date.now(), tokenFingerprint(configured.refresh)))
                     continue;
                 account = configured;
                 const quota = quotaManager.getFallback(configured.id, configured)?.quota ??
@@ -786,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);
@@ -802,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()}`);

package/package.json

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