@cortexkit/pi-anthropic-auth 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ex Machina
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,76 @@
+# @cortexkit/pi-anthropic-auth
+
+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.
+
+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
+
+Install with Pi's package manager:
+
+```bash
+pi install npm:@cortexkit/pi-anthropic-auth@1.0.0
+```
+
+For an unpinned install:
+
+```bash
+pi install npm:@cortexkit/pi-anthropic-auth
+```
+
+To try it for one run without changing Pi settings:
+
+```bash
+pi -e npm:@cortexkit/pi-anthropic-auth
+```
+
+Restart Pi after installing, then authenticate through Pi's normal login flow:
+
+```text
+/login anthropic
+```
+
+## Sidecar config
+
+Pi state is stored separately from OpenCode at:
+
+```text
+~/.pi/agent/anthropic-auth.json
+```
+
+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.
+
+## Commands
+
+```text
+/claude-cache
+/claude-cache on
+/claude-cache off
+/claude-cache mode explicit
+/claude-cache mode automatic
+/claude-cache mode hybrid
+
+/claude-dump
+/claude-dump on
+/claude-dump off
+
+/claude-quota
+```
+
+`/claude-quota` reports sidecar fallback account quota state from `~/.pi/agent/anthropic-auth.json`.
+
+## Relay
+
+The Pi package can use the same user-owned Cloudflare relay config as the OpenCode package. The relay setup helper currently lives in the OpenCode package CLI:
+
+```bash
+CLOUDFLARE_API_TOKEN=... CLOUDFLARE_ACCOUNT_ID=... bunx @cortexkit/opencode-anthropic-auth relay setup
+```
+
+For Pi, copy the generated `relay` block into `~/.pi/agent/anthropic-auth.json`.
+
+## License
+
+MIT

package/dist/commands.d.ts

@@ -0,0 +1,2 @@
+import type { ExtensionAPI } from '@mariozechner/pi-coding-agent';
+export declare function registerCommands(pi: ExtensionAPI): void;

package/dist/commands.js

