@agentionai/agents 1.0.2 → 1.1.0

package/dist/agents/Agent.d.ts

@@ -35,7 +35,7 @@ type LlamaCppAgentConfig = Omit<BaseAgentConfig, "vendor" | "model"> & {
 };
 type AgentConfig = ClaudeAgentConfig | OpenAIAgentConfig | GeminiAgentConfig | MistralAgentConfig | OllamaAgentConfig | LlamaCppAgentConfig;
 export declare class Agent {
-    static create(config: AgentConfig, history?: History): ClaudeAgent | GeminiAgent | OpenAiAgent | MistralAgent | OllamaAgent | LlamaCppAgent;
+    static create(config: AgentConfig, history?: History): ClaudeAgent | GeminiAgent | MistralAgent | OllamaAgent | LlamaCppAgent | OpenAiAgent<(string & {}) | "gpt-5-pro" | "gpt-5.2-pro" | "gpt-5.4-pro" | "gpt-5.5-pro" | "o1" | "o1-pro" | "o3" | "o3-mini" | "o4-mini" | "gpt-5" | "gpt-5-mini" | "gpt-5-nano" | "gpt-5.1" | "gpt-5.2" | "gpt-5.4" | "gpt-5.4-mini" | "gpt-5.4-nano" | "gpt-5.5" | "gpt-5.6" | "gpt-5.6-sol" | "gpt-5.6-terra" | "gpt-5.6-luna" | "gpt-4.1" | "gpt-4.1-mini" | "gpt-4.1-nano" | "gpt-4o" | "gpt-4o-mini" | "gpt-4o-2024-11-20" | "gpt-4o-2024-08-06" | "gpt-4o-2024-05-13" | "gpt-4o-mini-2024-07-18" | "gpt-4-turbo" | "gpt-4-turbo-2024-04-09" | "gpt-4-turbo-preview" | "gpt-4-0125-preview" | "gpt-4-1106-preview" | "gpt-4" | "gpt-4-0613" | "gpt-3.5-turbo" | "gpt-3.5-turbo-0125" | "gpt-3.5-turbo-1106" | "o1-preview" | "o1-mini">;
 }
 export {};
 //# sourceMappingURL=Agent.d.ts.map

package/dist/agents/AgentConfig.d.ts

@@ -1,6 +1,7 @@
 import { Tool } from "../tools/Tool";
 import { BuiltInTool } from "../tools/BuiltInTool";
 import { BaseAgent } from "./BaseAgent";
+import type { ReasoningEffort } from "./model-types";
 /** Supported LLM vendors */
 export type AgentVendor = "openai" | "anthropic" | "mistral" | "gemini" | "ollama" | "llamacpp";
 /**
@@ -84,13 +85,28 @@ export interface ClaudeSpecificConfig {
      */
     thinkingBudgetTokens?: number;
 }
+/**
+ * How much the model should think before answering, for OpenAI reasoning models.
+ *
+ * Which values a given model accepts is **model-dependent**; see
+ * {@link ReasoningEffortFor} for the per-model set and
+ * {@link OPENAI_REASONING_SUPPORT} for the verified matrix.
+ */
+export type { ReasoningEffort, ReasoningEffortFor } from "./model-types";
 /**
  * Vendor-specific configuration for OpenAI
  */
 export interface OpenAISpecificConfig {
     disableParallelToolUse?: boolean;
+    /**
+     * Ask for the least reasoning the configured model supports.
+     *
+     * Resolved per model family — there is no single "off" value. Has no effect on
+     * models that do not support `reasoning.effort` at all. Takes precedence over
+     * {@link OpenAISpecificConfig.reasoningEffort}.
+     */
     disableReasoning?: boolean;
-    reasoningEffort?: "low" | "medium" | "high";
+    reasoningEffort?: ReasoningEffort;
     seed?: number;
     user?: string;
 }

package/dist/agents/model-types.d.ts

@@ -39,5 +39,81 @@ export type LlamaCppModel = "default" | "gpt-oss-20b" | "gpt-oss-120b" | "llama-
  * You can also provide any custom string for newer models not yet listed.
  * @see https://platform.openai.com/docs/models
  */
