@fractaal/pi-ai 0.85.3 → 0.86.1

package/dist/api/openai-completions.js

@@ -5,13 +5,16 @@ import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { shortHash } from "../utils/hash.js";
 import { headersToRecord } from "../utils/headers.js";
 import { parseStreamingJson } from "../utils/json-parse.js";
+import { getPiUserAgent } from "../utils/pi-user-agent.js";
 import { getProviderEnvValue } from "../utils/provider-env.js";
 import { retryProviderRequest } from "../utils/provider-retry.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
-import { appendGrammarToolInputJsonDelta, createGrammarToolInputProperties, getGrammarToolInput, resolveGrammarConstrainedSampling, resolveJsonSchemaStrictSampling, } from "./constrained-sampling.js";
+import { getSystemMessageText, renderSystemMessageUpdate } from "../utils/text.js";
+import { getDeclaredTools, resolveTranscript, resolveTranscriptTools, } from "../utils/transcript.js";
+import { appendGrammarToolInputJsonDelta, createGrammarToolInputProperties, getGrammarToolInput, getJsonSchemaToolParameters, resolveGrammarConstrainedSampling, resolveJsonSchemaStrictSampling, } from "./constrained-sampling.js";
 import { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "./github-copilot-headers.js";
 import { clampOpenAIPromptCacheKey } from "./openai-prompt-cache.js";
-import { buildBaseOptions } from "./simple-options.js";
+import { buildBaseOptions, clampThinkingBudgetToAnswerRoom, resolveSamplingParams, thinkingBudgetForLevel, } from "./simple-options.js";
 import { transformMessages } from "./transform-messages.js";
 /**
  * Check if conversation messages contain tool calls or tool results.
@@ -48,25 +51,6 @@ 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";
 }
@@ -79,16 +63,81 @@ function isToolCallBlock(block) {
 function isImageContentBlock(block) {
     return block.type === "image";
 }
-function isEncryptedReasoningDetail(detail) {
-    if (typeof detail !== "object" || detail === null) {
+function isReasoningDetailObject(detail) {
+    return typeof detail === "object" && detail !== null && !Array.isArray(detail);
+}
+function hasValidCommonReasoningDetailFields(candidate) {
+    return ((candidate.id === undefined || candidate.id === null || typeof candidate.id === "string") &&
+        (candidate.format === undefined || typeof candidate.format === "string") &&
+        (candidate.index === undefined || typeof candidate.index === "number"));
+}
+function isOpenAIReasoningDetail(detail) {
+    if (!isReasoningDetailObject(detail) || !hasValidCommonReasoningDetailFields(detail)) {
         return false;
     }
-    const candidate = detail;
-    return (candidate.type === "reasoning.encrypted" &&
-        typeof candidate.id === "string" &&
-        candidate.id.length > 0 &&
-        typeof candidate.data === "string" &&
-        candidate.data.length > 0);
+    switch (detail.type) {
+        case "reasoning.summary":
+            return typeof detail.summary === "string";
+        case "reasoning.encrypted":
+            return typeof detail.data === "string";
+        case "reasoning.text":
+            return (typeof detail.text === "string" &&
+                (detail.signature === undefined || detail.signature === null || typeof detail.signature === "string"));
+        default:
+            return false;
+    }
+}
+function parseOpenAIReasoningDetails(signature) {
+    if (!signature)
+        return undefined;
+    try {
+        const parsed = JSON.parse(signature);
+        return Array.isArray(parsed) && parsed.length > 0 && parsed.every(isOpenAIReasoningDetail) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseLegacyEncryptedReasoningDetail(signature) {
+    if (!signature)
+        return undefined;
+    try {
+        const parsed = JSON.parse(signature);
+        return isOpenAIReasoningDetail(parsed) &&
+            parsed.type === "reasoning.encrypted" &&
+            typeof parsed.id === "string" &&
+            parsed.id.length > 0 &&
+            parsed.data.length > 0
+            ? parsed
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function fillMissingCommonReasoningDetailFields(target, source) {
+    target.id ??= source.id;
+    target.format ||= source.format;
+    target.index ??= source.index;
+}
+function appendOpenAIReasoningDetail(details, detail) {
+    const lastDetail = details[details.length - 1];
+    if (detail.type === "reasoning.text" && lastDetail?.type === "reasoning.text") {
+        lastDetail.text += detail.text;
+        lastDetail.signature ||= detail.signature;
+        fillMissingCommonReasoningDetailFields(lastDetail, detail);
+        return;
+    }
+    if (detail.type === "reasoning.summary" && lastDetail?.type === "reasoning.summary") {
+        lastDetail.summary += detail.summary;
+        fillMissingCommonReasoningDetailFields(lastDetail, detail);
+        return;
+    }
+    details.push({ ...detail });
+}
+const OPENAI_COMPLETIONS_REASONING_FIELDS = ["reasoning", "reasoning_content", "reasoning_text"];
+function isOpenAICompletionsReasoningField(field) {
+    return OPENAI_COMPLETIONS_REASONING_FIELDS.includes(field);
 }
 function resolveCacheRetention(cacheRetention, env) {
     if (cacheRetention) {
@@ -101,6 +150,7 @@ function resolveCacheRetention(cacheRetention, env) {
 }
 export const stream = (model, context, options) => {
     const stream = new AssistantMessageEventStream();
+    const normalizedContext = resolveTranscript(context, getCompat(model).supportsMidConvoSystemMessages);
     (async () => {
         const output = {
             role: "assistant",
@@ -119,14 +169,22 @@ export const stream = (model, context, options) => {
             stopReason: "pending",
             timestamp: Date.now(),
         };
+        // `reasoning_details` are replay metadata, not user-visible stream deltas.
+        // Keep them in memory during streaming and serialize once when the block is finalized.
+        let streamedReasoningDetails;
+        const applyStreamedReasoningDetails = (block) => {
+            if (streamedReasoningDetails !== undefined) {
+                block.thinkingSignature = JSON.stringify(streamedReasoningDetails);
+            }
+        };
         try {
             const apiKey = getClientApiKey(model.provider, options?.apiKey, options?.headers);
             const compat = getCompat(model);
-            const grammarToolInputProperties = createGrammarToolInputProperties(context.tools, compat.supportsOpenAIGrammarTools);
+            const grammarToolInputProperties = createGrammarToolInputProperties(getDeclaredTools(normalizedContext.messages), compat.supportsOpenAIGrammarTools);
             const cacheRetention = resolveCacheRetention(options?.cacheRetention, options?.env);
             const cacheSessionId = cacheRetention === "none" ? undefined : options?.sessionId;
-            const client = createClient(model, context, apiKey, options?.headers, options?.fetch, cacheSessionId, compat);
-            let params = buildParams(model, context, options, compat, cacheRetention, grammarToolInputProperties);
+            const client = createClient(model, normalizedContext, apiKey, options?.headers, options?.fetch, cacheSessionId, compat);
+            let params = buildParams(model, normalizedContext, options, compat, cacheRetention, grammarToolInputProperties);
             const nextParams = await options?.onPayload?.(params, model);
             if (nextParams !== undefined) {
                 params = nextParams;
@@ -148,7 +206,6 @@ export const stream = (model, context, options) => {
             let hasFinishReason = false;
             const toolCallBlocksByIndex = new Map();
             const toolCallBlocksById = new Map();
-            const pendingReasoningDetailsByToolCallId = new Map();
             const blocks = output.content;
             const getContentIndex = (block) => blocks.indexOf(block);
             const getCustomToolCallInput = (block) => {
@@ -180,6 +237,7 @@ export const stream = (model, context, options) => {
                     });
                 }
                 else if (block.type === "thinking") {
+                    applyStreamedReasoningDetails(block);
                     stream.push({
                         type: "thinking_end",
                         contentIndex,
@@ -235,16 +293,6 @@ export const stream = (model, context, options) => {
                 }
                 return thinkingBlock;
             };
-            const applyPendingReasoningDetail = (block) => {
-                if (!block.id) {
-                    return;
-                }
-                const pendingReasoningDetail = pendingReasoningDetailsByToolCallId.get(block.id);
-                if (pendingReasoningDetail) {
-                    block.thoughtSignature = pendingReasoningDetail;
-                    pendingReasoningDetailsByToolCallId.delete(block.id);
-                }
-            };
             const ensureToolCallBlock = (toolCall) => {
                 const streamIndex = typeof toolCall.index === "number" ? toolCall.index : undefined;
                 const name = toolCall.function?.name ?? toolCall.custom?.name ?? "";
@@ -300,10 +348,10 @@ export const stream = (model, context, options) => {
                     };
                     delete block.partialArgs;
                 }
-                applyPendingReasoningDetail(block);
                 return block;
             };
             for await (const chunk of openaiStream) {
+                await options?.onProviderStreamEvent?.(chunk, model);
                 if (!chunk || typeof chunk !== "object")
                     continue;
                 // OpenAI documents ChatCompletionChunk.id as the unique chat completion identifier,
@@ -407,16 +455,14 @@ export const stream = (model, context, options) => {
                     const reasoningDetails = choice.delta.reasoning_details;
                     if (Array.isArray(reasoningDetails)) {
                         for (const detail of reasoningDetails) {
-                            if (isEncryptedReasoningDetail(detail)) {
-                                const serializedDetail = JSON.stringify(detail);
-                                const matchingToolCall = toolCallBlocksById.get(detail.id);
-                                if (matchingToolCall) {
-                                    matchingToolCall.thoughtSignature = serializedDetail;
-                                }
-                                else {
-                                    pendingReasoningDetailsByToolCallId.set(detail.id, serializedDetail);
-                                }
-                            }
+                            if (!isOpenAIReasoningDetail(detail))
+                                continue;
+                            ensureThinkingBlock("");
+                            streamedReasoningDetails ??= [];
+                            // Keep provider replay data in the existing signature slot. OpenRouter streams
+                            // reasoning_details as deltas: consecutive text/summary deltas are merged into
+                            // logical entries, while encrypted entries remain opaque and discrete.
+                            appendOpenAIReasoningDetail(streamedReasoningDetails, detail);
                         }
                     }
                 }
@@ -430,10 +476,13 @@ export const stream = (model, context, options) => {
             if (output.stopReason === "aborted") {
                 throw new Error("Request was aborted");
             }
+            if (!hasFinishReason && !compat.supportsFinishReason) {
+                output.stopReason = output.content.some((block) => block.type === "toolCall") ? "toolUse" : "stop";
+            }
             if (output.stopReason === "error") {
                 throw new Error(output.errorMessage || "Provider returned an error stop reason");
             }
-            if (!hasFinishReason || output.stopReason === "pending") {
+            if ((compat.supportsFinishReason && !hasFinishReason) || output.stopReason === "pending") {
                 throw new Error("Stream ended without finish_reason");
             }
             stream.push({ type: "done", reason: output.stopReason, message: output });
@@ -441,6 +490,9 @@ export const stream = (model, context, options) => {
         }
         catch (error) {
             for (const block of output.content) {
+                if (block.type === "thinking") {
+                    applyStreamedReasoningDetails(block);
+                }
                 delete block.index;
                 // Streaming scratch buffers are only used during parsing; never persist them.
                 delete block.partialArgs;
@@ -465,18 +517,20 @@ export const stream = (model, context, options) => {
 };
 export const streamSimple = (model, context, options) => {
     getClientApiKey(model.provider, options?.apiKey, options?.headers);
-    const base = buildBaseOptions(model, context, options, options?.apiKey);
+    const base = {
+        ...buildBaseOptions(model, context, options, options?.apiKey),
+        toolChoice: options?.toolChoice,
+    };
     const clampedReasoning = options?.reasoning ? clampThinkingLevel(model, options.reasoning) : undefined;
     const reasoningEffort = clampedReasoning === "off" ? undefined : clampedReasoning;
-    const toolChoice = options?.toolChoice;
     return stream(model, context, {
         ...base,
         reasoningEffort,
-        toolChoice,
+        thinkingBudgets: options?.thinkingBudgets,
     });
 };
 function createClient(model, context, apiKey, optionsHeaders, fetch, sessionId, compat = getCompat(model)) {
-    const headers = { ...model.headers };
+    const headers = { "User-Agent": getPiUserAgent(), ...model.headers };
     if (model.provider === "github-copilot") {
         const hasImages = hasCopilotVisionInput(context.messages);
         const copilotHeaders = buildCopilotDynamicHeaders({
@@ -509,8 +563,11 @@ function createClient(model, context, apiKey, optionsHeaders, fetch, sessionId,
         defaultHeaders: headers,
     });
 }
-function buildParams(model, context, options, compat = getCompat(model), cacheRetention = resolveCacheRetention(options?.cacheRetention, options?.env), grammarToolInputProperties = createGrammarToolInputProperties(context.tools, compat.supportsOpenAIGrammarTools)) {
-    const messages = convertMessages(model, context, compat, { grammarToolInputProperties });
+function buildParams(model, context, options, compat = getCompat(model), cacheRetention = resolveCacheRetention(options?.cacheRetention, options?.env), grammarToolInputProperties = createGrammarToolInputProperties(getDeclaredTools(context.messages), compat.supportsOpenAIGrammarTools)) {
+    const transcriptTools = resolveTranscriptTools(context.messages, compat.supportsMidConvoSystemMessages === true && compat.supportsMidConvoToolAdditions === true);
+    const messages = convertMessages(model, context, compat, {
+        grammarToolInputProperties,
+    });
     const cacheControl = getCompatCacheControl(compat, cacheRetention);
     const params = {
         model: model.id,
@@ -530,6 +587,7 @@ function buildParams(model, context, options, compat = getCompat(model), cacheRe
     }
     if (options?.maxTokens) {
         if (compat.maxTokensField === "max_tokens") {
+            // Deprecated by OpenAI, but some OpenAI-compatible providers only accept max_tokens.
             params.max_tokens = options.maxTokens;
         }
         else {
@@ -539,10 +597,8 @@ function buildParams(model, context, options, compat = getCompat(model), cacheRe
     if (options?.temperature !== undefined) {
         params.temperature = options.temperature;
     }
-    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 (transcriptTools.requestTools.length > 0) {
+        params.tools = convertTools(transcriptTools.requestTools, compat);
         if (compat.zaiToolStream) {
             params.tool_stream = true;
         }
@@ -557,6 +613,11 @@ function buildParams(model, context, options, compat = getCompat(model), cacheRe
     if (options?.toolChoice) {
         params.tool_choice = options.toolChoice;
     }
+    if (compat.vllmPriority !== undefined) {
+        params.priority = compat.vllmPriority;
+    }
+    const thinkingTokenBudgetField = resolveThinkingTokenBudgetField(compat);
+    const thinkingBudget = resolveClampedThinkingBudget(model, options, params);
     if (compat.thinkingFormat === "zai" && model.reasoning) {
         const zaiParams = params;
         zaiParams.thinking = options?.reasoningEffort ? { type: "enabled", clear_thinking: false } : { type: "disabled" };
@@ -584,11 +645,26 @@ function buildParams(model, context, options, compat = getCompat(model), cacheRe
         };
     }
     else if (compat.thinkingFormat === "chat-template" && model.reasoning) {
-        const chatTemplateKwargs = buildChatTemplateKwargs(model, options, compat);
+        const chatTemplateKwargs = buildChatTemplateValues(model, options, compat.chatTemplateKwargs, thinkingBudget);
         if (chatTemplateKwargs) {
             params.chat_template_kwargs = chatTemplateKwargs;
         }
     }
+    else if (compat.thinkingFormat === "baseten" && model.reasoning) {
+        const basetenParams = params;
+        const chatTemplateArgs = buildChatTemplateValues(model, options, compat.chatTemplateArgs, thinkingBudget);
+        if (chatTemplateArgs) {
+            basetenParams.chat_template_args = chatTemplateArgs;
+        }
+        if (compat.supportsReasoningEffort) {
+            const requestedEffort = options?.reasoningEffort;
+            const mappedEffort = requestedEffort ? model.thinkingLevelMap?.[requestedEffort] : model.thinkingLevelMap?.off;
+            const effort = mappedEffort === undefined ? requestedEffort : mappedEffort;
+            if (typeof effort === "string") {
+                basetenParams.reasoning_effort = effort;
+            }
+        }
+    }
     else if (compat.thinkingFormat === "deepseek" && model.reasoning) {
         if (options?.reasoningEffort) {
             params.thinking = { type: "enabled" };
@@ -645,6 +721,13 @@ function buildParams(model, context, options, compat = getCompat(model), cacheRe
             params.reasoning_effort = offValue;
         }
     }
+    // Cap reasoning with a top-level budget field. Independent of thinkingFormat: the
+    // same server can serve zai, qwen or chat-template models. Reasoning and the answer
+    // share max_tokens here, so an uncapped reasoning phase can consume the whole
+    // response and leave no answer and no tool call.
+    if (thinkingTokenBudgetField && thinkingBudget !== undefined) {
+        Object.assign(params, { [thinkingTokenBudgetField]: thinkingBudget });
+    }
     // OpenRouter provider routing preferences
     if (model.compat?.openRouterRouting) {
         params.provider = model.compat.openRouterRouting;
@@ -661,19 +744,38 @@ function buildParams(model, context, options, compat = getCompat(model), cacheRe
             params.providerOptions = { gateway: gatewayOptions };
         }
     }
+    // Last so model and request sampling parameters override named request fields.
+    const samplingParams = resolveSamplingParams(model, options?.reasoningEffort ?? "off", options?.samplingParams);
+    if (samplingParams) {
+        Object.assign(params, samplingParams);
+    }
     return params;
 }
-function buildChatTemplateKwargs(model, options, compat) {
-    const kwargs = {};
-    for (const [key, value] of Object.entries(compat.chatTemplateKwargs)) {
-        const resolved = resolveChatTemplateKwargValue(model, options, value);
+function resolveThinkingTokenBudgetField(compat) {
+    if (compat.thinkingTokenBudgetField)
+        return compat.thinkingTokenBudgetField;
+    if (compat.supportsThinkingTokenBudget)
+        return "thinking_token_budget";
+    return undefined;
+}
+function resolveClampedThinkingBudget(model, options, params) {
+    if (!options?.reasoningEffort || !model.reasoning)
+        return undefined;
+    const ceiling = params.max_tokens ?? params.max_completion_tokens ?? model.maxTokens;
+    const budget = clampThinkingBudgetToAnswerRoom(thinkingBudgetForLevel(options.reasoningEffort, options.thinkingBudgets), ceiling);
+    return budget > 0 ? budget : undefined;
+}
+function buildChatTemplateValues(model, options, values, thinkingBudget) {
+    const resolvedValues = {};
+    for (const [key, value] of Object.entries(values)) {
+        const resolved = resolveChatTemplateKwargValue(model, options, value, thinkingBudget);
         if (resolved !== undefined) {
-            kwargs[key] = resolved;
+            resolvedValues[key] = resolved;
         }
     }
-    return Object.keys(kwargs).length > 0 ? kwargs : undefined;
+    return Object.keys(resolvedValues).length > 0 ? resolvedValues : undefined;
 }
-function resolveChatTemplateKwargValue(model, options, value) {
+function resolveChatTemplateKwargValue(model, options, value, thinkingBudget) {
     if (typeof value !== "object" || value === null) {
         return value;
     }
@@ -684,6 +786,9 @@ function resolveChatTemplateKwargValue(model, options, value) {
     if (value.$var === "thinking.enabled") {
         return !!reasoningEffort;
     }
+    if (value.$var === "thinking.budget") {
+        return thinkingBudget;
+    }
     const mappedValue = reasoningEffort ? model.thinkingLevelMap?.[reasoningEffort] : model.thinkingLevelMap?.off;
     return mappedValue === undefined ? reasoningEffort : typeof mappedValue === "string" ? mappedValue : undefined;
 }
@@ -762,6 +867,7 @@ function addCacheControlToTextContent(message, cacheControl) {
     return false;
 }
 export function convertMessages(model, context, compat, options) {
+    const normalizedContext = resolveTranscript(context, compat.supportsMidConvoSystemMessages);
     const params = [];
     const normalizeToolCallId = (id) => {
         // Handle pipe-separated IDs from OpenAI Responses API
@@ -788,12 +894,9 @@ export function convertMessages(model, context, compat, options) {
             return id.length > 40 ? id.slice(0, 40) : id;
         return id;
     };
-    const transformedMessages = transformMessages(context.messages, model, (id) => normalizeToolCallId(id));
-    if (context.systemPrompt) {
-        const useDeveloperRole = model.reasoning && compat.supportsDeveloperRole;
-        const role = useDeveloperRole ? "developer" : "system";
-        params.push({ role: role, content: sanitizeSurrogates(context.systemPrompt) });
-    }
+    const transformedMessages = transformMessages(normalizedContext.messages, model, (id) => normalizeToolCallId(id));
+    const transcriptTools = resolveTranscriptTools(normalizedContext.messages, compat.supportsMidConvoSystemMessages === true && compat.supportsMidConvoToolAdditions === true);
+    const instructionRole = model.reasoning && compat.supportsDeveloperRole ? "developer" : "system";
     let lastRole = null;
     for (let i = 0; i < transformedMessages.length; i++) {
         const msg = transformedMessages[i];
@@ -805,7 +908,21 @@ export function convertMessages(model, context, compat, options) {
                 content: "I have processed the tool results.",
             });
         }
-        if (msg.role === "user") {
+        if (msg.role === "system") {
+            const addedTools = i > 0 && transcriptTools.anchorsAdditions ? (msg.toolsAdded ?? []) : [];
+            if (addedTools.length > 0) {
+                const kimiToolMessage = {
+                    role: "system",
+                    tools: convertTools(addedTools, compat),
+                };
+                params.push(kimiToolMessage);
+            }
+            const text = i === 0 ? getSystemMessageText(msg) : renderSystemMessageUpdate(msg);
+            if (text.length > 0) {
+                params.push({ role: instructionRole, content: sanitizeSurrogates(text) });
+            }
+        }
+        else if (msg.role === "user") {
             if (typeof msg.content === "string") {
                 params.push({
                     role: "user",
@@ -813,7 +930,9 @@ export function convertMessages(model, context, compat, options) {
                 });
             }
             else {
-                const content = msg.content.map((item) => {
+                const content = msg.content
+                    .filter((item) => item.type !== "text" || item.text.length > 0)
+                    .map((item) => {
                     if (item.type === "text") {
                         return {
                             type: "text",
@@ -851,9 +970,16 @@ export function convertMessages(model, context, compat, options) {
                 text: sanitizeSurrogates(block.text),
             }));
             const assistantText = assistantTextParts.map((part) => part.text).join("");
-            const nonEmptyThinkingBlocks = msg.content
-                .filter(isThinkingContentBlock)
-                .filter((block) => block.thinking.trim().length > 0);
+            const thinkingBlocks = msg.content.filter(isThinkingContentBlock);
+            const toolCalls = msg.content.filter(isToolCallBlock);
+            const signedReasoningDetails = thinkingBlocks
+                .map((block) => parseOpenAIReasoningDetails(block.thinkingSignature))
+                .find((details) => details !== undefined);
+            const legacyReasoningDetails = toolCalls
+                .map((toolCall) => parseLegacyEncryptedReasoningDetail(toolCall.thoughtSignature))
+                .filter((detail) => detail !== undefined);
+            const preservedReasoningDetails = signedReasoningDetails ?? (legacyReasoningDetails.length > 0 ? legacyReasoningDetails : undefined);
+            const nonEmptyThinkingBlocks = thinkingBlocks.filter((block) => block.thinking.trim().length > 0);
             if (nonEmptyThinkingBlocks.length > 0) {
                 if (compat.requiresThinkingAsText) {
                     // Convert thinking blocks to plain text (no tags to avoid model mimicking them)
@@ -871,13 +997,16 @@ export function convertMessages(model, context, compat, options) {
                     if (assistantText.length > 0) {
                         assistantMsg.content = assistantText;
                     }
-                    // Use the signature from the first thinking block if available (for llama.cpp server + gpt-oss)
-                    let signature = nonEmptyThinkingBlocks[0].thinkingSignature;
-                    if (model.provider === "opencode-go" && signature === "reasoning") {
-                        signature = "reasoning_content";
-                    }
-                    if (signature && signature.length > 0) {
-                        assistantMsg[signature] = nonEmptyThinkingBlocks.map((block) => block.thinking).join("\n");
+                    // reasoning_details is the structured alternative to a raw reasoning field.
+                    if (!preservedReasoningDetails) {
+                        // Use the signature from the first thinking block if available (for llama.cpp server + gpt-oss)
+                        let signature = nonEmptyThinkingBlocks[0].thinkingSignature;
+                        if (model.provider === "opencode-go" && signature === "reasoning") {
+                            signature = "reasoning_content";
+                        }
+                        if (signature && isOpenAICompletionsReasoningField(signature)) {
+                            assistantMsg[signature] = nonEmptyThinkingBlocks.map((block) => block.thinking).join("\n");
+                        }
                     }
                 }
             }
@@ -889,7 +1018,6 @@ export function convertMessages(model, context, compat, options) {
                 // output, producing recursive nesting like [{'type':'text','text':'[{...}]'}].
                 assistantMsg.content = assistantText;
             }
-            const toolCalls = msg.content.filter(isToolCallBlock);
             if (toolCalls.length > 0) {
                 assistantMsg.tool_calls = toolCalls.map((tc) => {
                     const customInputProperty = options?.grammarToolInputProperties?.get(tc.name);
@@ -912,20 +1040,9 @@ export function convertMessages(model, context, compat, options) {
                         },
                     };
                 });
-                const reasoningDetails = toolCalls
-                    .filter((tc) => tc.thoughtSignature)
-                    .map((tc) => {
-                    try {
-                        return JSON.parse(tc.thoughtSignature);
-                    }
-                    catch {
-                        return null;
-                    }
-                })
-                    .filter(Boolean);
-                if (reasoningDetails.length > 0) {
-                    assistantMsg.reasoning_details = reasoningDetails;
-                }
+            }
+            if (preservedReasoningDetails) {
+                assistantMsg.reasoning_details = preservedReasoningDetails;
             }
             if (compat.requiresReasoningContentOnAssistantMessages &&
                 model.reasoning &&
@@ -947,7 +1064,6 @@ export function convertMessages(model, context, compat, options) {
         }
         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];
@@ -970,11 +1086,6 @@ export function convertMessages(model, context, compat, options) {
                     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)) {
@@ -1011,17 +1122,6 @@ export function convertMessages(model, context, compat, options) {
             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;
@@ -1053,7 +1153,7 @@ function convertTools(tools, compat) {
             function: {
                 name: tool.name,
                 description: tool.description,
-                parameters: tool.parameters, // TypeBox already generates JSON Schema
+                parameters: getJsonSchemaToolParameters(tool, strict),
                 // Only include strict if provider supports it. Some reject unknown fields.
                 ...(compat.supportsStrictMode !== false && { strict: strict ?? false }),
             },
@@ -1062,10 +1162,13 @@ function convertTools(tools, compat) {
 }
 function parseChunkUsage(rawUsage, model) {
     const promptTokens = rawUsage.prompt_tokens || 0;
-    const cacheReadTokens = rawUsage.prompt_tokens_details?.cached_tokens ?? rawUsage.prompt_cache_hit_tokens ?? 0;
+    const cacheReadTokens = rawUsage.prompt_tokens_details?.cached_tokens ?? rawUsage.prompt_cache_hit_tokens ?? rawUsage.cached_tokens ?? 0;
     const cacheWriteTokens = rawUsage.prompt_tokens_details?.cache_write_tokens || 0;
     // Follow documented OpenAI/OpenRouter semantics: cached_tokens is cache-read
-    // tokens (hits). OpenAI does not document or emit cache_write_tokens, but
+    // tokens (hits). Providers disagree on placement: OpenAI/OpenRouter use
+    // prompt_tokens_details.cached_tokens, DeepSeek uses prompt_cache_hit_tokens,
+    // and Kimi documents top-level usage.cached_tokens on the final usage chunk.
+    // OpenAI does not document or emit cache_write_tokens, but
     // OpenRouter-compatible providers can include it as a separate write count.
     // OpenRouter's own provider/tests affirm the separate mapping:
     // https://github.com/OpenRouterTeam/ai-sdk-provider/pull/409
@@ -1129,14 +1232,15 @@ function detectCompat(model) {
     const isCloudflareAiGateway = provider === "cloudflare-ai-gateway" || baseUrl.includes("gateway.ai.cloudflare.com");
     const isNvidia = provider === "nvidia" || baseUrl.includes("integrate.api.nvidia.com");
     const isAntLing = provider === "ant-ling" || baseUrl.includes("api.ant-ling.com");
+    const isCerebras = provider === "cerebras" || baseUrl.includes("cerebras.ai");
+    const isDeepSeek = provider === "deepseek" || baseUrl.toLowerCase().includes("deepseek.com");
     const isNonStandard = isNvidia ||
-        provider === "cerebras" ||
-        baseUrl.includes("cerebras.ai") ||
+        isCerebras ||
         provider === "xai" ||
         baseUrl.includes("api.x.ai") ||
         isTogether ||
         baseUrl.includes("chutes.ai") ||
-        baseUrl.includes("deepseek.com") ||
+        isDeepSeek ||
         isZai ||
         isMoonshot ||
         provider === "opencode" ||
@@ -1145,6 +1249,7 @@ function detectCompat(model) {
         isCloudflareAiGateway ||
         isAntLing;
     const useMaxTokens = baseUrl.includes("chutes.ai") ||
+        isDeepSeek ||
         isMoonshot ||
         isCloudflareAiGateway ||
         isTogether ||
@@ -1152,7 +1257,6 @@ function detectCompat(model) {
         isAntLing ||
         isZai;
     const isGrok = provider === "xai" || baseUrl.includes("api.x.ai");
-    const isDeepSeek = provider === "deepseek" || baseUrl.includes("deepseek.com");
     const isOpenRouterDeveloperRoleModel = isOpenRouter && (model.id.startsWith("anthropic/") || model.id.startsWith("openai/"));
     const cacheControlFormat = provider === "openrouter" && model.id.startsWith("anthropic/") ? "anthropic" : undefined;
     return {
@@ -1160,6 +1264,7 @@ function detectCompat(model) {
         supportsDeveloperRole: isOpenRouterDeveloperRoleModel || (!isNonStandard && !isOpenRouter),
         supportsReasoningEffort: !isGrok && !isZai && !isMoonshot && !isTogether && !isCloudflareAiGateway && !isNvidia && !isAntLing,
         supportsUsageInStreaming: true,
+        supportsFinishReason: true,
         maxTokensField: useMaxTokens ? "max_tokens" : "max_completion_tokens",
         requiresToolResultName: false,
         requiresAssistantAfterToolResult: false,
@@ -1179,12 +1284,17 @@ function detectCompat(model) {
         openRouterRouting: {},
         vercelGatewayRouting: {},
         chatTemplateKwargs: {},
+        chatTemplateArgs: {},
         zaiToolStream: false,
-        supportsStrictMode: !isMoonshot && !isTogether && !isCloudflareAiGateway && !isNvidia,
+        supportsThinkingTokenBudget: false,
+        thinkingTokenBudgetField: undefined,
+        // OpenAI compatibility alone does not imply strict JSON-schema tool support.
+        supportsStrictMode: false,
         supportsOpenAIGrammarTools: false,
+        supportsMidConvoSystemMessages: false,
+        supportsMidConvoToolAdditions: false,
         cacheControlFormat,
-        sendSessionAffinityHeaders: false,
-        deferredToolsMode: undefined,
+        sendSessionAffinityHeaders: isOpenRouter,
         sessionAffinityFormat: isOpenRouter ? "openrouter" : "openai",
         supportsLongCacheRetention: !(isTogether ||
             isCloudflareWorkersAI ||
@@ -1206,6 +1316,7 @@ function getCompat(model) {
         supportsDeveloperRole: model.compat.supportsDeveloperRole ?? detected.supportsDeveloperRole,
         supportsReasoningEffort: model.compat.supportsReasoningEffort ?? detected.supportsReasoningEffort,
         supportsUsageInStreaming: model.compat.supportsUsageInStreaming ?? detected.supportsUsageInStreaming,
+        supportsFinishReason: model.compat.supportsFinishReason ?? detected.supportsFinishReason,
         maxTokensField: model.compat.maxTokensField ?? detected.maxTokensField,
         requiresToolResultName: model.compat.requiresToolResultName ?? detected.requiresToolResultName,
         requiresAssistantAfterToolResult: model.compat.requiresAssistantAfterToolResult ?? detected.requiresAssistantAfterToolResult,
@@ -1216,14 +1327,19 @@ function getCompat(model) {
         openRouterRouting: model.compat.openRouterRouting ?? {},
         vercelGatewayRouting: model.compat.vercelGatewayRouting ?? detected.vercelGatewayRouting,
         chatTemplateKwargs: model.compat.chatTemplateKwargs ?? detected.chatTemplateKwargs,
+        chatTemplateArgs: model.compat.chatTemplateArgs ?? detected.chatTemplateArgs,
         zaiToolStream: model.compat.zaiToolStream ?? detected.zaiToolStream,
+        supportsThinkingTokenBudget: model.compat.supportsThinkingTokenBudget ?? detected.supportsThinkingTokenBudget,
+        thinkingTokenBudgetField: model.compat.thinkingTokenBudgetField ?? detected.thinkingTokenBudgetField,
         supportsStrictMode: model.compat.supportsStrictMode ?? detected.supportsStrictMode,
         supportsOpenAIGrammarTools: model.compat.supportsOpenAIGrammarTools ?? detected.supportsOpenAIGrammarTools,
+        supportsMidConvoSystemMessages: model.compat.supportsMidConvoSystemMessages ?? detected.supportsMidConvoSystemMessages,
+        supportsMidConvoToolAdditions: model.compat.supportsMidConvoToolAdditions ?? detected.supportsMidConvoToolAdditions,
         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,
+        vllmPriority: model.compat.vllmPriority,
     };
 }
 //# sourceMappingURL=openai-completions.js.map