@agentionai/agents 1.0.2 → 1.2.0

package/dist/agents/ollama/OllamaAgent.js

@@ -135,7 +135,7 @@ class OllamaAgent extends BaseAgent_1.BaseAgent {
     }
     async execute(input) {
         this.emit(AgentEvent_1.AgentEvent.BEFORE_EXECUTE, input);
-        this.lastTokenUsage = undefined;
+        this.resetTokenUsage();
         this.currentToolCallCount = 0;
         const inputPreview = typeof input === "string" ? input : JSON.stringify(input);
         if (VizConfig_1.vizConfig.isEnabled()) {
@@ -203,6 +203,7 @@ class OllamaAgent extends BaseAgent_1.BaseAgent {
         const messages = transformers_1.ollamaTransformer.toProvider(this.history.getEntries());
         const tools = this.tools.size > 0 ? this.getToolDefinitions() : undefined;
         const options = this.buildOptions();
+        this.startTurnTimer();
         return client.chat({
             model: this.config.model,
             messages,
@@ -214,15 +215,7 @@ class OllamaAgent extends BaseAgent_1.BaseAgent {
     }
     async handleResponse(response) {
         const ollamaResponse = response;
-        const usage = this.parseUsage(ollamaResponse);
-        if (this.lastTokenUsage) {
-            this.lastTokenUsage.input_tokens += usage.input_tokens;
-            this.lastTokenUsage.output_tokens += usage.output_tokens;
-            this.lastTokenUsage.total_tokens += usage.total_tokens;
-        }
-        else {
-            this.lastTokenUsage = { ...usage };
-        }
+        const usage = this.accumulateUsage(this.parseUsage(ollamaResponse));
         if (ollamaResponse.done_reason === "length") {
             const error = new AgentError_1.MaxTokensExceededError("Response exceeded maximum token limit", this.config.maxTokens || 2048);
             this.emit(AgentEvent_1.AgentEvent.MAX_TOKENS_EXCEEDED, error);
@@ -306,10 +299,19 @@ class OllamaAgent extends BaseAgent_1.BaseAgent {
     }
     parseUsage(input) {
         const response = input;
+        // Ollama reports its own timings in nanoseconds. Time to first token is
+        // model load plus prompt evaluation — everything before generation starts.
+        const toMs = (ns) => ns === undefined ? undefined : ns / 1000000;
+        const timeToFirstTokenMs = response.prompt_eval_duration === undefined
+            ? undefined
+            : toMs((response.load_duration ?? 0) + response.prompt_eval_duration);
         return {
             input_tokens: response.prompt_eval_count ?? 0,
             output_tokens: response.eval_count ?? 0,
             total_tokens: (response.prompt_eval_count ?? 0) + (response.eval_count ?? 0),
+            timeToFirstTokenMs,
+            generationMs: toMs(response.eval_duration),
+            totalMs: toMs(response.total_duration),
         };
     }
 }

package/dist/agents/openai/OpenAiAgent.d.ts

@@ -1,18 +1,43 @@
 import { BaseAgent, BaseAgentConfig, TokenUsage } from "../BaseAgent";
 import { History, MessageContent } from "../../history/History";
 import { Tool, Response, ResponseUsage } from "openai/resources/responses/responses";
-import { OpenAIModel } from "../model-types";
+import { OpenAIModel, ReasoningEffort, ReasoningEffortFor } from "../model-types";
 import { StreamChunk } from "../openai-compatible/OpenAICompatibleAgent";
-type AgentConfig = BaseAgentConfig & {
+type AgentConfig<M extends OpenAIModel = OpenAIModel> = BaseAgentConfig & {
     apiKey: string;
-    model?: OpenAIModel;
+    model?: M;
     maxTokens?: number;
     disableParallelToolUse?: boolean;
-    /** Disable extended thinking/reasoning for models that support it (like gpt-5-nano) */
+    /**
+     * Ask for the least reasoning the configured model supports (e.g. `minimal` on
+     * `gpt-5-nano`, `none` on `gpt-5.6`). Takes precedence over `reasoningEffort`.
+     * No effect on models without reasoning support.
+     */
     disableReasoning?: boolean;
-    reasoningEffort?: "low" | "medium" | "high";
+    /**
+     * How hard the model should think. Narrowed to the values the configured
+     * `model` actually accepts — `reasoningEffort: "none"` is a type error on
+     * `gpt-5-nano`, which takes `minimal` instead.
+     */
+    reasoningEffort?: ReasoningEffortFor<M>;
     user?: string;
 };
+/**
+ * Lowest `reasoning.effort` the given model accepts, used to resolve
+ * `disableReasoning`. Returns `undefined` when the model has no reasoning to turn
+ * off, in which case the caller omits `reasoning` entirely rather than risk a 400
+ * — non-reasoning models such as `gpt-4.1-mini` reject the parameter outright.
+ *
+ * There is no single "off" value, and `effort: null` is not one either: it means
+ * *unset*, so the model falls back to its own default (`medium` on every family
+ * released before `gpt-5.1`).
+ *
+ * Reads {@link OPENAI_REASONING_SUPPORT}, the same table {@link ReasoningEffortFor}
+ * is derived from, so the compile-time and runtime views cannot disagree. Models
+ * missing from it — including newer families — return `undefined`; set
+ * `reasoningEffort` explicitly to override.
+ */
+export declare function lowestReasoningEffort(model: string | undefined): ReasoningEffort | undefined;
 /**
  * Agent for OpenAI models using the Responses API.
  *
@@ -28,17 +53,38 @@ type AgentConfig = BaseAgentConfig & {
  * const response = await agent.execute("Hello!");
  * ```
  */
-export declare class OpenAiAgent extends BaseAgent {
+export declare class OpenAiAgent<M extends OpenAIModel = OpenAIModel> extends BaseAgent {
     private client;
+    /**
+     * Resolved runtime config. Deliberately not narrowed by `M` — the constructor
+     * fills in defaults and merges `vendorConfig`, whose values are not
+     * model-scoped. Narrowing happens on the constructor's parameter, where the
+     * caller's model is known.
+     */
     protected config: Partial<AgentConfig>;
-    /** Token usage from the last execution (for metrics tracking) */
-    lastTokenUsage?: TokenUsage;
     /** Current visualization event ID for tracking */
     private vizEventId?;
     /** Count of tool calls in current execution */
     private currentToolCallCount;
-    constructor(config: Omit<AgentConfig, "vendor">, history?: History);
+    constructor(config: Omit<AgentConfig<M>, "vendor">, history?: History);
     protected getToolDefinitions(): Tool[];
+    /**
+     * Build the `reasoning` field for a Responses API request, as an object to
+     * spread into the request params.
+     *
+     * `disableReasoning` takes precedence over `reasoningEffort` and resolves to the
+     * lowest effort the configured model accepts (see {@link lowestReasoningEffort}).
+     * The field is omitted entirely when neither option applies — `reasoning: {}` is
+     * not the same as omitting it, and non-reasoning models reject the parameter.
+     *
+     * All three request sites go through here: they were copies of the same
+     * expression, and one drifted into overwriting the disable case with an
+     * unconditional `reasoning` key.
+     *
+     * @param summary Pass `"auto"` for streaming requests — the Responses API only
+     * emits `response.reasoning_summary_text.delta` events when it is set.
+     */
+    private buildReasoningParams;
     protected process(_input: string): Promise<string>;
     execute(input: string | MessageContent[]): Promise<string>;
     protected handleResponse(response: Response): Promise<string>;

package/dist/agents/openai/OpenAiAgent.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAiAgent = void 0;
+exports.lowestReasoningEffort = lowestReasoningEffort;
 const openai_1 = __importDefault(require("openai"));
 const BaseAgent_1 = require("../BaseAgent");
 const AgentEvent_1 = require("../AgentEvent");
@@ -11,6 +12,30 @@ const AgentError_1 = require("../errors/AgentError");
 const transformers_1 = require("../../history/transformers");
 const VizReporter_1 = require("../../viz/VizReporter");
 const VizConfig_1 = require("../../viz/VizConfig");
+const model_types_1 = require("../model-types");
+/**
+ * Lowest `reasoning.effort` the given model accepts, used to resolve
+ * `disableReasoning`. Returns `undefined` when the model has no reasoning to turn
+ * off, in which case the caller omits `reasoning` entirely rather than risk a 400
+ * — non-reasoning models such as `gpt-4.1-mini` reject the parameter outright.
+ *
+ * There is no single "off" value, and `effort: null` is not one either: it means
+ * *unset*, so the model falls back to its own default (`medium` on every family
+ * released before `gpt-5.1`).
+ *
+ * Reads {@link OPENAI_REASONING_SUPPORT}, the same table {@link ReasoningEffortFor}
+ * is derived from, so the compile-time and runtime views cannot disagree. Models
+ * missing from it — including newer families — return `undefined`; set
+ * `reasoningEffort` explicitly to override.
+ */
+function lowestReasoningEffort(model) {
+    if (!model)
+        return undefined;
+    // Snapshot ids (`gpt-5-nano-2025-08-07`) share their alias's support set.
+    const base = model.replace(/-20\d{2}-\d{2}-\d{2}$/, "");
+    const group = model_types_1.OPENAI_REASONING_SUPPORT.find((entry) => entry.models.includes(base));
+    return group?.efforts[0];
+}
 /**
  * Agent for OpenAI models using the Responses API.
  *
@@ -78,13 +103,44 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
             };
         });
     }
+    /**
+     * Build the `reasoning` field for a Responses API request, as an object to
+     * spread into the request params.
+     *
+     * `disableReasoning` takes precedence over `reasoningEffort` and resolves to the
+     * lowest effort the configured model accepts (see {@link lowestReasoningEffort}).
+     * The field is omitted entirely when neither option applies — `reasoning: {}` is
+     * not the same as omitting it, and non-reasoning models reject the parameter.
+     *
+     * All three request sites go through here: they were copies of the same
+     * expression, and one drifted into overwriting the disable case with an
+     * unconditional `reasoning` key.
+     *
+     * @param summary Pass `"auto"` for streaming requests — the Responses API only
+     * emits `response.reasoning_summary_text.delta` events when it is set.
+     */
+    buildReasoningParams(summary) {
+        const effort = this.config.disableReasoning
+            ? lowestReasoningEffort(this.config.model)
+            : this.config.reasoningEffort;
+        if (!effort)
+            return {};
+        return {
+            reasoning: {
+                // The Responses API accepts "max" (verified on gpt-5.6), but the installed
+                // SDK's ReasoningEffort union predates it — cast at this one boundary.
+                effort: effort,
+                ...(summary ? { summary } : {}),
+            },
+        };
+    }
     async process(_input) {
         return "";
     }
     async execute(input) {
         this.emit(AgentEvent_1.AgentEvent.BEFORE_EXECUTE, input);
         // Reset token usage for this execution
-        this.lastTokenUsage = undefined;
+        this.resetTokenUsage();
         this.currentToolCallCount = 0;
         const inputPreview = typeof input === "string" ? input : JSON.stringify(input);
         // Start visualization reporting
@@ -110,6 +166,7 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
         this.history.beginExecution();
         try {
             const inputMessages = transformers_1.openAiTransformer.toProvider(this.history.getEntries());
+            this.startTurnTimer();
             const response = await this.client.responses.create({
                 model: this.config.model,
                 max_output_tokens: this.config.maxTokens,
@@ -120,8 +177,7 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
                 top_p: this.config.topP,
                 // Note: Responses API doesn't support seed, presence_penalty, frequency_penalty, stop
                 user: this.config.user,
-                ...(this.config.disableReasoning && { reasoning: { effort: null } }),
-                reasoning: { effort: this.config.reasoningEffort },
+                ...this.buildReasoningParams(),
             });
             this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, response);
             return await this.handleResponse(response);
@@ -165,15 +221,7 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
         }
         // Track token usage if available
         if (response.usage) {
-            const usage = this.parseUsage(response.usage);
-            if (this.lastTokenUsage) {
-                this.lastTokenUsage.input_tokens += usage.input_tokens;
-                this.lastTokenUsage.output_tokens += usage.output_tokens;
-                this.lastTokenUsage.total_tokens += usage.total_tokens;
-            }
-            else {
-                this.lastTokenUsage = { ...usage };
-            }
+            this.accumulateUsage(this.parseUsage(response.usage));
         }
         const toolCalls = response.output.filter((output) => output.type === "function_call");
         // Find the message output (skip reasoning outputs)
@@ -232,6 +280,7 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
                 // Continue conversation
                 try {
                     const inputMessages = transformers_1.openAiTransformer.toProvider(this.history.getEntries());
+                    this.startTurnTimer();
                     const newResponse = await this.client.responses.create({
                         model: this.config.model,
                         max_output_tokens: this.config.maxTokens,
@@ -242,13 +291,7 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
                         top_p: this.config.topP,
                         // Note: Responses API doesn't support seed, presence_penalty, frequency_penalty, stop
                         user: this.config.user,
-                        ...(this.config.disableReasoning && {
-                            reasoning: { effort: null },
-                        }),
-                        ...(this.config.reasoningEffort &&
-                            !this.config.disableReasoning && {
-                            reasoning: { effort: this.config.reasoningEffort },
-                        }),
+                        ...this.buildReasoningParams(),
                     });
                     this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, newResponse);
                     return this.handleResponse(newResponse);
@@ -355,7 +398,7 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
      */
     async *executeStream(input) {
         this.emit(AgentEvent_1.AgentEvent.BEFORE_EXECUTE, input);
-        this.lastTokenUsage = undefined;
+        this.resetTokenUsage();
         this.currentToolCallCount = 0;
         const inputPreview = typeof input === "string" ? input : JSON.stringify(input);
         if (VizConfig_1.vizConfig.isEnabled()) {
@@ -409,6 +452,7 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
     }
     async *streamTurn() {
         const inputMessages = transformers_1.openAiTransformer.toProvider(this.history.getEntries());
+        this.startTurnTimer();
         const stream = await this.client.responses.create({
             model: this.config.model,
             max_output_tokens: this.config.maxTokens,
@@ -419,35 +463,24 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
             temperature: this.config.temperature,
             top_p: this.config.topP,
             user: this.config.user,
-            ...(this.config.disableReasoning && { reasoning: { effort: null } }),
-            ...(this.config.reasoningEffort && !this.config.disableReasoning && {
-                // `summary: "auto"` is required for the Responses API to stream
-                // `response.reasoning_summary_text.delta` events.
-                reasoning: { effort: this.config.reasoningEffort, summary: "auto" },
-            }),
+            ...this.buildReasoningParams("auto"),
         });
         let completedEvent = null;
         for await (const event of stream) {
             if (event.type === "response.output_text.delta") {
+                this.markFirstToken();
                 this.emit(AgentEvent_1.AgentEvent.CHUNK, event.delta);
                 yield { type: "text", content: event.delta };
             }
             if (event.type === "response.reasoning_summary_text.delta") {
+                this.markFirstToken();
                 this.emit(AgentEvent_1.AgentEvent.REASONING_CHUNK, event.delta);
                 yield { type: "reasoning", content: event.delta };
             }
             if (event.type === "response.completed") {
                 completedEvent = event;
                 if (event.response.usage) {
-                    const usage = this.parseUsage(event.response.usage);
-                    if (this.lastTokenUsage) {
-                        this.lastTokenUsage.input_tokens += usage.input_tokens;
-                        this.lastTokenUsage.output_tokens += usage.output_tokens;
-                        this.lastTokenUsage.total_tokens += usage.total_tokens;
-                    }
-                    else {
-                        this.lastTokenUsage = { ...usage };
-                    }
+                    this.accumulateUsage(this.parseUsage(event.response.usage));
                 }
             }
             if (event.type === "response.incomplete") {
@@ -496,6 +529,8 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
             input_tokens: input.input_tokens,
             output_tokens: input.output_tokens,
             total_tokens: input.total_tokens,
+            // Reasoning tokens are already counted inside `output_tokens`.
+            reasoning_tokens: input.output_tokens_details?.reasoning_tokens,
         };
     }
 }

package/dist/agents/openai-compatible/OpenAICompatibleAgent.d.ts

@@ -32,7 +32,6 @@ export type OpenAICompatibleConfig = BaseAgentConfig & {
 export declare abstract class OpenAICompatibleAgent extends BaseAgent {
     protected client: OpenAI;
     protected config: Partial<OpenAICompatibleConfig>;
-    lastTokenUsage?: TokenUsage;
     private vizEventId?;
     private currentToolCallCount;
     constructor(config: OpenAICompatibleConfig & {

package/dist/agents/openai-compatible/OpenAICompatibleAgent.js

@@ -77,7 +77,7 @@ class OpenAICompatibleAgent extends BaseAgent_1.BaseAgent {
     }
     async execute(input) {
         this.emit(AgentEvent_1.AgentEvent.BEFORE_EXECUTE, input);
-        this.lastTokenUsage = undefined;
+        this.resetTokenUsage();
         this.currentToolCallCount = 0;
         const inputPreview = typeof input === "string" ? input : JSON.stringify(input);
         if (VizConfig_1.vizConfig.isEnabled()) {
@@ -133,6 +133,7 @@ class OpenAICompatibleAgent extends BaseAgent_1.BaseAgent {
     async callProvider() {
         const messages = transformers_1.chatCompletionsTransformer.toProvider(this.history.getEntries());
         const tools = this.tools.size > 0 ? this.getToolDefinitions() : undefined;
+        this.startTurnTimer();
         return this.client.chat.completions.create({
             model: this.config.model,
             messages,
@@ -149,15 +150,7 @@ class OpenAICompatibleAgent extends BaseAgent_1.BaseAgent {
         });
     }
     async handleResponse(response) {
-        const usage = this.parseUsage(response);
-        if (this.lastTokenUsage) {
-            this.lastTokenUsage.input_tokens += usage.input_tokens;
-            this.lastTokenUsage.output_tokens += usage.output_tokens;
-            this.lastTokenUsage.total_tokens += usage.total_tokens;
-        }
-        else {
-            this.lastTokenUsage = { ...usage };
-        }
+        const usage = this.accumulateUsage(this.parseUsage(response));
         const choice = response.choices[0];
         const message = choice.message;
         if (choice.finish_reason === "length") {
@@ -253,7 +246,7 @@ class OpenAICompatibleAgent extends BaseAgent_1.BaseAgent {
      */
     async *executeStream(input) {
         this.emit(AgentEvent_1.AgentEvent.BEFORE_EXECUTE, input);
-        this.lastTokenUsage = undefined;
+        this.resetTokenUsage();
         this.currentToolCallCount = 0;
         const inputPreview = typeof input === "string" ? input : JSON.stringify(input);
         if (VizConfig_1.vizConfig.isEnabled()) {
@@ -307,6 +300,7 @@ class OpenAICompatibleAgent extends BaseAgent_1.BaseAgent {
     async *streamTurn() {
         const messages = transformers_1.chatCompletionsTransformer.toProvider(this.history.getEntries());
         const tools = this.tools.size > 0 ? this.getToolDefinitions() : undefined;
+        this.startTurnTimer();
         const stream = await this.client.chat.completions.create({
             model: this.config.model,
             messages,
@@ -323,6 +317,7 @@ class OpenAICompatibleAgent extends BaseAgent_1.BaseAgent {
             ...this.buildExtraRequestParams(),
         });
         let textContent = "";
+        let reasoningContent = "";
         const toolCallAcc = new Map();
         let finishReason = null;
         for await (const chunk of stream) {
@@ -336,6 +331,7 @@ class OpenAICompatibleAgent extends BaseAgent_1.BaseAgent {
             finishReason = choice.finish_reason ?? finishReason;
             const delta = choice.delta;
             if (delta.content) {
+                this.markFirstToken();
                 textContent += delta.content;
                 this.emit(AgentEvent_1.AgentEvent.CHUNK, delta.content);
                 yield { type: "text", content: delta.content };
@@ -347,6 +343,11 @@ class OpenAICompatibleAgent extends BaseAgent_1.BaseAgent {
             const deltaExtras = delta;
             const reasoningDelta = (deltaExtras.reasoning ?? deltaExtras.reasoning_content);
             if (reasoningDelta) {
+                this.markFirstToken();
+                // Accumulated as well as yielded: DeepSeek's thinking mode requires the
+                // assistant turn's reasoning to be replayed on the next request, so it
+                // has to reach history rather than only the caller.
+                reasoningContent += reasoningDelta;
                 this.emit(AgentEvent_1.AgentEvent.REASONING_CHUNK, reasoningDelta);
                 yield { type: "reasoning", content: reasoningDelta };
             }
@@ -389,6 +390,7 @@ class OpenAICompatibleAgent extends BaseAgent_1.BaseAgent {
                 role: "assistant",
                 content: textContent || null,
                 tool_calls: toolCalls,
+                reasoning_content: reasoningContent || null,
             });
             this.addToHistory(assistantEntry);
             const toolResults = await this.handleToolCalls(toolCalls);
@@ -401,6 +403,7 @@ class OpenAICompatibleAgent extends BaseAgent_1.BaseAgent {
             const assistantEntry = transformers_1.chatCompletionsTransformer.fromProviderMessage({
                 role: "assistant",
                 content: textContent || null,
+                reasoning_content: reasoningContent || null,
             });
             this.addToHistory(assistantEntry);
             this.emit(AgentEvent_1.AgentEvent.DONE, { content: textContent }, this.lastTokenUsage);
@@ -417,19 +420,12 @@ class OpenAICompatibleAgent extends BaseAgent_1.BaseAgent {
     accumulateStreamUsage(usage) {
         if (!usage)
             return;
-        const u = {
+        this.accumulateUsage({
             input_tokens: usage.prompt_tokens ?? 0,
             output_tokens: usage.completion_tokens ?? 0,
             total_tokens: usage.total_tokens ?? 0,
-        };
-        if (this.lastTokenUsage) {
-            this.lastTokenUsage.input_tokens += u.input_tokens;
-            this.lastTokenUsage.output_tokens += u.output_tokens;
-            this.lastTokenUsage.total_tokens += u.total_tokens;
-        }
-        else {
-            this.lastTokenUsage = u;
-        }
+            reasoning_tokens: extractReasoningTokens(usage),
+        });
     }
     parseUsage(response) {
         const usage = response.usage;
@@ -437,8 +433,38 @@ class OpenAICompatibleAgent extends BaseAgent_1.BaseAgent {
             input_tokens: usage?.prompt_tokens ?? 0,
             output_tokens: usage?.completion_tokens ?? 0,
             total_tokens: usage?.total_tokens ?? 0,
+            reasoning_tokens: extractReasoningTokens(usage),
+            ...extractServerTimings(response),
         };
     }
 }
 exports.OpenAICompatibleAgent = OpenAICompatibleAgent;
+/**
+ * Reasoning token count from `completion_tokens_details`, which reasoning
+ * models (and OpenAI-compatible proxies fronting them) fill in.
+ */
+function extractReasoningTokens(usage) {
+    const details = usage
+        ?.completion_tokens_details;
+    return details?.reasoning_tokens;
+}
+/**
+ * Timings reported by llama.cpp's `llama-server`, which adds a non-standard
+ * `timings` object to its chat completion responses. Absent on every other
+ * OpenAI-compatible server, in which case the durations are measured locally.
+ */
+function extractServerTimings(response) {
+    const timings = response?.timings;
+    if (!timings)
+        return {};
+    const { prompt_ms, predicted_ms } = timings;
+    const totalMs = prompt_ms === undefined && predicted_ms === undefined
+        ? undefined
+        : (prompt_ms ?? 0) + (predicted_ms ?? 0);
+    return {
+        timeToFirstTokenMs: prompt_ms,
+        generationMs: predicted_ms,
+        totalMs,
+    };
+}
 //# sourceMappingURL=OpenAICompatibleAgent.js.map

package/dist/history/transformers.d.ts

@@ -182,6 +182,12 @@ type ChatCompletionMessage = {
     role: "assistant";
     content: string | null;
     tool_calls?: ChatCompletionToolCallParam[];
+    /**
+     * Reasoning replayed from a previous turn. Required by DeepSeek's thinking
+     * mode; accepted by OpenRouter as an alias for `reasoning`. Omitted
+     * entirely when the turn carried no reasoning.
+     */
+    reasoning_content?: string;
 } | {
     role: "tool";
     tool_call_id: string;
@@ -197,6 +203,10 @@ type ChatCompletionResponseMessage = {
             arguments: string;
         };
     }>;
+    /** Reasoning tokens as sent by OpenRouter. Not part of the OpenAI schema. */
+    reasoning?: string | null;
+    /** Reasoning tokens as sent by DeepSeek and llama.cpp. */
+    reasoning_content?: string | null;
 };
 export {};
 //# sourceMappingURL=transformers.d.ts.map

package/dist/history/transformers.js

@@ -614,6 +614,7 @@ exports.chatCompletionsTransformer = {
             const textBlocks = entry.content.filter(types_1.isTextContent);
             const toolUseBlocks = entry.content.filter(types_1.isToolUseContent);
             const toolResultBlocks = entry.content.filter(types_1.isToolResultContent);
+            const thinkingBlocks = entry.content.filter(types_1.isThinkingContent);
             const imageUrlBlocks = entry.content.filter(types_1.isImageUrlContent);
             const imageBase64Blocks = entry.content.filter(types_1.isImageBase64Content);
             const hasImages = imageUrlBlocks.length > 0 || imageBase64Blocks.length > 0;
@@ -626,6 +627,20 @@ exports.chatCompletionsTransformer = {
                     role: "assistant",
                     content: textBlocks.map((c) => c.text).join("\n") || null,
                 };
+                // DeepSeek's thinking mode rejects a conversation whose assistant turns
+                // dropped their reasoning ("The reasoning_content in the thinking mode
+                // must be passed back to the API"), so it has to survive the round trip.
+                // `reasoning_content` is DeepSeek's field name and an accepted alias for
+                // `reasoning` on OpenRouter. Only set it when there is something to send:
+                // servers that reject unknown fields must not start seeing it, and
+                // redacted-only blocks (Anthropic) carry no text to replay.
+                const reasoning = thinkingBlocks
+                    .map((block) => block.thinking)
+                    .filter((thought) => thought.length > 0)
+                    .join("\n");
+                if (reasoning) {
+                    msg.reasoning_content = reasoning;
+                }
                 if (toolUseBlocks.length > 0) {
                     msg.tool_calls = toolUseBlocks.map((block) => ({
                         id: block.id,
@@ -684,6 +699,15 @@ exports.chatCompletionsTransformer = {
      */
     fromProviderMessage(message) {
         const content = [];
+        // Reasoning first, matching the order the model produced it in. Servers
+        // disagree on the field name — OpenRouter sends `reasoning`, DeepSeek and
+        // llama.cpp send `reasoning_content` — so accept either, preferring
+        // `reasoning` as the streaming path does. Stored as the neutral thinking
+        // block the history layer already round-trips for Anthropic.
+        const reasoning = message.reasoning ?? message.reasoning_content;
+        if (typeof reasoning === "string" && reasoning) {
+            content.push((0, types_1.thinking)(reasoning));
+        }
         if (typeof message.content === "string" && message.content) {
             content.push((0, types_1.text)(message.content));
         }