teapot-coding-agent 0.26.8 → 0.26.10

package/dist/agent/agent.js

@@ -191,6 +191,13 @@ export class Agent {
     consecutiveToolErrors = 0;
     /** consecutive round-fatal API errors (drives the retry backoff) */
     consecutiveApiErrors = 0;
+    /**
+     * Consecutive auto-continued rounds that did no work (#106).
+     *
+     * Reset by any tool call, any finish, a stop, or fresh operator input — only a
+     * round that produced neither a tool call nor a finish increments it.
+     */
+    consecutiveIdleRounds = 0;
     constructor(opts) {
         this.opts = {
             progressIntervalMs: 10 * 60_000,
@@ -205,6 +212,8 @@ export class Agent {
             supportedParameters: [],
             maxConsecutiveToolErrors: 5,
             maxTurnsPerRound: 200,
+            // generous: only a model that never acts and never finishes reaches it
+            maxConsecutiveIdleRounds: 50,
             onError: "stop",
             retryDelayMs: 60_000,
             contextTokenBudget: 96_000,
@@ -1145,16 +1154,30 @@ export class Agent {
         // stable id shared by the log event and the UI's pending echo — the UI
         // flips its echo to "sent" when prompt-delivered carries this id back
         const promptId = source === "user" ? `u${Date.now().toString(36)}${Math.random().toString(36).slice(2, 6)}` : "";
+        // #108: the queue entry is registered SYNCHRONOUSLY, before the async work.
+        //
+        // It used to be pushed inside the `.then()`, so it only existed once
+        // `ensureReady()` resolved — while `cancelPrompt` reads the array
+        // synchronously. A cancel issued in that window found nothing, returned null,
+        // got a 409, and the UI discarded the draft: the operator saw a withdrawn
+        // prompt that the model then received and acted on.
+        //
+        // The wide case is worse than the same-tick one: an agent still restoring a
+        // 4,000-event session log holds that promise for real wall-clock time, so the
+        // cancel essentially always loses.
+        //
+        // Registering first is safe because the queue is drained only at a turn
+        // boundary (`drainPendingPrompts`), which cannot run inside this
+        // synchronous stretch. The log append still happens in order, after.
+        const entry = { source, text, images, ...(promptId ? { id: promptId } : {}) };
+        this.pendingPrompts.push(entry);
         void this.ensureReady()
-            .then(() => {
-            this.pendingPrompts.push({ source, text, images, ...(promptId ? { id: promptId } : {}) });
-            return this.log.append("prompt", this.currentSession, this.currentBranch, {
-                source,
-                text,
-                ...(images?.length ? { images: images.map((i) => ({ url: i.url, name: i.name })) } : {}),
-                ...(promptId ? { promptId } : {}),
-            });
-        })
+            .then(() => this.log.append("prompt", this.currentSession, this.currentBranch, {
+            source,
+            text,
+            ...(images?.length ? { images: images.map((i) => ({ url: i.url, name: i.name })) } : {}),
+            ...(promptId ? { promptId } : {}),
+        }))
             .then(() => bus.emit("update", { kind: "agent-update", agentId: this.opts.id }))
             .catch(() => { });
         return promptId;
@@ -1426,6 +1449,11 @@ export class Agent {
                         finished = true; // it IS finished now — don't auto-nudge a reporter
                     }
                 }
+                // #106: a round that did real work resets the idle counter. `finished`
+                // covers the finish() paths; a round that ran tool calls is caught by the
+                // turn counter below, which is checked before this point.
+                if (finished)
+                    this.consecutiveIdleRounds = 0;
                 // auto-continue only makes sense with an active goal to continue toward
                 if (finished ||
                     !this.opts.autoContinue ||
@@ -1437,6 +1465,38 @@ export class Agent {
                 // "Continue working toward the current goal" made a forked sub-agent
                 // re-read its inherited context and drift into one of the parent's
                 // older tasks — it would keep going forever without ever finish()ing.
+                // #106: bound CONSECUTIVE auto-continued rounds.
+                //
+                // maxTurnsPerRound cannot bound this loop, and the reason is structural:
+                // a ROOT agent that answers with a bare message ends its round after ONE
+                // turn (`return finished` in runTurnsUntilIdle), so no single round ever
+                // reaches the per-round cap. `finished` stays false, the goal stays
+                // active, and auto-continue starts the next round — forever.
+                //
+                // Measured: maxTurnsPerRound=40 produced 997 turns and ZERO
+                // `round-turn-cap` notes, because the cap is only ever evaluated once a
+                // round ENDS, and these rounds end at turn 1. A tool-calling model does
+                // trip it (8 turns, 1 note) — the gap is specific to the talk-only shape.
+                //
+                // So the bound belongs here, where the real loop is: consecutive rounds
+                // that produced neither a finish() nor a tool call. Any tool call resets
+                // it — that is real work, not stalling — and so does a stop, a fresh
+                // user prompt, or an operator reply.
+                //
+                // This is a SAFETY VALVE, not a policy. It is deliberately generous
+                // (default 50) because a long autonomous stretch that keeps calling tools
+                // resets the counter on every turn and is never affected; only a model
+                // that never acts and never finishes trips it.
+                if (++this.consecutiveIdleRounds > this.opts.maxConsecutiveIdleRounds) {
+                    this.consecutiveIdleRounds = 0;
+                    await this.log.append("system_note", this.currentSession, this.currentBranch, {
+                        event: "auto-continue-bounded",
+                        rounds: this.opts.maxConsecutiveIdleRounds,
+                        detail: "the agent produced no tool calls and no finish() across this many " +
+                            "consecutive rounds — stopping the loop rather than letting it spin (#106)",
+                    });
+                    break;
+                }
                 await this.sleepInterruptible(this.opts.continueDelayMs);
                 if (this.stopRequested)
                     break;
@@ -1764,7 +1824,18 @@ export class Agent {
                     // answer the tool_call so a follow-up round stays API-valid
                     await this.answerMeta(call, this.goal.status === "done" ? "(goal complete)" : "(round ended)");
                     finished = true;
-                    continue;
+                    // #105: `continue` advanced the TOOL-CALL loop, so every later call in
+                    // this same assistant message still executed — a model emitting
+                    // finish() plus one more call got real filesystem writes AFTER it had
+                    // reported `final: true` and the goal was already done. The parent was
+                    // told the work finished while the workspace was still being mutated.
+                    //
+                    // So finish ends the BATCH: answer anything still outstanding (so no
+                    // tool_call is left unpaired — the provider rejects the next request
+                    // otherwise, #76) and leave the tool loop. The outer loop then returns
+                    // on `finished`.
+                    await this.answerUnansweredToolCalls(m);
+                    return true;
                 }
                 if (call.function.name === "report_progress") {
                     await this.recordProgress(call.function.arguments);
@@ -1981,14 +2052,29 @@ export class Agent {
                     result = { ok: false, result: `tool could not run: ${err.message}` };
                 }
                 this.stats.toolCalls++;
+                // #106: a tool call is real work, so it clears the idle-round counter.
+                this.consecutiveIdleRounds = 0;
+                // #109: ONE clip, applied to BOTH the log and the live message.
+                //
+                // The log stored `result.slice(0, 8000)` while `messages` kept the full
+                // text, and a restore rebuilds `messages` from the log — so a model
+                // resuming work saw a different (and much smaller) tool result than it
+                // had just seen live. Measured: 8000 bytes logged, 436 after restart.
+                //
+                // The 8000-byte log clip is deliberate — it bounds the log file — so the
+                // fix is not to log everything. It is to clip the live message the SAME
+                // way, so the two views agree and a restart is not a silent downgrade.
+                // Restore is byte-exact everywhere else (`answerMeta` preserves its exact
+                // content); this was the one place the replay diverged.
+                const capped = result.result.slice(0, 8000);
                 await this.log.append("tool_result", this.currentSession, this.currentBranch, {
                     callId: call.id,
                     name: call.function.name,
                     ok: result.ok,
                     durationMs: Date.now() - t0,
-                    result: result.result.slice(0, 8000),
+                    result: capped,
                 });
-                this.messages.push({ role: "tool", tool_call_id: call.id, content: result.result });
+                this.messages.push({ role: "tool", tool_call_id: call.id, content: capped });
                 this.consecutiveToolErrors = result.ok ? 0 : this.consecutiveToolErrors + 1;
                 if (this.consecutiveToolErrors >= this.opts.maxConsecutiveToolErrors) {
                     // structured, greppable AND visible: the note carries what failed so

package/dist/server/api.js

@@ -368,7 +368,15 @@ export function buildApp(master) {
     app.get("/api/agents", (c) => c.json({ agents: [...master.agents.values()].map((a) => a.snapshot()) }));
     // create + start an agent on an arbitrary directory
     app.post("/api/agents", async (c) => {
-        const body = await c.req.json();
+        // #110: `.catch(() => null)` like every other body read in this file. An
+        // unparseable body used to throw inside the handler and surface as a bare
+        // 500 — a client bug reported to the operator as a server fault, and it made
+        // the route's own `400 "workspace required"` unreachable.
+        const body = await c.req
+            .json()
+            .catch(() => null);
+        if (!body)
+            return c.json({ error: "invalid JSON" }, 400);
         if (!body.workspace?.trim())
             return c.json({ error: "workspace required" }, 400);
         const ws = resolveWorkspace(body.workspace, path.dirname(master.configPath));
@@ -757,7 +765,11 @@ export function buildApp(master) {
         const a = master.agents.get(c.req.param("id"));
         if (!a)
             return c.json({ error: "not found" }, 404);
-        const body = await c.req.json();
+        const body = await c.req
+            .json()
+            .catch(() => null); // #110
+        if (!body)
+            return c.json({ error: "invalid JSON" }, 400);
         if (!body.text?.trim() && !body.images?.length)
             return c.json({ error: "text or images required" }, 400);
         // validate images: data URLs or http(s), size-capped (a 20MB base64 blob
@@ -782,7 +794,9 @@ export function buildApp(master) {
         const a = master.agents.get(c.req.param("id"));
         if (!a)
             return c.json({ error: "not found" }, 404);
-        const body = await c.req.json();
+        const body = await c.req.json().catch(() => null); // #110
+        if (!body)
+            return c.json({ error: "invalid JSON" }, 400);
         if (!body.promptId)
             return c.json({ error: "promptId required" }, 400);
         const text = a.cancelPrompt(body.promptId);
@@ -864,7 +878,10 @@ export function buildApp(master) {
         const a = master.agents.get(c.req.param("id"));
         if (!a)
             return c.json({ error: "not found" }, 404);
-        const body = await c.req.json();
+        const body = await c.req.json()
+            .catch(() => null); // #110
+        if (!body)
+            return c.json({ error: "invalid JSON" }, 400);
         if (body.text) {
             await a.setGoal(body.text);
             if (typeof body.verify === "string" && body.verify.trim())

package/package.json

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