@cortexkit/pi-anthropic-auth 1.0.0 → 1.1.1

package/README.md

@@ -40,7 +40,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 `claudeCache`, `dump`, `relay`, and fallback `accounts` blocks.
+The sidecar uses the same JSON shape as the OpenCode package, including `claudeCache`, `claudeFast`, `dump`, `relay`, and fallback `accounts` blocks.
 
 ## Commands
 
@@ -56,10 +56,14 @@ The sidecar uses the same JSON shape as the OpenCode package, including `claudeC
 /claude-dump on
 /claude-dump off
 
+/claude-fast
+/claude-fast on
+/claude-fast off
+
 /claude-quota
 ```
 
-`/claude-quota` reports sidecar fallback account quota state from `~/.pi/agent/anthropic-auth.json`.
+`/claude-quota` reports sidecar fallback account quota state from `~/.pi/agent/anthropic-auth.json`. `/claude-fast on` adds Anthropic `speed: "fast"` plus the `fast-mode-2026-02-01` beta header for supported Opus models (`claude-opus-4-6` and `claude-opus-4-7`).
 
 ## Relay
 

package/dist/commands.js

@@ -1,4 +1,4 @@
-import { buildClaudeQuotaSummary, buildFallbackQuotaSummaries, executeCache1hCommand, executeDumpCommand, getCache1hPersistentMode, isCache1hPersistentlyEnabled, isDumpPersistentlyEnabled, loadAccounts, parseCache1hCommandAction, parseDumpCommandAction, setCache1hPersistentEnabled, setCache1hPersistentMode, setDumpPersistentEnabled, } from '@cortexkit/anthropic-auth-core';
+import { buildClaudeQuotaSummary, buildFallbackQuotaSummaries, executeCache1hCommand, executeDumpCommand, executeFastModeCommand, getCache1hPersistentMode, isCache1hPersistentlyEnabled, isDumpPersistentlyEnabled, isFastModePersistentlyEnabled, loadAccounts, parseCache1hCommandAction, parseDumpCommandAction, parseFastModeCommandAction, setCache1hPersistentEnabled, setCache1hPersistentMode, setDumpPersistentEnabled, setFastModePersistentEnabled, } from '@cortexkit/anthropic-auth-core';
 import { getPiAccountStoragePath } from "./paths.js";
 function notify(ctx, message, kind = 'info') {
     ctx.ui.notify(message, kind);
@@ -55,6 +55,30 @@ export function registerCommands(pi) {
             notify(ctx, executeDumpCommand({ argumentsText: args ?? '', enabled: nextEnabled }), action.type === 'usage' ? 'warning' : 'info');
         },
     });
