@sammorrowdrums/mcpi-ai 0.85.1 → 0.85.3

package/dist/api/anthropic-messages.js

@@ -1,6 +1,7 @@
 import Anthropic from "@anthropic-ai/sdk";
 import { calculateCost } from "../models.js";
-import { splitDeferredTools } from "../utils/deferred-tools.js";
+import { appendDeferredToolsUnsupportedDiagnostic, splitDeferredTools } from "../utils/deferred-tools.js";
+import { appendAssistantMessageDiagnostic, createAssistantMessageDiagnostic } from "../utils/diagnostics.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { headersToRecord } from "../utils/headers.js";
 import { parseJsonWithRepair, parseStreamingJson } from "../utils/json-parse.js";
@@ -119,18 +120,68 @@ function getAnthropicCompat(model) {
         supportsTemperature: model.compat?.supportsTemperature ?? true,
         allowEmptySignature: model.compat?.allowEmptySignature ?? false,
         supportsStrictTools: model.compat?.supportsStrictTools ?? false,
-        supportsToolReferences: model.compat?.supportsToolReferences ?? defaultSupportsToolReferences(model),
+        supportsToolReferences: resolveSupportsToolReferences(model),
+        // On by default wherever deferral works: Anthropic defines `defer_loading` as "only
+        // loaded when returned via tool_reference from tool search", so withholding a schema
+        // without offering search leaves no way to hand it back. Verified against the Copilot
+        // gateway on every id in `GITHUB_COPILOT_TOOL_REFERENCE_MODEL_IDS` routed through this
+        // API, each answering with `server_tool_use` -> `tool_search_tool_result` -> `tool_use`.
+        // Only consulted when `supportsToolReferences` is on, which gates deferral itself.
+        supportsToolSearch: model.compat?.supportsToolSearch ?? true,
     };
 }
 /**
- * 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).
+ * Models whose deferred-tool support was withdrawn after the endpoint rejected
+ * `defer_loading` or `tool_reference`. Process-lifetime only, and only reachable
+ * for endpoints that claim the capability without implementing it, since built-in
+ * catalog metadata is probe-verified.
+ */
+const toolReferencesRejectedByEndpoint = new Set();
+function toolReferenceEndpointKey(model) {
+    return `${model.provider}\u0000${model.id}\u0000${model.baseUrl}`;
+}
+/** Record a hard endpoint rejection so this process stops sending deferred tools. */
+export function disableToolReferencesForEndpoint(model) {
+    toolReferencesRejectedByEndpoint.add(toolReferenceEndpointKey(model));
+}
+function resolveSupportsToolReferences(model) {
+    if (toolReferencesRejectedByEndpoint.has(toolReferenceEndpointKey(model)))
+        return false;
+    return model.compat?.supportsToolReferences ?? defaultSupportsToolReferences(model);
+}
+/**
+ * Anthropic's server-side tool search, offered whenever a request carries deferred tools.
+ *
+ * BM25 rather than the regex variant: a regex that matches nothing returns no references
+ * and leaves the tool hidden, which is the failure this exists to prevent, while BM25
+ * always ranks the catalog and returns the closest matches. It stays outside the deferred
+ * set so the model can always see that searching is possible.
+ */
+const TOOL_SEARCH_TOOL = {
+    name: "tool_search_tool_bm25",
+    type: "tool_search_tool_bm25_20251119",
+};
+/**
+ * Fallback for `anthropic-messages` models with no explicit capability metadata.
+ *
+ * First-party Anthropic ships dated snapshots of the same model
+ * (`claude-opus-4-6-20260101`), so support is derived from the family version
+ * rather than an exact-id allowlist: Sonnet, Opus, and Fable at 4.5 or newer,
+ * excluding Haiku, which rejects client-side `tool_reference` blocks.
+ *
+ * Every other provider returns false and must opt in through
+ * `compat.supportsToolReferences`. Gateways that reuse Claude ids do not
+ * necessarily implement the protocol, and the generated catalog carries
+ * probe-verified metadata for the ones that do (see
+ * `GITHUB_COPILOT_TOOL_REFERENCE_MODEL_IDS` in `scripts/generate-models.ts`).
  */
 function defaultSupportsToolReferences(model) {
     if (model.provider !== "anthropic" || model.id.includes("haiku"))
         return false;
-    const version = model.id.match(/^claude-(?:opus|sonnet|fable)-(\d+)(?:-(\d+))?(?:-|$)/);
+    // Minor versions appear as `claude-opus-4-6` and `claude-opus-4.8` depending on
+    // the catalog, so accept either separator. A trailing 8-digit group is a release
+    // date (`claude-sonnet-4-20250514`), not a minor version.
+    const version = model.id.match(/^claude-(?:opus|sonnet|fable)-(\d+)(?:[-.](\d+))?(?:[-.]|$)/);
     if (!version)
         return false;
     const major = Number(version[1]);
@@ -328,6 +379,41 @@ async function* iterateAnthropicEvents(response, signal) {
         throw new Error("Anthropic stream ended before message_stop");
     }
 }
