@code-yeongyu/senpi 2026.7.10 → 2026.7.13

package/node_modules/@earendil-works/pi-ai/dist/api/anthropic-messages.js

@@ -1,5 +1,6 @@
 import Anthropic from "@anthropic-ai/sdk";
 import { calculateCost } from "../models.js";
+import { splitDeferredTools } from "../utils/deferred-tools.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { headersToRecord, providerHeadersToRecord } from "../utils/headers.js";
 import { parseJsonWithRepair, parseStreamingJson } from "../utils/json-parse.js";
@@ -150,8 +151,24 @@ function getAnthropicCompat(model) {
         supportsToolChoice: model.compat?.supportsToolChoice ?? true,
         supportsForcedToolChoice: model.compat?.supportsForcedToolChoice ?? !CLAUDE_FABLE_OR_MYTHOS_MODEL_ID.test(model.id),
         allowEmptySignature: model.compat?.allowEmptySignature ?? false,
+        supportsToolReferences: model.compat?.supportsToolReferences ?? defaultSupportsToolReferences(model),
     };
 }
+/**
+ * Default for `supportsToolReferences`: first-party Anthropic models except
+ * Haiku (rejects client-side tool_reference blocks) and models that predate
+ * tool search (Claude 3.x, Opus/Sonnet 4.0, Opus 4.1).
+ */
+function defaultSupportsToolReferences(model) {
+    if (model.provider !== "anthropic" || model.id.includes("haiku"))
+        return false;
+    const version = model.id.match(/^claude-(?:opus|sonnet|fable)-(\d+)(?:-(\d+))?(?:-|$)/);
+    if (!version)
+        return false;
+    const major = Number(version[1]);
+    const minor = version[2] && version[2].length < 8 ? Number(version[2]) : 0;
+    return major > 4 || (major === 4 && minor >= 5);
+}
 function mergeHeaders(...headerSources) {
     const merged = {};
     for (const headers of headerSources) {
@@ -897,11 +914,8 @@ function supportsAdaptiveThinking(model) {
 }
 /**
  * Map ThinkingLevel to Anthropic effort levels for adaptive thinking.
- *
- * Model-specific effort tiers:
- * - Opus 4.7+ and Fable 5: supports "low" | "medium" | "high" | "xhigh" | "max"
- * - Opus 4.6: supports "low" | "medium" | "high" | "max" ("xhigh" maps to "max")
- * - Sonnet 4.6 and other adaptive models: "low" | "medium" | "high" ("xhigh"/"max" clamp to "high")
+ * Note: effort "max" is available on all adaptive-thinking Claude models, while native
+ * "xhigh" is only available on Opus 4.7/4.8, Sonnet 5, and Fable 5.
  */
 function mapThinkingLevelToEffort(model, level) {
     const mapped = level ? model.thinkingLevelMap?.[level] : undefined;
@@ -1039,9 +1053,27 @@ function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStre
 function buildParams(model, context, isOAuthToken, options) {
     const compat = getAnthropicCompat(model);
     const { cacheControl } = getCacheControl(model, options?.cacheRetention ?? model.cacheRetention, options?.env);
+    const transformedMessages = transformMessages(context.messages, model, normalizeToolCallId, {
+        preserveThinking: options?.thinkingEnabled === true,
+        preserveUnsignedThinking: true,
+    });
+    const normalizeToolName = isOAuthToken ? toClaudeCodeName : (name) => name;
+    // A marker on a discarded pre-fallback result must not defer its tool:
+    // convertMessages drops that result, so no tool_reference would replay to
+    // load the deferred definition.
+    const discardedFallbackToolCallIds = collectDiscardedFallbackToolCallIds(transformedMessages, model);
+    const partitionMessages = transformedMessages.filter((message) => !(message.role === "toolResult" && discardedFallbackToolCallIds.has(message.toolCallId)));
+    const toolPlacement = splitDeferredTools({ ...context, messages: partitionMessages }, compat.supportsToolReferences, normalizeToolName);
+    let immediateTools = toolPlacement.immediate;
+    let deferredTools = [...toolPlacement.deferred.values()];
+    if (immediateTools.length === 0 && deferredTools.length > 0) {
+        immediateTools = deferredTools;
+        deferredTools = [];
+    }
+    const deferredToolNames = new Set(deferredTools.map((tool) => normalizeToolName(tool.name)));
     const params = {
         model: model.id,
-        messages: convertMessages(context.messages, model, isOAuthToken, cacheControl, options?.thinkingEnabled === true, compat.allowEmptySignature),
+        messages: convertMessages(transformedMessages, model, isOAuthToken, cacheControl, compat.allowEmptySignature, deferredToolNames, normalizeToolName),
         max_tokens: options?.maxTokens ?? model.maxTokens,
         stream: true,
     };
@@ -1081,8 +1113,11 @@ function buildParams(model, context, isOAuthToken, options) {
             configurable: true,
         });
     }
-    if (context.tools && context.tools.length > 0) {
-        params.tools = convertTools(context.tools, isOAuthToken, compat.supportsEagerToolInputStreaming, compat.supportsCacheControlOnTools ? cacheControl : undefined);
+    if (immediateTools.length > 0 || deferredTools.length > 0) {
+        params.tools = [
+            ...convertTools(immediateTools, isOAuthToken, compat.supportsEagerToolInputStreaming, compat.supportsCacheControlOnTools ? cacheControl : undefined),
+            ...convertTools(deferredTools, isOAuthToken, compat.supportsEagerToolInputStreaming, undefined, true),
+        ];
     }
     // Configure thinking mode: adaptive, budget-based, or explicitly disabled.
     if (model.reasoning) {
@@ -1146,13 +1181,37 @@ function applyExtraBodyToAnthropicParams(params, extraBody) {
 function normalizeToolCallId(id) {
     return id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
 }
-function convertMessages(messages, model, isOAuthToken, cacheControl, preserveThinking = true, allowEmptySignature = false) {
+function convertToolResult(msg, isOAuthToken, deferredToolNames, loadedToolNames, normalizeToolName) {
+    const references = [];
+    for (const name of msg.addedToolNames ?? []) {
+        const normalizedName = normalizeToolName(name);
+        if (!deferredToolNames.has(normalizedName) || loadedToolNames.has(normalizedName))
+            continue;
+        loadedToolNames.add(normalizedName);
+        references.push({
+            type: "tool_reference",
+            tool_name: isOAuthToken ? toClaudeCodeName(name) : name,
+        });
+    }
+    const convertedContent = convertContentBlocks(msg.content);
+    // Anthropic rejects tool references mixed with ordinary tool-result content.
+    return {
+        toolResult: {
+            type: "tool_result",
+            tool_use_id: msg.toolCallId,
+            content: references.length > 0 ? references : convertedContent,
+            is_error: msg.isError,
+        },
+        siblingContent: references.length === 0
+            ? []
+            : typeof convertedContent === "string"
+                ? [{ type: "text", text: convertedContent }]
+                : convertedContent,
+    };
+}
+function convertMessages(transformedMessages, model, isOAuthToken, cacheControl, allowEmptySignature = false, deferredToolNames = new Set(), normalizeToolName = (name) => name) {
     const params = [];
-    // Transform messages for cross-provider compatibility
-    const transformedMessages = transformMessages(messages, model, normalizeToolCallId, {
-        preserveThinking,
-        preserveUnsignedThinking: true,
-    });
+    const loadedToolNames = new Set();
     // Tool calls from a declined pre-fallback attempt are dropped from their
     // assistant turn below; drop their tool_results in lockstep so none dangle.
     const discardedFallbackToolCallIds = collectDiscardedFallbackToolCallIds(transformedMessages, model);
@@ -1241,12 +1300,14 @@ function convertMessages(messages, model, isOAuthToken, cacheControl, preserveTh
                         });
                         continue;
                     }
-                    if (block.thinking.trim().length === 0)
+                    const thinkingSignature = block.thinkingSignature;
+                    const hasThinkingSignature = !!thinkingSignature && thinkingSignature.trim().length > 0;
+                    if (block.thinking.trim().length === 0 && !hasThinkingSignature)
                         continue;
                     // If thinking signature is missing/empty (e.g., from aborted stream),
                     // convert to plain text for Anthropic. Some compatible providers emit
                     // and accept empty signatures, so let marked models preserve the block.
-                    if (!block.thinkingSignature || block.thinkingSignature.trim().length === 0) {
+                    if (!hasThinkingSignature) {
                         blocks.push(allowEmptySignature
                             ? {
                                 type: "thinking",
@@ -1262,7 +1323,7 @@ function convertMessages(messages, model, isOAuthToken, cacheControl, preserveTh
                         blocks.push({
                             type: "thinking",
                             thinking: block.thinking,
-                            signature: block.thinkingSignature,
+                            signature: thinkingSignature,
                         });
                     }
                 }
@@ -1290,41 +1351,28 @@ function convertMessages(messages, model, isOAuthToken, cacheControl, preserveTh
             });
         }
         else if (msg.role === "toolResult") {
-            // Collect all consecutive toolResult messages, needed for z.ai Anthropic endpoint
+            // Collect all consecutive toolResult messages, needed for z.ai Anthropic endpoint.
             const toolResults = [];
-            // Add the current tool result, unless its tool_use was dropped as a
-            // declined pre-fallback attempt (its result would otherwise dangle).
-            if (!discardedFallbackToolCallIds.has(msg.toolCallId)) {
-                toolResults.push({
-                    type: "tool_result",
-                    tool_use_id: msg.toolCallId,
-                    content: convertContentBlocks(msg.content),
-                    is_error: msg.isError,
-                });
-            }
-            // Look ahead for consecutive toolResult messages
-            let j = i + 1;
+            const siblingContent = [];
+            let j = i;
             while (j < transformedMessages.length && transformedMessages[j].role === "toolResult") {
                 const nextMsg = transformedMessages[j]; // We know it's a toolResult
                 if (!discardedFallbackToolCallIds.has(nextMsg.toolCallId)) {
-                    toolResults.push({
-                        type: "tool_result",
-                        tool_use_id: nextMsg.toolCallId,
-                        content: convertContentBlocks(nextMsg.content),
-                        is_error: nextMsg.isError,
-                    });
+                    const converted = convertToolResult(nextMsg, isOAuthToken, deferredToolNames, loadedToolNames, normalizeToolName);
+                    toolResults.push(converted.toolResult);
+                    siblingContent.push(...converted.siblingContent);
                 }
                 j++;
             }
-            // Skip the messages we've already processed
+            // Skip the messages we've already processed.
             i = j - 1;
             // Every result in this run may have been dropped; don't emit an empty turn.
             if (toolResults.length === 0)
                 continue;
-            // Add a single user message with all tool results
+            // Displaced reference-bearing results must follow every tool_result block.
             params.push({
                 role: "user",
-                content: toolResults,
+                content: [...toolResults, ...siblingContent],
             });
         }
     }
@@ -1354,7 +1402,7 @@ function convertMessages(messages, model, isOAuthToken, cacheControl, preserveTh
 function shouldUseFineGrainedToolStreamingBeta(model, context) {
     return !!context.tools?.length && !getAnthropicCompat(model).supportsEagerToolInputStreaming;
 }
-function convertTools(tools, isOAuthToken, supportsEagerToolInputStreaming, cacheControl) {
+function convertTools(tools, isOAuthToken, supportsEagerToolInputStreaming, cacheControl, deferLoading = false) {
     if (!tools)
         return [];
     return tools.map((tool, index) => {
@@ -1368,6 +1416,7 @@ function convertTools(tools, isOAuthToken, supportsEagerToolInputStreaming, cach
                 properties: schema.properties ?? {},
                 required: schema.required ?? [],
             },
+            ...(deferLoading ? { defer_loading: true } : {}),
             ...(cacheControl && index === tools.length - 1 ? { cache_control: cacheControl } : {}),
         };
     });