+    pi.registerCommand('claude-fast', {
+        description: 'Show or configure Anthropic fast mode for supported Opus models',
+        handler: async (args, ctx) => {
+            const path = getPiAccountStoragePath();
+            const storage = await loadAccounts(path);
+            const action = parseFastModeCommandAction(args ?? '');
+            const enabled = isFastModePersistentlyEnabled(storage);
+            const nextEnabled = action.type === 'enable'
+                ? true
+                : action.type === 'disable'
+                    ? false
+                    : enabled;
+            if (action.type === 'enable') {
+                await setFastModePersistentEnabled(true, path);
+            }
+            else if (action.type === 'disable') {
+                await setFastModePersistentEnabled(false, path);
+            }
+            notify(ctx, executeFastModeCommand({
+                argumentsText: args ?? '',
+                enabled: nextEnabled,
+            }), action.type === 'usage' ? 'warning' : 'info');
+        },
+    });
     pi.registerCommand('claude-quota', {
         description: 'Show Claude quota state for fallback accounts',
         handler: async (_args, ctx) => {

package/dist/convert.d.ts

@@ -1,4 +1,4 @@
-import { type Cache1hMode } from '@cortexkit/anthropic-auth-core';
+import { type Cache1hMode, type ClaudeCodeIdentity } from '@cortexkit/anthropic-auth-core';
 import type { Context, SimpleStreamOptions, Tool } from '@mariozechner/pi-ai';
 export type AnthropicRequestBody = {
     model: string;
@@ -14,12 +14,13 @@ export type AnthropicRequestBody = {
     cache_control?: {
         type: 'ephemeral';
     };
+    speed?: 'fast';
 };
 export declare function fromClaudeCodeToolName(name: string, tools?: Tool[]): string;
 export declare function buildAnthropicRequest(modelId: string, context: Context, options: SimpleStreamOptions | undefined, cache: {
     enabled: boolean;
     mode: Cache1hMode;
-}): Promise<{
+}, fastModeEnabled?: boolean, identity?: ClaudeCodeIdentity): Promise<{
     body: AnthropicRequestBody;
     bodyText: string;
 }>;

package/dist/convert.js

@@ -1,4 +1,4 @@
-import { buildBillingHeaderValue, CLAUDE_CODE_ENTRYPOINT, CLAUDE_CODE_IDENTITY, signRequestBody, } from '@cortexkit/anthropic-auth-core';
+import { applyClaudeCodeMetadata, buildBillingHeaderValue, CLAUDE_CODE_ENTRYPOINT, CLAUDE_CODE_IDENTITY, isFastModeSupportedModel, orderClaudeCodeBody, signRequestBody, } from '@cortexkit/anthropic-auth-core';
 const CLAUDE_CODE_TOOLS = new Map([
     'Read',
     'Write',
@@ -187,7 +187,7 @@ function applyCacheMode(body, enabled, mode) {
         body.cache_control = { type: 'ephemeral' };
     addTtl(body);
 }
-export async function buildAnthropicRequest(modelId, context, options, cache) {
+export async function buildAnthropicRequest(modelId, context, options, cache, fastModeEnabled = false, identity) {
     const messages = convertMessages(context.messages);
     const system = [
         {
@@ -209,6 +209,9 @@ export async function buildAnthropicRequest(modelId, context, options, cache) {
     const tools = convertTools(context.tools);
     if (tools?.length)
         body.tools = tools;
+    if (fastModeEnabled && isFastModeSupportedModel(modelId)) {
+        body.speed = 'fast';
+    }
     if (options?.reasoning) {
         const budgets = {
             minimal: 1024,
@@ -226,7 +229,9 @@ export async function buildAnthropicRequest(modelId, context, options, cache) {
     }
     addEphemeralCacheControl(body);
     applyCacheMode(body, cache.enabled, cache.mode);
-    const unsigned = JSON.stringify(body);
+    if (identity)
+        applyClaudeCodeMetadata(body, identity);
+    const unsigned = JSON.stringify(orderClaudeCodeBody(body));
     const bodyText = await signRequestBody(unsigned);
     return { body, bodyText };
 }

package/dist/index.js

@@ -1,4 +1,4 @@
-import { authorize, CLIENT_ID, exchange, TOKEN_URL, } from '@cortexkit/anthropic-auth-core';
+import { authorize, exchange, refreshClaudeOAuthToken, } from '@cortexkit/anthropic-auth-core';
 import { registerCommands } from "./commands.js";
 import { streamCortexKitAnthropic } from "./stream.js";
 async function loginAnthropic(callbacks) {
@@ -18,27 +18,13 @@ async function loginAnthropic(callbacks) {
     };
 }
 async function refreshAnthropicToken(credentials) {
-    const response = await fetch(TOKEN_URL, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-            Accept: 'application/json, text/plain, */*',
-            'User-Agent': 'axios/1.13.6',
-        },
-        body: JSON.stringify({
-            grant_type: 'refresh_token',
-            client_id: CLIENT_ID,
-            refresh_token: credentials.refresh,
-        }),
+    const refreshed = await refreshClaudeOAuthToken({
+        refreshToken: credentials.refresh,
     });
-    if (!response.ok) {
-        throw new Error(`Anthropic OAuth refresh failed: ${await response.text()}`);
-    }
-    const json = (await response.json());
     return {
-        refresh: json.refresh_token ?? credentials.refresh,
-        access: json.access_token,
-        expires: Date.now() + json.expires_in * 1000,
+        refresh: refreshed.refresh,
+        access: refreshed.access,
+        expires: refreshed.expires,
     };
 }
 export default function cortexKitPiAnthropicAuth(pi) {

package/dist/stream.js

@@ -1,4 +1,4 @@
-import { FallbackAccountManager, getCache1hPersistentMode, getRelayConfig, isCache1hPersistentlyEnabled, loadAccounts, REQUIRED_BETAS, sendViaRelay, shouldFallbackStatus, USER_AGENT, } from '@cortexkit/anthropic-auth-core';
+import { applyClaudeCodeHeaders, FAST_MODE_BETA, FallbackAccountManager, getCache1hPersistentMode, getRelayConfig, isCache1hPersistentlyEnabled, isFastModePersistentlyEnabled, loadAccounts, mergeAnthropicBetas, resolveClaudeCodeIdentity, sendViaRelay, shouldFallbackStatus, } from '@cortexkit/anthropic-auth-core';
 import { calculateCost, createAssistantMessageEventStream, } from '@mariozechner/pi-ai';
 import { buildAnthropicRequest, fromClaudeCodeToolName } from "./convert.js";
 import { getPiAccountStoragePath } from "./paths.js";
@@ -80,22 +80,24 @@ async function* parseSse(response) {
 }
 async function sendAnthropicRequest(options) {
     const storage = await loadAccounts(options.storagePath);
-    const headers = new Headers({
-        accept: 'application/json',
-        'content-type': 'application/json',
-        authorization: `Bearer ${options.accessToken}`,
-        'anthropic-beta': REQUIRED_BETAS.join(','),
-        'user-agent': USER_AGENT,
-        'x-app': 'cli',
+    const identity = await resolveClaudeCodeIdentity(options.accessToken, options.model.id);
+    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 (options.streamOptions?.sessionId) {
-        headers.set('x-session-affinity', options.streamOptions.sessionId);
+    if (body.speed === 'fast') {
+        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 init = {
         method: 'POST',
         headers,
-        body: options.bodyText,
+        body: bodyText,
         signal: options.streamOptions?.signal,
     };
     return sendViaRelay({
@@ -103,8 +105,9 @@ async function sendAnthropicRequest(options) {
         input,
         init,
         headers,
-        body: options.bodyText,
+        body: bodyText,
         fallback: () => fetch(input, init),
+        affinity: relayAffinity,
     });
 }
 async function firstStreamingError(response) {
@@ -169,16 +172,10 @@ export function streamCortexKitAnthropic(model, context, options) {
             if (!accessToken)
                 throw new Error('Missing Anthropic OAuth access token');
             const storagePath = getPiAccountStoragePath();
-            const storage = await loadAccounts(storagePath);
-            const { bodyText } = await buildAnthropicRequest(model.id, context, options, {
-                enabled: isCache1hPersistentlyEnabled(storage),
-                mode: getCache1hPersistentMode(storage),
-            });
             const response = await executeWithFallback({
                 model,
                 context,
                 streamOptions: options,
-                bodyText,
                 primaryAccessToken: accessToken,
                 storagePath,
             });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cortexkit/pi-anthropic-auth",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "type": "module",
   "repository": {
     "type": "git",
@@ -35,7 +35,7 @@
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@cortexkit/anthropic-auth-core": "1.0.0"
+    "@cortexkit/anthropic-auth-core": "1.1.1"
   },
   "peerDependencies": {
     "@mariozechner/pi-ai": "*",