@draht/ai 2026.5.12 → 2026.6.11

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, clampToXhigh } from "./simple-options.js";
+import { clampOpenAIPromptCacheKey } from "./openai-prompt-cache.js";
+import { buildBaseOptions, clampToXhigh } 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 () => {
@@ -46,47 +69,127 @@ export const streamOpenAICompletions = (model, context, options) => {
             timestamp: Date.now(),
         };
         try {
-            const apiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
-            const client = createClient(model, context, apiKey, options?.headers);
-            let params = buildParams(model, context, options);
+            const apiKey = options?.apiKey;
+            if (!apiKey) {
+                throw new Error(`No API key for provider: ${model.provider}`);
+            }
+            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 openaiStream = await client.chat.completions.create(params, { signal: options?.signal });
+            const requestOptions = {
+                ...(options?.signal ? { signal: options.signal } : {}),
+                ...(options?.timeoutMs !== undefined ? { timeout: options.timeoutMs } : {}),
+                maxRetries: options?.maxRetries ?? 0,
+            };
+            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;
+            let hasFinishReason = false;
+            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,
-                        });
+            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 === "thinking") {
-                        stream.push({
-                            type: "thinking_end",
-                            contentIndex: blockIndex(),
-                            content: block.thinking,
-                            partial: output,
-                        });
-                    }
-                    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")
@@ -94,6 +197,9 @@ export const streamOpenAICompletions = (model, context, options) => {
                 // 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) {
                     output.usage = parseChunkUsage(chunk.usage, model);
                 }
@@ -111,60 +217,46 @@ export const streamOpenAICompletions = (model, context, options) => {
                     if (finishReasonResult.errorMessage) {
                         output.errorMessage = finishReasonResult.errorMessage;
                     }
+                    hasFinishReason = true;
                 }
                 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 thinkingSignature = model.provider === "opencode-go" && foundReasoningField === "reasoning"
+                                ? "reasoning_content"
+                                : foundReasoningField;
+                            const block = ensureThinkingBlock(thinkingSignature);
+                            block.thinking += delta;
                             stream.push({
                                 type: "thinking_delta",
-                                contentIndex: blockIndex(),
+                                contentIndex: getContentIndex(block),
                                 delta,
                                 partial: output,
                             });
@@ -172,38 +264,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;
@@ -219,7 +299,9 @@ 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");
             }
@@ -229,12 +311,19 @@ export const streamOpenAICompletions = (model, context, options) => {
             if (output.stopReason === "error") {
                 throw new Error(output.errorMessage || "Provider returned an error stop reason");
             }
+            if (!hasFinishReason) {
+                throw new Error("Stream ended without finish_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.
@@ -248,12 +337,14 @@ export const streamOpenAICompletions = (model, context, options) => {
     return stream;
 };
 export const streamSimpleOpenAICompletions = (model, context, options) => {
-    const apiKey = options?.apiKey || getEnvApiKey(model.provider);
+    const apiKey = options?.apiKey;
     if (!apiKey) {
         throw new Error(`No API key for provider: ${model.provider}`);
     }
     const base = buildBaseOptions(model, options, apiKey);
-    const reasoningEffort = supportsXhigh(model) ? clampToXhigh(options?.reasoning) : clampReasoning(options?.reasoning);
+    const rawLevel = options?.reasoning ? clampThinkingLevel(model, options.reasoning) : undefined;
+    const clampedReasoning = rawLevel === "off" ? rawLevel : clampToXhigh(rawLevel);
+    const reasoningEffort = clampedReasoning === "off" ? undefined : clampedReasoning;
     const toolChoice = options?.toolChoice;
     return streamOpenAICompletions(model, context, {
         ...base,
@@ -261,13 +352,7 @@ export const streamSimpleOpenAICompletions = (model, context, options) => {
         toolChoice,
     });
 };
-function createClient(model, context, apiKey, optionsHeaders) {
-    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.");
-        }
-        apiKey = process.env.OPENAI_API_KEY;
-    }
+function createClient(model, context, apiKey, optionsHeaders, sessionId, compat = getCompat(model)) {
     const headers = { ...model.headers };
     if (model.provider === "github-copilot") {
         const hasImages = hasCopilotVisionInput(context.messages);
@@ -277,25 +362,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)
+            ? clampOpenAIPromptCacheKey(options?.sessionId)
+            : undefined,
+        prompt_cache_retention: cacheRetention === "long" && compat.supportsLongCacheRetention ? "24h" : undefined,
     };
     if (compat.supportsUsageInStreaming !== false) {
         params.stream_options = { include_usage: true };
@@ -314,7 +415,7 @@ 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;
@@ -324,36 +425,78 @@ function buildParams(model, context, options) {
         // 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" && model.reasoning) {
-        params.enable_thinking = !!options?.reasoningEffort;
+        const zaiParams = params;
+        zaiParams.thinking = { type: options?.reasoningEffort ? "enabled" : "disabled" };
     }
     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 };
+        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 && compat.supportsReasoningEffort) {
+            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: mapReasoningEffort(options.reasoningEffort, compat.reasoningEffortMap),
+                effort: model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort,
             };
         }
-        else {
-            openRouterParams.reasoning = { effort: "none" };
+        else if (model.thinkingLevelMap?.off !== null) {
+            openRouterParams.reasoning = { effort: model.thinkingLevelMap?.off ?? "none" };
+        }
+    }
+    else if (compat.thinkingFormat === "ant-ling" && model.reasoning && options?.reasoningEffort) {
+        const effort = model.thinkingLevelMap?.[options.reasoningEffort];
+        if (typeof effort === "string") {
+            params.reasoning = { effort };
+        }
+    }
+    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 (compat.thinkingFormat === "string-thinking" && model.reasoning) {
+        const stringThinkingParams = params;
+        if (options?.reasoningEffort) {
+            stringThinkingParams.thinking = model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort;
+        }
+        else if (model.thinkingLevelMap?.off !== null) {
+            stringThinkingParams.thinking = model.thinkingLevelMap?.off ?? "none";
         }
     }
     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) {
+    if (model.compat?.openRouterRouting) {
         params.provider = model.compat.openRouterRouting;
     }
     // Vercel AI Gateway provider routing preferences
@@ -370,37 +513,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) => {
@@ -458,14 +644,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,
                 });
             }
         }
