@cortexkit/pi-anthropic-auth 1.7.0 → 1.8.0

package/README.md

@@ -2,6 +2,8 @@
 
 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 4.8, Claude Opus 4.5, and Claude Sonnet 4.5. Fable/Mythos reasoning uses Anthropic adaptive thinking with `output_config.effort`; the package does not send rejected manual `thinking.budget_tokens` for those models.
+
 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.
 
 ## Install
@@ -71,7 +73,7 @@ The sidecar uses the same JSON shape as the OpenCode package, including `routing
 /claude-quota
 ```
 
-`/claude-quota` reports sidecar fallback account quota state from `~/.pi/agent/anthropic-auth.json`. `/claude-routing fallback-first` prefers usable fallback accounts before the main account; `/claude-routing main-first` restores the default. `/claude-cachekeep HH-HH` keeps recently used hybrid-mode session caches warm during the configured local time window by sending `max_tokens: 0` pre-warm requests about five minutes before the 1-hour TTL expires. `/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`, and `claude-opus-4-8`).
+`/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. 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 HH-HH` keeps recently used hybrid-mode session caches warm during the configured local time window by sending `max_tokens: 0` pre-warm requests about five minutes before the 1-hour TTL expires. `/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`, and `claude-opus-4-8`).
 
 ## Relay
 

package/dist/convert.d.ts

@@ -11,6 +11,9 @@ export type AnthropicRequestBody = {
         type: 'enabled';
         budget_tokens: number;
     };
+    output_config?: {
+        effort: string;
+    };
     cache_control?: {
         type: 'ephemeral';
     };

package/dist/convert.js

