talon-agent 3.23.0 → 3.24.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "talon-agent",
-  "version": "3.23.0",
+  "version": "3.24.0",
   "description": "Multi-frontend AI agent with full tool access, streaming, cron jobs, and plugin system",
   "author": "Dylan Neve",
   "license": "MIT",

package/src/backend/codex/discovery.ts

@@ -90,7 +90,14 @@ interface CodexCacheFile {
 
 /** Where the Codex CLI writes its model cache. Exported for tests. */
 export function getCodexCachePath(): string {
-  return join(homedir(), ".codex", "models_cache.json");
+  // Honor CODEX_HOME like token-usage.ts and plan-usage.ts do — the CLI
+  // itself relocates with it, so a pinned deployment would otherwise
+  // read a cache the CLI never writes. (Also what lets tests fake the
+  // path under bun, whose os.homedir() ignores $HOME.)
+  const home = process.env.CODEX_HOME?.trim();
+  return home && home.length > 0
+    ? join(home, "models_cache.json")
+    : join(homedir(), ".codex", "models_cache.json");
 }
 
 /** Default soft timeout when callers await an in-flight discovery. */

package/src/core/engine/gateway.ts

@@ -596,16 +596,28 @@ export class Gateway {
         resolve();
         return;
       }
-      this.server.close(() => {
+      const server = this.server;
+      const settle = (): void => {
         this.server = null;
         this.port = 0;
         resolve();
+      };
+      // Bun's closeAllConnections() (≤1.3.x) doesn't sever live SSE
+      // streams, so close()'s callback can never fire there and stop()
+      // would hang shutdown (and every test teardown). Resolve on a
+      // deadline either way: by then no new connections are accepted,
+      // and the process this runs in is exiting anyway.
+      const deadline = setTimeout(settle, 2_000);
+      deadline.unref?.();
+      server.close(() => {
+        clearTimeout(deadline);
+        settle();
       });
       // `close()` only stops NEW connections; MCP hub sessions hold
       // long-lived SSE streams that would keep the close callback from
       // ever firing. Terminate them — everything on this server is
       // localhost request/response or SSE, safe to drop at stop time.
-      this.server.closeAllConnections();
+      server.closeAllConnections();
     });
   }
 }

package/src/core/errors.ts

@@ -18,6 +18,10 @@ type ErrorReason =
   | "bad_request"
   | "forbidden"
   | "telegram_api"
+  // The user stopped the turn (/stop, talon kill). Not a fault: the
+  // frontends deliver nothing for it — the stop acknowledgement already
+  // told the user what happened.
+  | "stopped"
   | "unknown";
 
 /**
@@ -342,6 +346,7 @@ const FRIENDLY_MESSAGES: Record<ErrorReason, string> = {
   bad_request: "Something went wrong. Try /reset if this keeps happening.",
   forbidden: "Permission denied for this action.",
   telegram_api: "Telegram API error. Try again.",
+  stopped: "⏹ Stopped.",
   unknown: "Something went wrong. Try again or /reset.",
 };
 

package/src/core/tools/bridge.ts

@@ -6,6 +6,7 @@
  */
 
 import { Agent, fetch as undiciFetch } from "undici";
+import { isBunRuntime } from "../../util/runtime.js";
 import type { BridgeFunction } from "./types.js";
 
 /** Default wall-clock budget for a bridge action. */
