phi-code-ai 0.56.3 → 0.74.0

package/dist/providers/openai-completions.js

@@ -1,11 +1,13 @@
 import OpenAI from "openai";
 import { getEnvApiKey } from "../env-api-keys.js";
-import { calculateCost, supportsXhigh } from "../models.js";
+import { calculateCost, clampThinkingLevel } from "../models.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
+import { headersToRecord } from "../utils/headers.js";
 import { parseStreamingJson } from "../utils/json-parse.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
+import { isCloudflareProvider, resolveCloudflareBaseUrl } from "./cloudflare.js";
 import { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "./github-copilot-headers.js";
-import { buildBaseOptions, clampReasoning } from "./simple-options.js";
+import { buildBaseOptions } from "./simple-options.js";
 import { transformMessages } from "./transform-messages.js";
 /**
  * Check if conversation messages contain tool calls or tool results.
@@ -25,6 +27,27 @@ function hasToolHistory(messages) {
     }
     return false;
 }
+function isTextContentBlock(block) {
+    return block.type === "text";
+}
+function isThinkingContentBlock(block) {
+    return block.type === "thinking";
+}
+function isToolCallBlock(block) {
+    return block.type === "toolCall";
+}
+function isImageContentBlock(block) {
+    return block.type === "image";
+}
+function resolveCacheRetention(cacheRetention) {
+    if (cacheRetention) {
+        return cacheRetention;
+    }
+    if (typeof process !== "undefined" && process.env.PI_CACHE_RETENTION === "long") {
+        return "long";
+    }
+    return "short";
+}
 export const streamOpenAICompletions = (model, context, options) => {
     const stream = new AssistantMessageEventStream();
     (async () => {
@@ -47,128 +70,185 @@ export const streamOpenAICompletions = (model, context, options) => {
         };
         try {
             const apiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
-            const client = createClient(model, context, apiKey, options?.headers);
-            const params = buildParams(model, context, options);
-            options?.onPayload?.(params);
-            const openaiStream = await client.chat.completions.create(params, { signal: options?.signal });
+            const compat = getCompat(model);
+            const cacheRetention = resolveCacheRetention(options?.cacheRetention);
+            const cacheSessionId = cacheRetention === "none" ? undefined : options?.sessionId;
+            const client = createClient(model, context, apiKey, options?.headers, cacheSessionId, compat);
+            let params = buildParams(model, context, options, compat, cacheRetention);
+            const nextParams = await options?.onPayload?.(params, model);
+            if (nextParams !== undefined) {
+                params = nextParams;
+            }
+            const requestOptions = {
+                ...(options?.signal ? { signal: options.signal } : {}),
+                ...(options?.timeoutMs !== undefined ? { timeout: options.timeoutMs } : {}),
+                ...(options?.maxRetries !== undefined ? { maxRetries: options.maxRetries } : {}),
+            };
+            const { data: openaiStream, response } = await client.chat.completions
+                .create(params, requestOptions)
+                .withResponse();
+            await options?.onResponse?.({ status: response.status, headers: headersToRecord(response.headers) }, model);
             stream.push({ type: "start", partial: output });
-            let currentBlock = null;
+            let textBlock = null;
+            let thinkingBlock = null;
+            const toolCallBlocksByIndex = new Map();
+            const toolCallBlocksById = new Map();
             const blocks = output.content;
-            const blockIndex = () => blocks.length - 1;
-            const finishCurrentBlock = (block) => {
-                if (block) {
-                    if (block.type === "text") {
-                        stream.push({
-                            type: "text_end",
-                            contentIndex: blockIndex(),
-                            content: block.text,
-                            partial: output,
-                        });
-                    }
-                    else if (block.type === "thinking") {
-                        stream.push({
-                            type: "thinking_end",
-                            contentIndex: blockIndex(),
-                            content: block.thinking,
-                            partial: output,
-                        });
+            const getContentIndex = (block) => blocks.indexOf(block);
+            const finishBlock = (block) => {
+                const contentIndex = getContentIndex(block);
+                if (contentIndex === -1) {
+                    return;
+                }
+                if (block.type === "text") {
+                    stream.push({
+                        type: "text_end",
+                        contentIndex,
+                        content: block.text,
+                        partial: output,
+                    });
+                }
+                else if (block.type === "thinking") {
+                    stream.push({
+                        type: "thinking_end",
+                        contentIndex,
+                        content: block.thinking,
+                        partial: output,
+                    });
+                }
+                else if (block.type === "toolCall") {
+                    block.arguments = parseStreamingJson(block.partialArgs);
+                    // Finalize in-place and strip the scratch buffers so replay only
+                    // carries parsed arguments.
+                    delete block.partialArgs;
+                    delete block.streamIndex;
+                    stream.push({
+                        type: "toolcall_end",
+                        contentIndex,
+                        toolCall: block,
+                        partial: output,
+                    });
+                }
+            };
+            const ensureTextBlock = () => {
+                if (!textBlock) {
+                    textBlock = { type: "text", text: "" };
+                    blocks.push(textBlock);
+                    stream.push({ type: "text_start", contentIndex: getContentIndex(textBlock), partial: output });
+                }
+                return textBlock;
+            };
+            const ensureThinkingBlock = (thinkingSignature) => {
+                if (!thinkingBlock) {
+                    thinkingBlock = {
+                        type: "thinking",
+                        thinking: "",
+                        thinkingSignature,
+                    };
+                    blocks.push(thinkingBlock);
+                    stream.push({ type: "thinking_start", contentIndex: getContentIndex(thinkingBlock), partial: output });
+                }
+                return thinkingBlock;
+            };
+            const ensureToolCallBlock = (toolCall) => {
+                const streamIndex = typeof toolCall.index === "number" ? toolCall.index : undefined;
+                let block = streamIndex !== undefined ? toolCallBlocksByIndex.get(streamIndex) : undefined;
+                if (!block && toolCall.id) {
+                    block = toolCallBlocksById.get(toolCall.id);
+                }
+                if (!block) {
+                    block = {
+                        type: "toolCall",
+                        id: toolCall.id || "",
+                        name: toolCall.function?.name || "",
+                        arguments: {},
+                        partialArgs: "",
+                        streamIndex,
+                    };
+                    if (streamIndex !== undefined) {
+                        toolCallBlocksByIndex.set(streamIndex, block);
                     }
-                    else if (block.type === "toolCall") {
-                        block.arguments = parseStreamingJson(block.partialArgs);
-                        delete block.partialArgs;
-                        stream.push({
-                            type: "toolcall_end",
-                            contentIndex: blockIndex(),
-                            toolCall: block,
-                            partial: output,
-                        });
+                    if (toolCall.id) {
+                        toolCallBlocksById.set(toolCall.id, block);
                     }
+                    blocks.push(block);
+                    stream.push({
+                        type: "toolcall_start",
+                        contentIndex: getContentIndex(block),
+                        partial: output,
+                    });
                 }
+                if (streamIndex !== undefined && block.streamIndex === undefined) {
+                    block.streamIndex = streamIndex;
+                    toolCallBlocksByIndex.set(streamIndex, block);
+                }
+                if (toolCall.id) {
+                    toolCallBlocksById.set(toolCall.id, block);
+                }
+                return block;
             };
             for await (const chunk of openaiStream) {
+                if (!chunk || typeof chunk !== "object")
+                    continue;
+                // OpenAI documents ChatCompletionChunk.id as the unique chat completion identifier,
+                // and each chunk in a streamed completion carries the same id.
+                output.responseId ||= chunk.id;
+                if (typeof chunk.model === "string" && chunk.model.length > 0 && chunk.model !== model.id) {
+                    output.responseModel ||= chunk.model;
+                }
                 if (chunk.usage) {
-                    const cachedTokens = chunk.usage.prompt_tokens_details?.cached_tokens || 0;
-                    const reasoningTokens = chunk.usage.completion_tokens_details?.reasoning_tokens || 0;
-                    const input = (chunk.usage.prompt_tokens || 0) - cachedTokens;
-                    const outputTokens = (chunk.usage.completion_tokens || 0) + reasoningTokens;
-                    output.usage = {
-                        // OpenAI includes cached tokens in prompt_tokens, so subtract to get non-cached input
-                        input,
-                        output: outputTokens,
-                        cacheRead: cachedTokens,
-                        cacheWrite: 0,
-                        // Compute totalTokens ourselves since we add reasoning_tokens to output
-                        // and some providers (e.g., Groq) don't include them in total_tokens
-                        totalTokens: input + outputTokens + cachedTokens,
-                        cost: {
-                            input: 0,
-                            output: 0,
-                            cacheRead: 0,
-                            cacheWrite: 0,
-                            total: 0,
-                        },
-                    };
-                    calculateCost(model, output.usage);
+                    output.usage = parseChunkUsage(chunk.usage, model);
                 }
-                const choice = chunk.choices?.[0];
+                const choice = Array.isArray(chunk.choices) ? chunk.choices[0] : undefined;
                 if (!choice)
                     continue;
+                // Fallback: some providers (e.g., Moonshot) return usage
+                // in choice.usage instead of the standard chunk.usage
+                if (!chunk.usage && choice.usage) {
+                    output.usage = parseChunkUsage(choice.usage, model);
+                }
                 if (choice.finish_reason) {
-                    output.stopReason = mapStopReason(choice.finish_reason);
+                    const finishReasonResult = mapStopReason(choice.finish_reason);
+                    output.stopReason = finishReasonResult.stopReason;
+                    if (finishReasonResult.errorMessage) {
+                        output.errorMessage = finishReasonResult.errorMessage;
+                    }
                 }
                 if (choice.delta) {
                     if (choice.delta.content !== null &&
                         choice.delta.content !== undefined &&
                         choice.delta.content.length > 0) {
-                        if (!currentBlock || currentBlock.type !== "text") {
-                            finishCurrentBlock(currentBlock);
-                            currentBlock = { type: "text", text: "" };
-                            output.content.push(currentBlock);
-                            stream.push({ type: "text_start", contentIndex: blockIndex(), partial: output });
-                        }
-                        if (currentBlock.type === "text") {
-                            currentBlock.text += choice.delta.content;
-                            stream.push({
-                                type: "text_delta",
-                                contentIndex: blockIndex(),
-                                delta: choice.delta.content,
-                                partial: output,
-                            });
-                        }
+                        const block = ensureTextBlock();
+                        block.text += choice.delta.content;
+                        stream.push({
+                            type: "text_delta",
+                            contentIndex: getContentIndex(block),
+                            delta: choice.delta.content,
+                            partial: output,
+                        });
                     }
                     // Some endpoints return reasoning in reasoning_content (llama.cpp),
                     // or reasoning (other openai compatible endpoints)
                     // Use the first non-empty reasoning field to avoid duplication
                     // (e.g., chutes.ai returns both reasoning_content and reasoning with same content)
                     const reasoningFields = ["reasoning_content", "reasoning", "reasoning_text"];
+                    const deltaFields = choice.delta;
                     let foundReasoningField = null;
                     for (const field of reasoningFields) {
-                        if (choice.delta[field] !== null &&
-                            choice.delta[field] !== undefined &&
-                            choice.delta[field].length > 0) {
-                            if (!foundReasoningField) {
-                                foundReasoningField = field;
-                                break;
-                            }
+                        const value = deltaFields[field];
+                        if (typeof value === "string" && value.length > 0) {
+                            foundReasoningField = field;
+                            break;
                         }
                     }
                     if (foundReasoningField) {
-                        if (!currentBlock || currentBlock.type !== "thinking") {
-                            finishCurrentBlock(currentBlock);
-                            currentBlock = {
-                                type: "thinking",
-                                thinking: "",
-                                thinkingSignature: foundReasoningField,
-                            };
-                            output.content.push(currentBlock);
-                            stream.push({ type: "thinking_start", contentIndex: blockIndex(), partial: output });
-                        }
-                        if (currentBlock.type === "thinking") {
-                            const delta = choice.delta[foundReasoningField];
-                            currentBlock.thinking += delta;
+                        const delta = deltaFields[foundReasoningField];
+                        if (typeof delta === "string" && delta.length > 0) {
+                            const block = ensureThinkingBlock(foundReasoningField);
+                            block.thinking += delta;
                             stream.push({
                                 type: "thinking_delta",
-                                contentIndex: blockIndex(),
+                                contentIndex: getContentIndex(block),
                                 delta,
                                 partial: output,
                             });
@@ -176,38 +256,26 @@ export const streamOpenAICompletions = (model, context, options) => {
                     }
                     if (choice?.delta?.tool_calls) {
                         for (const toolCall of choice.delta.tool_calls) {
-                            if (!currentBlock ||
-                                currentBlock.type !== "toolCall" ||
-                                (toolCall.id && currentBlock.id !== toolCall.id)) {
-                                finishCurrentBlock(currentBlock);
-                                currentBlock = {
-                                    type: "toolCall",
-                                    id: toolCall.id || "",
-                                    name: toolCall.function?.name || "",
-                                    arguments: {},
-                                    partialArgs: "",
-                                };
-                                output.content.push(currentBlock);
-                                stream.push({ type: "toolcall_start", contentIndex: blockIndex(), partial: output });
+                            const block = ensureToolCallBlock(toolCall);
+                            if (!block.id && toolCall.id) {
+                                block.id = toolCall.id;
+                                toolCallBlocksById.set(toolCall.id, block);
                             }
-                            if (currentBlock.type === "toolCall") {
-                                if (toolCall.id)
-                                    currentBlock.id = toolCall.id;
-                                if (toolCall.function?.name)
-                                    currentBlock.name = toolCall.function.name;
-                                let delta = "";
-                                if (toolCall.function?.arguments) {
-                                    delta = toolCall.function.arguments;
-                                    currentBlock.partialArgs += toolCall.function.arguments;
-                                    currentBlock.arguments = parseStreamingJson(currentBlock.partialArgs);
-                                }
-                                stream.push({
-                                    type: "toolcall_delta",
-                                    contentIndex: blockIndex(),
-                                    delta,
-                                    partial: output,
-                                });
+                            if (!block.name && toolCall.function?.name) {
+                                block.name = toolCall.function.name;
+                            }
+                            let delta = "";
+                            if (toolCall.function?.arguments) {
+                                delta = toolCall.function.arguments;
+                                block.partialArgs = (block.partialArgs ?? "") + toolCall.function.arguments;
+                                block.arguments = parseStreamingJson(block.partialArgs);
                             }
+                            stream.push({
+                                type: "toolcall_delta",
+                                contentIndex: getContentIndex(block),
+                                delta,
+                                partial: output,
+                            });
                         }
                     }
                     const reasoningDetails = choice.delta.reasoning_details;
@@ -223,19 +291,28 @@ export const streamOpenAICompletions = (model, context, options) => {
                     }
                 }
             }
-            finishCurrentBlock(currentBlock);
+            for (const block of blocks) {
+                finishBlock(block);
+            }
             if (options?.signal?.aborted) {
                 throw new Error("Request was aborted");
             }
-            if (output.stopReason === "aborted" || output.stopReason === "error") {
-                throw new Error("An unknown error occurred");
+            if (output.stopReason === "aborted") {
+                throw new Error("Request was aborted");
+            }
+            if (output.stopReason === "error") {
+                throw new Error(output.errorMessage || "Provider returned an error stop reason");
             }
             stream.push({ type: "done", reason: output.stopReason, message: output });
             stream.end();
         }
         catch (error) {
-            for (const block of output.content)
+            for (const block of output.content) {
                 delete block.index;
+                // Streaming scratch buffers are only used during parsing; never persist them.
+                delete block.partialArgs;
+                delete block.streamIndex;
+            }
             output.stopReason = options?.signal?.aborted ? "aborted" : "error";
             output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
             // Some providers via OpenRouter give additional information in this field.
@@ -254,7 +331,8 @@ export const streamSimpleOpenAICompletions = (model, context, options) => {
         throw new Error(`No API key for provider: ${model.provider}`);
     }
     const base = buildBaseOptions(model, options, apiKey);
-    const reasoningEffort = supportsXhigh(model) ? options?.reasoning : clampReasoning(options?.reasoning);
+    const clampedReasoning = options?.reasoning ? clampThinkingLevel(model, options.reasoning) : undefined;
+    const reasoningEffort = clampedReasoning === "off" ? undefined : clampedReasoning;
     const toolChoice = options?.toolChoice;
     return streamOpenAICompletions(model, context, {
         ...base,
@@ -262,7 +340,7 @@ export const streamSimpleOpenAICompletions = (model, context, options) => {
         toolChoice,
     });
 };
-function createClient(model, context, apiKey, optionsHeaders) {
+function createClient(model, context, apiKey, optionsHeaders, sessionId, compat = getCompat(model)) {
     if (!apiKey) {
         if (!process.env.OPENAI_API_KEY) {
             throw new Error("OpenAI API key is required. Set OPENAI_API_KEY environment variable or pass it as an argument.");
@@ -278,25 +356,41 @@ function createClient(model, context, apiKey, optionsHeaders) {
         });
         Object.assign(headers, copilotHeaders);
     }
+    if (sessionId && compat.sendSessionAffinityHeaders) {
+        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) {
         Object.assign(headers, optionsHeaders);
     }
+    const defaultHeaders = model.provider === "cloudflare-ai-gateway"
+        ? {
+            ...headers,
+            Authorization: headers.Authorization ?? null,
+            "cf-aig-authorization": `Bearer ${apiKey}`,
+        }
+        : headers;
     return new OpenAI({
         apiKey,
-        baseURL: model.baseUrl,
+        baseURL: isCloudflareProvider(model.provider) ? resolveCloudflareBaseUrl(model) : model.baseUrl,
         dangerouslyAllowBrowser: true,
-        defaultHeaders: headers,
+        defaultHeaders,
     });
 }
-function buildParams(model, context, options) {
-    const compat = getCompat(model);
+function buildParams(model, context, options, compat = getCompat(model), cacheRetention = resolveCacheRetention(options?.cacheRetention)) {
     const messages = convertMessages(model, context, compat);
-    maybeAddOpenRouterAnthropicCacheControl(model, messages);
+    const cacheControl = getCompatCacheControl(compat, cacheRetention);
     const params = {
         model: model.id,
         messages,
         stream: true,
+        prompt_cache_key: (model.baseUrl.includes("api.openai.com") && cacheRetention !== "none") ||
+            (cacheRetention === "long" && compat.supportsLongCacheRetention)
+            ? options?.sessionId
+            : undefined,
+        prompt_cache_retention: cacheRetention === "long" && compat.supportsLongCacheRetention ? "24h" : undefined,
     };
     if (compat.supportsUsageInStreaming !== false) {
         params.stream_options = { include_usage: true };
@@ -315,23 +409,69 @@ function buildParams(model, context, options) {
     if (options?.temperature !== undefined) {
         params.temperature = options.temperature;
     }
-    if (context.tools) {
+    if (context.tools && context.tools.length > 0) {
         params.tools = convertTools(context.tools, compat);
+        if (compat.zaiToolStream) {
+            params.tool_stream = true;
+        }
     }
     else if (hasToolHistory(context.messages)) {
         // Anthropic (via LiteLLM/proxy) requires tools param when conversation has tool_calls/tool_results
         params.tools = [];
     }
+    if (cacheControl) {
+        applyAnthropicCacheControl(messages, params.tools, cacheControl);
+    }
     if (options?.toolChoice) {
         params.tool_choice = options.toolChoice;
     }
-    if ((compat.thinkingFormat === "zai" || compat.thinkingFormat === "qwen") && model.reasoning) {
-        // Both Z.ai and Qwen use enable_thinking: boolean
+    if (compat.thinkingFormat === "zai" && model.reasoning) {
+        params.enable_thinking = !!options?.reasoningEffort;
+    }
+    else if (compat.thinkingFormat === "qwen" && model.reasoning) {
         params.enable_thinking = !!options?.reasoningEffort;
     }
+    else if (compat.thinkingFormat === "qwen-chat-template" && model.reasoning) {
+        params.chat_template_kwargs = {
+            enable_thinking: !!options?.reasoningEffort,
+            preserve_thinking: true,
+        };
+    }
+    else if (compat.thinkingFormat === "deepseek" && model.reasoning) {
+        params.thinking = { type: options?.reasoningEffort ? "enabled" : "disabled" };
+        if (options?.reasoningEffort) {
+            params.reasoning_effort =
+                model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort;
+        }
+    }
+    else if (compat.thinkingFormat === "openrouter" && model.reasoning) {
+        // OpenRouter normalizes reasoning across providers via a nested reasoning object.
+        const openRouterParams = params;
+        if (options?.reasoningEffort) {
+            openRouterParams.reasoning = {
+                effort: model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort,
+            };
+        }
+        else if (model.thinkingLevelMap?.off !== null) {
+            openRouterParams.reasoning = { effort: model.thinkingLevelMap?.off ?? "none" };
+        }
+    }
+    else if (compat.thinkingFormat === "together" && model.reasoning) {
+        const togetherParams = params;
+        togetherParams.reasoning = { enabled: !!options?.reasoningEffort };
+        if (options?.reasoningEffort && compat.supportsReasoningEffort) {
+            togetherParams.reasoning_effort = model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort;
+        }
+    }
     else if (options?.reasoningEffort && model.reasoning && compat.supportsReasoningEffort) {
         // OpenAI-style reasoning_effort
-        params.reasoning_effort = mapReasoningEffort(options.reasoningEffort, compat.reasoningEffortMap);
+        params.reasoning_effort = model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort;
+    }
+    else if (!options?.reasoningEffort && model.reasoning && compat.supportsReasoningEffort) {
+        const offValue = model.thinkingLevelMap?.off;
+        if (typeof offValue === "string") {
+            params.reasoning_effort = offValue;
+        }
     }
     // OpenRouter provider routing preferences
     if (model.baseUrl.includes("openrouter.ai") && model.compat?.openRouterRouting) {
@@ -351,37 +491,80 @@ function buildParams(model, context, options) {
     }
     return params;
 }
-function mapReasoningEffort(effort, reasoningEffortMap) {
-    return reasoningEffortMap[effort] ?? effort;
+function getCompatCacheControl(compat, cacheRetention) {
+    if (compat.cacheControlFormat !== "anthropic" || cacheRetention === "none") {
+        return undefined;
+    }
+    const ttl = cacheRetention === "long" && compat.supportsLongCacheRetention ? "1h" : undefined;
+    return { type: "ephemeral", ...(ttl ? { ttl } : {}) };
 }
-function maybeAddOpenRouterAnthropicCacheControl(model, messages) {
-    if (model.provider !== "openrouter" || !model.id.startsWith("anthropic/"))
-        return;
-    // Anthropic-style caching requires cache_control on a text part. Add a breakpoint
-    // on the last user/assistant message (walking backwards until we find text content).
-    for (let i = messages.length - 1; i >= 0; i--) {
-        const msg = messages[i];
-        if (msg.role !== "user" && msg.role !== "assistant")
-            continue;
-        const content = msg.content;
-        if (typeof content === "string") {
-            msg.content = [
-                Object.assign({ type: "text", text: content }, { cache_control: { type: "ephemeral" } }),
-            ];
+function applyAnthropicCacheControl(messages, tools, cacheControl) {
+    addCacheControlToSystemPrompt(messages, cacheControl);
+    addCacheControlToLastTool(tools, cacheControl);
+    addCacheControlToLastConversationMessage(messages, cacheControl);
+}
+function addCacheControlToSystemPrompt(messages, cacheControl) {
+    for (const message of messages) {
+        if (message.role === "system" || message.role === "developer") {
+            addCacheControlToInstructionMessage(message, cacheControl);
             return;
         }
-        if (!Array.isArray(content))
-            continue;
-        // Find last text part and add cache_control
-        for (let j = content.length - 1; j >= 0; j--) {
-            const part = content[j];
-            if (part?.type === "text") {
-                Object.assign(part, { cache_control: { type: "ephemeral" } });
+    }
+}
+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 (addCacheControlToMessage(message, cacheControl)) {
                 return;
             }
         }
     }
 }
+function addCacheControlToLastTool(tools, cacheControl) {
+    if (!tools || tools.length === 0) {
+        return;
+    }
+    const lastTool = tools[tools.length - 1];
+    lastTool.cache_control = cacheControl;
+}
+function addCacheControlToInstructionMessage(message, cacheControl) {
+    return addCacheControlToTextContent(message, cacheControl);
+}
+function addCacheControlToMessage(message, cacheControl) {
+    if (message.role === "user" || message.role === "assistant") {
+        return addCacheControlToTextContent(message, cacheControl);
+    }
+    return false;
+}
+function addCacheControlToTextContent(message, cacheControl) {
+    const content = message.content;
+    if (typeof content === "string") {
+        if (content.length === 0) {
+            return false;
+        }
+        message.content = [
+            {
+                type: "text",
+                text: content,
+                cache_control: cacheControl,
+            },
+        ];
+        return true;
+    }
+    if (!Array.isArray(content)) {
+        return false;
+    }
+    for (let i = content.length - 1; i >= 0; i--) {
+        const part = content[i];
+        if (part?.type === "text") {
+            const textPart = part;
+            textPart.cache_control = cacheControl;
+            return true;
+        }
+    }
+    return false;
+}
 export function convertMessages(model, context, compat) {
     const params = [];
     const normalizeToolCallId = (id) => {
@@ -439,14 +622,11 @@ export function convertMessages(model, context, compat) {
                         };
                     }
                 });
-                const filteredContent = !model.input.includes("image")
-                    ? content.filter((c) => c.type !== "image_url")
-                    : content;
-                if (filteredContent.length === 0)
+                if (content.length === 0)
                     continue;
                 params.push({
                     role: "user",
-                    content: filteredContent,
+                    content,
                 });
             }
         }
@@ -456,46 +636,50 @@ export function convertMessages(model, context, compat) {
                 role: "assistant",
                 content: compat.requiresAssistantAfterToolResult ? "" : null,
             };
-            const textBlocks = msg.content.filter((b) => b.type === "text");
-            // Filter out empty text blocks to avoid API validation errors
-            const nonEmptyTextBlocks = textBlocks.filter((b) => b.text && b.text.trim().length > 0);
-            if (nonEmptyTextBlocks.length > 0) {
-                // GitHub Copilot requires assistant content as a string, not an array.
-                // Sending as array causes Claude models to re-answer all previous prompts.
-                if (model.provider === "github-copilot") {
-                    assistantMsg.content = nonEmptyTextBlocks.map((b) => sanitizeSurrogates(b.text)).join("");
-                }
-                else {
-                    assistantMsg.content = nonEmptyTextBlocks.map((b) => {
-                        return { type: "text", text: sanitizeSurrogates(b.text) };
-                    });
-                }
-            }
-            // Handle thinking blocks
-            const thinkingBlocks = msg.content.filter((b) => b.type === "thinking");
-            // Filter out empty thinking blocks to avoid API validation errors
-            const nonEmptyThinkingBlocks = thinkingBlocks.filter((b) => b.thinking && b.thinking.trim().length > 0);
+            const assistantTextParts = msg.content
+                .filter(isTextContentBlock)
+                .filter((block) => block.text.trim().length > 0)
+                .map((block) => ({
+                type: "text",
+                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);
             if (nonEmptyThinkingBlocks.length > 0) {
                 if (compat.requiresThinkingAsText) {
                     // Convert thinking blocks to plain text (no tags to avoid model mimicking them)
-                    const thinkingText = nonEmptyThinkingBlocks.map((b) => b.thinking).join("\n\n");
-                    const textContent = assistantMsg.content;
-                    if (textContent) {
-                        textContent.unshift({ type: "text", text: thinkingText });
-                    }
-                    else {
-                        assistantMsg.content = [{ type: "text", text: thinkingText }];
-                    }
+                    const thinkingText = nonEmptyThinkingBlocks
+                        .map((block) => sanitizeSurrogates(block.thinking))
+                        .join("\n\n");
+                    assistantMsg.content = [{ type: "text", text: thinkingText }, ...assistantTextParts];
                 }
                 else {
+                    // Always send assistant content as a plain string (OpenAI Chat Completions
+                    // API standard format). Sending as an array of {type:"text", text:"..."}
+                    // objects is non-standard and causes some models (e.g. DeepSeek V3.2 via
+                    // NVIDIA NIM) to mirror the content-block structure literally in their
+                    // output, producing recursive nesting like [{'type':'text','text':'[{...}]'}].
+                    if (assistantText.length > 0) {
+                        assistantMsg.content = assistantText;
+                    }
                     // Use the signature from the first thinking block if available (for llama.cpp server + gpt-oss)
                     const signature = nonEmptyThinkingBlocks[0].thinkingSignature;
                     if (signature && signature.length > 0) {
-                        assistantMsg[signature] = nonEmptyThinkingBlocks.map((b) => b.thinking).join("\n");
+                        assistantMsg[signature] = nonEmptyThinkingBlocks.map((block) => block.thinking).join("\n");
                     }
                 }
             }
-            const toolCalls = msg.content.filter((b) => b.type === "toolCall");
+            else if (assistantText.length > 0) {
+                // Always send assistant content as a plain string (OpenAI Chat Completions
+                // API standard format). Sending as an array of {type:"text", text:"..."}
+                // objects is non-standard and causes some models (e.g. DeepSeek V3.2 via
+                // NVIDIA NIM) to mirror the content-block structure literally in their
+                // 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) => ({
                     id: tc.id,
@@ -520,6 +704,11 @@ export function convertMessages(model, context, compat) {
                     assistantMsg.reasoning_details = reasoningDetails;
                 }
             }
+            if (compat.requiresReasoningContentOnAssistantMessages &&
+                model.reasoning &&
+                assistantMsg.reasoning_content === undefined) {
+                assistantMsg.reasoning_content = "";
+            }
             // Skip assistant messages that have no content and no tool calls.
             // Some providers require "either content or tool_calls, but not none".
             // Other providers also don't accept empty assistant messages.
@@ -540,8 +729,8 @@ export function convertMessages(model, context, compat) {
                 const toolMsg = transformedMessages[j];
                 // Extract text and image content
                 const textResult = toolMsg.content
-                    .filter((c) => c.type === "text")
-                    .map((c) => c.text)
+                    .filter(isTextContentBlock)
+                    .map((block) => block.text)
                     .join("\n");
                 const hasImages = toolMsg.content.some((c) => c.type === "image");
                 // Always send tool result with text (or placeholder if only images)
@@ -558,7 +747,7 @@ export function convertMessages(model, context, compat) {
                 params.push(toolResultMsg);
                 if (hasImages && model.input.includes("image")) {
                     for (const block of toolMsg.content) {
-                        if (block.type === "image") {
+                        if (isImageContentBlock(block)) {
                             imageBlocks.push({
                                 type: "image_url",
                                 image_url: {
@@ -610,23 +799,51 @@ function convertTools(tools, compat) {
         },
     }));
 }
+function parseChunkUsage(rawUsage, model) {
+    const promptTokens = rawUsage.prompt_tokens || 0;
+    const reportedCachedTokens = rawUsage.prompt_tokens_details?.cached_tokens ?? rawUsage.prompt_cache_hit_tokens ?? 0;
+    const cacheWriteTokens = rawUsage.prompt_tokens_details?.cache_write_tokens || 0;
+    // Normalize to pi-ai semantics:
+    // - cacheRead: hits from cache created by previous requests only
+    // - cacheWrite: tokens written to cache in this request
+    // Some OpenAI-compatible providers (observed on OpenRouter) report cached_tokens
+    // as (previous hits + current writes). In that case, remove cacheWrite from cacheRead.
+    const cacheReadTokens = cacheWriteTokens > 0 ? Math.max(0, reportedCachedTokens - cacheWriteTokens) : reportedCachedTokens;
+    const input = Math.max(0, promptTokens - cacheReadTokens - cacheWriteTokens);
+    // OpenAI completion_tokens already includes reasoning_tokens.
+    const outputTokens = rawUsage.completion_tokens || 0;
+    const usage = {
+        input,
+        output: outputTokens,
+        cacheRead: cacheReadTokens,
+        cacheWrite: cacheWriteTokens,
+        totalTokens: input + outputTokens + cacheReadTokens + cacheWriteTokens,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+    };
+    calculateCost(model, usage);
+    return usage;
+}
 function mapStopReason(reason) {
     if (reason === null)
-        return "stop";
+        return { stopReason: "stop" };
     switch (reason) {
         case "stop":
-            return "stop";
+        case "end":
+            return { stopReason: "stop" };
         case "length":
-            return "length";
+            return { stopReason: "length" };
         case "function_call":
         case "tool_calls":
-            return "toolUse";
+            return { stopReason: "toolUse" };
         case "content_filter":
-            return "error";
-        default: {
-            const _exhaustive = reason;
-            throw new Error(`Unhandled stop reason: ${_exhaustive}`);
-        }
+            return { stopReason: "error", errorMessage: "Provider finish_reason: content_filter" };
+        case "network_error":
+            return { stopReason: "error", errorMessage: "Provider finish_reason: network_error" };
+        default:
+            return {
+                stopReason: "error",
+                errorMessage: `Provider finish_reason: ${reason}`,
+            };
     }
 }
 /**
@@ -638,41 +855,54 @@ function detectCompat(model) {
     const provider = model.provider;
     const baseUrl = model.baseUrl;
     const isZai = provider === "zai" || baseUrl.includes("api.z.ai");
+    const isTogether = provider === "together" || baseUrl.includes("api.together.ai") || baseUrl.includes("api.together.xyz");
+    const isMoonshot = provider === "moonshotai" || provider === "moonshotai-cn" || baseUrl.includes("api.moonshot.");
+    const isCloudflareWorkersAI = provider === "cloudflare-workers-ai" || baseUrl.includes("api.cloudflare.com");
+    const isCloudflareAiGateway = provider === "cloudflare-ai-gateway" || baseUrl.includes("gateway.ai.cloudflare.com");
     const isNonStandard = provider === "cerebras" ||
         baseUrl.includes("cerebras.ai") ||
         provider === "xai" ||
         baseUrl.includes("api.x.ai") ||
+        isTogether ||
         baseUrl.includes("chutes.ai") ||
         baseUrl.includes("deepseek.com") ||
+        baseUrl.includes("dashscope.aliyuncs.com") ||
         isZai ||
+        isMoonshot ||
         provider === "opencode" ||
-        baseUrl.includes("opencode.ai");
-    const useMaxTokens = baseUrl.includes("chutes.ai");
+        baseUrl.includes("opencode.ai") ||
+        isCloudflareWorkersAI ||
+        isCloudflareAiGateway;
+    const useMaxTokens = baseUrl.includes("chutes.ai") || isMoonshot || isCloudflareAiGateway || isTogether;
     const isGrok = provider === "xai" || baseUrl.includes("api.x.ai");
-    const isGroq = provider === "groq" || baseUrl.includes("groq.com");
-    const reasoningEffortMap = isGroq && model.id === "qwen/qwen3-32b"
-        ? {
-            minimal: "default",
-            low: "default",
-            medium: "default",
-            high: "default",
-            xhigh: "default",
-        }
-        : {};
+    const isDeepSeek = provider === "deepseek" || baseUrl.includes("deepseek.com");
+    const cacheControlFormat = provider === "openrouter" && model.id.startsWith("anthropic/") ? "anthropic" : undefined;
     return {
         supportsStore: !isNonStandard,
         supportsDeveloperRole: !isNonStandard,
-        supportsReasoningEffort: !isGrok && !isZai,
-        reasoningEffortMap,
+        supportsReasoningEffort: !isGrok && !isZai && !isMoonshot && !isTogether && !isCloudflareAiGateway,
         supportsUsageInStreaming: true,
         maxTokensField: useMaxTokens ? "max_tokens" : "max_completion_tokens",
         requiresToolResultName: false,
         requiresAssistantAfterToolResult: false,
         requiresThinkingAsText: false,
-        thinkingFormat: isZai ? "zai" : "openai",
+        requiresReasoningContentOnAssistantMessages: isDeepSeek,
+        thinkingFormat: isDeepSeek
+            ? "deepseek"
+            : isZai
+                ? "zai"
+                : isTogether
+                    ? "together"
+                    : provider === "openrouter" || baseUrl.includes("openrouter.ai")
+                        ? "openrouter"
+                        : "openai",
         openRouterRouting: {},
         vercelGatewayRouting: {},
-        supportsStrictMode: true,
+        zaiToolStream: false,
+        supportsStrictMode: !isMoonshot && !isTogether && !isCloudflareAiGateway,
+        cacheControlFormat,
+        sendSessionAffinityHeaders: false,
+        supportsLongCacheRetention: !(isTogether || isCloudflareWorkersAI || isCloudflareAiGateway),
     };
 }
 /**
@@ -687,16 +917,21 @@ function getCompat(model) {
         supportsStore: model.compat.supportsStore ?? detected.supportsStore,
         supportsDeveloperRole: model.compat.supportsDeveloperRole ?? detected.supportsDeveloperRole,
         supportsReasoningEffort: model.compat.supportsReasoningEffort ?? detected.supportsReasoningEffort,
-        reasoningEffortMap: model.compat.reasoningEffortMap ?? detected.reasoningEffortMap,
         supportsUsageInStreaming: model.compat.supportsUsageInStreaming ?? detected.supportsUsageInStreaming,
         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: model.compat.thinkingFormat ?? detected.thinkingFormat,
         openRouterRouting: model.compat.openRouterRouting ?? {},
         vercelGatewayRouting: model.compat.vercelGatewayRouting ?? detected.vercelGatewayRouting,
+        zaiToolStream: model.compat.zaiToolStream ?? detected.zaiToolStream,
         supportsStrictMode: model.compat.supportsStrictMode ?? detected.supportsStrictMode,
+        cacheControlFormat: model.compat.cacheControlFormat ?? detected.cacheControlFormat,
+        sendSessionAffinityHeaders: model.compat.sendSessionAffinityHeaders ?? detected.sendSessionAffinityHeaders,
+        supportsLongCacheRetention: model.compat.supportsLongCacheRetention ?? detected.supportsLongCacheRetention,
     };
 }
 //# sourceMappingURL=openai-completions.js.map