@@ -475,48 +658,53 @@ 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) {
-                // 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 = nonEmptyTextBlocks.map((b) => sanitizeSurrogates(b.text)).join("");
-            }
-            // 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);
-            if (compat.requiresThinkingAsText) {
-                if (nonEmptyThinkingBlocks.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 });
+                    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;
                     }
-                    else {
-                        assistantMsg.content = [{ type: "text", text: thinkingText }];
+                    // 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");
                     }
                 }
             }
-            else {
-                // Replay the reasoning field (e.g. "reasoning_content" for llama.cpp,
-                // gpt-oss, and DeepSeek reasoner) under its captured signature.
-                // DeepSeek requires this field on every assistant turn produced under
-                // thinking mode — even if the captured reasoning text was empty —
-                // otherwise the next request fails with:
-                //   400: The `reasoning_content` in the thinking mode must be passed back to the API.
-                const signature = thinkingBlocks.find((b) => b.thinkingSignature && b.thinkingSignature.length > 0)?.thinkingSignature;
-                if (signature) {
-                    const matchingBlocks = thinkingBlocks.filter((b) => b.thinkingSignature === signature);
-                    assistantMsg[signature] = matchingBlocks.map((b) => b.thinking || "").join("\n");
-                }
+            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((b) => b.type === "toolCall");
+            const toolCalls = msg.content.filter(isToolCallBlock);
             if (toolCalls.length > 0) {
                 assistantMsg.tool_calls = toolCalls.map((tc) => ({
                     id: tc.id,
@@ -541,6 +729,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.
@@ -549,8 +742,7 @@ export function convertMessages(model, context, compat) {
             const hasContent = content !== null &&
                 content !== undefined &&
                 (typeof content === "string" ? content.length > 0 : content.length > 0);
-            const hasReasoning = thinkingBlocks.some((b) => b.thinkingSignature && b.thinkingSignature.length > 0);
-            if (!hasContent && !hasReasoning && !assistantMsg.tool_calls) {
+            if (!hasContent && !assistantMsg.tool_calls) {
                 continue;
             }
             params.push(assistantMsg);
@@ -562,8 +754,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)
@@ -580,7 +772,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: {
@@ -634,19 +826,19 @@ function convertTools(tools, compat) {
 }
 function parseChunkUsage(rawUsage, model) {
     const promptTokens = rawUsage.prompt_tokens || 0;
-    const reportedCachedTokens = rawUsage.prompt_tokens_details?.cached_tokens || 0;
+    const cacheReadTokens = rawUsage.prompt_tokens_details?.cached_tokens ?? rawUsage.prompt_cache_hit_tokens ?? 0;
     const cacheWriteTokens = rawUsage.prompt_tokens_details?.cache_write_tokens || 0;
-    const reasoningTokens = rawUsage.completion_tokens_details?.reasoning_tokens || 0;
-    // Normalize to @draht/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;
+    // Follow documented OpenAI/OpenRouter semantics: cached_tokens is cache-read
+    // tokens (hits). 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
+    // Do not subtract writes from cached_tokens, otherwise spec-compliant
+    // providers are under-reported. DS4 mirrors this contract too:
+    // https://github.com/antirez/ds4/pull/29
     const input = Math.max(0, promptTokens - cacheReadTokens - cacheWriteTokens);
-    // Compute totalTokens ourselves since we add reasoning_tokens to output
-    // and some providers (e.g., Groq) don't include them in total_tokens
-    const outputTokens = (rawUsage.completion_tokens || 0) + reasoningTokens;
+    // OpenAI completion_tokens already includes reasoning_tokens.
+    const outputTokens = rawUsage.completion_tokens || 0;
     const usage = {
         input,
         output: outputTokens,
@@ -689,47 +881,69 @@ function mapStopReason(reason) {
 function detectCompat(model) {
     const provider = model.provider;
     const baseUrl = model.baseUrl;
-    const isZai = provider === "zai" || baseUrl.includes("api.z.ai");
-    const isNonStandard = provider === "cerebras" ||
+    const isZai = provider === "zai" ||
+        provider === "zai-coding-cn" ||
+        baseUrl.includes("api.z.ai") ||
+        baseUrl.includes("open.bigmodel.cn");
+    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 isOpenRouter = provider === "openrouter" || baseUrl.includes("openrouter.ai");
+    const isCloudflareWorkersAI = provider === "cloudflare-workers-ai" || baseUrl.includes("api.cloudflare.com");
+    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 isNonStandard = isNvidia ||
+        provider === "cerebras" ||
         baseUrl.includes("cerebras.ai") ||
         provider === "xai" ||
         baseUrl.includes("api.x.ai") ||
+        isTogether ||
         baseUrl.includes("chutes.ai") ||
         baseUrl.includes("deepseek.com") ||
         isZai ||
+        isMoonshot ||
         provider === "opencode" ||
-        baseUrl.includes("opencode.ai");
-    const useMaxTokens = baseUrl.includes("chutes.ai");
+        baseUrl.includes("opencode.ai") ||
+        isCloudflareWorkersAI ||
+        isCloudflareAiGateway ||
+        isAntLing;
+    const useMaxTokens = baseUrl.includes("chutes.ai") || isMoonshot || isCloudflareAiGateway || isTogether || isNvidia || isAntLing;
     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 isOpenRouterDeveloperRoleModel = isOpenRouter && (model.id.startsWith("anthropic/") || model.id.startsWith("openai/"));
+    const cacheControlFormat = provider === "openrouter" && model.id.startsWith("anthropic/") ? "anthropic" : undefined;
     return {
         supportsStore: !isNonStandard,
-        supportsDeveloperRole: !isNonStandard,
-        supportsReasoningEffort: !isGrok && !isZai,
-        reasoningEffortMap,
+        supportsDeveloperRole: isOpenRouterDeveloperRoleModel || (!isNonStandard && !isOpenRouter),
+        supportsReasoningEffort: !isGrok && !isZai && !isMoonshot && !isTogether && !isCloudflareAiGateway && !isNvidia && !isAntLing,
         supportsUsageInStreaming: true,
         maxTokensField: useMaxTokens ? "max_tokens" : "max_completion_tokens",
         requiresToolResultName: false,
         requiresAssistantAfterToolResult: false,
         requiresThinkingAsText: false,
-        thinkingFormat: isZai
-            ? "zai"
-            : provider === "openrouter" || baseUrl.includes("openrouter.ai")
-                ? "openrouter"
-                : "openai",
+        requiresReasoningContentOnAssistantMessages: isDeepSeek,
+        thinkingFormat: isDeepSeek
+            ? "deepseek"
+            : isZai
+                ? "zai"
+                : isTogether
+                    ? "together"
+                    : isAntLing
+                        ? "ant-ling"
+                        : isOpenRouter
+                            ? "openrouter"
+                            : "openai",
         openRouterRouting: {},
         vercelGatewayRouting: {},
         zaiToolStream: false,
-        supportsStrictMode: true,
+        supportsStrictMode: !isMoonshot && !isTogether && !isCloudflareAiGateway && !isNvidia,
+        cacheControlFormat,
+        sendSessionAffinityHeaders: false,
+        supportsLongCacheRetention: !(isTogether ||
+            isCloudflareWorkersAI ||
+            isCloudflareAiGateway ||
+            isNvidia ||
+            isAntLing),
     };
 }
 /**
@@ -744,17 +958,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