@code-yeongyu/senpi 2026.7.25-2 → 2026.7.26

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

@@ -10,6 +10,7 @@ import { getProviderEnvValue } from "../utils/provider-env.js";
 import { retryProviderRequest } from "../utils/provider-retry.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
 import { applyServerFallbackAbort, parseServerFallbackReceipt, parseStickyFallbackReceipt, } from "../utils/server-fallback-receipt.js";
+import { normalizeToolCallId } from "../utils/tool-call-id.js";
 import { isForcedToolChoiceUnsupportedError, omitToolChoiceParam } from "../utils/tool-choice-fallback.js";
 import { resolveCloudflareBaseUrl } from "./cloudflare.js";
 import { resolveJsonSchemaStrictSampling } from "./constrained-sampling.js";
@@ -309,6 +310,97 @@ function isAnthropicWebSearchReplayBlock(raw) {
         return true;
     return raw.type === "server_tool_use" && raw.name === "web_search";
 }
+// The user turn a pending server tool can survive is one that carries only
+// tool results. Anything else the wire would emit — real text, an image —
+// closes the assistant turn (the API then 400s the still-open use). A blank
+// message serializes to nothing, so it closes nothing.
+function userMessageClosesServerTurn(message) {
+    if (typeof message.content === "string")
+        return message.content.trim().length > 0;
+    return message.content.some((block) => (block.type === "text" && block.text.trim().length > 0) || block.type === "image");
+}
+function collectProviderNativeToolPairing(messages, model, deferredToolNames, normalizeToolName, discardedFallbackToolCallIds) {
+    const resolvedUseIds = new Set();
+    const validResultIds = new Set();
+    // Uses whose turn can still be resumed. A same-model assistant resets the
+    // set: its own result blocks may answer the prior pending uses, and any use
+    // it leaves pending becomes the open set. Anything that closes the turn —
+    // user text, a tool result whose deferred-tool references serialize sibling
+    // text after the results, or another model's assistant — empties it.
+    let pendingUseIds = new Set();
+    const loadedReferenceNames = new Set();
+    for (const message of messages) {
+        if (message.role === "assistant") {
+            const priorUseIds = pendingUseIds;
+            pendingUseIds = new Set();
+            if (!isSameAnthropicModel(message, model))
+                continue;
+            for (const block of message.content) {
+                if (block.type !== "providerNative" || !isRecord(block.raw))
+                    continue;
+                const raw = block.raw;
+                if (typeof raw.type !== "string" || !REPLAYABLE_ANTHROPIC_PROVIDER_NATIVE_TYPES.has(raw.type))
+                    continue;
+                if (isProviderNativeToolUseBlock(raw) && typeof raw.id === "string")
+                    pendingUseIds.add(raw.id);
+            }
+            for (const block of message.content) {
+                if (block.type !== "providerNative" || !isRecord(block.raw))
+                    continue;
+                const raw = block.raw;
+                if (typeof raw.type !== "string" || !REPLAYABLE_ANTHROPIC_PROVIDER_NATIVE_TYPES.has(raw.type))
+                    continue;
+                const toolUseId = raw.tool_use_id;
+                if (typeof toolUseId !== "string")
+                    continue;
+                if (priorUseIds.has(toolUseId) || pendingUseIds.has(toolUseId)) {
+                    resolvedUseIds.add(toolUseId);
+                    validResultIds.add(toolUseId);
+                }
+            }
+            continue;
+        }
+        if (message.role === "toolResult") {
+            // Conversion drops a discarded pre-fallback result without touching
+            // loadedToolNames, so it must not load the name here either.
+            if (discardedFallbackToolCallIds.has(message.toolCallId))
+                continue;
+            // convertToolResult emits sibling text after the tool_result blocks only
+            // for names that survive the deferred/loaded filter, so only those names
+            // close the turn; a stale or already-loaded name leaves the result plain
+            // and the pending use resumable.
+            let emitsReferences = false;
+            for (const name of message.addedToolNames ?? []) {
+                const normalizedName = normalizeToolName(name);
+                if (!deferredToolNames.has(normalizedName) || loadedReferenceNames.has(normalizedName))
+                    continue;
+                loadedReferenceNames.add(normalizedName);
+                emitsReferences = true;
+            }
+            if (emitsReferences)
+                pendingUseIds = new Set();
+            continue;
+        }
+        if (message.role === "user" && userMessageClosesServerTurn(message)) {
+            pendingUseIds = new Set();
+        }
+    }
+    // Whatever is still pending at the end of history belongs to the last
+    // assistant message and can still resume, so it is live rather than unpaired.
+    return { resolvedUseIds, liveUseIds: pendingUseIds, validResultIds };
+}
+// True for a server-tool block whose counterpart can never arrive: a use that
+// is neither answered nor resumable, or a result whose use is nowhere.
+// Blocks that pair nothing (`fallback`, `container_upload`) are never unpaired.
+function isUnpairedProviderNativeToolBlock(raw, pairing) {
+    if (!isRecord(raw))
+        return false;
+    if (isProviderNativeToolUseBlock(raw)) {
+        return typeof raw.id !== "string" || !(pairing.resolvedUseIds.has(raw.id) || pairing.liveUseIds.has(raw.id));
+    }
+    const toolUseId = raw.tool_use_id;
+    return typeof toolUseId === "string" && !pairing.validResultIds.has(toolUseId);
+}
 // tool_use ids referenced by server-tool result blocks in content[0, boundary).
 // A pre-boundary `server_tool_use` whose id is absent here is unpaired — the
 // fallback interrupted the declined attempt before its result arrived — so
