teapot-coding-agent 0.37.50 → 0.37.53

package/dist/agent/agent.js

@@ -933,14 +933,6 @@ export class Agent {
             // `needs_operator` snapshot reported `live: false` until this was added.
             this.status === "needs_operator");
     }
-    /**
-     * Is this agent doing in-flight work that a WAITER (wait_children) should
-     * hold for? Deliberately narrower than isLive(): queued prompts are DORMANT
-     * work (a stopped/idle child touches them only after it is started), so
-     * they must not keep a parent parked on a child that is visibly idle —
-     * that wait would hang. isLive() answers "stop vs start" (#59/#133); this
-     * answers "is work in flight".
-     */
     /**
      * The text of every prompt still waiting for a turn boundary.
      *
@@ -951,6 +943,14 @@ export class Agent {
     pendingPromptTexts() {
         return this.pendingPrompts.map((p) => p.text);
     }
+    /**
+     * Is this agent doing in-flight work that a WAITER (wait_children) should
+     * hold for? Deliberately narrower than isLive(): queued prompts are DORMANT
+     * work (a stopped/idle child touches them only after it is started), so
+     * they must not keep a parent parked on a child that is visibly idle —
+     * that wait would hang. isLive() answers "stop vs start" (#59/#133); this
+     * answers "is work in flight".
+     */
     isBusy() {
         if (this.stopRequested)
             return false;
@@ -1080,11 +1080,6 @@ export class Agent {
             bus.emit("update", { kind: "agent-update", agentId: this.opts.id });
         }
     }
-    /**
-     * Restore the conversation from the JSONL log exactly once, on demand.
-     * Everything that touches history (prompts, start, fork, UI selection)
-     * funnels through here; boot stays cheap no matter how many sessions exist.
-     */
     /**
      * Resolve the session/workspace this agent operates on.
      *
@@ -1255,16 +1250,6 @@ export class Agent {
             /* keep the session copy if the agent-wide write failed — losing notes is worse */
         }
     }
-    /**
-     * Rebuild the in-memory conversation from the JSONL event log so a restart
-     * continues where the agent left off instead of starting blank.
-     *
-     * Strategy: find the most recent event overall (its branch is where the
-     * agent was), walk the `parent` chain backwards (crossing fork points),
-     * then replay events forward into ChatMessages. Meta-tool calls
-     * (finish / report_progress) never produced logged tool results, so we
-     * synthesize their responses to keep the message sequence valid.
-     */
     /**
      * Resolve a leading sub_fork header: load the parent session's file (and
      * recurse if THAT one is itself a sub_fork), take its lineage up to the
@@ -1306,6 +1291,17 @@ export class Agent {
             prefix.shift();
         return [...prefix, ...own.filter((e) => e !== header)];
     }
+    /**
+     * Restore the conversation from the JSONL log exactly once, on demand.
+     * Everything that touches history (prompts, start, fork, UI selection)
+     * funnels through here; boot stays cheap no matter how many sessions exist.
+     *
+     * Strategy: find the most recent event overall (its branch is where the
+     * agent was), walk the `parent` chain backwards (crossing fork points),
+     * then replay events forward into ChatMessages. Meta-tool calls
+     * (finish / report_progress) never produced logged tool results, so we
+     * synthesize their responses to keep the message sequence valid.
+     */
     async restoreFromLog() {
         const own = await readEvents(this.log.filePath);
         if (own.length === 0)
@@ -1620,14 +1616,6 @@ export class Agent {
         await fs.writeFile(this.todoFile, text, "utf8");
         await this.log.append("todo", this.currentSession, this.currentBranch, { event: "set", by });
     }
-    /**
-     * Update SPECIFIC checkbox items without rewriting the whole list — the
-     * full-replacement path made agents lazy (a mid-task progress tick meant
-     * re-emitting the entire markdown, so they skipped updates) and risky (one
-     * sloppy regeneration mangled unrelated sections). Items are matched by
-     * normalized text; unknown items are reported back instead of silently
-     * dropped. Returns a short human-readable summary for the tool result.
-     */
     /**
      * Apply surgical changes to todo.md.
      *

package/dist/agent/mcp-registry.js

@@ -176,8 +176,31 @@ export class McpRegistry {
             st.status = "disabled";
             return st;
         }
-        if (st.status === "connected" && st.connection)
-            return st;
+        if (st.status === "connected" && st.connection) {
+            /**
+             * A cached connection is not proof the server is still there.
+             *
+             * This used to return immediately, so a server that restarted kept `status: "connected"` with
+             * its OLD tool list while the transport underneath was dead. The UI's `test` button opened a
+             * FRESH connection (`testConfig`), so it reported success and the tools appeared — and the
+             * agent, going through this cached path, could not call any of them. Reported as "test をすると
+             * 接続に成功するのに、エージェントからは呼べない".
+             *
+             * A cheap liveness probe settles it: a server that answers is reused, one that does not is
+             * dropped so the reconnect below builds a new transport. `tools()` is the cheapest call that
+             * exercises the transport for real (unlike reading the cached list).
+             */
+            try {
+                st.tools = await st.connection.tools();
+                st.lastChecked = Date.now();
+                return st;
+            }
+            catch {
+                st.connection = undefined;
+                st.tools = [];
+                st.status = "disconnected";
+            }
+        }
         st.status = "connecting";
         st.lastError = undefined;
         const auth = await this.authFor(name);
@@ -254,6 +277,22 @@ export class McpRegistry {
             return { ok: r.ok, text: r.text };
         }
         catch (err) {
+            /**
+             * A failed call means the transport is suspect, not just this one call.
+             *
+             * Leaving `status: "connected"` made the next attempt reuse the same dead connection, so one
+             * server restart broke every subsequent call until the process restarted. Dropping the
+             * connection here lets `connect()` rebuild it on the next attempt — and the tools list is
+             * cleared with it, because a stale list is what let the UI show tools that could not be called.
+             */
+            const st = this.servers.get(parts.server);
+            if (st) {
+                st.connection = undefined;
+                st.tools = [];
+                st.status = "disconnected";
+                st.lastError = err.message;
+                st.lastChecked = Date.now();
+            }
             return { ok: false, text: `MCP call failed: ${err.message}` };
         }
     }

package/package.json

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