@code-yeongyu/senpi-ai 2026.7.25-2 → 2026.7.28

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

@@ -1,5 +1,6 @@
 import Anthropic from "@anthropic-ai/sdk";
 import type { SimpleStreamOptions, StreamFunction, StreamOptions } from "../types.ts";
+export { getAnthropicCompat } from "../utils/prompt-cache-ttl.ts";
 export type AnthropicEffort = "low" | "medium" | "high" | "xhigh" | "max";
 export type AnthropicThinkingDisplay = "summarized" | "omitted";
 export interface AnthropicOptions extends StreamOptions {

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;AAU1C,OAAO,KAAK,EAYX,mBAAmB,EAEnB,cAAc,EACd,aAAa,EAMb,MAAM,aAAa,CAAC;AAgMrB,MAAM,MAAM,eAAe,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,GAAG,KAAK,CAAC;AAE1E,MAAM,MAAM,wBAAwB,GAAG,YAAY,GAAG,SAAS,CAAC;AAoHhE,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;;;;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;AA2iBD,eAAO,MAAM,MAAM,EAAE,cAAc,CAAC,oBAAoB,EAAE,gBAAgB,CAoYzE,CAAC;AAyEF,eAAO,MAAM,YAAY,EAAE,cAAc,CAAC,oBAAoB,EAAE,mBAAmB,CA2ClF,CAAC"}
+{"version":3,"file":"anthropic-messages.d.ts","sourceRoot":"","sources":["../../src/api/anthropic-messages.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,mBAAmB,CAAC;AAU1C,OAAO,KAAK,EAWX,mBAAmB,EAEnB,cAAc,EACd,aAAa,EAOb,MAAM,aAAa,CAAC;AA+BrB,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;AAoEhE,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;;;;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;AA8zBD,eAAO,MAAM,MAAM,EAAE,cAAc,CAAC,oBAAoB,EAAE,gBAAgB,CAqYzE,CAAC;AA0FF,eAAO,MAAM,YAAY,EAAE,cAAc,CAAC,oBAAoB,EAAE,mBAAmB,CA2ClF,CAAC"}

package/dist/api/anthropic-messages.js

@@ -6,16 +6,19 @@ 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";
+import { getAnthropicCompat, isAnthropicApiBaseUrl } from "../utils/prompt-cache-ttl.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";
 import { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "./github-copilot-headers.js";
 import { ANTHROPIC_RESERVED_BODY_KEYS, adjustMaxTokensForThinking, buildBaseOptions, clampMaxTokensToContext, } from "./simple-options.js";
 import { transformMessages } from "./transform-messages.js";
+export { getAnthropicCompat } from "../utils/prompt-cache-ttl.js";
 /**
  * Resolve cache retention preference.
  * Defaults to the provided fallback and uses PI_CACHE_RETENTION for backward compatibility.
@@ -32,14 +35,6 @@ function resolveCacheRetention(cacheRetention, env, fallback = "short") {
     }
     return fallback;
 }
-function isAnthropicApiBaseUrl(baseUrl) {
-    try {
-        return new URL(baseUrl).hostname === "api.anthropic.com";
-    }
-    catch {
-        return false;
-    }
-}
 function getCacheControl(model, cacheRetention, env) {
     const retention = resolveCacheRetention(cacheRetention, env, "long");
     if (retention === "none") {
@@ -167,7 +162,6 @@ const NATIVE_XHIGH_EFFORT_MODEL_MARKERS = [
  * 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",
     "opus-4.6",
@@ -190,47 +184,6 @@ function isInvalidUnsignedThinkingSignatureError(error) {
         error instanceof Error &&
         /Invalid signature in thinking block/i.test(error.message));
 }
-function getAnthropicCompat(model) {
-    // Auto-detect session affinity and cache control support from provider
-    const isFireworks = model.provider === "fireworks";
-    const isCloudflareAiGatewayAnthropic = model.provider === "cloudflare-ai-gateway" && model.baseUrl.includes("anthropic");
-    const isXiaomi = model.provider === "xiaomi" || model.provider.startsWith("xiaomi-token-plan-");
-    return {
-        supportsEagerToolInputStreaming: model.compat?.supportsEagerToolInputStreaming ?? !isFireworks,
-        supportsLongCacheRetention: model.compat?.supportsLongCacheRetention ?? !isFireworks,
-        sendSessionAffinityHeaders: model.compat?.sendSessionAffinityHeaders ?? !!(isFireworks || isCloudflareAiGatewayAnthropic),
-        supportsCacheControlOnTools: model.compat?.supportsCacheControlOnTools ?? !isFireworks,
-        supportsDisabledThinking: model.compat?.supportsDisabledThinking ?? !isXiaomi,
-        supportsTemperature: model.compat?.supportsTemperature ?? true,
-        supportsToolChoice: model.compat?.supportsToolChoice ?? true,
-        supportsForcedToolChoice: model.compat?.supportsForcedToolChoice ?? !CLAUDE_FABLE_OR_MYTHOS_MODEL_ID.test(model.id),
-        allowEmptySignature: model.compat?.allowEmptySignature ?? false,
-        unsignedThinkingReplay: model.compat?.unsignedThinkingReplay ?? (model.compat?.allowEmptySignature ? "empty-signature" : "text"),
-        supportsStrictTools: model.compat?.supportsStrictTools ?? false,
-        supportsToolReferences: model.compat?.supportsToolReferences ?? defaultSupportsToolReferences(model),
-        // Default: first-party Anthropic only. Anthropic-compatible providers
-        // (kimi-coding, fireworks, copilot, gateways) may execute the server-side
-        // search but reject the replayed server_tool_use / web_search_tool_result
-        // blocks on the next request (kimi-coding 400s with `tool_call_id is not
-        // found`).
-        supportsWebSearch: model.compat?.supportsWebSearch ?? isAnthropicApiBaseUrl(model.baseUrl),
-    };
-}
-/**
- * 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) {
@@ -309,6 +262,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
@@ -477,6 +521,164 @@ 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 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;
+                    content.push({ type: "text", text: demotedToolCallText(demotedName, block.input) });
+                    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, 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 demotedToolCallText(name, input) {
+    let serializedInput;
+    try {
+        serializedInput = JSON.stringify(input ?? {});
+    }
+    catch {
+        serializedInput = "{}";
+    }
+    return `[Called tool "${name}" (no longer available in this session) with input: ${serializedInput}]`;
+}
+function demotedToolResultText(name, content) {
+    return `[Result of unavailable tool "${name}": ${toolResultText(content)}]`;
+}
+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.";
+}
 function sanitizeAdaptiveThinkingPayload(model, params, options) {
     if (!supportsAdaptiveThinking(model)) {
         return params;
@@ -725,6 +927,7 @@ export const stream = (model, context, options) => {
                 }
                 params = sanitizeAdaptiveThinkingPayload(model, params, options);
                 params = sanitizeUnsupportedNativeTools(model, params);
+                params = demoteUnavailableToolReferences(params);
                 const payloadRequestMetadata = extractPayloadRequestMetadata(params);
                 params = payloadRequestMetadata.params;
                 const requestOptions = {
@@ -1055,6 +1258,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 +1503,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 +1544,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 +1600,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 +1734,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);
                     }
                 }