-export type OpenAIModel = "gpt-5.2" | "gpt-5" | "gpt-4.1" | "gpt-5-mini" | "gpt-5-nano" | "gpt-4o" | "gpt-4o-mini" | "gpt-4o-2024-11-20" | "gpt-4o-2024-08-06" | "gpt-4o-2024-05-13" | "gpt-4o-mini-2024-07-18" | "gpt-4-turbo" | "gpt-4-turbo-2024-04-09" | "gpt-4-turbo-preview" | "gpt-4-0125-preview" | "gpt-4-1106-preview" | "gpt-4" | "gpt-4-0613" | "gpt-3.5-turbo" | "gpt-3.5-turbo-0125" | "gpt-3.5-turbo-1106" | "o1" | "o1-preview" | "o1-mini" | "o3-mini" | (string & {});
+export type OpenAIModel = OpenAIReasoningModel | "gpt-4.1" | "gpt-4.1-mini" | "gpt-4.1-nano" | "gpt-4o" | "gpt-4o-mini" | "gpt-4o-2024-11-20" | "gpt-4o-2024-08-06" | "gpt-4o-2024-05-13" | "gpt-4o-mini-2024-07-18" | "gpt-4-turbo" | "gpt-4-turbo-2024-04-09" | "gpt-4-turbo-preview" | "gpt-4-0125-preview" | "gpt-4-1106-preview" | "gpt-4" | "gpt-4-0613" | "gpt-3.5-turbo" | "gpt-3.5-turbo-0125" | "gpt-3.5-turbo-1106" | "o1-preview" | "o1-mini" | (string & {});
+/**
+ * Every value the Responses API's `reasoning.effort` parameter defines.
+ *
+ * Which subset a given model accepts is model-dependent — see
+ * {@link OPENAI_REASONING_SUPPORT} and {@link ReasoningEffortFor}.
+ */
+export type ReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+/**
+ * Which reasoning efforts each OpenAI model accepts.
+ *
+ * There is no universal set and no universal "off" value: the families reject
+ * each other's minimum (`none` is rejected before `gpt-5.1`, `minimal` is
+ * rejected from `gpt-5.1` on, o-series takes neither), and `pro` variants drop
+ * the lower end. `effort: null` is not an off switch either — it means *unset*,
+ * so the model applies its own default.
+ *
+ * Each group's `efforts` are ordered lowest-first, so `efforts[0]` is the least
+ * reasoning that family will do.
+ *
+ * Every row was verified against the live Responses API on 2026-08-05. Models not
+ * listed here — non-reasoning models, and families released after this table was
+ * written — accept no `reasoning.effort` guess, so callers fall back to the full
+ * {@link ReasoningEffort} union and the runtime helper omits the parameter.
+ */
+export declare const OPENAI_REASONING_SUPPORT: readonly [{
+    readonly models: readonly ["gpt-5-pro"];
+    readonly efforts: readonly ["high"];
+}, {
+    readonly models: readonly ["gpt-5.2-pro", "gpt-5.4-pro", "gpt-5.5-pro"];
+    readonly efforts: readonly ["medium", "high", "xhigh"];
+}, {
+    readonly models: readonly ["o1", "o1-pro", "o3", "o3-mini", "o4-mini"];
+    readonly efforts: readonly ["low", "medium", "high"];
+}, {
+    readonly models: readonly ["gpt-5", "gpt-5-mini", "gpt-5-nano"];
+    readonly efforts: readonly ["minimal", "low", "medium", "high"];
+}, {
+    readonly models: readonly ["gpt-5.1"];
+    readonly efforts: readonly ["none", "low", "medium", "high"];
+}, {
+    readonly models: readonly ["gpt-5.2", "gpt-5.4", "gpt-5.4-mini", "gpt-5.4-nano", "gpt-5.5"];
+    readonly efforts: readonly ["none", "low", "medium", "high", "xhigh"];
+}, {
+    readonly models: readonly ["gpt-5.6", "gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna"];
+    readonly efforts: readonly ["none", "low", "medium", "high", "xhigh", "max"];
+}];
+type ReasoningGroup = (typeof OPENAI_REASONING_SUPPORT)[number];
+/** Every OpenAI model known to accept `reasoning.effort`. */
+export type OpenAIReasoningModel = ReasoningGroup["models"][number];
+/**
+ * Strip a dated snapshot suffix (`gpt-5-nano-2025-08-07` → `gpt-5-nano`) so
+ * pinned model ids resolve to the same support set as their alias. Snapshots
+ * always start `-20`, which keeps `gpt-5-mini` from looking like a snapshot of
+ * `gpt-5`.
+ */
+type BaseModel<M extends string> = M extends `${infer Base}-20${string}` ? Base : M;
+type EffortsOf<M extends string, G = ReasoningGroup> = G extends {
+    models: readonly (infer Models)[];
+    efforts: readonly (infer Efforts)[];
+} ? BaseModel<M> extends Models ? Efforts : never : never;
+/**
+ * The reasoning efforts a given model accepts.
+ *
+ * Resolves to the exact set for every model in {@link OPENAI_REASONING_SUPPORT},
+ * and to the full {@link ReasoningEffort} union for anything else — an unknown or
+ * newer model should not be blocked by a table that has gone stale.
+ *
+ * @example
+ * ```typescript
+ * type A = ReasoningEffortFor<"gpt-5-nano">;  // "minimal" | "low" | "medium" | "high"
+ * type B = ReasoningEffortFor<"gpt-5.6-sol">; // adds "none", "xhigh", "max"; no "minimal"
+ * type C = ReasoningEffortFor<"gpt-5-pro">;   // "high"
+ * ```
+ */
+export type ReasoningEffortFor<M extends string> = [EffortsOf<M>] extends [never] ? ReasoningEffort : EffortsOf<M>;
+export {};
 //# sourceMappingURL=model-types.d.ts.map

