@code-yeongyu/senpi 2026.7.16 → 2026.7.17-2

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

@@ -152,6 +152,12 @@ function getAnthropicCompat(model) {
         supportsForcedToolChoice: model.compat?.supportsForcedToolChoice ?? !CLAUDE_FABLE_OR_MYTHOS_MODEL_ID.test(model.id),
         allowEmptySignature: model.compat?.allowEmptySignature ?? 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),
     };
 }
 /**
@@ -227,6 +233,23 @@ function lastAnthropicFallbackBoundary(content) {
 function isAnthropicServerToolUseBlock(raw) {
     return isRecord(raw) && raw.type === "server_tool_use" && typeof raw.id === "string";
 }
+// Only tool_use-shaped provider-native blocks (server_tool_use, mcp_tool_use)
+// stream their input via input_json_delta. Result-shaped blocks must replay
+// byte-for-byte (encrypted_content), so never merge an `input` into them.
+function isProviderNativeToolUseBlock(raw) {
+    return isRecord(raw) && (raw.type === "server_tool_use" || raw.type === "mcp_tool_use");
+}
+// Endpoints without `supportsWebSearch` reject replayed web-search server-tool
+// blocks (kimi-coding 400s with `tool_call_id is not found`), wedging every
+// subsequent request of the session. Dropping the pair loses the searched
+// context but keeps the conversation usable.
+function isAnthropicWebSearchReplayBlock(raw) {
+    if (!isRecord(raw))
+        return false;
+    if (raw.type === "web_search_tool_result")
+        return true;
+    return raw.type === "server_tool_use" && raw.name === "web_search";
+}
 // 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
@@ -339,27 +362,28 @@ function rejectsComputerUseBeta(model) {
     return ((model.provider === "cloudflare-ai-gateway" && model.baseUrl.includes("anthropic")) ||
         matchesModelMarker(model, UNSUPPORTED_NATIVE_COMPUTER_TOOL_MODEL_MARKERS));
 }
+function isAnthropicWebSearchToolType(toolType) {
+    return toolType.startsWith("web_search_");
+}
 function sanitizeUnsupportedNativeTools(model, params) {
     const payload = params;
     const headers = stringRecord(payload.headers);
     const headerSanitization = rejectsComputerUseBeta(model)
         ? removeComputerUseBetaHeader(headers)
         : { changed: false };
+    const rejectsNativeWebSearch = !getAnthropicCompat(model).supportsWebSearch;
     const tools = payload.tools;
     const sanitized = { ...payload };
     let changed = false;
-    const removedToolNames = new Set();
     if (Array.isArray(tools)) {
         const supportedTools = [];
         for (const tool of tools) {
             const hookTool = tool;
             if (isRecord(hookTool) &&
                 typeof hookTool.type === "string" &&
-                rejectsNativeComputerTool(model, hookTool.type)) {
+                (rejectsNativeComputerTool(model, hookTool.type) ||
+                    (rejectsNativeWebSearch && isAnthropicWebSearchToolType(hookTool.type)))) {
                 changed = true;
-                if (typeof hookTool.name === "string") {
-                    removedToolNames.add(hookTool.name);
-                }
                 continue;
             }
             supportedTools.push(tool);
@@ -384,7 +408,10 @@ function sanitizeUnsupportedNativeTools(model, params) {
     }
     if (changed && isRecord(sanitized.tool_choice)) {
         const toolChoiceName = sanitized.tool_choice.name;
-        const shouldRemoveToolChoice = (typeof toolChoiceName === "string" && removedToolNames.has(toolChoiceName)) || sanitized.tools === undefined;
+        const hasSelectedTool = typeof toolChoiceName === "string" &&
+            Array.isArray(sanitized.tools) &&
+            sanitized.tools.some((tool) => isRecord(tool) && tool.name === toolChoiceName);
+        const shouldRemoveToolChoice = sanitized.tools === undefined || (typeof toolChoiceName === "string" && !hasSelectedTool);
         if (shouldRemoveToolChoice) {
             delete sanitized.tool_choice;
         }
@@ -764,6 +791,12 @@ export const stream = (model, context, options) => {
                                 partial: output,
                             });
                         }
+                        else if (block && block.type === "providerNative" && isProviderNativeToolUseBlock(block.raw)) {
+                            // Server-side tool blocks (server_tool_use) stream their input
+                            // the same way tool_use does; the block captured at
+                            // content_block_start still has `input: {}`.
+                            block.partialJson = (block.partialJson ?? "") + event.delta.partial_json;
+                        }
                     }
                     else if (event.delta.type === "signature_delta") {
                         const index = blocks.findIndex((b) => b.index === event.index);
@@ -807,6 +840,13 @@ export const stream = (model, context, options) => {
                                 partial: output,
                             });
                         }
+                        else if (block.type === "providerNative") {
+                            const partialJson = block.partialJson;
+                            delete block.partialJson;
+                            if (partialJson !== undefined && isRecord(block.raw)) {
+                                block.raw = { ...block.raw, input: parseStreamingJson(partialJson) };
+                            }
+                        }
                     }
                 }
                 else if (event.type === "message_delta") {
@@ -859,6 +899,13 @@ export const stream = (model, context, options) => {
         catch (error) {
             for (const block of output.content) {
                 delete block.index;
+                // An aborted stream never reaches content_block_stop; keep whatever
+                // provider-native input accumulated, mirroring toolCall's partial
+                // arguments.
+                const scratch = block.partialJson;
+                if (block.type === "providerNative" && scratch !== undefined && isRecord(block.raw)) {
+                    block.raw = { ...block.raw, input: parseStreamingJson(scratch) };
+                }
                 // partialJson is only a streaming scratch buffer; never persist it.
                 delete block.partialJson;
             }
@@ -1199,6 +1246,7 @@ function convertMessages(transformedMessages, model, isOAuthToken, cacheControl,
     // Tool calls from a declined pre-fallback attempt are dropped from their
     // assistant turn below; drop their tool_results in lockstep so none dangle.
     const discardedFallbackToolCallIds = collectDiscardedFallbackToolCallIds(transformedMessages, model);
+    const rejectsNativeWebSearchReplay = !getAnthropicCompat(model).supportsWebSearch;
     for (let i = 0; i < transformedMessages.length; i++) {
         const msg = transformedMessages[i];
         if (msg.role === "user") {
@@ -1320,8 +1368,11 @@ function convertMessages(transformedMessages, model, isOAuthToken, cacheControl,
                     });
                 }
                 else if (block.type === "providerNative") {
-                    if (isSameModel && isReplayableAnthropicProviderNativeBlock(block.raw))
+                    if (isSameModel &&
+                        isReplayableAnthropicProviderNativeBlock(block.raw) &&
+                        !(rejectsNativeWebSearchReplay && isAnthropicWebSearchReplayBlock(block.raw))) {
                         blocks.push(block.raw);
+                    }
                 }
             }
             if (blocks.length === 0)