@@ -95,8 +96,13 @@ export function createBridge(
       json(): Promise<unknown>;
     };
     try {
+      // Bun has no 300s header watchdog and aliases the npm undici
+      // module to its own internals (so the Agent knobs do nothing
+      // there anyway) — its global fetch serves long-haul calls fine,
+      // governed by the AbortSignal alone. The undici detour is a
+      // Node-only workaround.
       resp =
-        timeoutMs > BUILTIN_FETCH_HEADERS_CEILING_MS
+        timeoutMs > BUILTIN_FETCH_HEADERS_CEILING_MS && !isBunRuntime()
           ? await undiciFetch(`${bridgeUrl}/action`, {
               ...init,
               dispatcher: dispatcher(),

package/src/core/weaver/weaver.ts

@@ -24,6 +24,7 @@ import type { ContextManager, ExecuteParams, ExecuteResult } from "../types.js";
 import { bus } from "../bus/index.js";
 import { taskTable, type TaskHandle } from "../tasks/index.js";
 import { log, logDebug, logWarn } from "../../util/log.js";
+import { TalonError } from "../errors.js";
 import { Loom } from "./loom.js";
 import { carryTurnEvents } from "./shuttle.js";
 import type { Thread, ThreadSnapshot } from "./thread.js";
@@ -141,6 +142,16 @@ export class Weaver {
       return result;
     } catch (err) {
       task.fail(err);
+      if (lifecycle.killed) {
+        // The backend didn't manage a clean interrupt-completion (some
+        // SDK versions surface an interrupted turn as an error result).
+        // The user asked for this outcome — don't let it unwind as a
+        // fault the frontend then reports to the chat.
+        throw new TalonError("Turn stopped by user", {
+          reason: "stopped",
+          cause: err,
+        });
+      }
       throw err;
     } finally {
       this.activeCount--;

package/src/frontend/discord/commands/session.ts

@@ -108,6 +108,7 @@ export async function handleStatus(
     `**Workspace**  ${formatBytes(s.diskBytes)}`,
     `**Session**   ${s.sessionName ? `"${s.sessionName}" ` : ""}${s.sessionId ? "`" + s.sessionId.slice(0, 8) + "...`" : "_(new)_"} · ${s.sessionAge} old`,
     `**Uptime**    ${s.uptime} · ${s.activeSessionCount} active session${s.activeSessionCount === 1 ? "" : "s"}`,
+    `**Runtime**   ${s.runtime} · ${formatBytes(s.rssBytes)} RSS`,
   ];
   await i.editReply(lines.join("\n"));
 }

package/src/frontend/discord/handlers/queue.ts

@@ -93,6 +93,13 @@ async function flushQueue(chatId: string): Promise<void> {
     recordMessageProcessed();
   } catch (err) {
     const classified = classify(err);
+    // A user-initiated /stop is an outcome, not a fault — the stop command
+    // already acknowledged it; don't re-report it as an error.
+    if (classified.reason === "stopped") {
+      log("bot", `[${chatId}] turn stopped by user`);
+      recordMessageSettled();
+      return;
+    }
     const promptPreview = combinedPrompt.slice(0, 100).replace(/\n/g, " ");
     logError(
       "bot",

package/src/frontend/shared/session-status.ts

@@ -88,6 +88,10 @@ export interface SessionStatusData {
   sessionId: string | undefined;
   uptime: string;
   activeSessionCount: number;
+  /** Runtime name + version, e.g. "Bun 1.3.9" or "Node 24.4.0". */
+  runtime: string;
+  /** Daemon resident set size, in bytes. */
+  rssBytes: number;
 }
 
 /**
@@ -202,5 +206,9 @@ export async function collectSessionStatus(
     sessionId: info.sessionId,
     uptime: formatDuration(process.uptime() * 1000),
     activeSessionCount: getActiveSessionCount(),
+    runtime: process.versions.bun
+      ? `Bun ${process.versions.bun}`
+      : `Node ${process.versions.node}`,
+    rssBytes: process.memoryUsage().rss,
   };
 }

package/src/frontend/telegram/commands/session.ts

@@ -90,6 +90,7 @@ export function registerSessionCommands(
       `<b>Workspace</b>  ${formatBytes(s.diskBytes)}`,
       `<b>Session</b>   ${s.sessionName ? `"${escapeHtml(s.sessionName)}" ` : ""}${s.sessionId ? "<code>" + escapeHtml(s.sessionId.slice(0, 8)) + "...</code>" : "<i>(new)</i>"} · ${s.sessionAge} old`,
       `<b>Uptime</b>    ${s.uptime} · ${s.activeSessionCount} active session${s.activeSessionCount === 1 ? "" : "s"}`,
+      `<b>Runtime</b>   ${escapeHtml(s.runtime)} · ${formatBytes(s.rssBytes)} RSS`,
     ];
     await ctx.reply(lines.join("\n"), { parse_mode: "HTML" });
   });

package/src/frontend/telegram/handlers/queue.ts

@@ -188,6 +188,15 @@ async function flushQueue(chatId: string): Promise<void> {
     recordMessageProcessed();
   } catch (err) {
     const classified = classify(err);
+    // A user-initiated /stop is an outcome, not a fault: the stop command
+    // already acknowledged it, so delivering the unwound turn's error here
+    // would just contradict that with noise.
+    if (classified.reason === "stopped") {
+      log("bot", `[${chatId}] turn stopped by user`);
+      lastHandledMessageIdByChat.set(chatId, last.messageId);
+      recordMessageSettled();
+      return;
+    }
     const chatType = last.isGroup ? "group" : "DM";
     const promptPreview = promptWithContext.slice(0, 100).replace(/\n/g, " ");
     logError(