@@ -0,0 +1,68 @@
+import { buildClaudeQuotaSummary, buildFallbackQuotaSummaries, executeCache1hCommand, executeDumpCommand, getCache1hPersistentMode, isCache1hPersistentlyEnabled, isDumpPersistentlyEnabled, loadAccounts, parseCache1hCommandAction, parseDumpCommandAction, setCache1hPersistentEnabled, setCache1hPersistentMode, setDumpPersistentEnabled, } from '@cortexkit/anthropic-auth-core';
+import { getPiAccountStoragePath } from "./paths.js";
+function notify(ctx, message, kind = 'info') {
+    ctx.ui.notify(message, kind);
+}
+export function registerCommands(pi) {
+    pi.registerCommand('claude-cache', {
+        description: 'Show or configure Claude 1-hour prompt cache mode',
+        handler: async (args, ctx) => {
+            const path = getPiAccountStoragePath();
+            const storage = await loadAccounts(path);
+            const action = parseCache1hCommandAction(args ?? '');
+            const enabled = isCache1hPersistentlyEnabled(storage);
+            const mode = getCache1hPersistentMode(storage);
+            const nextEnabled = action.type === 'enable'
+                ? true
+                : action.type === 'disable'
+                    ? false
+                    : enabled;
+            const nextMode = action.type === 'mode' ? action.mode : mode;
+            if (action.type === 'enable') {
+                await setCache1hPersistentEnabled(true, undefined, path);
+            }
+            else if (action.type === 'disable') {
+                await setCache1hPersistentEnabled(false, undefined, path);
+            }
+            else if (action.type === 'mode') {
+                await setCache1hPersistentMode(action.mode, path);
+            }
+            notify(ctx, executeCache1hCommand({
+                argumentsText: args ?? '',
+                enabled: nextEnabled,
+                mode: nextMode,
+            }), action.type === 'usage' ? 'warning' : 'info');
+        },
+    });
+    pi.registerCommand('claude-dump', {
+        description: 'Show or configure Anthropic request/relay dumping',
+        handler: async (args, ctx) => {
+            const path = getPiAccountStoragePath();
+            const storage = await loadAccounts(path);
+            const action = parseDumpCommandAction(args ?? '');
+            const enabled = isDumpPersistentlyEnabled(storage);
+            const nextEnabled = action.type === 'enable'
+                ? true
+                : action.type === 'disable'
+                    ? false
+                    : enabled;
+            if (action.type === 'enable') {
+                await setDumpPersistentEnabled(true, path);
+            }
+            else if (action.type === 'disable') {
+                await setDumpPersistentEnabled(false, path);
+            }
+            notify(ctx, executeDumpCommand({ 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) => {
+            const storage = await loadAccounts(getPiAccountStoragePath());
+            notify(ctx, buildClaudeQuotaSummary({
+                accounts: buildFallbackQuotaSummaries(storage),
+                now: Date.now(),
+            }));
+        },
+    });
+}

package/dist/convert.d.ts

@@ -0,0 +1,25 @@
+import { type Cache1hMode } from '@cortexkit/anthropic-auth-core';
+import type { Context, SimpleStreamOptions, Tool } from '@mariozechner/pi-ai';
+export type AnthropicRequestBody = {
+    model: string;
+    max_tokens: number;
+    stream: true;
+    system?: Array<Record<string, unknown>>;
+    messages: Array<Record<string, unknown>>;
+    tools?: Array<Record<string, unknown>>;
+    thinking?: {
+        type: 'enabled';
+        budget_tokens: number;
+    };
+    cache_control?: {
+        type: 'ephemeral';
+    };
+};
+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<{
+    body: AnthropicRequestBody;
+    bodyText: string;
+}>;

package/dist/convert.js

@@ -0,0 +1,232 @@
+import { buildBillingHeaderValue, CLAUDE_CODE_ENTRYPOINT, CLAUDE_CODE_IDENTITY, signRequestBody, } from '@cortexkit/anthropic-auth-core';
+const CLAUDE_CODE_TOOLS = new Map([
+    'Read',
+    'Write',
+    'Edit',
+    'Bash',
+    'Grep',
+    'Glob',
+    'AskUserQuestion',
+    'TodoWrite',
+    'WebFetch',
+    'WebSearch',
+].map((name) => [name.toLowerCase(), name]));
+function sanitize(text) {
+    return text.replace(/[\uD800-\uDFFF]/g, '\uFFFD');
+}
+function toClaudeCodeToolName(name) {
+    return CLAUDE_CODE_TOOLS.get(name.toLowerCase()) ?? name;
+}
+export function fromClaudeCodeToolName(name, tools) {
+    const lower = name.toLowerCase();
+    return tools?.find((tool) => tool.name.toLowerCase() === lower)?.name ?? name;
+}
+function convertTextAndImages(content) {
+    if (!content.some((item) => item.type === 'image')) {
+        return content
+            .filter((item) => item.type === 'text')
+            .map((item) => sanitize(item.text))
+            .join('\n');
+    }
+    const blocks = content.map((item) => {
+        if (item.type === 'text') {
+            return { type: 'text', text: sanitize(item.text) };
+        }
+        return {
+            type: 'image',
+            source: {
+                type: 'base64',
+                media_type: item.mimeType,
+                data: item.data,
+            },
+        };
+    });
+    if (!blocks.some((block) => block.type === 'text')) {
+        blocks.unshift({ type: 'text', text: '(see attached image)' });
+    }
+    return blocks;
+}
+function convertMessages(messages) {
+    const result = [];
+    for (let index = 0; index < messages.length; index++) {
+        const message = messages[index];
+        if (!message)
+            continue;
+        if (message.role === 'user') {
+            if (typeof message.content === 'string') {
+                if (message.content.trim()) {
+                    result.push({ role: 'user', content: sanitize(message.content) });
+                }
+            }
+            else {
+                result.push({
+                    role: 'user',
+                    content: convertTextAndImages(message.content),
+                });
+            }
+            continue;
+        }
+        if (message.role === 'assistant') {
+            const blocks = [];
+            for (const block of message.content) {
+                if (block.type === 'text' && block.text.trim()) {
+                    blocks.push({ type: 'text', text: sanitize(block.text) });
+                }
+                else if (block.type === 'thinking' && block.thinking.trim()) {
+                    const thinking = block;
+                    if (thinking.thinkingSignature) {
+                        blocks.push({
+                            type: 'thinking',
+                            thinking: sanitize(thinking.thinking),
+                            signature: thinking.thinkingSignature,
+                        });
+                    }
+                    else {
+                        blocks.push({ type: 'text', text: sanitize(thinking.thinking) });
+                    }
+                }
+                else if (block.type === 'toolCall') {
+                    blocks.push({
+                        type: 'tool_use',
+                        id: block.id,
+                        name: toClaudeCodeToolName(block.name),
+                        input: block.arguments,
+                    });
+                }
+            }
+            if (blocks.length)
+                result.push({ role: 'assistant', content: blocks });
+            continue;
+        }
+        if (message.role === 'toolResult') {
+            const toolResult = message;
+            const toolResults = [];
+            toolResults.push({
+                type: 'tool_result',
+                tool_use_id: toolResult.toolCallId,
+                content: convertTextAndImages(toolResult.content),
+                is_error: toolResult.isError,
+            });
+            let nextIndex = index + 1;
+            while (nextIndex < messages.length &&
+                messages[nextIndex]?.role === 'toolResult') {
+                const next = messages[nextIndex];
+                toolResults.push({
+                    type: 'tool_result',
+                    tool_use_id: next.toolCallId,
+                    content: convertTextAndImages(next.content),
+                    is_error: next.isError,
+                });
+                nextIndex += 1;
+            }
+            index = nextIndex - 1;
+            result.push({ role: 'user', content: toolResults });
+        }
+    }
+    return result;
+}
+function convertTools(tools) {
+    if (!tools?.length)
+        return undefined;
+    return tools.map((tool) => ({
+        name: toClaudeCodeToolName(tool.name),
+        description: tool.description,
+        input_schema: {
+            type: 'object',
+            properties: tool.parameters.properties ?? {},
+            required: tool.parameters.required ?? [],
+        },
+    }));
+}
+function addEphemeralCacheControl(body) {
+    const lastTool = body.tools?.at(-1);
+    if (lastTool)
+        lastTool.cache_control = { type: 'ephemeral' };
+    const lastSystem = body.system?.at(-1);
+    if (lastSystem)
+        lastSystem.cache_control = { type: 'ephemeral' };
+    for (let index = body.messages.length - 1; index >= 0; index--) {
+        const message = body.messages[index];
+        if (message?.role !== 'user')
+            continue;
+        const content = message.content;
+        if (Array.isArray(content)) {
+            const lastBlock = content.at(-1);
+            if (lastBlock && typeof lastBlock === 'object') {
+                lastBlock.cache_control = { type: 'ephemeral' };
+            }
+        }
+        break;
+    }
+}
+function applyCacheMode(body, enabled, mode) {
+    if (!enabled)
+        return;
+    if (mode === 'automatic') {
+        body.cache_control = { type: 'ephemeral' };
+        return;
+    }
+    const addTtl = (value) => {
+        if (!value || typeof value !== 'object')
+            return;
+        if (Array.isArray(value)) {
+            for (const item of value)
+                addTtl(item);
+            return;
+        }
+        const record = value;
+        const cacheControl = record.cache_control;
+        if (cacheControl && typeof cacheControl === 'object') {
+            ;
+            cacheControl.ttl = '1h';
+        }
+        for (const child of Object.values(record))
+            addTtl(child);
+    };
+    if (mode === 'hybrid')
+        body.cache_control = { type: 'ephemeral' };
+    addTtl(body);
+}
+export async function buildAnthropicRequest(modelId, context, options, cache) {
+    const messages = convertMessages(context.messages);
+    const system = [
+        {
+            type: 'text',
+            text: buildBillingHeaderValue(messages, undefined, CLAUDE_CODE_ENTRYPOINT),
+        },
+        { type: 'text', text: CLAUDE_CODE_IDENTITY },
+    ];
+    if (context.systemPrompt?.trim()) {
+        system.push({ type: 'text', text: sanitize(context.systemPrompt) });
+    }
+    const body = {
+        model: modelId,
+        max_tokens: options?.maxTokens ?? 16_384,
+        stream: true,
+        system,
+        messages,
+    };
+    const tools = convertTools(context.tools);
+    if (tools?.length)
+        body.tools = tools;
+    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,
+        };
+    }
+    addEphemeralCacheControl(body);
+    applyCacheMode(body, cache.enabled, cache.mode);
+    const unsigned = JSON.stringify(body);
+    const bodyText = await signRequestBody(unsigned);
+    return { body, bodyText };
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import type { ExtensionAPI } from '@mariozechner/pi-coding-agent';
+export default function cortexKitPiAnthropicAuth(pi: ExtensionAPI): void;

package/dist/index.js

@@ -0,0 +1,78 @@
+import { authorize, CLIENT_ID, exchange, TOKEN_URL, } from '@cortexkit/anthropic-auth-core';
+import { registerCommands } from "./commands.js";
+import { streamCortexKitAnthropic } from "./stream.js";
+async function loginAnthropic(callbacks) {
+    const auth = await authorize('max');
+    callbacks.onAuth({ url: auth.url });
+    const callback = await callbacks.onPrompt({
+        message: 'Paste the Claude OAuth callback URL or code:',
+    });
+    const result = await exchange(callback, auth.verifier, auth.redirectUri, auth.state);
+    if (result.type !== 'success') {
+        throw new Error('Anthropic OAuth exchange failed');
+    }
+    return {
+        refresh: result.refresh,
+        access: result.access,
+        expires: result.expires,
+    };
+}
+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,
+        }),
+    });
+    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,
+    };
+}
+export default function cortexKitPiAnthropicAuth(pi) {
+    registerCommands(pi);
+    pi.registerProvider('anthropic', {
+        name: 'Anthropic (CortexKit OAuth)',
+        baseUrl: 'https://api.anthropic.com',
+        api: 'cortexkit-anthropic-messages',
+        models: [
+            {
+                id: 'claude-opus-4-5',
+                name: 'Claude Opus 4.5',
+                reasoning: true,
+                input: ['text', 'image'],
+                cost: { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
+                contextWindow: 200_000,
+                maxTokens: 64_000,
+            },
+            {
+                id: 'claude-sonnet-4-5',
+                name: 'Claude Sonnet 4.5',
+                reasoning: true,
+                input: ['text', 'image'],
+                cost: { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+                contextWindow: 200_000,
+                maxTokens: 64_000,
+            },
+        ],
+        oauth: {
+            name: 'Anthropic Claude Pro/Max (CortexKit)',
+            login: loginAnthropic,
+            refreshToken: refreshAnthropicToken,
+            getApiKey: (credentials) => credentials.access,
+        },
+        streamSimple: streamCortexKitAnthropic,
+    });
+}

package/dist/paths.d.ts

@@ -0,0 +1,2 @@
+export declare function getPiConfigDir(): string;
+export declare function getPiAccountStoragePath(): string;

package/dist/paths.js

@@ -0,0 +1,10 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { ACCOUNT_FILE_NAME } from '@cortexkit/anthropic-auth-core';
+export function getPiConfigDir() {
+    return process.env.PI_AGENT_DIR?.trim() || join(homedir(), '.pi', 'agent');
+}
+export function getPiAccountStoragePath() {
+    return (process.env.PI_ANTHROPIC_AUTH_FILE?.trim() ||
+        join(getPiConfigDir(), ACCOUNT_FILE_NAME));
+}

package/dist/stream.d.ts

@@ -0,0 +1,2 @@
+import { type Api, type AssistantMessageEventStream, type Context, type Model, type SimpleStreamOptions } from '@mariozechner/pi-ai';
+export declare function streamCortexKitAnthropic(model: Model<Api>, context: Context, options?: SimpleStreamOptions): AssistantMessageEventStream;

package/dist/stream.js

@@ -0,0 +1,348 @@
+import { FallbackAccountManager, getCache1hPersistentMode, getRelayConfig, isCache1hPersistentlyEnabled, loadAccounts, REQUIRED_BETAS, sendViaRelay, shouldFallbackStatus, USER_AGENT, } from '@cortexkit/anthropic-auth-core';
+import { calculateCost, createAssistantMessageEventStream, } from '@mariozechner/pi-ai';
+import { buildAnthropicRequest, fromClaudeCodeToolName } from "./convert.js";
+import { getPiAccountStoragePath } from "./paths.js";
+function mapStopReason(reason) {
+    switch (reason) {
+        case 'end_turn':
+        case 'pause_turn':
+        case 'stop_sequence':
+            return 'stop';
+        case 'max_tokens':
+            return 'length';
+        case 'tool_use':
+            return 'toolUse';
+        default:
+            return 'error';
+    }
+}
+function createOutput(model) {
+    return {
+        role: 'assistant',
+        content: [],
+        api: model.api,
+        provider: model.provider,
+        model: model.id,
+        usage: {
+            input: 0,
+            output: 0,
+            cacheRead: 0,
+            cacheWrite: 0,
+            totalTokens: 0,
+            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+        },
+        stopReason: 'stop',
+        timestamp: Date.now(),
+    };
+}
+function updateUsage(model, output, usage) {
+    if (!usage)
+        return;
+    output.usage.input = usage.input_tokens ?? output.usage.input;
+    output.usage.output = usage.output_tokens ?? output.usage.output;
+    output.usage.cacheRead =
+        usage.cache_read_input_tokens ?? output.usage.cacheRead;
+    output.usage.cacheWrite =
+        usage.cache_creation_input_tokens ?? output.usage.cacheWrite;
+    output.usage.totalTokens =
+        output.usage.input +
+            output.usage.output +
+            output.usage.cacheRead +
+            output.usage.cacheWrite;
+    calculateCost(model, output.usage);
+}
+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);
+            }
+        }
+    }
+}
+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',
+    });
+    if (options.streamOptions?.sessionId) {
+        headers.set('x-session-affinity', options.streamOptions.sessionId);
+    }
+    const input = new URL('/v1/messages?beta=true', options.model.baseUrl);
+    const init = {
+        method: 'POST',
+        headers,
+        body: options.bodyText,
+        signal: options.streamOptions?.signal,
+    };
+    return sendViaRelay({
+        config: getRelayConfig(storage),
+        input,
+        init,
+        headers,
+        body: options.bodyText,
+        fallback: () => fetch(input, init),
+    });
+}
+async function firstStreamingError(response) {
+    if (!response.ok)
+        return response;
+    const clone = response.clone();
+    try {
+        for await (const event of parseSse(clone)) {
+            if (event.type === 'error' &&
+                typeof event.delta?.type === 'string' &&
+                event.delta.type === 'rate_limit_error') {
+                return 'rate_limit_error';
+            }
+            return response;
+        }
+    }
+    catch {
+        return response;
+    }
+    return response;
+}
+async function executeWithFallback(options) {
+    const manager = new FallbackAccountManager({
+        configPath: options.storagePath,
+    });
+    const storage = await loadAccounts(options.storagePath);
+    const primary = await sendAnthropicRequest({
+        ...options,
+        accessToken: options.primaryAccessToken,
+    });
+    const primaryPreflight = await firstStreamingError(primary);
+    if (primaryPreflight instanceof Response) {
+        if (!shouldFallbackStatus(primaryPreflight.status, storage))
+            return primaryPreflight;
+    }
+    for (const account of await manager.getUsableFallbackAccounts()) {
+        if (!account.access)
+            continue;
+        const response = await sendAnthropicRequest({
+            ...options,
+            accessToken: account.access,
+        });
+        const preflight = await firstStreamingError(response);
+        if (preflight instanceof Response && preflight.ok) {
+            await manager.markUsed(account);
+            return preflight;
+        }
+        if (preflight instanceof Response &&
+            !shouldFallbackStatus(preflight.status, storage)) {
+            return preflight;
+        }
+    }
+    return primaryPreflight instanceof Response ? primaryPreflight : primary;
+}
+export function streamCortexKitAnthropic(model, context, options) {
+    const stream = createAssistantMessageEventStream();
+    void (async () => {
+        const output = createOutput(model);
+        stream.push({ type: 'start', partial: output });
+        try {
+            const accessToken = options?.apiKey ?? '';
+            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,
+            });
+            if (!response.ok) {
+                throw new Error(`Anthropic request failed: HTTP ${response.status} ${await response.text()}`);
+            }
+            const blocks = output.content;
+            for await (const event of parseSse(response)) {
+                if (event.type === 'message_start') {
+                    updateUsage(model, output, event.message?.usage);
+                }
+                else if (event.type === 'content_block_start') {
+                    const block = event.content_block;
+                    if (block?.type === 'text') {
+                        output.content.push({
+                            type: 'text',
+                            text: '',
+                            index: event.index,
+                        });
+                        stream.push({
+                            type: 'text_start',
+                            contentIndex: output.content.length - 1,
+                            partial: output,
+                        });
+                    }
+                    else if (block?.type === 'thinking') {
+                        output.content.push({
+                            type: 'thinking',
+                            thinking: '',
+                            thinkingSignature: '',
+                            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',
+                            id: String(block.id),
+                            name: fromClaudeCodeToolName(String(block.name), context.tools),
+                            arguments: {},
+                            partialJson: '',
+                            index: event.index,
+                        });
+                        stream.push({
+                            type: 'toolcall_start',
+                            contentIndex: output.content.length - 1,
+                            partial: output,
+                        });
+                    }
+                }
+                else if (event.type === 'content_block_delta') {
+                    const contentIndex = blocks.findIndex((block) => block.index === event.index);
+                    const block = blocks[contentIndex];
+                    if (!block || !event.delta)
+                        continue;
+                    if (event.delta.type === 'text_delta' && block.type === 'text') {
+                        const delta = String(event.delta.text ?? '');
+                        block.text += delta;
+                        stream.push({
+                            type: 'text_delta',
+                            contentIndex,
+                            delta,
+                            partial: output,
+                        });
+                    }
+                    else if (event.delta.type === 'thinking_delta' &&
+                        block.type === 'thinking') {
+                        const delta = String(event.delta.thinking ?? '');
+                        block.thinking += delta;
+                        stream.push({
+                            type: 'thinking_delta',
+                            contentIndex,
+                            delta,
+                            partial: output,
+                        });
+                    }
+                    else if (event.delta.type === 'signature_delta' &&
+                        block.type === 'thinking') {
+                        block.thinkingSignature = `${block.thinkingSignature ?? ''}${String(event.delta.signature ?? '')}`;
+                    }
+                    else if (event.delta.type === 'input_json_delta' &&
+                        block.type === 'toolCall') {
+                        const delta = String(event.delta.partial_json ?? '');
+                        block.partialJson = `${block.partialJson ?? ''}${delta}`;
+                        try {
+                            block.arguments = JSON.parse(block.partialJson);
+                        }
+                        catch { }
+                        stream.push({
+                            type: 'toolcall_delta',
+                            contentIndex,
+                            delta,
+                            partial: output,
+                        });
+                    }
+                }
+                else if (event.type === 'content_block_stop') {
+                    const contentIndex = blocks.findIndex((block) => block.index === event.index);
+                    const block = blocks[contentIndex];
+                    if (!block)
+                        continue;
+                    delete block.index;
+                    if (block.type === 'text') {
+                        stream.push({
+                            type: 'text_end',
+                            contentIndex,
+                            content: block.text,
+                            partial: output,
+                        });
+                    }
+                    else if (block.type === 'thinking') {
+                        stream.push({
+                            type: 'thinking_end',
+                            contentIndex,
+                            content: block.thinking,
+                            partial: output,
+                        });
+                    }
+                    else if (block.type === 'toolCall') {
+                        try {
+                            block.arguments = JSON.parse(block.partialJson ?? '{}');
+                        }
+                        catch { }
+                        delete block.partialJson;
+                        stream.push({
+                            type: 'toolcall_end',
+                            contentIndex,
+                            toolCall: block,
+                            partial: output,
+                        });
+                    }
+                }
+                else if (event.type === 'message_delta') {
+                    output.stopReason = mapStopReason(String(event.delta?.stop_reason ?? ''));
+                    updateUsage(model, output, event.usage);
+                }
+                else if (event.type === 'error') {
+                    throw new Error(JSON.stringify(event));
+                }
+            }
+            if (options?.signal?.aborted)
+                throw new Error('Request was aborted');
+            for (const block of output.content)
+                delete block.index;
+            stream.push({
+                type: 'done',
+                reason: output.stopReason,
+                message: output,
+            });
+            stream.end();
+        }
+        catch (error) {
+            for (const block of output.content)
+                delete block.index;
+            output.stopReason = options?.signal?.aborted ? 'aborted' : 'error';
+            output.errorMessage =
+                error instanceof Error ? error.message : String(error);
+            stream.push({ type: 'error', reason: output.stopReason, error: output });
+            stream.end();
+        }
+    })();
+    return stream;
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@cortexkit/pi-anthropic-auth",
+  "version": "1.0.0",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cortexkit/anthropic-auth.git",
+    "directory": "packages/pi"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "pi-package"
+  ],
+  "pi": {
+    "extensions": [
+      "./dist/index.js"
+    ]
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "typecheck": "tsc",
+    "types": "tsc",
+    "prepublishOnly": "bun run build"
+  },
+  "dependencies": {
+    "@cortexkit/anthropic-auth-core": "1.0.0"
+  },
+  "peerDependencies": {
+    "@mariozechner/pi-ai": "*",
+    "@mariozechner/pi-coding-agent": "*"
+  }
+}