@cortexkit/pi-anthropic-auth 1.9.2 → 1.9.4

package/dist/commands.js

@@ -1,4 +1,4 @@
-import { buildClaudeQuotaSummary, buildFallbackQuotaSummaries, CLAUDE_CACHE_KEEP_COMMAND_NAME, CLAUDE_ROUTING_COMMAND_NAME, executeCache1hCommand, executeCacheKeepCommand, executeDumpCommand, executeFastModeCommand, executeRoutingCommand, getCache1hPersistentMode, getCacheKeepWindow, getRoutingMode, isCache1hPersistentlyEnabled, isCacheKeepHybridActive, isCacheKeepPersistentlyEnabled, isDumpPersistentlyEnabled, isFastModePersistentlyEnabled, loadAccounts, parseCache1hCommandAction, parseCacheKeepCommandAction, parseDumpCommandAction, parseFastModeCommandAction, parseRoutingCommandAction, setCache1hPersistentEnabled, setCache1hPersistentMode, setCacheKeepPersistentEnabled, setCacheKeepPersistentWindow, setDumpPersistentEnabled, setFastModePersistentEnabled, setRoutingMode, } from '@cortexkit/anthropic-auth-core';
+import { buildClaudeQuotaSummary, buildFallbackQuotaSummaries, CLAUDE_CACHE_KEEP_COMMAND_NAME, CLAUDE_ROUTING_COMMAND_NAME, executeCache1hCommand, executeCacheKeepCommand, executeDumpCommand, executeFastModeCommand, executeRoutingCommand, getCache1hPersistentMode, getCacheKeepWindow, getRoutingMode, isCache1hPersistentlyEnabled, isCacheKeepHybridActive, isCacheKeepPersistentlyEnabled, isDumpPersistentlyEnabled, isFastModePersistentlyEnabled, loadAccounts, parseCache1hCommandAction, parseCacheKeepCommandAction, parseDumpCommandAction, parseFastModeCommandAction, parseRoutingCommandAction, setCache1hPersistentEnabled, setCache1hPersistentMode, setCacheKeepPersistentEnabled, setCacheKeepPersistentWindow, setDumpEnabled, setDumpPersistentEnabled, setFastModePersistentEnabled, setRoutingMode, } from '@cortexkit/anthropic-auth-core';
 import { getPiAccountStoragePath } from "./paths.js";
 function notify(ctx, message, kind = 'info') {
     ctx.ui.notify(message, kind);
@@ -68,9 +68,14 @@ export function registerCommands(pi) {
                     : enabled;
             if (action.type === 'enable') {
                 await setDumpPersistentEnabled(true, path);
+                setDumpEnabled(true);
             }
             else if (action.type === 'disable') {
                 await setDumpPersistentEnabled(false, path);
+                setDumpEnabled(false);
+            }
+            else {
+                setDumpEnabled(enabled);
             }
             notify(ctx, executeDumpCommand({ argumentsText: args ?? '', enabled: nextEnabled }), action.type === 'usage' ? 'warning' : 'info');
         },

package/dist/convert.js

@@ -1,4 +1,4 @@
-import { applyClaudeCodeMetadata, buildBillingHeaderValue, CLAUDE_CODE_ENTRYPOINT, CLAUDE_CODE_IDENTITY, CLAUDE_FABLE_MYTHOS_5_SUMMARIZED_THINKING, isClaudeFableOrMythos5Model, isFastModeSupportedModel, orderClaudeCodeBody, signRequestBody, } from '@cortexkit/anthropic-auth-core';
+import { applyClaudeCodeMetadata, buildBillingHeaderValue, CLAUDE_CODE_ENTRYPOINT, CLAUDE_CODE_IDENTITY, CLAUDE_FABLE_MYTHOS_5_SUMMARIZED_THINKING, isClaudeFableOrMythos5Model, isFastModeSupportedModel, isOpenAIReasoningSignature, orderClaudeCodeBody, signRequestBody, } from '@cortexkit/anthropic-auth-core';
 const CLAUDE_CODE_TOOLS = new Map([
     'Read',
     'Write',
@@ -41,6 +41,37 @@ export function fromClaudeCodeToolName(name, tools) {
     const lower = name.toLowerCase();
     return tools?.find((tool) => tool.name.toLowerCase() === lower)?.name ?? name;
 }
+function getAssistantToolCallIds(message) {
+    const ids = new Set();
+    if (message?.role !== 'assistant' || !Array.isArray(message.content)) {
+        return ids;
+    }
+    for (const block of message.content) {
+        if (block.type === 'toolCall')
+            ids.add(sanitizeToolId(block.id));
+    }
+    return ids;
+}
+function getImmediateToolResultIds(messages, assistantIndex) {
+    const ids = new Set();
+    let index = assistantIndex + 1;
+    while (messages[index]?.role === 'toolResult') {
+        ids.add(sanitizeToolId(messages[index].toolCallId));
+        index += 1;
+    }
+    return ids;
+}
+function assistantToolCallsHaveImmediateResults(messages, assistantIndex) {
+    const toolCallIds = getAssistantToolCallIds(messages[assistantIndex]);
+    if (toolCallIds.size === 0)
+        return true;
+    const resultIds = getImmediateToolResultIds(messages, assistantIndex);
+    for (const id of toolCallIds) {
+        if (!resultIds.has(id))
+            return false;
+    }
+    return true;
+}
 function convertTextAndImages(content) {
     if (!content.some((item) => item.type === 'image')) {
         return content
@@ -91,6 +122,15 @@ function convertMessages(messages) {
             continue;
         }
         if (message.role === 'assistant') {
+            const toolCallIds = getAssistantToolCallIds(message);
+            if (toolCallIds.size > 0 &&
+                !assistantToolCallsHaveImmediateResults(messages, index)) {
+                // Anthropic requires every tool_use block to be followed immediately by
+                // a matching tool_result message. Interrupted Pi runs can leave an
+                // aborted assistant message with a partial toolCall and no result; drop
+                // that incomplete assistant turn from the replayed history.
+                continue;
+            }
             const blocks = [];
             for (const block of message.content) {
                 if (block.type === 'text' && block.text.trim()) {
@@ -98,6 +138,12 @@ function convertMessages(messages) {
                 }
                 else if (block.type === 'thinking' && block.thinking.trim()) {
                     const thinking = block;
+                    if (isOpenAIReasoningSignature(thinking.thinkingSignature)) {
+                        // OpenAI reasoningEncryptedContent is also opaque encrypted state,
+                        // but it is not an Anthropic thinking signature. Sending it as
+                        // `thinking.signature` makes Anthropic reject the request.
+                        continue;
+                    }
                     if (thinking.thinkingSignature &&
                         !hasLoneSurrogate(thinking.thinking)) {
                         // Signed thinking blocks must be sent back verbatim — the signature
@@ -132,41 +178,43 @@ function convertMessages(messages) {
             continue;
         }
         if (message.role === 'toolResult') {
-            const toolResult = message;
-            const toolResults = [];
-            let content = convertTextAndImages(toolResult.content);
-            // Anthropic rejects tool_result with is_error=true but empty content
-            if (toolResult.isError &&
-                (!content || (Array.isArray(content) && content.length === 0))) {
-                content = [{ type: 'text', text: 'Error' }];
+            const previous = messages[index - 1];
+            if (previous?.role !== 'assistant' ||
+                !assistantToolCallsHaveImmediateResults(messages, index - 1)) {
+                while (messages[index + 1]?.role === 'toolResult')
+                    index += 1;
+                continue;
             }
-            toolResults.push({
-                type: 'tool_result',
-                tool_use_id: sanitizeToolId(toolResult.toolCallId),
-                content: content,
-                is_error: toolResult.isError,
-            });
-            let nextIndex = index + 1;
-            while (nextIndex < messages.length &&
-                messages[nextIndex]?.role === 'toolResult') {
-                const next = messages[nextIndex];
-                let nextContent = convertTextAndImages(next.content);
+            const expectedToolCallIds = getAssistantToolCallIds(previous);
+            const appendToolResult = (toolResult) => {
+                const toolUseId = sanitizeToolId(toolResult.toolCallId);
+                if (!expectedToolCallIds.delete(toolUseId))
+                    return;
+                let content = convertTextAndImages(toolResult.content);
                 // Anthropic rejects tool_result with is_error=true but empty content
-                if (next.isError &&
-                    (!nextContent ||
-                        (Array.isArray(nextContent) && nextContent.length === 0))) {
-                    nextContent = [{ type: 'text', text: 'Error' }];
+                if (toolResult.isError &&
+                    (!content || (Array.isArray(content) && content.length === 0))) {
+                    content = [{ type: 'text', text: 'Error' }];
                 }
                 toolResults.push({
                     type: 'tool_result',
-                    tool_use_id: sanitizeToolId(next.toolCallId),
-                    content: nextContent,
-                    is_error: next.isError,
+                    tool_use_id: toolUseId,
+                    content: content,
+                    is_error: toolResult.isError,
                 });
+            };
+            const toolResult = message;
+            const toolResults = [];
+            appendToolResult(toolResult);
+            let nextIndex = index + 1;
+            while (nextIndex < messages.length &&
+                messages[nextIndex]?.role === 'toolResult') {
+                appendToolResult(messages[nextIndex]);
                 nextIndex += 1;
             }
             index = nextIndex - 1;
-            result.push({ role: 'user', content: toolResults });
+            if (toolResults.length)
+                result.push({ role: 'user', content: toolResults });
         }
     }
     return result;

package/dist/stream.d.ts

@@ -1,6 +1,18 @@
 import { type ApiKeyAccount } from '@cortexkit/anthropic-auth-core';
 import { type Api, type AssistantMessageEventStream, type Context, type Model, type SimpleStreamOptions } from '@earendil-works/pi-ai';
+type AnthropicEvent = {
+    type?: string;
+    index?: number;
+    content_block?: Record<string, unknown>;
+    delta?: Record<string, unknown>;
+    message?: {
+        usage?: Record<string, number>;
+    };
+    usage?: Record<string, number>;
+};
 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 {};

package/dist/stream.js

@@ -1,7 +1,10 @@
-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 { applyClaudeCodeHeaders, CACHE_KEEP_EXTENDED_TTL_BETA, CacheKeepManager, dumpDirectRequest, FAST_MODE_BETA, FallbackAccountManager, getCache1hPersistentMode, getRelayConfig, getRoutingMode, isApiKeyAccount, isCache1hPersistentlyEnabled, isCacheKeepHybridActive, isDumpPersistentlyEnabled, isFastModePersistentlyEnabled, isOAuthAccount, isValidApiBaseURL, loadAccounts, mergeAnthropicBetas, QuotaManager, resolveClaudeCodeIdentity, sendViaRelay, setDumpEnabled, 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";
+function errorText(error) {
+    return error instanceof Error ? error.message : String(error);
+}
 const cacheKeepManager = new CacheKeepManager({
     loadStorage: () => loadAccounts(getPiAccountStoragePath()),
     prepareHeaders: async (headers, target) => {
@@ -100,20 +103,17 @@ export function configureApiRouteHeaders(account, fastMode) {
     }
     return headers;
 }
-async function* parseSse(response) {
+export async function* parseSse(response) {
     if (!response.body)
         return;
     const reader = response.body.getReader();
     const decoder = new TextDecoder();
     let buffer = '';
-    let completed = false;
     try {
         while (true) {
             const { done, value } = await reader.read();
-            if (done) {
-                completed = true;
+            if (done)
                 break;
-            }
             buffer += decoder.decode(value, { stream: true });
             let boundary = buffer.indexOf('\n\n');
             while (boundary !== -1) {
@@ -132,13 +132,18 @@ async function* parseSse(response) {
         }
     }
     finally {
-        if (!completed)
-            await reader.cancel().catch(() => { });
+        // Do not cancel the reader on early abandon. `firstStreamingError()` peeks
+        // the first SSE event from a `response.clone()` and then abandons this
+        // generator; cancelling the cloned (tee'd) reader tears down the shared
+        // underlying body, so the real `parseSse(response)` that streams the reply
+        // reads zero events and the assistant message comes back empty. Releasing
+        // the lock is enough — the abandoned clone branch is garbage-collected.
         reader.releaseLock();
     }
 }
 async function sendAnthropicRequest(options) {
     const storage = await loadAccounts(options.storagePath);
+    setDumpEnabled(isDumpPersistentlyEnabled(storage));
     const identity = options.accessToken
         ? await resolveClaudeCodeIdentity(options.accessToken, options.model.id)
         : undefined;
@@ -174,15 +179,42 @@ async function sendAnthropicRequest(options) {
         storage,
         cacheMode: isCacheKeepHybridActive(storage) ? 'hybrid' : 'disabled',
     });
+    const directFetch = async () => {
+        try {
+            const response = await fetch(input, init);
+            await dumpDirectRequest({
+                affinity: relayAffinity,
+                route: options.apiAccount ? `api:${options.apiAccount.id}` : 'oauth',
+                status: response.status,
+                bodyText,
+                url: input.toString(),
+                method: init.method,
+                headers,
+            });
+            return response;
+        }
+        catch (error) {
+            await dumpDirectRequest({
+                affinity: relayAffinity,
+                route: options.apiAccount ? `api:${options.apiAccount.id}` : 'oauth',
+                error: errorText(error),
+                bodyText,
+                url: input.toString(),
+                method: init.method,
+                headers,
+            });
+            throw error;
+        }
+    };
     if (options.apiAccount)
-        return fetch(input, init);
+        return directFetch();
     return sendViaRelay({
         config: getRelayConfig(storage),
         input,
         init,
         headers,
         body: bodyText,
-        fallback: () => fetch(input, init),
+        fallback: directFetch,
         affinity: relayAffinity,
     });
 }

package/package.json

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