@code-yeongyu/senpi-ai 2026.9.7 → 2026.9.9-2

package/dist/api/anthropic-messages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"anthropic-messages.d.ts","sourceRoot":"","sources":["../../src/api/anthropic-messages.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,mBAAmB,CAAC;AAC1C,OAAO,KAAK,EAMX,+BAA+B,EAK/B,MAAM,uDAAuD,CAAC;AAG/D,OAAO,KAAK,EACX,wBAAwB,EAKxB,OAAO,EAGP,KAAK,EAGL,mBAAmB,EAEnB,cAAc,EACd,aAAa,EAOb,MAAM,aAAa,CAAC;AAqCrB,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AA6JlE,MAAM,MAAM,eAAe,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,GAAG,KAAK,CAAC;AAE1E,MAAM,MAAM,wBAAwB,GAAG,YAAY,GAAG,SAAS,CAAC;AA+FhE,MAAM,WAAW,gBAAiB,SAAQ,aAAa;IACtD;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB;;;;;;;;;;;OAWG;IACH,eAAe,CAAC,EAAE,wBAAwB,CAAC;IAC3C;;;;;OAKG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,wEAAwE;IACxE,gBAAgB,CAAC,EAAE,wBAAwB,CAAC;IAC5C;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,GAAG,KAAK,GAAG,MAAM,GAAG;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACtE;;;;OAIG;IACH,MAAM,CAAC,EAAE,SAAS,CAAC;CACnB;AAo4BD,eAAO,MAAM,MAAM,EAAE,cAAc,CAAC,oBAAoB,EAAE,gBAAgB,CA2czE,CAAC;AAyFF,eAAO,MAAM,YAAY,EAAE,cAAc,CAAC,oBAAoB,EAAE,mBAAmB,CA+ClF,CAAC;AA6IF,wBAAgB,mCAAmC,CAClD,KAAK,EAAE,KAAK,CAAC,oBAAoB,CAAC,EAClC,OAAO,EAAE,OAAO,EAChB,OAAO,CAAC,EAAE,gBAAgB,GACxB,+BAA+B,CAkBjC"}
+{"version":3,"file":"anthropic-messages.d.ts","sourceRoot":"","sources":["../../src/api/anthropic-messages.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,mBAAmB,CAAC;AAC1C,OAAO,KAAK,EAMX,+BAA+B,EAK/B,MAAM,uDAAuD,CAAC;AAG/D,OAAO,KAAK,EACX,wBAAwB,EAKxB,OAAO,EAGP,KAAK,EAGL,mBAAmB,EAEnB,cAAc,EACd,aAAa,EAOb,MAAM,aAAa,CAAC;AAsCrB,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AA6JlE,MAAM,MAAM,eAAe,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,GAAG,KAAK,CAAC;AAE1E,MAAM,MAAM,wBAAwB,GAAG,YAAY,GAAG,SAAS,CAAC;AA+FhE,MAAM,WAAW,gBAAiB,SAAQ,aAAa;IACtD;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB;;;;;;;;;;;OAWG;IACH,eAAe,CAAC,EAAE,wBAAwB,CAAC;IAC3C;;;;;OAKG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,wEAAwE;IACxE,gBAAgB,CAAC,EAAE,wBAAwB,CAAC;IAC5C;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,GAAG,KAAK,GAAG,MAAM,GAAG;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACtE;;;;OAIG;IACH,MAAM,CAAC,EAAE,SAAS,CAAC;CACnB;AAmvBD,eAAO,MAAM,MAAM,EAAE,cAAc,CAAC,oBAAoB,EAAE,gBAAgB,CAudzE,CAAC;AAyFF,eAAO,MAAM,YAAY,EAAE,cAAc,CAAC,oBAAoB,EAAE,mBAAmB,CA+ClF,CAAC;AA6IF,wBAAgB,mCAAmC,CAClD,KAAK,EAAE,KAAK,CAAC,oBAAoB,CAAC,EAClC,OAAO,EAAE,OAAO,EAChB,OAAO,CAAC,EAAE,gBAAgB,GACxB,+BAA+B,CAkBjC"}

package/dist/api/anthropic-messages.js

@@ -15,12 +15,12 @@ import { retryProviderRequest } from "../utils/provider-retry.js";
 import { appendRetryAfterMsMarker, extract429RetryAfterMs } from "../utils/retry-hint.js";
 import { normalizeAnthropicRetryFailure } from "../utils/retry-profile/failure.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
-import { applyServerFallbackAbort, parseServerFallbackReceipt, parseStickyFallbackReceipt, } from "../utils/server-fallback-receipt.js";
+import { applyServerFallbackAbort, applyServerFallbackContinuation, 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 { resolveRootObjectSchema } from "../utils/tool-schema-compat.js";
-import { demotedToolCallText, demotedToolResultText } from "../utils/unavailable-tool-text.js";
 import { sanitizeAnthropicToolPairs } from "./anthropic-tool-pairs.js";
+import { demoteUnavailableToolReferences } from "./anthropic-tool-references.js";
 import { resolveCloudflareBaseUrl } from "./cloudflare.js";
 import { getJsonSchemaToolParameters, resolveJsonSchemaStrictSampling } from "./constrained-sampling.js";
 import { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "./github-copilot-headers.js";
@@ -571,157 +571,12 @@ function sanitizeUnsupportedNativeTools(model, params) {
     }
     return changed ? sanitized : params;
 }
-/**
- * Anthropic validates that every tool referenced by the message history is
- * available in the same request — defined in `tools` or discovered through a
- * `tool_reference` block — and rejects the whole request otherwise
- * ("Tool reference '<name>' not found in available tools"). Sessions outlive
- * their tools: an MCP server can be absent after a resume, an extension can
- * stop registering a tool, or a payload hook can strip a definition while the
- * history still carries the call. Demote those references to plain text so
- * the turn can proceed; the matching tool_result is demoted in lockstep so no
- * orphan pairing error replaces the original one.
- */
-function demoteUnavailableToolReferences(params) {
-    const messages = params.messages;
-    if (!Array.isArray(messages) || messages.length === 0)
-        return params;
-    const definedNames = new Set();
-    if (Array.isArray(params.tools)) {
-        for (const tool of params.tools) {
-            if (isRecord(tool) && typeof tool.name === "string")
-                definedNames.add(tool.name);
-        }
-    }
-    // `tool_reference` blocks — emitted for deferred tools or replayed from a
-    // server-side tool search — make their targets available without a
-    // non-deferred definition.
-    const discoveredNames = new Set();
-    collectToolReferenceNames(messages, discoveredNames);
-    const demotedCallNames = new Map();
-    for (const message of messages) {
-        if (message.role !== "assistant" || !Array.isArray(message.content))
-            continue;
-        for (const block of message.content) {
-            if (isRecord(block) &&
-                block.type === "tool_use" &&
-                typeof block.name === "string" &&
-                !definedNames.has(block.name) &&
-                !discoveredNames.has(block.name)) {
-                demotedCallNames.set(block.id, block.name);
-            }
-        }
-    }
-    // A `tool_reference` without its definition 400s the same way.
-    const danglingReferenceNames = new Set();
-    for (const name of discoveredNames) {
-        if (!definedNames.has(name))
-            danglingReferenceNames.add(name);
-    }
-    if (demotedCallNames.size === 0 && danglingReferenceNames.size === 0)
-        return params;
-    let changed = false;
-    const availableToolNames = [...definedNames];
-    const seenDemotedCallNames = new Set();
-    const rewrittenMessages = [];
-    for (const message of messages) {
-        if (!Array.isArray(message.content)) {
-            rewrittenMessages.push(message);
-            continue;
-        }
-        let messageChanged = false;
-        const content = [];
-        for (const block of message.content) {
-            if (message.role === "assistant" && isRecord(block) && block.type === "tool_use") {
-                const demotedName = demotedCallNames.get(block.id);
-                if (demotedName !== undefined) {
-                    messageChanged = true;
-                    const firstOccurrence = !seenDemotedCallNames.has(demotedName);
-                    seenDemotedCallNames.add(demotedName);
-                    content.push({
-                        type: "text",
-                        text: demotedToolCallText(demotedName, availableToolNames, firstOccurrence),
-                    });
-                    continue;
-                }
-            }
-            if (isRecord(block) && block.type === "tool_result") {
-                const demotedName = demotedCallNames.get(block.tool_use_id);
-                if (demotedName !== undefined) {
-                    messageChanged = true;
-                    content.push({ type: "text", text: demotedToolResultText(demotedName, toolResultText(block.content)) });
-                    continue;
-                }
-                if (danglingReferenceNames.size > 0 && Array.isArray(block.content)) {
-                    const kept = [];
-                    const omitted = [];
-                    for (const item of block.content) {
-                        if (isRecord(item) &&
-                            item.type === "tool_reference" &&
-                            typeof item.tool_name === "string" &&
-                            danglingReferenceNames.has(item.tool_name)) {
-                            omitted.push(item.tool_name);
-                            continue;
-                        }
-                        kept.push(item);
-                    }
-                    if (omitted.length > 0) {
-                        messageChanged = true;
-                        const nextContent = kept.length > 0
-                            ? kept
-                            : [{ type: "text", text: `Tool reference unavailable: ${[...new Set(omitted)].join(", ")}` }];
-                        content.push({ ...block, content: nextContent });
-                        continue;
-                    }
-                }
-            }
-            content.push(block);
-        }
-        if (content.length === 0) {
-            changed = true;
-            continue;
-        }
-        if (messageChanged) {
-            changed = true;
-            rewrittenMessages.push({ ...message, content });
-            continue;
-        }
-        rewrittenMessages.push(message);
-    }
-    if (!changed)
-        return params;
-    return { ...params, messages: rewrittenMessages };
-}
-function collectToolReferenceNames(value, names) {
-    if (Array.isArray(value)) {
-        for (const item of value)
-            collectToolReferenceNames(item, names);
-        return;
-    }
-    if (!isRecord(value))
-        return;
-    if (value.type === "tool_reference" && typeof value.tool_name === "string")
-        names.add(value.tool_name);
-    for (const nested of Object.values(value))
-        collectToolReferenceNames(nested, names);
-}
-function toolResultText(content) {
-    if (typeof content === "string")
-        return content;
-    if (Array.isArray(content)) {
-        const parts = [];
-        for (const item of content) {
-            if (!isRecord(item))
-                continue;
-            if (item.type === "text" && typeof item.text === "string")
-                parts.push(item.text);
-            else if (typeof item.type === "string")
-                parts.push(`[${item.type}]`);
-        }
-        if (parts.length > 0)
-            return parts.join("\n");
-    }
-    return "Tool output unavailable.";
+/** Numeric HTTP status carried by an SDK error (Anthropic APIError.status), if any. */
+function httpStatusOfError(error) {
+    if (!isRecord(error))
+        return undefined;
+    const status = error.status;
+    return typeof status === "number" && Number.isInteger(status) && status >= 100 && status < 600 ? status : undefined;
 }
 function sanitizeAdaptiveThinkingPayload(model, params, options) {
     if (!supportsAdaptiveThinking(model)) {
@@ -1046,24 +901,40 @@ export const stream = (model, context, options) => {
                     throw error;
                 }
             };
-            const { params: sentParams, response } = await retryProviderRequest(async () => {
-                try {
-                    return await createRequest();
-                }
-                catch (error) {
-                    if (unsignedThinkingReplay !== "text" && isInvalidUnsignedThinkingSignatureError(error)) {
-                        unsignedThinkingReplay = "text";
-                        if (fallbackKey)
-                            unsignedThinkingTextReplayFallbacks.add(fallbackKey);
-                        return createRequest();
+            let requestOutcome;
+            try {
+                requestOutcome = await retryProviderRequest(async () => {
+                    try {
+                        return await createRequest();
                     }
-                    throw error;
+                    catch (error) {
+                        if (unsignedThinkingReplay !== "text" && isInvalidUnsignedThinkingSignatureError(error)) {
+                            unsignedThinkingReplay = "text";
+                            if (fallbackKey)
+                                unsignedThinkingTextReplayFallbacks.add(fallbackKey);
+                            return createRequest();
+                        }
+                        throw error;
+                    }
+                }, {
+                    maxRetries: options?.maxRetries,
+                    maxRetryDelayMs: options?.maxRetryDelayMs,
+                    signal: requestSignal,
+                });
+            }
+            catch (error) {
+                // The SDK rejects HTTP failures instead of returning a Response, so a
+                // rejected request never reached onResponse. Deliver the numeric status
+                // once, after every internal retry, before the caller handles the error;
+                // errors without a status (network, aborts) report nothing rather than
+                // a fabricated code.
+                const status = httpStatusOfError(error);
+                if (status !== undefined) {
+                    await options?.onResponse?.({ status, headers: {} }, model);
                 }
-            }, {
-                maxRetries: options?.maxRetries,
-                maxRetryDelayMs: options?.maxRetryDelayMs,
-                signal: requestSignal,
-            });
+                throw error;
+            }
+            const { params: sentParams, response } = requestOutcome;
             await options?.onResponse?.({ status: response.status, headers: headersToRecord(response.headers) }, model);
             stream.push({ type: "start", partial: output });
             const blocks = output.content;
@@ -1102,16 +973,14 @@ export const stream = (model, context, options) => {
                     }
                 }
                 else if (event.type === "content_block_start") {
-                    if (event.content_block.type === "fallback" && output.content.length > 0) {
-                        throw new Error("Anthropic performed an unsupported mid-output model fallback");
-                    }
-                    const receipt = options?.abortServerSideFallback === true
-                        ? parseServerFallbackReceipt(event.content_block)
-                        : undefined;
+                    const receipt = parseServerFallbackReceipt(event.content_block);
                     if (receipt !== undefined) {
-                        serverFallbackReceipt = receipt;
-                        serverFallbackAbort.abort();
-                        break;
+                        if (options?.abortServerSideFallback === true) {
+                            serverFallbackReceipt = receipt;
+                            serverFallbackAbort.abort();
+                            break;
+                        }
+                        usageModel = applyServerFallbackContinuation(output, model, receipt);
                     }
                     if (event.content_block.type === "text") {
                         const block = {
@@ -1749,11 +1618,19 @@ function buildParams(model, context, isOAuthToken, options, unsignedThinkingRepl
             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))
+    // A budget-thinking request whose final assistant turn came from another API
+    // and starts with tool_use (its thinking demoted to text or dropped) is the
+    // history shape Anthropic has rejected with "final assistant message must
+    // start with a thinking block", so that request degrades thinking instead of
+    // failing every turn. Nothing else degrades: adaptive families accept a
+    // tool_use-first final turn (verified live 2026-09-09 on claude-opus-5,
+    // claude-opus-4-6 and claude-fable-5), the model itself skips thinking before
+    // trivial tool calls, and every change to `thinking` re-keys the prompt
+    // cache - degrading here re-wrote the whole cached prefix on each tool
+    // continuation (the "cache misses every second prompt" report).
+    if (params.thinking?.type === "enabled" &&
+        finalAssistantTurnIsForeign(context.messages) &&
+        finalAssistantTurnStartsWithToolUse(params.messages))
         disableThinkingForRequest(params, model, compat);
     if (options?.metadata) {
         const userId = options.metadata.user_id;
@@ -1794,6 +1671,16 @@ function applyExtraBodyToAnthropicParams(params, extraBody) {
  * thinking/redacted_thinking block. Anthropic requires thinking-enabled
  * requests to start that turn with a thinking block.
  */
+/** True when the last assistant message was produced through a different wire API. */
+function finalAssistantTurnIsForeign(messages) {
+    for (let index = messages.length - 1; index >= 0; index--) {
+        const message = messages[index];
+        if (message.role !== "assistant")
+            continue;
+        return message.api !== "anthropic-messages";
+    }
+    return false;
+}
 function finalAssistantTurnStartsWithToolUse(messages) {
     for (let index = messages.length - 1; index >= 0; index--) {
         const message = messages[index];