@@ -1055,6 +1147,18 @@ function cannotDisableThinking(model, compat) {
         return true;
     return matchesModelMarker(model, DISABLED_THINKING_REJECTING_MODEL_MARKERS);
 }
+function disableThinkingForRequest(params, model, compat) {
+    // A degraded/disabled turn must not retain the caller's higher effort.
+    delete params.output_config;
+    if (cannotDisableThinking(model, compat)) {
+        delete params.thinking;
+        if (supportsAdaptiveThinking(model)) {
+            params.output_config = { effort: "low" };
+        }
+        return;
+    }
+    params.thinking = { type: "disabled" };
+}
 function supportsAdaptiveThinking(model) {
     if (model.compat?.forceAdaptiveThinking !== undefined) {
         return model.compat.forceAdaptiveThinking;
@@ -1288,20 +1392,18 @@ function buildParams(model, context, isOAuthToken, options, unsignedThinkingRepl
             }
         }
         else if (options?.thinkingEnabled === false) {
-            if (cannotDisableThinking(model, compat)) {
-                // These families reject `thinking.type: "disabled"` with a 400 AND default to adaptive
-                // thinking when the field is absent, so omitting it silently bills full reasoning for a
-                // "thinking off" turn. The API exposes no true off switch here, so pin the cheapest
-                // effort: the request stays valid and reasoning stays at the documented minimum.
-                if (supportsAdaptiveThinking(model)) {
-                    params.output_config = { effort: "low" };
-                }
-            }
-            else {
-                params.thinking = { type: "disabled" };
-            }
+            // Some adaptive families reject `thinking.type: "disabled"` and default
+            // to reasoning when omitted. Keep their request valid at the cheapest
+            // legal effort; use an explicit disabled block everywhere else.
+            disableThinkingForRequest(params, model, compat);
         }
     }
+    // Anthropic rejects a thinking-enabled request whose final assistant turn
+    // contains tool_use but does not begin with a thinking block. Cross-model
+    // histories lose their signed thinking blocks (demoted to text or dropped),
+    // so degrade thinking for this request instead of failing every turn.
+    if (params.thinking && params.thinking.type !== "disabled" && finalAssistantTurnStartsWithToolUse(params.messages))
+        disableThinkingForRequest(params, model, compat);
     if (options?.metadata) {
         const userId = options.metadata.user_id;
         if (typeof userId === "string") {
@@ -1331,9 +1433,24 @@ function applyExtraBodyToAnthropicParams(params, extraBody) {
         Object.defineProperty(params, key, { value, writable: true, enumerable: true, configurable: true });
     }
 }
-// Normalize tool call IDs to match Anthropic's required pattern and length
-function normalizeToolCallId(id) {
-    return id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
+/**
+ * Whether the final assistant turn contains tool_use without a leading
+ * thinking/redacted_thinking block. Anthropic requires thinking-enabled
+ * requests to start that turn with a thinking block.
+ */
+function finalAssistantTurnStartsWithToolUse(messages) {
+    for (let index = messages.length - 1; index >= 0; index--) {
+        const message = messages[index];
+        if (message.role !== "assistant")
+            continue;
+        if (!Array.isArray(message.content) || message.content.length === 0)
+            return false;
+        const first = message.content[0];
+        if (first.type === "thinking" || first.type === "redacted_thinking")
+            return false;
+        return message.content.some((block) => block.type === "tool_use");
+    }
+    return false;
 }
 function convertToolResult(msg, isOAuthToken, deferredToolNames, loadedToolNames, normalizeToolName) {
     const references = [];
@@ -1372,6 +1489,7 @@ function convertMessages(transformedMessages, model, isOAuthToken, cacheControl,
     // assistant turn below; drop their tool_results in lockstep so none dangle.
     const discardedFallbackToolCallIds = collectDiscardedFallbackToolCallIds(transformedMessages, model);
     const rejectsNativeWebSearchReplay = !getAnthropicCompat(model).supportsWebSearch;
+    const providerNativeToolPairing = collectProviderNativeToolPairing(transformedMessages, model, deferredToolNames, normalizeToolName, discardedFallbackToolCallIds);
     for (let i = 0; i < transformedMessages.length; i++) {
         const msg = transformedMessages[i];
         if (msg.role === "user") {
@@ -1505,7 +1623,8 @@ function convertMessages(transformedMessages, model, isOAuthToken, cacheControl,
                 else if (block.type === "providerNative") {
                     if (isSameModel &&
                         isReplayableAnthropicProviderNativeBlock(block.raw) &&
-                        !(rejectsNativeWebSearchReplay && isAnthropicWebSearchReplayBlock(block.raw))) {
+                        !(rejectsNativeWebSearchReplay && isAnthropicWebSearchReplayBlock(block.raw)) &&
+                        !isUnpairedProviderNativeToolBlock(block.raw, providerNativeToolPairing)) {
                         blocks.push(block.raw);
                     }
                 }