@@ -1,4 +1,4 @@
-import { applyClaudeCodeMetadata, buildBillingHeaderValue, CLAUDE_CODE_ENTRYPOINT, CLAUDE_CODE_IDENTITY, isFastModeSupportedModel, orderClaudeCodeBody, signRequestBody, } from '@cortexkit/anthropic-auth-core';
+import { applyClaudeCodeMetadata, buildBillingHeaderValue, CLAUDE_CODE_ENTRYPOINT, CLAUDE_CODE_IDENTITY, isClaudeFableOrMythos5Model, isFastModeSupportedModel, orderClaudeCodeBody, signRequestBody, } from '@cortexkit/anthropic-auth-core';
 const CLAUDE_CODE_TOOLS = new Map([
     'Read',
     'Write',
@@ -264,19 +264,24 @@ export async function buildAnthropicRequest(modelId, context, options, cache, fa
         body.speed = 'fast';
     }
     if (options?.reasoning) {
-        const budgets = {
-            minimal: 1024,
-            low: 4096,
-            medium: 10_240,
-            high: 20_480,
-            xhigh: 32_000,
-        };
-        body.thinking = {
-            type: 'enabled',
-            budget_tokens: options.thinkingBudgets?.[options.reasoning] ??
-                budgets[options.reasoning] ??
-                10_240,
-        };
+        if (isClaudeFableOrMythos5Model(modelId)) {
+            body.output_config = { effort: options.reasoning };
+        }
+        else {
+            const budgets = {
+                minimal: 1024,
+                low: 4096,
+                medium: 10_240,
+                high: 20_480,
+                xhigh: 32_000,
+            };
+            body.thinking = {
+                type: 'enabled',
+                budget_tokens: options.thinkingBudgets?.[options.reasoning] ??
+                    budgets[options.reasoning] ??
+                    10_240,
+            };
+        }
     }
     addEphemeralCacheControl(body);
     applyCacheMode(body, cache.enabled, cache.mode);

package/dist/index.js

@@ -1,4 +1,4 @@
-import { authorize, exchange, refreshClaudeOAuthToken, } from '@cortexkit/anthropic-auth-core';
+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 { registerCommands } from "./commands.js";
 import { streamCortexKitAnthropic } from "./stream.js";
 async function loginAnthropic(callbacks) {
@@ -17,6 +17,9 @@ async function loginAnthropic(callbacks) {
         expires: result.expires,
     };
 }
+function textImageInput() {
+    return ['text', 'image'];
+}
 async function refreshAnthropicToken(credentials) {
     const refreshed = await refreshClaudeOAuthToken({
         refreshToken: credentials.refresh,
@@ -34,11 +37,25 @@ export default function cortexKitPiAnthropicAuth(pi) {
         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,
+            })),
             {
                 id: 'claude-opus-4-8',
                 name: 'Claude Opus 4.8',
                 reasoning: true,
-                input: ['text', 'image'],
+                input: textImageInput(),
                 cost: { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
                 contextWindow: 1_000_000,
                 maxTokens: 128_000,
@@ -47,7 +64,7 @@ export default function cortexKitPiAnthropicAuth(pi) {
                 id: 'claude-opus-4-5',
                 name: 'Claude Opus 4.5',
                 reasoning: true,
-                input: ['text', 'image'],
+                input: textImageInput(),
                 cost: { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
                 contextWindow: 200_000,
                 maxTokens: 64_000,
@@ -56,7 +73,7 @@ export default function cortexKitPiAnthropicAuth(pi) {
                 id: 'claude-sonnet-4-5',
                 name: 'Claude Sonnet 4.5',
                 reasoning: true,
-                input: ['text', 'image'],
+                input: textImageInput(),
                 cost: { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
                 contextWindow: 200_000,
                 maxTokens: 64_000,

package/dist/stream.d.ts

@@ -1,2 +1,6 @@
+import { type ApiKeyAccount } from '@cortexkit/anthropic-auth-core';
 import { type Api, type AssistantMessageEventStream, type Context, type Model, type SimpleStreamOptions } from '@earendil-works/pi-ai';
+export declare function buildExplicitBaseMessagesUrl(baseURL: string): URL;
+export declare function configureApiRouteHeaders(account: ApiKeyAccount, fastMode: boolean): Headers;
+export declare function primaryResponseAllowsApiFallback(preflight: Response | string): boolean;
 export declare function streamCortexKitAnthropic(model: Model<Api>, context: Context, options?: SimpleStreamOptions): AssistantMessageEventStream;

package/dist/stream.js

@@ -1,4 +1,4 @@
-import { applyClaudeCodeHeaders, CACHE_KEEP_EXTENDED_TTL_BETA, CacheKeepManager, FAST_MODE_BETA, FallbackAccountManager, getCache1hPersistentMode, getRelayConfig, getRoutingMode, isCache1hPersistentlyEnabled, isCacheKeepHybridActive, isFastModePersistentlyEnabled, loadAccounts, mergeAnthropicBetas, resolveClaudeCodeIdentity, sendViaRelay, shouldFallbackStatus, } from '@cortexkit/anthropic-auth-core';
+import { applyClaudeCodeHeaders, CACHE_KEEP_EXTENDED_TTL_BETA, CacheKeepManager, FAST_MODE_BETA, FallbackAccountManager, getCache1hPersistentMode, getRelayConfig, getRoutingMode, isApiKeyAccount, isCache1hPersistentlyEnabled, isCacheKeepHybridActive, isFastModePersistentlyEnabled, isOAuthAccount, isValidApiBaseURL, loadAccounts, mergeAnthropicBetas, QuotaManager, resolveClaudeCodeIdentity, sendViaRelay, shouldFallbackStatus, } from '@cortexkit/anthropic-auth-core';
 import { calculateCost, createAssistantMessageEventStream, } from '@earendil-works/pi-ai';
 import { buildAnthropicRequest, fromClaudeCodeToolName } from "./convert.js";
 import { getPiAccountStoragePath } from "./paths.js";
@@ -77,49 +77,89 @@ function updateUsage(model, output, usage) {
             output.usage.cacheWrite;
     calculateCost(model, output.usage);
 }
+export function buildExplicitBaseMessagesUrl(baseURL) {
+    const url = new URL(baseURL);
+    url.pathname = `${url.pathname.replace(/\/$/, '')}/v1/messages`;
+    url.searchParams.set('beta', 'true');
+    return url;
+}
+export function configureApiRouteHeaders(account, fastMode) {
+    const headers = new Headers();
+    headers.set('accept', 'application/json');
+    headers.set('content-type', 'application/json');
+    headers.set('anthropic-version', '2023-06-01');
+    headers.set('anthropic-beta', mergeAnthropicBetas(null, []));
+    if (account.authHeader === 'x-api-key') {
+        headers.set('x-api-key', account.apiKey ?? '');
+    }
+    else {
+        headers.set('authorization', `Bearer ${account.apiKey ?? ''}`);
+    }
+    if (fastMode) {
+        headers.set('anthropic-beta', mergeAnthropicBetas(headers.get('anthropic-beta'), [FAST_MODE_BETA]));
+    }
+    return headers;
+}
 async function* parseSse(response) {
     if (!response.body)
         return;
     const reader = response.body.getReader();
     const decoder = new TextDecoder();
     let buffer = '';
-    while (true) {
-        const { done, value } = await reader.read();
-        if (done)
-            break;
-        buffer += decoder.decode(value, { stream: true });
-        let boundary = buffer.indexOf('\n\n');
-        while (boundary !== -1) {
-            const frame = buffer.slice(0, boundary);
-            buffer = buffer.slice(boundary + 2);
-            boundary = buffer.indexOf('\n\n');
-            for (const line of frame.split('\n')) {
-                if (!line.startsWith('data:'))
-                    continue;
-                const data = line.slice(5).trim();
-                if (!data || data === '[DONE]')
-                    continue;
-                yield JSON.parse(data);
+    let completed = false;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                completed = true;
+                break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            let boundary = buffer.indexOf('\n\n');
+            while (boundary !== -1) {
+                const frame = buffer.slice(0, boundary);
+                buffer = buffer.slice(boundary + 2);
+                boundary = buffer.indexOf('\n\n');
+                for (const line of frame.split('\n')) {
+                    if (!line.startsWith('data:'))
+                        continue;
+                    const data = line.slice(5).trim();
+                    if (!data || data === '[DONE]')
+                        continue;
+                    yield JSON.parse(data);
+                }
             }
         }
     }
+    finally {
+        if (!completed)
+            await reader.cancel().catch(() => { });
+        reader.releaseLock();
+    }
 }
 async function sendAnthropicRequest(options) {
     const storage = await loadAccounts(options.storagePath);
-    const identity = await resolveClaudeCodeIdentity(options.accessToken, options.model.id);
+    const identity = options.accessToken
+        ? await resolveClaudeCodeIdentity(options.accessToken, options.model.id)
+        : undefined;
     const { body, bodyText } = await buildAnthropicRequest(options.model.id, options.context, options.streamOptions, {
         enabled: isCache1hPersistentlyEnabled(storage),
         mode: getCache1hPersistentMode(storage),
     }, isFastModePersistentlyEnabled(storage), identity);
-    const headers = applyClaudeCodeHeaders(new Headers(), options.accessToken, {
-        body,
-        identity,
-    });
-    if (body.speed === 'fast') {
+    const fastMode = body.speed === 'fast';
+    const headers = options.apiAccount
+        ? configureApiRouteHeaders(options.apiAccount, fastMode)
+        : applyClaudeCodeHeaders(new Headers(), options.accessToken ?? '', {
+            body,
+            identity,
+        });
+    if (!options.apiAccount && fastMode) {
         headers.set('anthropic-beta', mergeAnthropicBetas(headers.get('anthropic-beta'), [FAST_MODE_BETA]));
     }
     const relayAffinity = options.streamOptions?.sessionId ?? null;
-    const input = new URL('/v1/messages?beta=true', options.model.baseUrl);
+    const input = options.apiAccount
+        ? buildExplicitBaseMessagesUrl(options.apiAccount.baseURL)
+        : new URL('/v1/messages?beta=true', options.model.baseUrl);
     const init = {
         method: 'POST',
         headers,
@@ -134,6 +174,8 @@ async function sendAnthropicRequest(options) {
         storage,
         cacheMode: isCacheKeepHybridActive(storage) ? 'hybrid' : 'disabled',
     });
+    if (options.apiAccount)
+        return fetch(input, init);
     return sendViaRelay({
         config: getRelayConfig(storage),
         input,
@@ -144,6 +186,13 @@ async function sendAnthropicRequest(options) {
         affinity: relayAffinity,
     });
 }
+function quotaSnapshotIsExhausted(quota) {
+    return Object.values(quota ?? {}).some((window) => window && window.remainingPercent <= 0);
+}
+export function primaryResponseAllowsApiFallback(preflight) {
+    return (preflight === 'rate_limit_error' ||
+        (preflight instanceof Response && preflight.status === 429));
+}
 async function firstStreamingError(response) {
     if (!response.ok)
         return response;
@@ -168,14 +217,49 @@ async function executeWithFallback(options) {
         configPath: options.storagePath,
     });
     const storage = await loadAccounts(options.storagePath);
-    async function tryFallbackAccounts() {
-        for (const account of await manager.getUsableFallbackAccounts(storage)) {
-            if (!account.access)
+    const quotaManager = new QuotaManager({ storage });
+    async function primaryQuotaRefreshConfirmsExhausted() {
+        try {
+            const quota = await quotaManager.refreshMain(options.primaryAccessToken);
+            const entry = quotaManager.getMain(options.primaryAccessToken);
+            return Boolean(entry &&
+                entry.refreshAfter > Date.now() &&
+                quotaSnapshotIsExhausted(quota));
+        }
+        catch {
+            return false;
+        }
+    }
+    async function tryFallbackAccounts(routeOptions = {}) {
+        const usableOAuth = await manager.getUsableFallbackAccounts(storage);
+        const usableOAuthById = new Map(usableOAuth.map((account) => [account.id, account]));
+        for (const configured of storage?.accounts ?? []) {
+            let response = null;
+            const account = isOAuthAccount(configured)
+                ? usableOAuthById.get(configured.id)
+                : configured;
+            if (!account)
+                continue;
+            if (isOAuthAccount(account)) {
+                if (!account.access)
+                    continue;
+                response = await sendAnthropicRequest({
+                    ...options,
+                    accessToken: account.access,
+                });
+            }
+            else if (routeOptions.includeApiRoutes === true &&
+                isApiKeyAccount(account) &&
+                account.enabled !== false &&
+                account.apiKey &&
+                isValidApiBaseURL(account.baseURL)) {
+                response = await sendAnthropicRequest({
+                    ...options,
+                    apiAccount: account,
+                });
+            }
+            if (!response)
                 continue;
-            const response = await sendAnthropicRequest({
-                ...options,
-                accessToken: account.access,
-            });
             const preflight = await firstStreamingError(response);
             if (preflight instanceof Response && preflight.ok) {
                 await manager.markUsed(account);
@@ -185,6 +269,7 @@ async function executeWithFallback(options) {
                 !shouldFallbackStatus(preflight.status, storage)) {
                 return preflight;
             }
+            await response.body?.cancel().catch(() => { });
         }
         return null;
     }
@@ -203,10 +288,18 @@ async function executeWithFallback(options) {
         if (!shouldFallbackStatus(primaryPreflight.status, storage))
             return primaryPreflight;
     }
-    if (!fallbackFirst) {
-        const fallback = await tryFallbackAccounts();
-        if (fallback)
+    const allowApiFallback = primaryResponseAllowsApiFallback(primaryPreflight) &&
+        (await primaryQuotaRefreshConfirmsExhausted());
+    if (!fallbackFirst || allowApiFallback) {
+        const fallback = await tryFallbackAccounts({
+            includeApiRoutes: allowApiFallback,
+        });
+        if (fallback) {
+            if (primaryPreflight instanceof Response) {
+                await primaryPreflight.body?.cancel().catch(() => { });
+            }
             return fallback;
+        }
     }
     return primaryPreflight instanceof Response ? primaryPreflight : primary;
 }

package/package.json

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