+/**
+ * Signals that the endpoint does not implement the deferred-tool protocol at all:
+ * the field is rejected as unknown, or the content block type is unrecognized.
+ */
+const DEFERRED_TOOL_CAPABILITY_REJECTION = /extra inputs are not permitted|not permitted|unsupported|not supported|unrecognized|unexpected (?:field|keyword|argument|property)|unknown (?:field|parameter|argument|property)|does not match any of the expected|invalid[^.]{0,32}\btype\b/i;
+/**
+ * Signals that the endpoint *does* implement references and could not resolve one.
+ * That is a client-side activation or naming bug, not a capability gap, so it must
+ * surface rather than silently downgrade the request.
+ */
+const TOOL_REFERENCE_RESOLUTION_FAILURE = /not found|does not exist|no such|unresolved|unknown tool\b/i;
+/**
+ * True only for an unambiguous rejection of the deferred-tool protocol itself:
+ * a 400 naming the `defer_loading` field, the `tool_reference` block type, or the
+ * `tool_search_tool_*` server tool, *and* describing it as unknown, extra, or
+ * unsupported.
+ *
+ * The Copilot gateway words these as `Extra inputs are not permitted:
+ * tools.1.defer_loading` and as an unrecognized content block type.
+ *
+ * `Tool reference 'x' not found in available tools` is deliberately excluded. It
+ * proves the endpoint implements references, so downgrading would mask a client
+ * activation or tool-naming bug behind a silent capability loss.
+ */
+function isDeferredToolRejection(error) {
+    if (!(error instanceof Error))
+        return false;
+    if (error.status !== 400)
+        return false;
+    if (!/\b(?:defer_loading|tool_reference|tool_search_tool\w*)\b/.test(error.message))
+        return false;
+    if (TOOL_REFERENCE_RESOLUTION_FAILURE.test(error.message))
+        return false;
+    return DEFERRED_TOOL_CAPABILITY_REJECTION.test(error.message);
+}
 export const stream = (model, context, options) => {
     const stream = new AssistantMessageEventStream();
     (async () => {
@@ -372,7 +458,9 @@ export const stream = (model, context, options) => {
                 client = created.client;
                 isOAuth = created.isOAuthToken;
             }
-            let params = buildParams(model, context, isOAuth, options);
+            let built = buildParams(model, context, isOAuth, options);
+            appendDeferredToolsUnsupportedDiagnostic(output, model, built.unsupportedDeferredToolNames);
+            let params = built.params;
             const nextParams = await options?.onPayload?.(params, model);
             if (nextParams !== undefined) {
                 params = nextParams;
@@ -382,14 +470,40 @@ export const stream = (model, context, options) => {
                 ...(options?.timeoutMs !== undefined ? { timeout: options.timeoutMs } : {}),
                 maxRetries: 0,
             };
-            const response = await retryProviderRequest(() => client.messages.create({ ...params, stream: true }, requestOptions).asResponse(), {
+            const sendRequest = (body) => retryProviderRequest(() => client.messages.create({ ...body, stream: true }, requestOptions).asResponse(), {
                 maxRetries: options?.maxRetries,
                 maxRetryDelayMs: options?.maxRetryDelayMs,
                 signal: options?.signal,
             });
+            let response;
+            try {
+                response = await sendRequest(params);
+            }
+            catch (error) {
+                // Only a 400 that names the deferred-tool fields is treated as a
+                // capability mismatch. Every other failure, including other 400s,
+                // propagates with the provider's exact message.
+                if (built.deferredToolNames.length === 0 || !isDeferredToolRejection(error))
+                    throw error;
+                disableToolReferencesForEndpoint(model);
+                appendAssistantMessageDiagnostic(output, createAssistantMessageDiagnostic("deferred_tools_rejected", error, {
+                    provider: model.provider,
+                    model: model.id,
+                    deferredTools: built.deferredToolNames,
+                }));
+                built = buildParams(model, context, isOAuth, options);
+                appendDeferredToolsUnsupportedDiagnostic(output, model, built.unsupportedDeferredToolNames);
+                params = built.params;
+                const retryParams = await options?.onPayload?.(params, model);
+                if (retryParams !== undefined) {
+                    params = retryParams;
+                }
+                response = await sendRequest(params);
+            }
             await options?.onResponse?.({ status: response.status, headers: headersToRecord(response.headers) }, model);
             stream.push({ type: "start", partial: output });
             const blocks = output.content;
+            const replayBlocks = [];
             for await (const event of iterateAnthropicEvents(response, options?.signal)) {
                 if (event.type === "message_start") {
                     output.responseId = event.message.id;
@@ -406,6 +520,11 @@ export const stream = (model, context, options) => {
                     calculateCost(model, output.usage);
                 }
                 else if (event.type === "content_block_start") {
+                    replayBlocks.push({
+                        index: event.index,
+                        block: event.content_block,
+                        partialJson: "",
+                    });
                     if (event.content_block.type === "text") {
                         const block = {
                             type: "text",
@@ -452,6 +571,31 @@ export const stream = (model, context, options) => {
                     }
                 }
                 else if (event.type === "content_block_delta") {
+                    const replayBlock = replayBlocks.find((block) => block.index === event.index);
+                    if (replayBlock) {
+                        if (event.delta.type === "text_delta") {
+                            const text = replayBlock.block.text;
+                            replayBlock.block.text = `${typeof text === "string" ? text : ""}${event.delta.text}`;
+                        }
+                        else if (event.delta.type === "thinking_delta") {
+                            const thinking = replayBlock.block.thinking;
+                            replayBlock.block.thinking = `${typeof thinking === "string" ? thinking : ""}${event.delta.thinking}`;
+                        }
+                        else if (event.delta.type === "signature_delta") {
+                            const signature = replayBlock.block.signature;
+                            replayBlock.block.signature = `${typeof signature === "string" ? signature : ""}${event.delta.signature}`;
+                        }
+                        else if (event.delta.type === "input_json_delta") {
+                            replayBlock.partialJson += event.delta.partial_json;
+                            replayBlock.block.input = parseStreamingJson(replayBlock.partialJson);
+                        }
+                        else if (event.delta.type === "citations_delta") {
+                            const citations = replayBlock.block.citations;
+                            replayBlock.block.citations = Array.isArray(citations)
+                                ? [...citations, event.delta.citation]
+                                : [event.delta.citation];
+                        }
+                    }
                     if (event.delta.type === "text_delta") {
                         const index = blocks.findIndex((b) => b.index === event.index);
                         const block = blocks[index];
@@ -502,6 +646,10 @@ export const stream = (model, context, options) => {
                     }
                 }
                 else if (event.type === "content_block_stop") {
+                    const replayBlock = replayBlocks.find((block) => block.index === event.index);
+                    if (replayBlock?.partialJson) {
+                        replayBlock.block.input = parseStreamingJson(replayBlock.partialJson);
+                    }
                     const index = blocks.findIndex((b) => b.index === event.index);
                     const block = blocks[index];
                     if (block) {
@@ -584,6 +732,17 @@ export const stream = (model, context, options) => {
             if (output.stopReason === "aborted" || output.stopReason === "error") {
                 throw new Error(output.errorMessage || "An unknown error occurred");
             }
+            const providerContent = replayBlocks
+                .sort((left, right) => left.index - right.index)
+                .map((block) => block.block);
+            if (providerContent.some((block) => typeof block === "object" && block !== null && !Array.isArray(block) && block.type !== "text")) {
+                output.providerReplay = {
+                    provider: model.provider,
+                    api: model.api,
+                    model: model.id,
+                    content: providerContent,
+                };
+            }
             stream.push({ type: "done", reason: output.stopReason, message: output });
             stream.end();
         }
@@ -718,13 +877,22 @@ function buildParams(model, context, isOAuthToken, options) {
     const compat = getAnthropicCompat(model);
     const transformedMessages = transformMessages(context.messages, model, normalizeToolCallId);
     const normalizeToolName = isOAuthToken ? toClaudeCodeName : (name) => name;
-    const toolPlacement = splitDeferredTools({ ...context, messages: transformedMessages }, compat.supportsToolReferences, normalizeToolName);
-    let immediateTools = toolPlacement.immediate;
-    let deferredTools = [...toolPlacement.deferred.values()];
-    if (immediateTools.length === 0 && deferredTools.length > 0) {
-        immediateTools = deferredTools;
-        deferredTools = [];
-    }
+    const deferralContext = { ...context, messages: transformedMessages };
+    const toolPlacement = splitDeferredTools(deferralContext, {
+        enabled: compat.supportsToolReferences,
+        // Without server-side search, the only load point is a `tool_reference` in a tool
+        // result, so a tool registered with `deferred: true` that no result introduces would
+        // stay hidden for the whole session. Report those instead of losing them.
+        registrationDeferral: compat.supportsToolSearch,
+        // The all-deferred safety floor exists so the model always has somewhere to start. The
+        // search tool below is somewhere to start, so a tool set that is entirely deferred --
+        // the all-MCP-proxy shape that gains the most here -- stays deferred rather than being
+        // expanded wholesale.
+        providesToolSearch: compat.supportsToolSearch,
+        normalizeName: normalizeToolName,
+    });
+    const immediateTools = toolPlacement.immediate;
+    const deferredTools = [...toolPlacement.deferred.values()];
     const deferredToolNames = new Set(deferredTools.map((tool) => normalizeToolName(tool.name)));
     const params = {
         model: model.id,
@@ -768,6 +936,11 @@ function buildParams(model, context, isOAuthToken, options) {
             ...convertTools(immediateTools, isOAuthToken, compat.supportsEagerToolInputStreaming, compat.supportsStrictTools, compat.supportsCacheControlOnTools ? cacheControl : undefined),
             ...convertTools(deferredTools, isOAuthToken, compat.supportsEagerToolInputStreaming, compat.supportsStrictTools, undefined, true),
         ];
+        // Appended last so it sits outside the cached prefix, which ends at the
+        // `cache_control` breakpoint on the final immediate tool.
+        if (deferredTools.length > 0 && compat.supportsToolSearch) {
+            params.tools.push(TOOL_SEARCH_TOOL);
+        }
     }
     // Configure thinking mode: adaptive, budget-based, or explicitly disabled.
     if (model.reasoning) {
@@ -813,7 +986,11 @@ function buildParams(model, context, isOAuthToken, options) {
             params.tool_choice = options.toolChoice;
         }
     }
-    return params;
+    return {
+        params,
+        deferredToolNames: [...deferredToolNames],
+        unsupportedDeferredToolNames: toolPlacement.unsupported,
+    };
 }
 // Normalize tool call IDs to match Anthropic's required pattern and length
 function normalizeToolCallId(id) {
@@ -850,6 +1027,7 @@ function convertToolResult(msg, isOAuthToken, deferredToolNames, loadedToolNames
 function convertMessages(transformedMessages, isOAuthToken, cacheControl, allowEmptySignature = false, deferredToolNames = new Set(), normalizeToolName = (name) => name) {
     const params = [];
     const loadedToolNames = new Set();
+    const providerToolCallIds = new Map();
     for (let i = 0; i < transformedMessages.length; i++) {
         const msg = transformedMessages[i];
         if (msg.role === "user") {
@@ -896,59 +1074,88 @@ function convertMessages(transformedMessages, isOAuthToken, cacheControl, allowE
         }
         else if (msg.role === "assistant") {
             const blocks = [];
-            for (const block of msg.content) {
-                if (block.type === "text") {
-                    if (block.text.trim().length === 0)
-                        continue;
-                    blocks.push({
-                        type: "text",
-                        text: sanitizeSurrogates(block.text),
-                    });
+            const providerReplay = msg.providerReplay;
+            const canReplayProviderContent = providerReplay?.provider === msg.provider &&
+                providerReplay.api === msg.api &&
+                providerReplay.model === msg.model &&
+                providerReplay.api === "anthropic-messages";
+            if (canReplayProviderContent) {
+                const replayBlocks = structuredClone(providerReplay.content);
+                const replayToolCalls = replayBlocks.filter((block) => block.type === "tool_use");
+                const localToolCalls = msg.content.filter((block) => block.type === "toolCall");
+                for (let index = 0; index < Math.min(localToolCalls.length, replayToolCalls.length); index++) {
+                    providerToolCallIds.set(localToolCalls[index].id, replayToolCalls[index].id);
                 }
-                else if (block.type === "thinking") {
-                    // Redacted thinking: pass the opaque payload back as redacted_thinking
-                    if (block.redacted) {
+                blocks.push(...replayBlocks);
+            }
+            else {
+                for (let index = 0; index < msg.content.length - 1; index++) {
+                    const current = msg.content[index];
+                    const next = msg.content[index + 1];
+                    if (current.type === "thinking" &&
+                        next.type === "thinking" &&
+                        current.thinkingSignature &&
+                        next.thinkingSignature &&
+                        msg.content.slice(index + 2).some((block) => block.type === "toolCall")) {
+                        throw new Error("Cannot safely replay this Anthropic assistant message: it contains adjacent signed thinking blocks but no provider-native replay data. mcpi 0.85.2 could drop native server-tool blocks between those thoughts. Start a new session or branch before this turn, or start a new session with thinking disabled.");
+                    }
+                }
+                for (const block of msg.content) {
+                    if (block.type === "text") {
+                        if (block.text.trim().length === 0)
+                            continue;
                         blocks.push({
-                            type: "redacted_thinking",
-                            data: block.thinkingSignature,
+                            type: "text",
+                            text: sanitizeSurrogates(block.text),
                         });
-                        continue;
                     }
-                    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 (!hasThinkingSignature) {
-                        blocks.push(allowEmptySignature
-                            ? {
+                    else if (block.type === "thinking") {
+                        // Redacted thinking: pass the opaque payload back as redacted_thinking
+                        if (block.redacted) {
+                            blocks.push({
+                                type: "redacted_thinking",
+                                data: block.thinkingSignature,
+                            });
+                            continue;
+                        }
+                        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 (!hasThinkingSignature) {
+                            blocks.push(allowEmptySignature
+                                ? {
+                                    type: "thinking",
+                                    thinking: sanitizeSurrogates(block.thinking),
+                                    signature: "",
+                                }
+                                : {
+                                    type: "text",
+                                    text: sanitizeSurrogates(block.thinking),
+                                });
+                        }
+                        else {
+                            // Signatures authenticate the exact thinking text. Never sanitize
+                            // or otherwise rewrite a signed block during replay.
+                            blocks.push({
                                 type: "thinking",
-                                thinking: sanitizeSurrogates(block.thinking),
-                                signature: "",
-                            }
-                            : {
-                                type: "text",
-                                text: sanitizeSurrogates(block.thinking),
+                                thinking: block.thinking,
+                                signature: thinkingSignature,
                             });
+                        }
                     }
-                    else {
+                    else if (block.type === "toolCall") {
                         blocks.push({
-                            type: "thinking",
-                            thinking: sanitizeSurrogates(block.thinking),
-                            signature: thinkingSignature,
+                            type: "tool_use",
+                            id: block.id,
+                            name: isOAuthToken ? toClaudeCodeName(block.name) : block.name,
+                            input: block.arguments ?? {},
                         });
                     }
                 }
-                else if (block.type === "toolCall") {
-                    blocks.push({
-                        type: "tool_use",
-                        id: block.id,
-                        name: isOAuthToken ? toClaudeCodeName(block.name) : block.name,
-                        input: block.arguments ?? {},
-                    });
-                }
             }
             if (blocks.length === 0)
                 continue;
@@ -963,7 +1170,11 @@ function convertMessages(transformedMessages, isOAuthToken, cacheControl, allowE
             const siblingContent = [];
             let j = i;
             while (j < transformedMessages.length && transformedMessages[j].role === "toolResult") {
-                const converted = convertToolResult(transformedMessages[j], isOAuthToken, deferredToolNames, loadedToolNames, normalizeToolName);
+                const toolResult = transformedMessages[j];
+                const converted = convertToolResult({
+                    ...toolResult,
+                    toolCallId: providerToolCallIds.get(toolResult.toolCallId) ?? toolResult.toolCallId,
+                }, isOAuthToken, deferredToolNames, loadedToolNames, normalizeToolName);
                 toolResults.push(converted.toolResult);
                 siblingContent.push(...converted.siblingContent);
                 j++;