@aexol/spectral 0.9.80 → 0.9.82

package/dist/sdk/ai/providers/openai-completions.js

@@ -5,7 +5,7 @@ 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 { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "./github-copilot-headers.js";
+import { buildCopilotDynamicHeaders, hasCopilotVisionInput, } from "./github-copilot-headers.js";
 import { clampOpenAIPromptCacheKey } from "./openai-prompt-cache.js";
 import { buildBaseOptions } from "./simple-options.js";
 import { transformMessages } from "./transform-messages.js";
@@ -39,8 +39,18 @@ function isToolCallBlock(block) {
 function isImageContentBlock(block) {
     return block.type === "image";
 }
+const SAFE_REASONING_REPLAY_FIELDS = [
+    "reasoning_content",
+    "reasoning",
+    "reasoning_text",
+    "reasoning_summary",
+    "reasoning_summary_text",
+    "summary_text",
+    "summary",
+];
 function isOpenRouterModel(model) {
-    return model.provider === "openrouter" || model.baseUrl.includes("openrouter.ai");
+    return model.provider === "openrouter" ||
+        model.baseUrl.includes("openrouter.ai");
 }
 function isOpenRouterAnthropicModel(model) {
     return isOpenRouterModel(model) && model.id.startsWith("anthropic/");
@@ -52,11 +62,206 @@ function resolveCacheRetention(cacheRetention, model) {
     if (model && isOpenRouterAnthropicModel(model)) {
         return "long";
     }
-    if (typeof process !== "undefined" && process.env.PI_CACHE_RETENTION === "long") {
+    if (typeof process !== "undefined" &&
+        process.env.PI_CACHE_RETENTION === "long") {
         return "long";
     }
     return "short";
 }
+function asRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function collectReasoningText(value) {
+    if (typeof value === "string")
+        return value;
+    if (Array.isArray(value))
+        return value.map(collectReasoningText).join("");
+    const record = asRecord(value);
+    if (!record)
+        return "";
+    const direct = [
+        record.delta,
+        record.text,
+        record.value,
+        record.output_text,
+        record.reasoning_text,
+        record.reasoning_content,
+        record.reasoning_summary,
+        record.reasoning_summary_text,
+        record.summary_text,
+    ];
+    for (const candidate of direct) {
+        if (typeof candidate === "string" && candidate.length > 0)
+            return candidate;
+    }
+    return [record.summary, record.parts, record.content, record.annotations]
+        .map(collectReasoningText)
+        .join("");
+}
+function extractReasoningDelta(deltaFields) {
+    const reasoningFields = [
+        "reasoning_content",
+        "reasoning",
+        "reasoning_text",
+        "reasoning_summary",
+        "reasoning_summary_text",
+        "summary_text",
+        "summary",
+    ];
+    for (const field of reasoningFields) {
+        const delta = collectReasoningText(deltaFields[field]);
+        if (delta.length > 0)
+            return { field, delta };
+    }
+    const details = collectReasoningText(deltaFields.reasoning_details);
+    return details.length > 0
+        ? { field: "reasoning_details", delta: details }
+        : undefined;
+}
+function extractReasoningSignature(value) {
+    if (typeof value === "string" && value.length > 0)
+        return value;
+    const record = asRecord(value);
+    if (!record)
+        return undefined;
+    for (const candidate of [
+        record.id,
+        record.item_id,
+        record.data,
+    ]) {
+        if (typeof candidate === "string" && candidate.length > 0)
+            return candidate;
+    }
+    return undefined;
+}
+function extractReasoningMetadata(value) {
+    const record = asRecord(value);
+    if (!record)
+        return undefined;
+    const metadata = {};
+    for (const key of [
+        "id",
+        "item_id",
+        "output_index",
+        "summary_index",
+        "encrypted_content",
+        "type",
+    ]) {
+        if (record[key] !== undefined && record[key] !== null)
+            metadata[key] = record[key];
+    }
+    return Object.keys(metadata).length > 0 ? metadata : undefined;
+}
+function stringMetadata(metadata, key) {
+    const value = metadata?.[key];
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function numberMetadata(metadata, key) {
+    const value = metadata?.[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function hasEncryptedReasoningMetadata(block) {
+    return stringMetadata(block.thinkingMetadata, "encrypted_content") !== undefined;
+}
+function buildResponsesReasoningSidecar(metadata, includeOutputIndex) {
+    const sidecar = {};
+    const id = stringMetadata(metadata, "id");
+    if (id)
+        sidecar.id = id;
+    const itemId = stringMetadata(metadata, "item_id");
+    if (itemId)
+        sidecar.item_id = itemId;
+    if (includeOutputIndex) {
+        const outputIndex = numberMetadata(metadata, "output_index");
+        if (outputIndex !== undefined)
+            sidecar.output_index = outputIndex;
+        const summaryIndex = numberMetadata(metadata, "summary_index");
+        if (summaryIndex !== undefined)
+            sidecar.summary_index = summaryIndex;
+    }
+    const encryptedContent = stringMetadata(metadata, "encrypted_content");
+    if (encryptedContent)
+        sidecar.encrypted_content = encryptedContent;
+    return sidecar;
+}
+function isSafeReasoningReplayField(field) {
+    return SAFE_REASONING_REPLAY_FIELDS.includes(field);
+}
+function normalizeReasoningReplayField(field, model) {
+    const normalized = model.provider === "opencode-go" && field === "reasoning"
+        ? "reasoning_content"
+        : field;
+    return normalized && isSafeReasoningReplayField(normalized)
+        ? normalized
+        : "reasoning_content";
+}
+function setAssistantReasoningField(message, field, value) {
+    const messageWithSidecars = message;
+    messageWithSidecars[field] = value;
+}
+function setAssistantReasoningLifecycleSidecars(message, blocks) {
+    const encryptedBlock = blocks.find(hasEncryptedReasoningMetadata);
+    if (!encryptedBlock)
+        return;
+    const messageWithSidecars = message;
+    messageWithSidecars.reasoning_start = buildResponsesReasoningSidecar(encryptedBlock.thinkingMetadata, true);
+    messageWithSidecars.reasoning_content = blocks
+        .map((block) => block.thinking)
+        .join("\n");
+    messageWithSidecars.reasoning_end = buildResponsesReasoningSidecar(encryptedBlock.thinkingMetadata, false);
+}
+function assistantHasReasoningReplay(message) {
+    const messageWithSidecars = message;
+    return messageWithSidecars.reasoning_start !== undefined ||
+        messageWithSidecars.reasoning_end !== undefined ||
+        SAFE_REASONING_REPLAY_FIELDS.some((field) => typeof messageWithSidecars[field] === "string");
+}
+function mergeThinkingMetadata(block, metadata) {
+    if (!metadata)
+        return;
+    block.thinkingMetadata = { ...(block.thinkingMetadata ?? {}), ...metadata };
+}
+function splitInlineThinkingDelta(pending, inInlineThinking, delta) {
+    const parts = [];
+    let buffer = pending + delta;
+    let thinking = inInlineThinking;
+    const append = (type, value) => {
+        if (!value)
+            return;
+        const last = parts[parts.length - 1];
+        if (last?.type === type) {
+            last.delta += value;
+            return;
+        }
+        parts.push({ type, delta: value });
+    };
+    while (buffer.length > 0) {
+        const tag = thinking ? "</think>" : "<think>";
+        const idx = buffer.toLowerCase().indexOf(tag);
+        if (idx >= 0) {
+            append(thinking ? "thinking" : "text", buffer.slice(0, idx));
+            buffer = buffer.slice(idx + tag.length);
+            thinking = !thinking;
+            continue;
+        }
+        const maxTagLength = "</think>".length - 1;
+        let keep = 0;
+        const limit = Math.min(maxTagLength, buffer.length);
+        for (let size = limit; size > 0; size--) {
+            const suffix = buffer.slice(-size).toLowerCase();
+            if ("<think>".startsWith(suffix) || "</think>".startsWith(suffix)) {
+                keep = size;
+                break;
+            }
+        }
+        append(thinking ? "thinking" : "text", buffer.slice(0, buffer.length - keep));
+        buffer = buffer.slice(buffer.length - keep);
+        break;
+    }
+    return { parts, pending: buffer, inInlineThinking: thinking };
+}
 export const streamOpenAICompletions = (model, context, options) => {
     const stream = new AssistantMessageEventStream();
     (async () => {
@@ -86,12 +291,17 @@ export const streamOpenAICompletions = (model, context, options) => {
             let params = buildParams(model, context, options, compat, cacheRetention);
             const nextParams = await options?.onPayload?.(params, model);
             if (nextParams !== undefined) {
-                params = nextParams;
+                params =
+                    nextParams;
             }
             const requestOptions = {
                 ...(options?.signal ? { signal: options.signal } : {}),
-                ...(options?.timeoutMs !== undefined ? { timeout: options.timeoutMs } : {}),
-                ...(options?.maxRetries !== undefined ? { maxRetries: options.maxRetries } : {}),
+                ...(options?.timeoutMs !== undefined
+                    ? { timeout: options.timeoutMs }
+                    : {}),
+                ...(options?.maxRetries !== undefined
+                    ? { maxRetries: options.maxRetries }
+                    : {}),
             };
             const { data: openaiStream, response } = await client.chat.completions
                 .create(params, requestOptions)
@@ -101,6 +311,9 @@ export const streamOpenAICompletions = (model, context, options) => {
             let textBlock = null;
             let thinkingBlock = null;
             let hasFinishReason = false;
+            let sawStreamOutput = false;
+            let inlineThinkingPending = "";
+            let inInlineThinking = false;
             const toolCallBlocksByIndex = new Map();
             const toolCallBlocksById = new Map();
             const blocks = output.content;
@@ -124,6 +337,7 @@ export const streamOpenAICompletions = (model, context, options) => {
                         contentIndex,
                         content: block.thinking,
                         partial: output,
+                        metadata: block.thinkingMetadata,
                     });
                 }
                 else if (block.type === "toolCall") {
@@ -144,25 +358,91 @@ export const streamOpenAICompletions = (model, context, options) => {
                 if (!textBlock) {
                     textBlock = { type: "text", text: "" };
                     blocks.push(textBlock);
-                    stream.push({ type: "text_start", contentIndex: getContentIndex(textBlock), partial: output });
+                    stream.push({
+                        type: "text_start",
+                        contentIndex: getContentIndex(textBlock),
+                        partial: output,
+                    });
                 }
                 return textBlock;
             };
-            const ensureThinkingBlock = (thinkingSignature) => {
+            const ensureThinkingBlock = (thinkingSignature, metadata) => {
                 if (!thinkingBlock) {
                     thinkingBlock = {
                         type: "thinking",
                         thinking: "",
                         thinkingSignature,
                     };
+                    mergeThinkingMetadata(thinkingBlock, metadata);
                     blocks.push(thinkingBlock);
-                    stream.push({ type: "thinking_start", contentIndex: getContentIndex(thinkingBlock), partial: output });
+                    stream.push({
+                        type: "thinking_start",
+                        contentIndex: getContentIndex(thinkingBlock),
+                        partial: output,
+                        metadata: thinkingBlock.thinkingMetadata,
+                    });
+                }
+                else {
+                    if (!thinkingBlock.thinkingSignature && thinkingSignature) {
+                        thinkingBlock.thinkingSignature = thinkingSignature;
+                    }
+                    mergeThinkingMetadata(thinkingBlock, metadata);
                 }
                 return thinkingBlock;
             };
+            const updateThinkingSignature = (value) => {
+                const signature = extractReasoningSignature(value);
+                const metadata = extractReasoningMetadata(value);
+                if (!signature && !metadata)
+                    return;
+                const block = ensureThinkingBlock(signature ?? "reasoning_content", metadata);
+                if (signature)
+                    block.thinkingSignature = signature;
+            };
+            const emitThinkingDelta = (field, delta, metadata) => {
+                const thinkingSignature = model.provider === "opencode-go" && field === "reasoning"
+                    ? "reasoning_content"
+                    : field;
+                const block = ensureThinkingBlock(thinkingSignature, metadata);
+                block.thinking += delta;
+                sawStreamOutput = true;
+                stream.push({
+                    type: "thinking_delta",
+                    contentIndex: getContentIndex(block),
+                    delta,
+                    partial: output,
+                    metadata: block.thinkingMetadata,
+                });
+            };
+            const emitTextDelta = (delta) => {
+                const block = ensureTextBlock();
+                block.text += delta;
+                sawStreamOutput = true;
+                stream.push({
+                    type: "text_delta",
+                    contentIndex: getContentIndex(block),
+                    delta,
+                    partial: output,
+                });
+            };
+            const emitContentDelta = (delta) => {
+                const split = splitInlineThinkingDelta(inlineThinkingPending, inInlineThinking, delta);
+                inlineThinkingPending = split.pending;
+                inInlineThinking = split.inInlineThinking;
+                for (const part of split.parts) {
+                    if (part.type === "thinking") {
+                        emitThinkingDelta("inline_think", part.delta);
+                    }
+                    else {
+                        emitTextDelta(part.delta);
+                    }
+                }
+            };
             const ensureToolCallBlock = (toolCall) => {
                 const streamIndex = typeof toolCall.index === "number" ? toolCall.index : undefined;
-                let block = streamIndex !== undefined ? toolCallBlocksByIndex.get(streamIndex) : undefined;
+                let block = streamIndex !== undefined
+                    ? toolCallBlocksByIndex.get(streamIndex)
+                    : undefined;
                 if (!block && toolCall.id) {
                     block = toolCallBlocksById.get(toolCall.id);
                 }
@@ -203,13 +483,17 @@ 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) {
+                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);
                 }
-                const choice = Array.isArray(chunk.choices) ? chunk.choices[0] : undefined;
+                const choice = Array.isArray(chunk.choices)
+                    ? chunk.choices[0]
+                    : undefined;
                 if (!choice)
                     continue;
                 // Fallback: some providers (e.g., Moonshot) return usage
@@ -226,47 +510,24 @@ export const streamOpenAICompletions = (model, context, options) => {
                     hasFinishReason = true;
                 }
                 if (choice.delta) {
+                    const deltaFields = choice.delta;
+                    const reasoningStart = deltaFields.reasoning_start;
+                    if (reasoningStart) {
+                        ensureThinkingBlock(extractReasoningSignature(reasoningStart) ?? "reasoning_content", extractReasoningMetadata(reasoningStart));
+                    }
                     if (choice.delta.content !== null &&
                         choice.delta.content !== undefined &&
                         choice.delta.content.length > 0) {
-                        const block = ensureTextBlock();
-                        block.text += choice.delta.content;
-                        stream.push({
-                            type: "text_delta",
-                            contentIndex: getContentIndex(block),
-                            delta: choice.delta.content,
-                            partial: output,
-                        });
+                        emitContentDelta(choice.delta.content);
                     }
-                    // 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) {
-                        const value = deltaFields[field];
-                        if (typeof value === "string" && value.length > 0) {
-                            foundReasoningField = field;
-                            break;
-                        }
-                    }
-                    if (foundReasoningField) {
-                        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: getContentIndex(block),
-                                delta,
-                                partial: output,
-                            });
-                        }
+                    // OpenAI-compatible providers do not agree on reasoning field names.
+                    // Normalize chat deltas, Responses summary deltas, and reasoning_details
+                    // into Spectral's single thinking stream, mirroring opencode's
+                    // canonical `reasoning` message part.
+                    const reasoningDelta = extractReasoningDelta(deltaFields);
+                    if (reasoningDelta) {
+                        emitThinkingDelta(reasoningDelta.field, reasoningDelta.delta, extractReasoningMetadata(deltaFields.reasoning_start) ??
+                            extractReasoningMetadata(deltaFields.reasoning_end));
                     }
                     if (choice?.delta?.tool_calls) {
                         for (const toolCall of choice.delta.tool_calls) {
@@ -281,9 +542,11 @@ export const streamOpenAICompletions = (model, context, options) => {
                             let delta = "";
                             if (toolCall.function?.arguments) {
                                 delta = toolCall.function.arguments;
-                                block.partialArgs = (block.partialArgs ?? "") + toolCall.function.arguments;
+                                block.partialArgs =
+                                    (block.partialArgs ?? "") + toolCall.function.arguments;
                                 block.arguments = parseStreamingJson(block.partialArgs);
                             }
+                            sawStreamOutput = true;
                             stream.push({
                                 type: "toolcall_delta",
                                 contentIndex: getContentIndex(block),
@@ -292,10 +555,16 @@ export const streamOpenAICompletions = (model, context, options) => {
                             });
                         }
                     }
+                    const reasoningEnd = deltaFields.reasoning_end;
+                    if (reasoningEnd) {
+                        updateThinkingSignature(reasoningEnd);
+                    }
                     const reasoningDetails = choice.delta.reasoning_details;
                     if (reasoningDetails && Array.isArray(reasoningDetails)) {
                         for (const detail of reasoningDetails) {
-                            if (detail.type === "reasoning.encrypted" && detail.id && detail.data) {
+                            if (detail.type === "reasoning.encrypted" &&
+                                detail.id &&
+                                detail.data) {
                                 const matchingToolCall = output.content.find((b) => b.type === "toolCall" && b.id === detail.id);
                                 if (matchingToolCall) {
                                     matchingToolCall.thoughtSignature = JSON.stringify(detail);
@@ -305,6 +574,15 @@ export const streamOpenAICompletions = (model, context, options) => {
                     }
                 }
             }
+            if (inlineThinkingPending) {
+                if (inInlineThinking) {
+                    emitThinkingDelta("inline_think", inlineThinkingPending);
+                }
+                else {
+                    emitTextDelta(inlineThinkingPending);
+                }
+                inlineThinkingPending = "";
+            }
             for (const block of blocks) {
                 finishBlock(block);
             }
@@ -318,7 +596,12 @@ export const streamOpenAICompletions = (model, context, options) => {
                 throw new Error(output.errorMessage || "Provider returned an error stop reason");
             }
             if (!hasFinishReason) {
-                throw new Error("Stream ended without finish_reason");
+                if (!sawStreamOutput && blocks.length === 0) {
+                    throw new Error("Stream ended without finish_reason");
+                }
+                output.stopReason = blocks.some((block) => block.type === "toolCall")
+                    ? "toolUse"
+                    : "stop";
             }
             stream.push({ type: "done", reason: output.stopReason, message: output });
             stream.end();
@@ -331,7 +614,8 @@ export const streamOpenAICompletions = (model, context, options) => {
                 delete block.streamIndex;
             }
             output.stopReason = options?.signal?.aborted ? "aborted" : "error";
-            output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
+            output.errorMessage =
+                error instanceof Error ? error.message : JSON.stringify(error);
             // Some providers via OpenRouter give additional information in this field.
             const rawMetadata = error?.error?.metadata?.raw;
             if (rawMetadata)
@@ -348,9 +632,12 @@ export const streamSimpleOpenAICompletions = (model, context, options) => {
         throw new Error(`No API key for provider: ${model.provider}`);
     }
     const base = buildBaseOptions(model, options, apiKey);
-    const clampedReasoning = options?.reasoning ? clampThinkingLevel(model, options.reasoning) : undefined;
+    const clampedReasoning = options?.reasoning
+        ? clampThinkingLevel(model, options.reasoning)
+        : undefined;
     const reasoningEffort = clampedReasoning === "off" ? undefined : clampedReasoning;
-    const toolChoice = options?.toolChoice;
+    const toolChoice = options
+        ?.toolChoice;
     return streamOpenAICompletions(model, context, {
         ...base,
         reasoningEffort,
@@ -455,17 +742,21 @@ function buildParams(model, context, options, compat = getCompat(model), cacheRe
     else if (compat.thinkingFormat === "qwen" && model.reasoning) {
         params.enable_thinking = !!options?.reasoningEffort;
     }
-    else if (compat.thinkingFormat === "qwen-chat-template" && model.reasoning) {
+    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" };
+        params.thinking = {
+            type: options?.reasoningEffort ? "enabled" : "disabled",
+        };
         if (options?.reasoningEffort) {
             params.reasoning_effort =
-                model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort;
+                model.thinkingLevelMap?.[options.reasoningEffort] ??
+                    options.reasoningEffort;
         }
     }
     else if (compat.thinkingFormat === "openrouter" && model.reasoning) {
@@ -473,36 +764,49 @@ function buildParams(model, context, options, compat = getCompat(model), cacheRe
         const openRouterParams = params;
         if (options?.reasoningEffort) {
             openRouterParams.reasoning = {
-                effort: model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort,
+                effort: model.thinkingLevelMap?.[options.reasoningEffort] ??
+                    options.reasoningEffort,
             };
         }
         else if (model.thinkingLevelMap?.off !== null) {
-            openRouterParams.reasoning = { effort: model.thinkingLevelMap?.off ?? "none" };
+            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;
+            togetherParams.reasoning_effort =
+                model.thinkingLevelMap?.[options.reasoningEffort] ??
+                    options.reasoningEffort;
         }
     }
-    else if (options?.reasoningEffort && model.reasoning && compat.supportsReasoningEffort) {
+    else if (options?.reasoningEffort &&
+        model.reasoning &&
+        compat.supportsReasoningEffort) {
         // OpenAI-style reasoning_effort
-        params.reasoning_effort = model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort;
+        params.reasoning_effort =
+            model.thinkingLevelMap?.[options.reasoningEffort] ??
+                options.reasoningEffort;
     }
-    else if (!options?.reasoningEffort && model.reasoning && compat.supportsReasoningEffort) {
+    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.baseUrl.includes("openrouter.ai") &&
+        model.compat?.openRouterRouting) {
         params.provider = model.compat.openRouterRouting;
     }
     // Vercel AI Gateway provider routing preferences
-    if (model.baseUrl.includes("ai-gateway.vercel.sh") && model.compat?.vercelGatewayRouting) {
+    if (model.baseUrl.includes("ai-gateway.vercel.sh") &&
+        model.compat?.vercelGatewayRouting) {
         const routing = model.compat.vercelGatewayRouting;
         if (routing.only || routing.order) {
             const gatewayOptions = {};
@@ -519,7 +823,9 @@ function getCompatCacheControl(compat, cacheRetention) {
     if (compat.cacheControlFormat !== "anthropic" || cacheRetention === "none") {
         return undefined;
     }
-    const ttl = cacheRetention === "long" && compat.supportsLongCacheRetention ? "1h" : undefined;
+    const ttl = cacheRetention === "long" && compat.supportsLongCacheRetention
+        ? "1h"
+        : undefined;
     return { type: "ephemeral", ...(ttl ? { ttl } : {}) };
 }
 function applyAnthropicCacheControl(messages, tools, cacheControl) {
@@ -609,14 +915,19 @@ export function convertMessages(model, context, compat) {
     if (context.systemPrompt) {
         const useDeveloperRole = model.reasoning && compat.supportsDeveloperRole;
         const role = useDeveloperRole ? "developer" : "system";
-        params.push({ role: role, content: sanitizeSurrogates(context.systemPrompt) });
+        params.push({
+            role: role,
+            content: sanitizeSurrogates(context.systemPrompt),
+        });
     }
     let lastRole = null;
     for (let i = 0; i < transformedMessages.length; i++) {
         const msg = transformedMessages[i];
         // Some providers don't allow user messages directly after tool results
         // Insert a synthetic assistant message to bridge the gap
-        if (compat.requiresAssistantAfterToolResult && lastRole === "toolResult" && msg.role === "user") {
+        if (compat.requiresAssistantAfterToolResult &&
+            lastRole === "toolResult" &&
+            msg.role === "user") {
             params.push({
                 role: "assistant",
                 content: "I have processed the tool results.",
@@ -667,7 +978,9 @@ export function convertMessages(model, context, compat) {
                 type: "text",
                 text: sanitizeSurrogates(block.text),
             }));
-            const assistantText = assistantTextParts.map((part) => part.text).join("");
+            const assistantText = assistantTextParts
+                .map((part) => part.text)
+                .join("");
             const nonEmptyThinkingBlocks = msg.content
                 .filter(isThinkingContentBlock)
                 .filter((block) => block.thinking.trim().length > 0);
@@ -677,7 +990,10 @@ export function convertMessages(model, context, compat) {
                     const thinkingText = nonEmptyThinkingBlocks
                         .map((block) => sanitizeSurrogates(block.thinking))
                         .join("\n\n");
-                    assistantMsg.content = [{ type: "text", text: thinkingText }, ...assistantTextParts];
+                    assistantMsg.content = [
+                        { type: "text", text: thinkingText },
+                        ...assistantTextParts,
+                    ];
                 }
                 else {
                     // Always send assistant content as a plain string (OpenAI Chat Completions
@@ -688,13 +1004,14 @@ export function convertMessages(model, context, compat) {
                     if (assistantText.length > 0) {
                         assistantMsg.content = assistantText;
                     }
-                    // Use the signature from the first thinking block if available (for llama.cpp server + gpt-oss)
-                    let signature = nonEmptyThinkingBlocks[0].thinkingSignature;
-                    if (model.provider === "opencode-go" && signature === "reasoning") {
-                        signature = "reasoning_content";
+                    const reasoningText = nonEmptyThinkingBlocks
+                        .map((block) => block.thinking)
+                        .join("\n");
+                    if (nonEmptyThinkingBlocks.some(hasEncryptedReasoningMetadata)) {
+                        setAssistantReasoningLifecycleSidecars(assistantMsg, nonEmptyThinkingBlocks);
                     }
-                    if (signature && signature.length > 0) {
-                        assistantMsg[signature] = nonEmptyThinkingBlocks.map((block) => block.thinking).join("\n");
+                    else {
+                        setAssistantReasoningField(assistantMsg, normalizeReasoningReplayField(nonEmptyThinkingBlocks[0].thinkingSignature, model), reasoningText);
                     }
                 }
             }
@@ -733,7 +1050,8 @@ export function convertMessages(model, context, compat) {
             }
             if (compat.requiresReasoningContentOnAssistantMessages &&
                 model.reasoning &&
-                assistantMsg.reasoning_content === undefined) {
+                assistantMsg.reasoning_content ===
+                    undefined) {
                 assistantMsg.reasoning_content = "";
             }
             // Skip assistant messages that have no content and no tool calls.
@@ -744,7 +1062,8 @@ export function convertMessages(model, context, compat) {
             const hasContent = content !== null &&
                 content !== undefined &&
                 (typeof content === "string" ? content.length > 0 : content.length > 0);
-            if (!hasContent && !assistantMsg.tool_calls) {
+            if (!hasContent && !assistantMsg.tool_calls &&
+                !assistantHasReasoningReplay(assistantMsg)) {
                 continue;
             }
             params.push(assistantMsg);
@@ -752,7 +1071,8 @@ export function convertMessages(model, context, compat) {
         else if (msg.role === "toolResult") {
             const imageBlocks = [];
             let j = i;
-            for (; j < transformedMessages.length && transformedMessages[j].role === "toolResult"; j++) {
+            for (; j < transformedMessages.length &&
+                transformedMessages[j].role === "toolResult"; j++) {
                 const toolMsg = transformedMessages[j];
                 // Extract text and image content
                 const textResult = toolMsg.content
@@ -828,7 +1148,9 @@ function convertTools(tools, compat) {
 }
 function parseChunkUsage(rawUsage, model) {
     const promptTokens = rawUsage.prompt_tokens || 0;
-    const cacheReadTokens = rawUsage.prompt_tokens_details?.cached_tokens ?? rawUsage.prompt_cache_hit_tokens ?? 0;
+    const cacheReadTokens = rawUsage.prompt_tokens_details?.cached_tokens ??
+        rawUsage.prompt_cache_hit_tokens ??
+        0;
     const cacheWriteTokens = rawUsage.prompt_tokens_details?.cache_write_tokens || 0;
     // Follow documented OpenAI/OpenRouter semantics: cached_tokens is cache-read
     // tokens (hits). OpenAI does not document or emit cache_write_tokens, but
@@ -865,9 +1187,15 @@ function mapStopReason(reason) {
         case "tool_calls":
             return { stopReason: "toolUse" };
         case "content_filter":
-            return { stopReason: "error", errorMessage: "Provider finish_reason: content_filter" };
+            return {
+                stopReason: "error",
+                errorMessage: "Provider finish_reason: content_filter",
+            };
         case "network_error":
-            return { stopReason: "error", errorMessage: "Provider finish_reason: network_error" };
+            return {
+                stopReason: "error",
+                errorMessage: "Provider finish_reason: network_error",
+            };
         default:
             return {
                 stopReason: "error",
@@ -884,8 +1212,12 @@ 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 isTogether = provider === "together" ||
+        baseUrl.includes("api.together.ai") ||
+        baseUrl.includes("api.together.xyz");
+    const isMoonshot = provider === "moonshotai" ||
+        provider === "moonshotai-cn" ||
+        baseUrl.includes("api.moonshot.");
     // Cloudflare providers not supported (cloudflare.ts was removed)
     const isCloudflareWorkersAI = false;
     const isCloudflareAiGateway = false;
@@ -902,10 +1234,15 @@ function detectCompat(model) {
         baseUrl.includes("opencode.ai") ||
         isCloudflareWorkersAI ||
         isCloudflareAiGateway;
-    const useMaxTokens = baseUrl.includes("chutes.ai") || isMoonshot || isCloudflareAiGateway || isTogether;
+    const useMaxTokens = baseUrl.includes("chutes.ai") ||
+        isMoonshot ||
+        isCloudflareAiGateway ||
+        isTogether;
     const isGrok = provider === "xai" || baseUrl.includes("api.x.ai");
     const isDeepSeek = provider === "deepseek" || baseUrl.includes("deepseek.com");
-    const cacheControlFormat = isOpenRouterAnthropicModel(model) ? "anthropic" : undefined;
+    const cacheControlFormat = isOpenRouterAnthropicModel(model)
+        ? "anthropic"
+        : undefined;
     return {
         supportsStore: !isNonStandard,
         supportsDeveloperRole: !isNonStandard,
@@ -931,7 +1268,9 @@ function detectCompat(model) {
         supportsStrictMode: !isMoonshot && !isTogether && !isCloudflareAiGateway,
         cacheControlFormat,
         sendSessionAffinityHeaders: isOpenRouterModel(model),
-        supportsLongCacheRetention: !(isTogether || isCloudflareWorkersAI || isCloudflareAiGateway),
+        supportsLongCacheRetention: !(isTogether ||
+            isCloudflareWorkersAI ||
+            isCloudflareAiGateway),
     };
 }
 /**
@@ -946,10 +1285,12 @@ function getCompat(model) {
         supportsStore: model.compat.supportsStore ?? detected.supportsStore,
         supportsDeveloperRole: model.compat.supportsDeveloperRole ?? detected.supportsDeveloperRole,
         supportsReasoningEffort: model.compat.supportsReasoningEffort ?? detected.supportsReasoningEffort,
-        supportsUsageInStreaming: model.compat.supportsUsageInStreaming ?? detected.supportsUsageInStreaming,
+        supportsUsageInStreaming: model.compat.supportsUsageInStreaming ??
+            detected.supportsUsageInStreaming,
         maxTokensField: model.compat.maxTokensField ?? detected.maxTokensField,
         requiresToolResultName: model.compat.requiresToolResultName ?? detected.requiresToolResultName,
-        requiresAssistantAfterToolResult: model.compat.requiresAssistantAfterToolResult ?? detected.requiresAssistantAfterToolResult,
+        requiresAssistantAfterToolResult: model.compat.requiresAssistantAfterToolResult ??
+            detected.requiresAssistantAfterToolResult,
         requiresThinkingAsText: model.compat.requiresThinkingAsText ?? detected.requiresThinkingAsText,
         requiresReasoningContentOnAssistantMessages: model.compat.requiresReasoningContentOnAssistantMessages ??
             detected.requiresReasoningContentOnAssistantMessages,
@@ -959,7 +1300,9 @@ function getCompat(model) {
         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,
+        sendSessionAffinityHeaders: model.compat.sendSessionAffinityHeaders ??
+            detected.sendSessionAffinityHeaders,
+        supportsLongCacheRetention: model.compat.supportsLongCacheRetention ??
+            detected.supportsLongCacheRetention,
     };
 }