@psnext/slingcli 2.5.20260710-1 → 2.5.20260718-2

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

@@ -1,5 +1,6 @@
 import Anthropic from "@anthropic-ai/sdk";
 import { calculateCost } from "../models.js";
+import { splitDeferredTools } from "../utils/deferred-tools.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { headersToRecord } from "../utils/headers.js";
 import { parseJsonWithRepair, parseStreamingJson } from "../utils/json-parse.js";
@@ -114,8 +115,24 @@ function getAnthropicCompat(model) {
         supportsCacheControlOnTools: model.compat?.supportsCacheControlOnTools ?? true,
         supportsTemperature: model.compat?.supportsTemperature ?? true,
         allowEmptySignature: model.compat?.allowEmptySignature ?? false,
+        supportsToolReferences: model.compat?.supportsToolReferences ?? defaultSupportsToolReferences(model),
     };
 }
+/**
+ * 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) {
@@ -510,25 +527,27 @@ export const stream = (model, context, options) => {
                     }
                     // Only update usage fields if present (not null).
                     // Preserves input_tokens from message_start when proxies omit it in message_delta.
-                    if (event.usage.input_tokens != null) {
-                        output.usage.input = event.usage.input_tokens;
-                    }
-                    if (event.usage.output_tokens != null) {
-                        output.usage.output = event.usage.output_tokens;
-                    }
-                    if (event.usage.cache_read_input_tokens != null) {
-                        output.usage.cacheRead = event.usage.cache_read_input_tokens;
-                    }
-                    if (event.usage.cache_creation_input_tokens != null) {
-                        output.usage.cacheWrite = event.usage.cache_creation_input_tokens;
-                    }
-                    // Anthropic reports reasoning tokens in `output_tokens_details.thinking_tokens` on the
-                    // final message_delta usage (a subset of output_tokens). SDK 0.91.1 omits the field from
-                    // its Usage type, so read it through a narrow cast. Verified against the live API.
-                    const thinkingTokens = event.usage
-                        .output_tokens_details?.thinking_tokens;
-                    if (thinkingTokens != null) {
-                        output.usage.reasoning = thinkingTokens;
+                    if (event.usage) {
+                        if (event.usage.input_tokens != null) {
+                            output.usage.input = event.usage.input_tokens;
+                        }
+                        if (event.usage.output_tokens != null) {
+                            output.usage.output = event.usage.output_tokens;
+                        }
+                        if (event.usage.cache_read_input_tokens != null) {
+                            output.usage.cacheRead = event.usage.cache_read_input_tokens;
+                        }
+                        if (event.usage.cache_creation_input_tokens != null) {
+                            output.usage.cacheWrite = event.usage.cache_creation_input_tokens;
+                        }
+                        // Anthropic reports reasoning tokens in `output_tokens_details.thinking_tokens` on the
+                        // final message_delta usage (a subset of output_tokens). SDK 0.91.1 omits the field from
+                        // its Usage type, so read it through a narrow cast. Verified against the live API.
+                        const thinkingTokens = event.usage
+                            .output_tokens_details?.thinking_tokens;
+                        if (thinkingTokens != null) {
+                            output.usage.reasoning = thinkingTokens;
+                        }
                     }
                     // Anthropic doesn't provide total_tokens, compute from components
                     output.usage.totalTokens =
@@ -561,7 +580,8 @@ export const stream = (model, context, options) => {
 };
 /**
  * Map ThinkingLevel to Anthropic effort levels for adaptive thinking.
- * Note: effort "max" is only valid on Opus 4.6, while Opus 4.7+ and Fable 5 support "xhigh".
+ * 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.
  */
 function mapThinkingLevelToEffort(model, level) {
     const mapped = level ? model.thinkingLevelMap?.[level] : undefined;
@@ -670,9 +690,19 @@ function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStre
 function buildParams(model, context, isOAuthToken, options) {
     const { cacheControl } = getCacheControl(model, options?.cacheRetention, options?.env);
     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 deferredToolNames = new Set(deferredTools.map((tool) => normalizeToolName(tool.name)));
     const params = {
         model: model.id,
-        messages: convertMessages(context.messages, model, isOAuthToken, cacheControl, compat.allowEmptySignature),
+        messages: convertMessages(transformedMessages, isOAuthToken, cacheControl, compat.allowEmptySignature, deferredToolNames, normalizeToolName),
         max_tokens: options?.maxTokens ?? model.maxTokens,
         stream: true,
     };
@@ -707,8 +737,11 @@ function buildParams(model, context, isOAuthToken, options) {
     if (options?.temperature !== undefined && !options?.thinkingEnabled && compat.supportsTemperature) {
         params.temperature = options.temperature;
     }
-    if (context.tools && context.tools.length > 0) {
-        params.tools = convertTools(context.tools, isOAuthToken, compat.supportsEagerToolInputStreaming, compat.supportsCacheControlOnTools ? cacheControl : undefined);
+    if (immediateTools.length > 0 || deferredTools.length > 0) {
+        params.tools = [
+            ...convertTools(immediateTools, isOAuthToken, compat.supportsEagerToolInputStreaming, compat.supportsCacheControlOnTools ? cacheControl : undefined),
+            ...convertTools(deferredTools, isOAuthToken, compat.supportsEagerToolInputStreaming, undefined, true),
+        ];
     }
     // Configure thinking mode: adaptive, budget-based, or explicitly disabled.
     if (model.reasoning) {
@@ -760,10 +793,37 @@ function buildParams(model, context, isOAuthToken, options) {
 function normalizeToolCallId(id) {
     return id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
 }
-function convertMessages(messages, model, isOAuthToken, cacheControl, allowEmptySignature = false) {
+function convertToolResult(msg, isOAuthToken, deferredToolNames, loadedToolNames, normalizeToolName) {
+    const references = [];
+    for (const name of msg.addedToolNames ?? []) {
+        const normalizedName = normalizeToolName(name);
+        if (!deferredToolNames.has(normalizedName) || loadedToolNames.has(normalizedName))
+            continue;
+        loadedToolNames.add(normalizedName);
+        references.push({
+            type: "tool_reference",
+            tool_name: isOAuthToken ? toClaudeCodeName(name) : name,
+        });
+    }
+    const convertedContent = convertContentBlocks(msg.content);
+    // Anthropic rejects tool references mixed with ordinary tool-result content.
+    return {
+        toolResult: {
+            type: "tool_result",
+            tool_use_id: msg.toolCallId,
+            content: references.length > 0 ? references : convertedContent,
+            is_error: msg.isError,
+        },
+        siblingContent: references.length === 0
+            ? []
+            : typeof convertedContent === "string"
+                ? [{ type: "text", text: convertedContent }]
+                : convertedContent,
+    };
+}
+function convertMessages(transformedMessages, isOAuthToken, cacheControl, allowEmptySignature = false, deferredToolNames = new Set(), normalizeToolName = (name) => name) {
     const params = [];
-    // Transform messages for cross-provider compatibility
-    const transformedMessages = transformMessages(messages, model, normalizeToolCallId);
+    const loadedToolNames = new Set();
     for (let i = 0; i < transformedMessages.length; i++) {
         const msg = transformedMessages[i];
         if (msg.role === "user") {
@@ -828,12 +888,14 @@ function convertMessages(messages, model, isOAuthToken, cacheControl, allowEmpty
                         });
                         continue;
                     }
-                    if (block.thinking.trim().length === 0)
+                    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 (!block.thinkingSignature || block.thinkingSignature.trim().length === 0) {
+                    if (!hasThinkingSignature) {
                         blocks.push(allowEmptySignature
                             ? {
                                 type: "thinking",
@@ -849,7 +911,7 @@ function convertMessages(messages, model, isOAuthToken, cacheControl, allowEmpty
                         blocks.push({
                             type: "thinking",
                             thinking: sanitizeSurrogates(block.thinking),
-                            signature: block.thinkingSignature,
+                            signature: thinkingSignature,
                         });
                     }
                 }
@@ -870,33 +932,22 @@ function convertMessages(messages, model, isOAuthToken, cacheControl, allowEmpty
             });
         }
         else if (msg.role === "toolResult") {
-            // Collect all consecutive toolResult messages, needed for z.ai Anthropic endpoint
+            // Collect all consecutive toolResult messages, needed for z.ai Anthropic endpoint.
             const toolResults = [];
-            // Add the current tool result
-            toolResults.push({
-                type: "tool_result",
-                tool_use_id: msg.toolCallId,
-                content: convertContentBlocks(msg.content),
-                is_error: msg.isError,
-            });
-            // Look ahead for consecutive toolResult messages
-            let j = i + 1;
+            const siblingContent = [];
+            let j = i;
             while (j < transformedMessages.length && transformedMessages[j].role === "toolResult") {
-                const nextMsg = transformedMessages[j]; // We know it's a toolResult
-                toolResults.push({
-                    type: "tool_result",
-                    tool_use_id: nextMsg.toolCallId,
-                    content: convertContentBlocks(nextMsg.content),
-                    is_error: nextMsg.isError,
-                });
+                const converted = convertToolResult(transformedMessages[j], isOAuthToken, deferredToolNames, loadedToolNames, normalizeToolName);
+                toolResults.push(converted.toolResult);
+                siblingContent.push(...converted.siblingContent);
                 j++;
             }
-            // Skip the messages we've already processed
+            // Skip the messages we've already processed.
             i = j - 1;
-            // Add a single user message with all tool results
+            // Displaced reference-bearing results must follow every tool_result block.
             params.push({
                 role: "user",
-                content: toolResults,
+                content: [...toolResults, ...siblingContent],
             });
         }
     }
@@ -927,7 +978,7 @@ function convertMessages(messages, model, isOAuthToken, cacheControl, allowEmpty
 function shouldUseFineGrainedToolStreamingBeta(model, context) {
     return !!context.tools?.length && !getAnthropicCompat(model).supportsEagerToolInputStreaming;
 }
-function convertTools(tools, isOAuthToken, supportsEagerToolInputStreaming, cacheControl) {
+function convertTools(tools, isOAuthToken, supportsEagerToolInputStreaming, cacheControl, deferLoading = false) {
     if (!tools)
         return [];
     return tools.map((tool, index) => {
@@ -941,6 +992,7 @@ function convertTools(tools, isOAuthToken, supportsEagerToolInputStreaming, cach
                 properties: schema.properties ?? {},
                 required: schema.required ?? [],
             },
+            ...(deferLoading ? { defer_loading: true } : {}),
             ...(cacheControl && index === tools.length - 1 ? { cache_control: cacheControl } : {}),
         };
     });

package/node_modules/@earendil-works/pi-ai/dist/api/azure-openai-responses.js

@@ -9,6 +9,8 @@ import { convertResponsesMessages, convertResponsesTools, processResponsesStream
 import { buildBaseOptions } from "./simple-options.js";
 const DEFAULT_AZURE_API_VERSION = "v1";
 const AZURE_TOOL_CALL_PROVIDERS = new Set(["openai", "openai-codex", "opencode", "azure-openai-responses"]);
+// OpenAI Responses rejects max_output_tokens below 16: https://github.com/earendil-works/pi/issues/6265
+const OPENAI_RESPONSES_MIN_OUTPUT_TOKENS = 16;
 function parseDeploymentNameMap(value) {
     const map = new Map();
     if (!value)
@@ -189,7 +191,7 @@ function buildParams(model, context, options, deploymentName) {
         store: false,
     };
     if (options?.maxTokens) {
-        params.max_output_tokens = options?.maxTokens;
+        params.max_output_tokens = Math.max(options.maxTokens, OPENAI_RESPONSES_MIN_OUTPUT_TOKENS);
     }
     if (options?.temperature !== undefined) {
         params.temperature = options?.temperature;

package/node_modules/@earendil-works/pi-ai/dist/api/bedrock-converse-stream.js

@@ -49,7 +49,10 @@ export const stream = (model, context, options = {}) => {
         }
         // Resolve bearer token for Bedrock API key auth.
         const skipAuth = getProviderEnvValue("AWS_BEDROCK_SKIP_AUTH", options.env) === "1";
-        const bearerToken = options.bearerToken || getProviderEnvValue("AWS_BEARER_TOKEN_BEDROCK", options.env) || undefined;
+        const bearerToken = options.bearerToken ||
+            options.apiKey ||
+            getProviderEnvValue("AWS_BEARER_TOKEN_BEDROCK", options.env) ||
+            undefined;
         const useBearerToken = bearerToken !== undefined && !skipAuth;
         // in Node.js/Bun environment only
         if (typeof process !== "undefined" && (process.versions?.node || process.versions?.bun)) {
@@ -155,7 +158,11 @@ export const stream = (model, context, options = {}) => {
                     handleContentBlockStop(item.contentBlockStop, blocks, output, stream);
                 }
                 else if (item.messageStop) {
-                    output.stopReason = mapStopReason(item.messageStop.stopReason);
+                    const { stopReason, errorMessage } = mapStopReason(item.messageStop.stopReason);
+                    output.stopReason = stopReason;
+                    if (errorMessage) {
+                        output.errorMessage = errorMessage;
+                    }
                 }
                 else if (item.metadata) {
                     handleMetadata(item.metadata, model, output);
@@ -180,7 +187,7 @@ export const stream = (model, context, options = {}) => {
                 throw new Error("Request was aborted");
             }
             if (output.stopReason === "error" || output.stopReason === "aborted") {
-                throw new Error("An unknown error occurred");
+                throw new Error(output.errorMessage || "An unknown error occurred");
             }
             stream.push({ type: "done", reason: output.stopReason, message: output });
             stream.end();
@@ -430,7 +437,7 @@ function supportsAdaptiveThinking(modelId, modelName) {
 }
 function supportsNativeXhighEffort(model) {
     const candidates = getModelMatchCandidates(model.id, model.name);
-    return candidates.some((s) => s.includes("opus-4-7") || s.includes("opus-4-8") || s.includes("fable-5"));
+    return candidates.some((s) => s.includes("opus-4-7") || s.includes("opus-4-8") || s.includes("sonnet-5") || s.includes("fable-5"));
 }
 function mapThinkingLevelToEffort(model, level) {
     if (level === "xhigh" && supportsNativeXhighEffort(model))
@@ -750,14 +757,14 @@ function mapStopReason(reason) {
     switch (reason) {
         case BedrockStopReason.END_TURN:
         case BedrockStopReason.STOP_SEQUENCE:
-            return "stop";
+            return { stopReason: "stop" };
         case BedrockStopReason.MAX_TOKENS:
         case BedrockStopReason.MODEL_CONTEXT_WINDOW_EXCEEDED:
-            return "length";
+            return { stopReason: "length" };
         case BedrockStopReason.TOOL_USE:
-            return "toolUse";
+            return { stopReason: "toolUse" };
         default:
-            return "error";
+            return reason ? { stopReason: "error", errorMessage: reason } : { stopReason: "error" };
     }
 }
 function getConfiguredBedrockRegion(options) {
@@ -826,10 +833,11 @@ function buildAdditionalModelRequestFields(model, options) {
                     low: 2048,
                     medium: 8192,
                     high: 16384,
-                    xhigh: 16384, // Claude doesn't support xhigh, clamp to high
+                    xhigh: 16384, // Budget-based Claude clamps extended levels to high
+                    max: 16384,
                 };
-                // Custom budgets override defaults (xhigh not in ThinkingBudgets, use high)
-                const level = options.reasoning === "xhigh" ? "high" : options.reasoning;
+                // Custom budgets only cover token-based levels through high.
+                const level = options.reasoning === "xhigh" || options.reasoning === "max" ? "high" : options.reasoning;
                 const budget = options.thinkingBudgets?.[level] ?? defaultBudgets[options.reasoning];
                 return {
                     thinking: {

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

@@ -19,13 +19,14 @@ function createSetupErrorMessage(model, error) {
         timestamp: Date.now(),
     };
 }
-function forwardStream(target, source) {
-    (async () => {
-        for await (const event of source) {
-            target.push(event);
-        }
-        target.end();
-    })();
+function hasResult(source) {
+    return typeof source.result === "function";
+}
+async function forwardStream(target, source) {
+    for await (const event of source) {
+        target.push(event);
+    }
+    target.end(hasResult(source) ? await source.result() : undefined);
 }
 /**
  * Returns a stream synchronously while running async setup (auth resolution,
@@ -35,9 +36,7 @@ function forwardStream(target, source) {
 export function lazyStream(model, setup) {
     const outer = new AssistantMessageEventStream();
     setup()
-        .then((inner) => {
-        forwardStream(outer, inner);
-    })
+        .then((inner) => forwardStream(outer, inner))
         .catch((error) => {
         const message = createSetupErrorMessage(model, error);
         outer.push({ type: "error", reason: "error", error: message });

package/node_modules/@earendil-works/pi-ai/dist/api/openai-codex-responses.js

@@ -9,6 +9,7 @@ const _os = loadNodeOs();
 import { clampThinkingLevel } from "../models.js";
 import { registerSessionResourceCleanup } from "../session-resources.js";
 import { combineAbortSignals } from "../utils/abort-signals.js";
+import { splitDeferredTools } from "../utils/deferred-tools.js";
 import { appendAssistantMessageDiagnostic, createAssistantMessageDiagnostic, formatThrownValue, } from "../utils/diagnostics.js";
 import { formatProviderError, normalizeProviderError } from "../utils/error-body.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
@@ -160,8 +161,9 @@ export const stream = (model, context, options) => {
             if (nextBody !== undefined) {
                 body = nextBody;
             }
-            const websocketRequestId = options?.sessionId || createCodexRequestId();
-            const sseHeaders = buildSSEHeaders(model.headers, options?.headers, accountId, apiKey, options?.sessionId);
+            const codexSessionId = clampOpenAIPromptCacheKey(options?.sessionId);
+            const websocketRequestId = codexSessionId || createCodexRequestId();
+            const sseHeaders = buildSSEHeaders(model.headers, options?.headers, accountId, apiKey, codexSessionId);
             const websocketHeaders = buildWebSocketHeaders(model.headers, options?.headers, accountId, apiKey, websocketRequestId);
             const bodyJson = JSON.stringify(body);
             const httpTimeoutMs = normalizeTimeoutMs(options?.timeoutMs);
@@ -336,8 +338,10 @@ export const streamSimple = (model, context, options) => {
 // Request Building
 // ============================================================================
 function buildRequestBody(model, context, options) {
+    const toolPlacement = splitDeferredTools(context, model.compat?.supportsToolSearch ?? false);
     const messages = convertResponsesMessages(model, context, CODEX_TOOL_CALL_PROVIDERS, {
         includeSystemPrompt: false,
+        deferredTools: toolPlacement.deferred,
     });
     const body = {
         model: model.id,
@@ -348,7 +352,7 @@ function buildRequestBody(model, context, options) {
         text: { verbosity: options?.textVerbosity || "low" },
         include: ["reasoning.encrypted_content"],
         prompt_cache_key: clampOpenAIPromptCacheKey(options?.sessionId),
-        tool_choice: "auto",
+        tool_choice: options?.toolChoice ?? "auto",
         parallel_tool_calls: true,
     };
     if (options?.temperature !== undefined) {
@@ -357,8 +361,8 @@ function buildRequestBody(model, context, options) {
     if (options?.serviceTier !== undefined) {
         body.service_tier = options.serviceTier;
     }
-    if (context.tools && context.tools.length > 0) {
-        body.tools = convertResponsesTools(context.tools, { strict: null });
+    if (toolPlacement.immediate.length > 0) {
+        body.tools = convertResponsesTools(toolPlacement.immediate, { strict: null });
     }
     if (options?.reasoningEffort !== undefined) {
         const effort = options.reasoningEffort === "none"

package/node_modules/@earendil-works/pi-ai/dist/api/openai-completions.js

@@ -45,6 +45,25 @@ function hasToolHistory(messages) {
     }
     return false;
 }
+function getDeferredToolNames(messages) {
+    const names = new Set();
+    for (const message of messages) {
+        if (message.role === "toolResult") {
+            for (const name of message.addedToolNames ?? []) {
+                names.add(name);
+            }
+        }
+    }
+    return names;
+}
+function getToolsByName(tools, names) {
+    if (!tools)
+        return [];
+    const toolsByName = new Map(tools.map((tool) => [tool.name, tool]));
+    return Array.from(names)
+        .map((name) => toolsByName.get(name))
+        .filter((tool) => tool !== undefined);
+}
 function isTextContentBlock(block) {
     return block.type === "text";
 }
@@ -405,9 +424,16 @@ function createClient(model, context, apiKey, optionsHeaders, sessionId, compat
         Object.assign(headers, copilotHeaders);
     }
     if (sessionId && compat.sendSessionAffinityHeaders) {
-        headers.session_id = sessionId;
-        headers["x-client-request-id"] = sessionId;
-        headers["x-session-affinity"] = sessionId;
+        if (compat.sessionAffinityFormat === "openrouter") {
+            headers["x-session-id"] = sessionId;
+        }
+        else {
+            if (compat.sessionAffinityFormat === "openai") {
+                headers.session_id = sessionId;
+            }
+            headers["x-client-request-id"] = sessionId;
+            headers["x-session-affinity"] = sessionId;
+        }
     }
     // Merge options headers last so they can override defaults
     if (optionsHeaders) {
@@ -450,8 +476,10 @@ function buildParams(model, context, options, compat = getCompat(model), cacheRe
     if (options?.temperature !== undefined) {
         params.temperature = options.temperature;
     }
-    if (context.tools && context.tools.length > 0) {
-        params.tools = convertTools(context.tools, compat);
+    const deferredToolNames = compat.deferredToolsMode === "kimi" ? getDeferredToolNames(context.messages) : new Set();
+    const activeTools = context.tools?.filter((tool) => !deferredToolNames.has(tool.name));
+    if (activeTools && activeTools.length > 0) {
+        params.tools = convertTools(activeTools, compat);
         if (compat.zaiToolStream) {
             params.tool_stream = true;
         }
@@ -826,6 +854,7 @@ export function convertMessages(model, context, compat) {
         }
         else if (msg.role === "toolResult") {
             const imageBlocks = [];
+            const deferredToolNames = new Set();
             let j = i;
             for (; j < transformedMessages.length && transformedMessages[j].role === "toolResult"; j++) {
                 const toolMsg = transformedMessages[j];
@@ -837,16 +866,22 @@ export function convertMessages(model, context, compat) {
                 const hasImages = toolMsg.content.some((c) => c.type === "image");
                 // Always send tool result with text (or placeholder if only images)
                 const hasText = textResult.length > 0;
+                const toolResultText = hasText ? textResult : hasImages ? "(see attached image)" : "(no tool output)";
                 // Some providers require the 'name' field in tool results
                 const toolResultMsg = {
                     role: "tool",
-                    content: sanitizeSurrogates(hasText ? textResult : "(see attached image)"),
+                    content: sanitizeSurrogates(toolResultText),
                     tool_call_id: toolMsg.toolCallId,
                 };
                 if (compat.requiresToolResultName && toolMsg.toolName) {
                     toolResultMsg.name = toolMsg.toolName;
                 }
                 params.push(toolResultMsg);
+                if (compat.deferredToolsMode === "kimi") {
+                    for (const name of toolMsg.addedToolNames ?? []) {
+                        deferredToolNames.add(name);
+                    }
+                }
                 if (hasImages && model.input.includes("image")) {
                     for (const block of toolMsg.content) {
                         if (isImageContentBlock(block)) {
@@ -883,6 +918,17 @@ export function convertMessages(model, context, compat) {
             else {
                 lastRole = "toolResult";
             }
+            if (deferredToolNames.size > 0) {
+                const deferredTools = getToolsByName(context.tools, deferredToolNames);
+                if (deferredTools.length > 0) {
+                    const kimiToolMessage = {
+                        role: "system",
+                        tools: convertTools(deferredTools, compat),
+                    };
+                    // Kimi accepts a system message with tools but omits the standard content field.
+                    params.push(kimiToolMessage);
+                }
+            }
             continue;
         }
         lastRole = msg.role;
@@ -1018,6 +1064,8 @@ function detectCompat(model) {
         supportsStrictMode: !isMoonshot && !isTogether && !isCloudflareAiGateway && !isNvidia,
         cacheControlFormat,
         sendSessionAffinityHeaders: false,
+        deferredToolsMode: undefined,
+        sessionAffinityFormat: isOpenRouter ? "openrouter" : "openai",
         supportsLongCacheRetention: !(isTogether ||
             isCloudflareWorkersAI ||
             isCloudflareAiGateway ||
@@ -1052,6 +1100,8 @@ function getCompat(model) {
         supportsStrictMode: model.compat.supportsStrictMode ?? detected.supportsStrictMode,
         cacheControlFormat: model.compat.cacheControlFormat ?? detected.cacheControlFormat,
         sendSessionAffinityHeaders: model.compat.sendSessionAffinityHeaders ?? detected.sendSessionAffinityHeaders,
+        deferredToolsMode: model.compat.deferredToolsMode ?? detected.deferredToolsMode,
+        sessionAffinityFormat: model.compat.sessionAffinityFormat ?? detected.sessionAffinityFormat,
         supportsLongCacheRetention: model.compat.supportsLongCacheRetention ?? detected.supportsLongCacheRetention,
     };
 }