@jecruz/merc-ai 0.1.4 → 0.2.0

package/dist/providers/openai-completions.js

@@ -4,11 +4,13 @@ import { calculateCost, clampThinkingLevel } from "../models.js";
 import { formatProviderError, normalizeProviderError } from "../utils/error-body.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { headersToRecord } from "../utils/headers.js";
-import { parseStreamingJson } from "../utils/json-parse.js";
+import { finalizeToolCallArguments, parseStreamingJson } from "../utils/json-parse.js";
 import { getProviderEnvValue } from "../utils/provider-env.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
+import { createProviderToolCallIdNormalizer } from "../utils/tool-call-id.js";
 import { isCloudflareProvider, resolveCloudflareBaseUrl } from "./cloudflare.js";
 import { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "./github-copilot-headers.js";
+import { clampOpenAIPromptCacheKey } from "./openai-prompt-cache.js";
 import { buildBaseOptions } from "./simple-options.js";
 import { transformMessages } from "./transform-messages.js";
 /**
@@ -42,9 +44,8 @@ function isImageContentBlock(block) {
     return block.type === "image";
 }
 function isMiniMaxModel(model) {
-    // LLM Dynamix is currently allowlisted to MiniMax-M3 on the local runtime;
-    // retain the provider match when discovery normalizes the model ID.
-    return model.provider === "llmdynamix" || model.id.toLowerCase().includes("minimax-m3");
+    // Merc-native: shared gateways carry multiple families; infer MiniMax only from the id.
+    return model.id.toLowerCase().includes("minimax-m3");
 }
 function createThinkingTagFilter(enabled) {
     let buffer = "";
@@ -102,6 +103,17 @@ function createThinkingTagFilter(enabled) {
         flush: () => (enabled ? consume() : buffer),
     };
 }
+function isEncryptedReasoningDetail(detail) {
+    if (typeof detail !== "object" || detail === null) {
+        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);
+}
 function isOpenRouterImageGenerationModel(model) {
     return model.provider === "openrouter" && model.compat?.openRouterImageGeneration === true;
 }
@@ -148,7 +160,7 @@ export const streamOpenAICompletions = (model, context, options) => {
             const requestOptions = {
                 ...(options?.signal ? { signal: options.signal } : {}),
                 ...(options?.timeoutMs !== undefined ? { timeout: options.timeoutMs } : {}),
-                ...(options?.maxRetries !== undefined ? { maxRetries: options.maxRetries } : {}),
+                maxRetries: options?.maxRetries ?? 0,
             };
             if (isOpenRouterImageGenerationModel(model)) {
                 const { stream_options: _streamOptions, ...nonStreamingBaseParams } = params;
@@ -219,10 +231,12 @@ export const streamOpenAICompletions = (model, context, options) => {
             let textBlock = null;
             let thinkingBlock = null;
             let hasFinishReason = false;
+            let hasIncompleteToolCallArguments = false;
             const toolCallBlocksByIndex = new Map();
             const toolCallBlocksById = new Map();
+            const pendingReasoningDetailsByToolCallId = new Map();
             const blocks = output.content;
-            const thinkingTagFilter = createThinkingTagFilter(isMiniMaxModel(model) || compat.thinkingFormat === "minimax");
+            const thinkingTagFilter = createThinkingTagFilter(compat.thinkingFormat === "minimax");
             const getContentIndex = (block) => blocks.indexOf(block);
             const finishBlock = (block) => {
                 const contentIndex = getContentIndex(block);
@@ -246,7 +260,14 @@ export const streamOpenAICompletions = (model, context, options) => {
                     });
                 }
                 else if (block.type === "toolCall") {
-                    block.arguments = parseStreamingJson(block.partialArgs);
+                    // Without finish_reason, only strictly valid raw arguments prove the call was not cut off.
+                    try {
+                        JSON.parse(block.partialArgs ?? "");
+                    }
+                    catch {
+                        hasIncompleteToolCallArguments = true;
+                    }
+                    finalizeToolCallArguments(block, block.partialArgs);
                     // Finalize in-place and strip the scratch buffers so replay only
                     // carries parsed arguments.
                     delete block.partialArgs;
@@ -291,6 +312,16 @@ export const streamOpenAICompletions = (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;
                 let block = streamIndex !== undefined ? toolCallBlocksByIndex.get(streamIndex) : undefined;
@@ -326,6 +357,7 @@ export const streamOpenAICompletions = (model, context, options) => {
                 if (toolCall.id) {
                     toolCallBlocksById.set(toolCall.id, block);
                 }
+                applyPendingReasoningDetail(block);
                 return block;
             };
             for await (const chunk of openaiStream) {
@@ -377,8 +409,7 @@ export const streamOpenAICompletions = (model, context, options) => {
                         }
                     }
                     if (foundReasoningField &&
-                        !((isMiniMaxModel(model) || compat.thinkingFormat === "minimax") &&
-                            (!options?.reasoningEffort || model.reasoning === false))) {
+                        !(compat.thinkingFormat === "minimax" && (!options?.reasoningEffort || model.reasoning === false))) {
                         const delta = deltaFields[foundReasoningField];
                         if (typeof delta === "string" && delta.length > 0) {
                             const thinkingSignature = model.provider === "opencode-go" && foundReasoningField === "reasoning"
@@ -419,12 +450,16 @@ export const streamOpenAICompletions = (model, context, options) => {
                         }
                     }
                     const reasoningDetails = choice.delta.reasoning_details;
-                    if (reasoningDetails && Array.isArray(reasoningDetails)) {
+                    if (Array.isArray(reasoningDetails)) {
                         for (const detail of reasoningDetails) {
-                            if (detail.type === "reasoning.encrypted" && detail.id && detail.data) {
-                                const matchingToolCall = output.content.find((b) => b.type === "toolCall" && b.id === detail.id);
+                            if (isEncryptedReasoningDetail(detail)) {
+                                const serializedDetail = JSON.stringify(detail);
+                                const matchingToolCall = toolCallBlocksById.get(detail.id);
                                 if (matchingToolCall) {
-                                    matchingToolCall.thoughtSignature = JSON.stringify(detail);
+                                    matchingToolCall.thoughtSignature = serializedDetail;
+                                }
+                                else {
+                                    pendingReasoningDetailsByToolCallId.set(detail.id, serializedDetail);
                                 }
                             }
                         }
@@ -441,10 +476,16 @@ export const streamOpenAICompletions = (model, context, options) => {
             if (output.stopReason === "aborted") {
                 throw new Error("Request was aborted");
             }
+            if (!hasFinishReason && !compat.supportsFinishReason) {
+                if (hasIncompleteToolCallArguments) {
+                    throw new Error("Stream ended without finish_reason and with incomplete tool call arguments");
+                }
+                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) {
+            if (compat.supportsFinishReason && !hasFinishReason) {
                 throw new Error("Stream ended without finish_reason");
             }
             stream.push({ type: "done", reason: output.stopReason, message: output });
@@ -458,11 +499,17 @@ export const streamOpenAICompletions = (model, context, options) => {
                 delete block.streamIndex;
             }
             output.stopReason = options?.signal?.aborted ? "aborted" : "error";
-            output.errorMessage = formatProviderError(normalizeProviderError(error));
+            const normalized = normalizeProviderError(error);
+            output.errorMetadata = normalized.errorMetadata;
+            output.errorMessage = formatProviderError(normalized);
             // Some providers via OpenRouter give additional information in this field.
+            // normalizeProviderError already stringifies the parsed body (error.error)
+            // into errorMessage, so only append the raw metadata when it is not already
+            // present to avoid double-printing it.
             const rawMetadata = error?.error?.metadata?.raw;
-            if (rawMetadata)
+            if (rawMetadata && !output.errorMessage.includes(String(rawMetadata))) {
                 output.errorMessage += `\n${rawMetadata}`;
+            }
             stream.push({ type: "error", reason: output.stopReason, error: output });
             stream.end();
         }
@@ -474,7 +521,7 @@ export const streamSimpleOpenAICompletions = (model, context, options) => {
     if (!apiKey && model.authHeader !== false) {
         throw new Error(`No API key for provider: ${model.provider}`);
     }
-    const base = buildBaseOptions(model, options, apiKey ?? "");
+    const base = buildBaseOptions(model, context, options, apiKey ?? "");
     const clampedReasoning = options?.reasoning ? clampThinkingLevel(model, options.reasoning) : undefined;
     const reasoningEffort = clampedReasoning === "off" ? undefined : clampedReasoning;
     const toolChoice = options?.toolChoice;
@@ -544,7 +591,7 @@ function buildParams(model, context, options, compat = getCompat(model), cacheRe
         stream: true,
         prompt_cache_key: (model.baseUrl.includes("api.openai.com") && cacheRetention !== "none") ||
             (cacheRetention === "long" && compat.supportsLongCacheRetention)
-            ? options?.sessionId
+            ? clampOpenAIPromptCacheKey(options?.sessionId)
             : undefined,
         prompt_cache_retention: cacheRetention === "long" && compat.supportsLongCacheRetention ? "24h" : undefined,
     };
@@ -581,12 +628,12 @@ function buildParams(model, context, options, compat = getCompat(model), cacheRe
     if (cacheControl) {
         applyAnthropicCacheControl(messages, params.tools, cacheControl);
     }
-    if (options?.toolChoice) {
+    if (options?.toolChoice && params.tools?.length) {
         params.tool_choice = options.toolChoice;
     }
     if (compat.thinkingFormat === "zai" && model.reasoning) {
         const zaiParams = params;
-        zaiParams.thinking = { type: options?.reasoningEffort ? "enabled" : "disabled" };
+        zaiParams.thinking = options?.reasoningEffort ? { type: "enabled", clear_thinking: false } : { type: "disabled" };
         if (options?.reasoningEffort && compat.supportsReasoningEffort) {
             const mappedEffort = model.thinkingLevelMap?.[options.reasoningEffort];
             const effort = mappedEffort === undefined ? options.reasoningEffort : mappedEffort;
@@ -595,7 +642,7 @@ function buildParams(model, context, options, compat = getCompat(model), cacheRe
             }
         }
     }
-    else if (compat.thinkingFormat === "minimax" || isMiniMaxModel(model)) {
+    else if (compat.thinkingFormat === "minimax") {
         const minimaxParams = params;
         minimaxParams.thinking = { type: options?.reasoningEffort ? "adaptive" : "disabled" };
         minimaxParams.reasoning_split = true;
@@ -690,7 +737,7 @@ function addCacheControlToSystemPrompt(messages, cacheControl) {
 function addCacheControlToLastConversationMessage(messages, cacheControl) {
     for (let i = messages.length - 1; i >= 0; i--) {
         const message = messages[i];
-        if (message.role === "user" || message.role === "assistant") {
+        if (message.role === "user" || message.role === "assistant" || message.role === "tool") {
             if (addCacheControlToMessage(message, cacheControl)) {
                 return;
             }
@@ -708,7 +755,7 @@ function addCacheControlToInstructionMessage(message, cacheControl) {
     return addCacheControlToTextContent(message, cacheControl);
 }
 function addCacheControlToMessage(message, cacheControl) {
-    if (message.role === "user" || message.role === "assistant") {
+    if (message.role === "user" || message.role === "assistant" || message.role === "tool") {
         return addCacheControlToTextContent(message, cacheControl);
     }
     return false;
@@ -743,20 +790,7 @@ function addCacheControlToTextContent(message, cacheControl) {
 }
 export function convertMessages(model, context, compat) {
     const params = [];
-    const normalizeToolCallId = (id) => {
-        // Handle pipe-separated IDs from OpenAI Responses API
-        // Format: {call_id}|{id} where {id} can be 400+ chars with special chars (+, /, =)
-        // These come from providers like github-copilot, openai-codex, opencode
-        // Extract just the call_id part and normalize it
-        if (id.includes("|")) {
-            const [callId] = id.split("|");
-            // Sanitize to allowed chars and truncate to 40 chars (OpenAI limit)
-            return callId.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 40);
-        }
-        if (model.provider === "openai")
-            return id.length > 40 ? id.slice(0, 40) : id;
-        return id;
-    };
+    const normalizeToolCallId = createProviderToolCallIdNormalizer(model);
     const transformedMessages = transformMessages(context.messages, model, (id) => normalizeToolCallId(id));
     if (context.systemPrompt) {
         const useDeveloperRole = model.reasoning && compat.supportsDeveloperRole;
@@ -782,7 +816,9 @@ export function convertMessages(model, context, compat) {
                 });
             }
             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",
@@ -981,10 +1017,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
@@ -1042,12 +1081,13 @@ function detectCompat(model) {
     const isCloudflareAiGateway = provider === "cloudflare-ai-gateway" || baseUrl.includes("gateway.ai.cloudflare.com");
     const isAntLing = provider === "ant-ling" || baseUrl.includes("api.ant-ling.com");
     const isMiniMax = isMiniMaxModel(model);
+    const isDeepSeek = provider === "deepseek" || baseUrl.toLowerCase().includes("deepseek.com");
     const isNonStandard = provider === "cerebras" ||
         baseUrl.includes("cerebras.ai") ||
         provider === "xai" ||
         baseUrl.includes("api.x.ai") ||
         baseUrl.includes("chutes.ai") ||
-        baseUrl.includes("deepseek.com") ||
+        isDeepSeek ||
         isZai ||
         isMoonshot ||
         provider === "opencode" ||
@@ -1055,16 +1095,23 @@ function detectCompat(model) {
         isCloudflareWorkersAI ||
         isCloudflareAiGateway ||
         isAntLing;
-    const useMaxTokens = baseUrl.includes("chutes.ai") || isMoonshot || isCloudflareAiGateway || isAntLing;
+    // Z.AI ignores max_completion_tokens, so its output cap only applies through max_tokens.
+    const isZaiMaxTokensEndpoint = isZai || provider === "zai-coding-cn" || baseUrl.includes("open.bigmodel.cn");
+    const useMaxTokens = baseUrl.includes("chutes.ai") ||
+        isDeepSeek ||
+        isMoonshot ||
+        isCloudflareAiGateway ||
+        isAntLing ||
+        isZaiMaxTokensEndpoint;
     const isGrok = provider === "xai" || baseUrl.includes("api.x.ai");
-    const isDeepSeek = provider === "deepseek" || baseUrl.includes("deepseek.com");
-    const cacheControlFormat = provider === "openrouter" && model.id.startsWith("anthropic/") ? "anthropic" : undefined;
+    const cacheControlFormat = provider === "openrouter" && /^~?anthropic\//.test(model.id) ? "anthropic" : undefined;
     const isOpenRouter = provider === "openrouter" || baseUrl.includes("openrouter.ai");
     return {
         supportsStore: !isNonStandard,
         supportsDeveloperRole: !isNonStandard,
         supportsReasoningEffort: !isGrok && !isZai && !isMoonshot && !isCloudflareAiGateway && !isAntLing,
         supportsUsageInStreaming: true,
+        supportsFinishReason: true,
         maxTokensField: useMaxTokens ? "max_tokens" : "max_completion_tokens",
         requiresToolResultName: false,
         requiresAssistantAfterToolResult: false,
@@ -1087,7 +1134,7 @@ function detectCompat(model) {
         zaiToolStream: false,
         supportsStrictMode: !isMoonshot && !isCloudflareAiGateway,
         cacheControlFormat,
-        sendSessionAffinityHeaders: false,
+        sendSessionAffinityHeaders: isOpenRouter,
         sessionAffinityFormat: isOpenRouter ? "openrouter" : "openai",
         supportsLongCacheRetention: !(isCloudflareWorkersAI || isCloudflareAiGateway || isAntLing),
     };
@@ -1105,13 +1152,14 @@ 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,
         requiresThinkingAsText: model.compat.requiresThinkingAsText ?? detected.requiresThinkingAsText,
         requiresReasoningContentOnAssistantMessages: model.compat.requiresReasoningContentOnAssistantMessages ??
             detected.requiresReasoningContentOnAssistantMessages,
-        thinkingFormat: isMiniMaxModel(model) ? "minimax" : (model.compat.thinkingFormat ?? detected.thinkingFormat),
+        thinkingFormat: model.compat.thinkingFormat ?? detected.thinkingFormat,
         openRouterRouting: model.compat.openRouterRouting ?? {},
         openRouterImageGeneration: model.compat.openRouterImageGeneration ?? detected.openRouterImageGeneration,
         vercelGatewayRouting: model.compat.vercelGatewayRouting ?? detected.vercelGatewayRouting,