package/dist/agents/model-types.js

@@ -5,4 +5,37 @@
  * All types also accept custom string values for new/unlisted models.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.OPENAI_REASONING_SUPPORT = void 0;
+/**
+ * Which reasoning efforts each OpenAI model accepts.
+ *
+ * There is no universal set and no universal "off" value: the families reject
+ * each other's minimum (`none` is rejected before `gpt-5.1`, `minimal` is
+ * rejected from `gpt-5.1` on, o-series takes neither), and `pro` variants drop
+ * the lower end. `effort: null` is not an off switch either — it means *unset*,
+ * so the model applies its own default.
+ *
+ * Each group's `efforts` are ordered lowest-first, so `efforts[0]` is the least
+ * reasoning that family will do.
+ *
+ * Every row was verified against the live Responses API on 2026-08-05. Models not
+ * listed here — non-reasoning models, and families released after this table was
+ * written — accept no `reasoning.effort` guess, so callers fall back to the full
+ * {@link ReasoningEffort} union and the runtime helper omits the parameter.
+ */
+exports.OPENAI_REASONING_SUPPORT = [
+    { models: ["gpt-5-pro"], efforts: ["high"] },
+    { models: ["gpt-5.2-pro", "gpt-5.4-pro", "gpt-5.5-pro"], efforts: ["medium", "high", "xhigh"] },
+    { models: ["o1", "o1-pro", "o3", "o3-mini", "o4-mini"], efforts: ["low", "medium", "high"] },
+    { models: ["gpt-5", "gpt-5-mini", "gpt-5-nano"], efforts: ["minimal", "low", "medium", "high"] },
+    { models: ["gpt-5.1"], efforts: ["none", "low", "medium", "high"] },
+    {
+        models: ["gpt-5.2", "gpt-5.4", "gpt-5.4-mini", "gpt-5.4-nano", "gpt-5.5"],
+        efforts: ["none", "low", "medium", "high", "xhigh"],
+    },
+    {
+        models: ["gpt-5.6", "gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna"],
+        efforts: ["none", "low", "medium", "high", "xhigh", "max"],
+    },
+];
 //# sourceMappingURL=model-types.js.map

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,8 +53,14 @@ 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;
@@ -37,8 +68,25 @@ export declare class OpenAiAgent extends BaseAgent {
     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,6 +103,37 @@ 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 "";
     }
@@ -120,8 +176,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);
@@ -242,13 +297,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);
@@ -419,12 +468,7 @@ 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) {

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

@@ -323,6 +323,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) {
@@ -347,6 +348,10 @@ class OpenAICompatibleAgent extends BaseAgent_1.BaseAgent {
             const deltaExtras = delta;
             const reasoningDelta = (deltaExtras.reasoning ?? deltaExtras.reasoning_content);
             if (reasoningDelta) {
+                // 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 +394,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 +407,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);

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));
         }