@code-yeongyu/senpi 2026.7.25 → 2026.7.26

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

@@ -1,6 +1,7 @@
 import Anthropic from "@anthropic-ai/sdk";
 import { calculateCost } from "../models.js";
 import { isVideoMimeType } from "../types.js";
+import { combineAbortSignals } from "../utils/abort-signals.js";
 import { splitDeferredTools } from "../utils/deferred-tools.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { headersToRecord, providerHeadersToRecord } from "../utils/headers.js";
@@ -8,6 +9,8 @@ import { parseJsonWithRepair, parseStreamingJson } from "../utils/json-parse.js"
 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";
@@ -136,7 +139,35 @@ const FINE_GRAINED_TOOL_STREAMING_BETA = "fine-grained-tool-streaming-2025-05-14
 const INTERLEAVED_THINKING_BETA = "interleaved-thinking-2025-05-14";
 const COMPUTER_USE_BETA_PREFIX = "computer-use-";
 const NATIVE_COMPUTER_TOOL_TYPE = "computer_20250124";
-const ADAPTIVE_THINKING_MODEL_MARKERS = ["opus-4-6", "opus-4-7", "sonnet-4-6"];
+const ADAPTIVE_THINKING_MODEL_MARKERS = [
+    "opus-4-6",
+    "opus-4-7",
+    "opus-4-8",
+    "opus-5",
+    "sonnet-4-6",
+    "sonnet-5",
+    "fable-5",
+    "mythos-5",
+];
+/**
+ * Adaptive families that expose the real `xhigh` effort tier. Everything else on the
+ * adaptive ladder tops out at `max` (Opus/Sonnet 4.6 are four-tier: low/medium/high/max).
+ */
+const NATIVE_XHIGH_EFFORT_MODEL_MARKERS = [
+    "opus-4-7",
+    "opus-4-8",
+    "opus-5",
+    "sonnet-5",
+    "fable-5",
+    "mythos-5",
+];
+/**
+ * Adaptive families that reject `thinking: {type: "disabled"}` outright (verified 400:
+ * `"thinking.type.disabled" is not supported for this model`). The generated catalog also encodes
+ * this as `compat.supportsDisabledThinking: false`, but `models.json` entries and third-party
+ * gateway rows carry no generated compat, so the family fact has to live here as well.
+ */
+const DISABLED_THINKING_REJECTING_MODEL_MARKERS = ["fable-5", "mythos-5"];
 const CLAUDE_FABLE_OR_MYTHOS_MODEL_ID = /^claude-(?:fable|mythos)(?:-|$)/i;
 const UNSUPPORTED_NATIVE_COMPUTER_TOOL_MODEL_MARKERS = [
     "opus-4-6",
@@ -279,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
@@ -652,6 +774,10 @@ export const stream = (model, context, options) => {
             stopReason: "stop",
             timestamp: Date.now(),
         };
+        const serverFallbackAbort = new AbortController();
+        let serverFallbackReceipt;
+        const combinedAbort = combineAbortSignals([options?.signal, serverFallbackAbort.signal]);
+        const requestSignal = combinedAbort.signal;
         try {
             let client;
             let isOAuth;
@@ -694,7 +820,7 @@ export const stream = (model, context, options) => {
                 const payloadRequestMetadata = extractPayloadRequestMetadata(params);
                 params = payloadRequestMetadata.params;
                 const requestOptions = {
-                    ...(options?.signal ? { signal: options.signal } : {}),
+                    ...(requestSignal ? { signal: requestSignal } : {}),
                     ...(options?.timeoutMs !== undefined ? { timeout: options.timeoutMs } : {}),
                     maxRetries: 0,
                     ...(payloadRequestMetadata.headers ? { headers: payloadRequestMetadata.headers } : {}),
@@ -714,7 +840,7 @@ export const stream = (model, context, options) => {
                     throw error;
                 }
             };
-            const { response } = await retryProviderRequest(async () => {
+            const { params: sentParams, response } = await retryProviderRequest(async () => {
                 try {
                     return await createRequest();
                 }
@@ -730,12 +856,12 @@ export const stream = (model, context, options) => {
             }, {
                 maxRetries: options?.maxRetries,
                 maxRetryDelayMs: options?.maxRetryDelayMs,
-                signal: options?.signal,
+                signal: requestSignal,
             });
             await options?.onResponse?.({ status: response.status, headers: headersToRecord(response.headers) }, model);
             stream.push({ type: "start", partial: output });
             const blocks = output.content;
-            for await (const event of iterateAnthropicEvents(response, options?.signal)) {
+            for await (const event of iterateAnthropicEvents(response, requestSignal)) {
                 if (event.type === "message_start") {
                     output.responseId = event.message.id;
                     // Capture initial token usage from message_start event
@@ -749,8 +875,24 @@ export const stream = (model, context, options) => {
                     output.usage.totalTokens =
                         output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
                     calculateCost(model, output.usage);
+                    const stickyReceipt = options?.abortServerSideFallback === true
+                        ? parseStickyFallbackReceipt(event.message.usage, sentParams.model, event.message.model)
+                        : undefined;
+                    if (stickyReceipt !== undefined) {
+                        serverFallbackReceipt = stickyReceipt;
+                        serverFallbackAbort.abort();
+                        break;
+                    }
                 }
                 else if (event.type === "content_block_start") {
+                    const receipt = options?.abortServerSideFallback === true
+                        ? parseServerFallbackReceipt(event.content_block)
+                        : undefined;
+                    if (receipt !== undefined) {
+                        serverFallbackReceipt = receipt;
+                        serverFallbackAbort.abort();
+                        break;
+                    }
                     if (event.content_block.type === "text") {
                         const block = {
                             type: "text",
@@ -948,13 +1090,18 @@ export const stream = (model, context, options) => {
             if (options?.signal?.aborted) {
                 throw new Error("Request was aborted");
             }
+            if (serverFallbackReceipt !== undefined) {
+                applyServerFallbackAbort(output, serverFallbackReceipt);
+            }
             if (output.stopReason === "aborted" || output.stopReason === "error") {
                 throw new Error(output.errorMessage || "An unknown error occurred");
             }
+            combinedAbort.cleanup();
             stream.push({ type: "done", reason: output.stopReason, message: output });
             stream.end();
         }
         catch (error) {
+            combinedAbort.cleanup();
             for (const block of output.content) {
                 delete block.index;
                 // An aborted stream never reaches content_block_stop; keep whatever
@@ -989,11 +1136,28 @@ function matchesModelMarker(model, markers) {
     const candidates = getModelMatchCandidates(model);
     return candidates.some((candidate) => markers.some((marker) => candidate.includes(marker)));
 }
-function isOpus46(model) {
-    return matchesModelMarker(model, ["opus-4-6"]);
+function supportsNativeXhighEffort(model) {
+    return matchesModelMarker(model, NATIVE_XHIGH_EFFORT_MODEL_MARKERS);
+}
+/** True when the model cannot accept `thinking: {type: "disabled"}` on the wire. */
+function cannotDisableThinking(model, compat) {
+    if (!compat.supportsDisabledThinking)
+        return true;
+    if (model.thinkingLevelMap?.off === null)
+        return true;
+    return matchesModelMarker(model, DISABLED_THINKING_REJECTING_MODEL_MARKERS);
 }
-function isOpus47(model) {
-    return matchesModelMarker(model, ["opus-4-7"]);
+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) {
@@ -1004,7 +1168,7 @@ function supportsAdaptiveThinking(model) {
 /**
  * Map ThinkingLevel to Anthropic effort levels for adaptive thinking.
  * 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.
+ * "xhigh" is only available on Opus 4.7/4.8, Opus 5, Sonnet 5, and Fable 5.
  */
 function mapThinkingLevelToEffort(model, level) {
     const mapped = level ? model.thinkingLevelMap?.[level] : undefined;
@@ -1019,15 +1183,11 @@ function mapThinkingLevelToEffort(model, level) {
         case "high":
             return "high";
         case "xhigh":
-            if (isOpus47(model))
-                return "xhigh";
-            if (isOpus46(model))
-                return "max";
-            return "high";
+            // Only called for adaptive models, so the floor is the adaptive ladder's top
+            // tier (`max`), never `high` — degrading xhigh to high silently under-thinks.
+            return supportsNativeXhighEffort(model) ? "xhigh" : "max";
         case "max":
-            if (isOpus47(model) || isOpus46(model))
-                return "max";
-            return "high";
+            return "max";
         default:
             return "high";
     }
@@ -1231,12 +1391,19 @@ function buildParams(model, context, isOAuthToken, options, unsignedThinkingRepl
                 };
             }
         }
-        else if (options?.thinkingEnabled === false &&
-            compat.supportsDisabledThinking &&
-            model.thinkingLevelMap?.off !== null) {
-            params.thinking = { type: "disabled" };
+        else if (options?.thinkingEnabled === false) {
+            // 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") {
@@ -1266,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 = [];
@@ -1307,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") {
@@ -1440,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);
                     }
                 }