teapot-coding-agent 0.37.78 → 0.37.80

package/dist/agent/agent.js

@@ -1807,6 +1807,15 @@ export class Agent {
                 await this.log.append("usage", this.currentSession, this.currentBranch, res.usage);
             }
             const m = res.message;
+            /**
+             * Carry the thinking on the message itself, not only in the log.
+             *
+             * `res.reasoning` was written to `chat.jsonl` and then dropped: `this.messages.push(m)` stored a
+             * message with no reasoning, so the NEXT request sent back an assistant turn with its thinking
+             * missing. Providers that require it (Beam, #187) answered 400; the rest simply lost the thread.
+             */
+            if (res.reasoning && !m.reasoning)
+                m.reasoning = res.reasoning;
             const isPlaceholder = m.content === "(tool call)" || m.content === "(no content)";
             await this.log.append("message", this.currentSession, this.currentBranch, {
                 role: "assistant",
@@ -2334,6 +2343,9 @@ export class Agent {
         resetToolCatalog(this.toolCtx);
         const res = await this.llmCall(this.buildMessages(), allToolSpecs());
         const calls = res.message.tool_calls ?? [];
+        // same rule as the main loop: the thinking belongs to the message it came with (#187)
+        if (res.reasoning && !res.message.reasoning)
+            res.message.reasoning = res.reasoning;
         this.messages.push(res.message);
         await this.log.append("message", this.currentSession, this.currentBranch, {
             role: "assistant",
@@ -2993,7 +3005,13 @@ async function rebuildMessagesFrom(list, imagesDir) {
             const hasCalls = Array.isArray(d.toolCalls) && d.toolCalls.length > 0;
             if (role === "assistant" && !content && !hasCalls)
                 continue;
-            const m = { role, content };
+            const m = {
+                role,
+                content,
+                ...(role === "assistant" && typeof d.reasoning === "string" && d.reasoning
+                    ? { reasoning: d.reasoning }
+                    : {}),
+            };
             if (hasCalls) {
                 m.tool_calls = d.toolCalls.map((c) => ({
                     id: c.id,

package/dist/agent/llm.js

@@ -188,7 +188,11 @@ function issuedBefore(messages, result) {
     }
     return false;
 }
-function sanitize(messages) {
+/** the field name this provider uses for a turn's thinking */
+export function reasoningSpelling(supported) {
+    return supported?.includes("reasoning") ? "plain" : "content";
+}
+function sanitize(messages, supported) {
     return repairToolPairing(messages).map((m) => {
         if (m.content_parts?.length) {
             const parts = m.content_parts.map((p) => p.type === "image_url"
@@ -208,7 +212,7 @@ function sanitize(messages) {
             // `content_parts` is OUR field, carrying the parts into `content`; sending it upstream is an
             // unknown property (a strict server rejects the request), so it is dropped here.
             const { content_parts: _parts, ...rest } = m;
-            return { ...rest, content: parts };
+            return withReasoning({ ...rest, content: parts }, reasoningSpelling(supported));
         }
         if ((m.role === "user" || m.role === "assistant") && !m.content) {
             return { ...m, content: m.tool_calls?.length ? "(tool call)" : "(no content)" };
@@ -216,9 +220,51 @@ function sanitize(messages) {
         if (m.role === "tool" && typeof m.content !== "string") {
             return { ...m, content: String(m.content ?? "(no output)") };
         }
-        return { ...m };
+        return withReasoning({ ...m }, reasoningSpelling(supported));
     });
 }
+/**
+ * Send an assistant turn's thinking back as `reasoning_content`.
+ *
+ * WHY THIS EXISTS AT ALL: providers disagree on the spelling. MEASURED (commit 880d054, #153):
+ *
+ *     OpenRouter (nemotron)      -> `reasoning`
+ *     commandcode (deepseek)     -> `reasoning_content`
+ *
+ * so the READ side accepts either (`reasoningTextOf`). The WRITE side cannot guess: OpenRouter rejects
+ * a field it does not know, and a reasoning model reached through Command Code REQUIRES
+ * `reasoning_content` on EVERY earlier assistant turn (#187).
+ *
+ * WHY THE EMPTY-STRING CASE: a turn whose thinking the provider never returned (or that was compacted
+ * away) still has to carry the field, because these providers check PRESENCE across the whole history,
+ * not just the turns that had thinking. MEASURED — this is what `ClawRouter` does after hitting the
+ * same wall: patch EVERY assistant message with `reasoning_content: ""` when it is absent, because
+ * "reasoning models require it on every assistant turn in history, not just tool-call turns".
+ *
+ * Only assistant messages get it: a user prompt or a tool result has no thinking, and a stray field
+ * there is noise.
+ */
+function withReasoning(m, spell) {
+    if (m.role !== "assistant")
+        return m;
+    const r = typeof m.reasoning === "string" ? m.reasoning : undefined;
+    // `reasoning` is OUR field; it travels under the provider's spelling, so the original is dropped
+    const { reasoning: _r, ...rest } = m;
+    /**
+     * WHICH SPELLING is decided by what the provider ADVERTISES, and that is measurable.
+     *
+     * MEASURED on `/models`:
+     *   OpenRouter  -> `supported_parameters` includes `reasoning` and `include_reasoning`
+     *   CommandCode -> no `supported_parameters` at all
+     *
+     * `reasoning` is what OpenRouter understands (and it rejects a key it does not know), while Command
+     * Code / DeepSeek requires `reasoning_content`. So: advertised `reasoning` → use `reasoning`; silence
+     * → `reasoning_content`, the DeepSeek-family spelling that is far more common among OpenAI-compatible
+     * servers.
+     */
+    const key = spell === "plain" ? "reasoning" : "reasoning_content";
+    return { ...rest, [key]: r ?? "" };
+}
 function reasoningTextOf(m) {
     for (const key of ["reasoning", "reasoning_content"]) {
         const v = m?.[key];
@@ -270,7 +316,7 @@ export async function chat(cfg, messages, tools, signal, onDelta) {
     try {
         const { value: res } = await withKeyRotation(cfg, (c) => client(c).chat.completions.create({
             model: c.model,
-            messages: sanitize(messages),
+            messages: sanitize(messages, cfg.supportedParameters),
             ...(tools.length ? { tools } : {}),
             ...effortForRequest(c),
             ...cacheControlForRequest(c),
@@ -346,7 +392,7 @@ export async function chatStream(cfg, messages, tools, signal, onDelta) {
     try {
         const { value: stream } = await withKeyRotation(cfg, (c) => client(c).chat.completions.create({
             model: c.model,
-            messages: sanitize(messages),
+            messages: sanitize(messages, cfg.supportedParameters),
             ...(tools.length ? { tools } : {}),
             ...effortForRequest(c),
             ...cacheControlForRequest(c),

package/dist/master.js

@@ -664,6 +664,8 @@ export class Master {
             ...(ac.chatFn ? { chatFn: ac.chatFn } : {}),
             ...(ac.reasoningEffort ? { reasoningEffort: ac.reasoningEffort } : {}),
             ...(modelMeta?.supportedEfforts?.length ? { supportedEfforts: modelMeta.supportedEfforts } : {}),
+            // decides the spelling of a turn's thinking on the wire (#187)
+            ...(modelMeta?.supportedParameters?.length ? { supportedParameters: modelMeta.supportedParameters } : {}),
         });
         void fetchModelList(llm.baseUrl, llm.apiKey)
             .then((list) => agent.setModelPricing(list.find((m) => m.id === llm.model)?.pricing))
@@ -1457,6 +1459,7 @@ When this task is done (or truly blocked), call finish() with a summary for @${p
                 cfgEntry.reasoningEffort = opts.opts.reasoningEffort || undefined;
         }
         opts.opts.supportedEfforts = meta?.supportedEfforts;
+        opts.opts.supportedParameters = meta?.supportedParameters;
         if (!llm.model)
             throw new Error("no model resolved (pass model or set one on the provider)");
         if (!llm.baseUrl)

package/dist/model-meta.js

@@ -231,6 +231,7 @@ async function fetchProviderModels(baseUrl, apiKey) {
             ...(ctx !== undefined ? { contextLength: ctx } : {}),
             ...(input ? { modalities: { input, output: output ?? ["text"] } } : {}),
             ...(params?.some((p) => p === "reasoning" || p === "reasoning_effort") ? { reasoning: true } : {}),
+            ...(params ? { supportedParameters: params } : {}),
         });
     }
     return out.length ? out : null;
@@ -251,6 +252,9 @@ function mergeMeta(own, db) {
          * effort LEVELS, only that reasoning exists. `own.reasoning` still wins for the yes/no question.
          */
         ...(db.supportedEfforts ? { supportedEfforts: db.supportedEfforts } : {}),
+        ...(own.supportedParameters ?? db.supportedParameters
+            ? { supportedParameters: own.supportedParameters ?? db.supportedParameters }
+            : {}),
         ...(own.reasoning ?? db.reasoning ? { reasoning: own.reasoning ?? db.reasoning } : {}),
         ...(db.pricing ? { pricing: db.pricing } : {}),
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teapot-coding-agent",
-  "version": "0.37.78",
+  "version": "0.37.80",
   "description": "A lightweight, always-on multi-agent harness for AI coding agents",
   "type": "module",
   "license": "AGPL-3.0-or-later",