talon-agent 3.35.0 → 3.37.0

package/package.json

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

package/src/core/plugin/mcp.ts

@@ -5,6 +5,7 @@
  */
 
 import { resolve } from "node:path";
+import { logWarn } from "../../util/log.js";
 import { wrapMcpServer } from "../../util/mcp-launcher.js";
 import { isBunRuntime } from "../../util/runtime.js";
 import { registry, reloadState } from "./registry.js";
@@ -51,6 +52,18 @@ export function getPluginMcpServers(
   for (const { plugin, envVars } of registry.all) {
     // Skip plugins not in the allow-list when filtering
     if (only !== undefined && !only.includes(plugin.name)) continue;
+
+    // Let the plugin re-materialize on-disk state the child will read. Runs
+    // on every build so a deleted file heals within a turn; never fatal.
+    try {
+      if (plugin.mcpServer || plugin.mcpServerPath) plugin.prepareMcpSpawn?.();
+    } catch (err) {
+      logWarn(
+        "plugin",
+        `${plugin.name}: prepareMcpSpawn failed: ${err instanceof Error ? err.message : String(err)}`,
+      );
+    }
+
     const baseEnv = buildBridgeEnv(bridgeUrl, chatId, envVars);
 
     if (plugin.mcpServer) {

package/src/core/plugin/registry.ts

@@ -119,6 +119,17 @@ export const _deps = {
     // dynamic import() rejects bare drive-letter paths (e.g. C:\...).
     // Leave node: specifiers, relative paths, and URLs unchanged.
     const isAbsFilePath = /^[a-zA-Z]:[/\\]/.test(path) || path.startsWith("/");
-    return import(isAbsFilePath ? pathToFileURL(path).href : path);
+    if (!isAbsFilePath) return import(path);
+
+    // Cache-bust with the reload timestamp. ESM caches modules by resolved
+    // URL forever, so without a changing query a hot reload re-imports the
+    // *old* module object and the plugin's own source edits are invisible
+    // until a full restart — silently, since the stale module still loads
+    // fine (observed 2026-09-16: a rewritten plugin kept reporting its
+    // previous version through three reloads). The timestamp only moves per
+    // reload, so every module in one load cycle shares a key.
+    const url = pathToFileURL(path);
+    url.searchParams.set("talonReloadAt", reloadState.lastReloadAt);
+    return import(url.href);
   },
 };

package/src/core/plugin/types.ts

@@ -85,6 +85,18 @@ export interface TalonPlugin {
     readonly args: readonly string[];
   };
 
+  /**
+   * Materialize anything the MCP child needs on disk before it is spawned.
+   *
+   * MCP children are spawned lazily and respawned on demand for the lifetime
+   * of the daemon, so state written once at load time can go missing long
+   * before the last spawn. This hook runs every time the MCP server map is
+   * built, making such state self-healing instead of broken-until-restart.
+   * Must be synchronous, cheap, and idempotent; throwing is swallowed and
+   * logged (a failed prepare must not take the whole server map down).
+   */
+  prepareMcpSpawn?(): void;
+
   /**
    * Map plugin config to env vars for the MCP subprocess and action handlers.
    * Called once at load time. Values are set on process.env for the main

package/src/core/weaver/typing-loop.ts

@@ -10,6 +10,16 @@ import { logWarn } from "../../util/log.js";
 /** Platforms expire typing indicators after ~5s; refresh under that. */
 const TYPING_REFRESH_MS = 4000;
 
+/**
+ * Consecutive failures after which the loop gives up for the rest of the
+ * turn. A chat that has gone away (deleted, kicked, migrated) fails every
+ * single refresh, and a long turn then logs one warning every 4 seconds for
+ * a cosmetic indicator — 55 of them in 30 seconds on 2026-09-15, all
+ * "sendChatAction failed (400: chat not found)". Three strikes is enough to
+ * tell a transient blip from a chat that is simply gone.
+ */
+const MAX_CONSECUTIVE_FAILURES = 3;
+
 export type SendTyping = (
   numericChatId: number,
   stringId?: string,
@@ -22,15 +32,36 @@ export function startTypingLoop(
   stringId: string,
   intervalMs = TYPING_REFRESH_MS,
 ): () => void {
+  let timer: ReturnType<typeof setInterval> | undefined;
+  let consecutiveFailures = 0;
+
+  const stop = () => {
+    if (timer !== undefined) clearInterval(timer);
+    timer = undefined;
+  };
+
   const send = (label: string) => {
-    sendTyping(numericChatId, stringId).catch((err: unknown) => {
-      logWarn(
-        "dispatcher",
-        `${label} failed: ${err instanceof Error ? err.message : String(err)}`,
-      );
-    });
+    sendTyping(numericChatId, stringId).then(
+      () => {
+        consecutiveFailures = 0;
+      },
+      (err: unknown) => {
+        consecutiveFailures++;
+        const reason = err instanceof Error ? err.message : String(err);
+        if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+          stop();
+          logWarn(
+            "dispatcher",
+            `${label} failed ${consecutiveFailures}x in a row — no typing indicator for the rest of this turn: ${reason}`,
+          );
+          return;
+        }
+        logWarn("dispatcher", `${label} failed: ${reason}`);
+      },
+    );
   };
+
   send("sendTyping");
-  const timer = setInterval(() => send("sendTyping interval"), intervalMs);
-  return () => clearInterval(timer);
+  timer = setInterval(() => send("sendTyping interval"), intervalMs);
+  return stop;
 }

package/src/frontend/native/chat-wire.ts

@@ -14,14 +14,18 @@ import type { ChatEntry } from "./chats.js";
 import type { ClientChat, QueuedMessage } from "./protocol.js";
 import type { NativeRuntime } from "./runtime.js";
 
-/** Project the stored queue entry to its wire shape (text + attachment flag). */
+/** Project the stored queue entry to its wire shape (text + attachments). */
 function toQueued(
   runtime: NativeRuntime,
   chatId: string,
 ): QueuedMessage | undefined {
   const q = runtime.queuedByChat.get(chatId);
   if (!q) return undefined;
-  return { text: q.text, hasAttachment: Boolean(q.attachmentPath) };
+  return {
+    text: q.text,
+    hasAttachment: q.attachments.length > 0,
+    attachmentCount: q.attachments.length,
+  };
 }
 
 export function toClientChat(

package/src/frontend/native/emit.ts

@@ -12,6 +12,7 @@ import {
   BOT_SENDER_ID,
   USER_SENDER_ID,
   type ClientButton,
+  type ClientAttachment,
   type ClientMessage,
 } from "./protocol.js";
 import type { NativeRuntime } from "./runtime.js";
@@ -104,43 +105,61 @@ export function emitPhoto(
   return id;
 }
 
+/** The sidebar preview for a message whose real content is its files. */
+function attachmentPreview(attachments: ClientAttachment[]): string {
+  if (attachments.length === 1) {
+    const only = attachments[0]!;
+    return only.image ? "[photo]" : `[${only.name}]`;
+  }
+  return `[${attachments.length} files]`;
+}
+
 /** Persist + broadcast a user message; returns its numeric id so the turn
  *  hands the model that same id (as `[msg_id:N]`) to react/reply to.
- *  An optional imagePath renders an attached image inline. */
+ *  Attached files ride along on the message and are persisted with it. */
 export function emitUser(
   runtime: NativeRuntime,
   entry: ChatEntry,
   text: string,
-  imagePath?: string,
-  attachmentPath?: string,
+  attachments: ClientAttachment[] = [],
 ): number {
   const id = runtime.nextId();
   const ts = Date.now();
+  // `imagePath` stays in sync with the first image so clients written against
+  // the single-image shape keep rendering it.
+  const firstImage = attachments.find((a) => a.image);
   const message: ClientMessage = {
     id: String(id),
     chatId: entry.id,
     role: "user",
     text,
     ts,
-    ...(imagePath ? { imagePath } : {}),
+    ...(firstImage ? { imagePath: firstImage.url } : {}),
+    ...(attachments.length ? { attachments } : {}),
   };
-  // For an attached image, persist the on-disk path + a `photo` mediaType so
-  // it re-renders on history reload (rehydrated in the `history` handler)
-  // instead of vanishing to a text-only placeholder. Caption stays as text.
+  // Persist the attachment records so the files re-render on history reload
+  // (rehydrated in `history.ts`) instead of vanishing to a text-only
+  // placeholder. mediaType/filePath keep the pre-multi-file row shape
+  // populated from the first attachment. Caption stays as text.
+  const first = attachments[0];
   pushMessage(entry.id, {
     msgId: id,
     senderId: USER_SENDER_ID,
     senderName: "User",
     text,
     timestamp: ts,
-    ...(imagePath
+    ...(first
       ? {
-          mediaType: "photo" as const,
-          ...(attachmentPath ? { filePath: attachmentPath } : {}),
+          mediaType: first.image ? ("photo" as const) : ("document" as const),
+          filePath: first.path,
+          attachments,
         }
       : {}),
   });
-  runtime.chats.touch(entry.id, imagePath ? text || "[photo]" : text);
+  runtime.chats.touch(
+    entry.id,
+    attachments.length ? text || attachmentPreview(attachments) : text,
+  );
   maybeAutoTitle(runtime, entry, text);
   runtime.broadcast({ kind: "message", chatId: entry.id, message });
   broadcastChatUpdated(runtime, entry);

package/src/frontend/native/handlers.ts

@@ -18,7 +18,12 @@ import {
 } from "./extensions.js";
 import { historyPage, searchHistory } from "./history.js";
 import { readLogEntries } from "./logs.js";
-import { mediaUrl, registerMedia, saveUpload } from "./media.js";
+import {
+  describeAttachment,
+  MAX_UPLOAD_BYTES,
+  resolveUpload,
+  saveUploadStream,
+} from "./media.js";
 import {
   effortLevels,
   listBackends,
@@ -30,11 +35,57 @@ import {
 import { setQueued } from "./queue.js";
 import { resetChat } from "./reset.js";
 import type { NativeRuntime } from "./runtime.js";
-import type { BridgeServerHandlers } from "./server.js";
+import type { BridgeServerHandlers, SendOptions } from "./server.js";
+import type { ClientAttachment } from "./protocol.js";
 import { configSnapshot, applyConfigUpdate } from "./settings.js";
 import { bridgeStatus, broadcastStatus } from "./status.js";
+import { logWarn } from "../../util/log.js";
 import { interruptTurn, isBusy, liveTurnEvents, startTurn } from "./turn.js";
 
+/**
+ * Turn a `/send` body's attachment references into the records this daemon
+ * minted at upload time. Both wire shapes land here: the `attachments` list
+ * multi-file clients send, and the `imagePath`/`attachmentPath` pair older
+ * single-image clients send. References the daemon cannot account for are
+ * dropped — a message can only ever point the model at a file the daemon
+ * itself wrote to its uploads dir.
+ */
+function resolveAttachments(
+  runtime: NativeRuntime,
+  opts: SendOptions | undefined,
+): ClientAttachment[] {
+  const refs = [...(opts?.attachments ?? [])];
+  if (!refs.length && (opts?.imagePath || opts?.attachmentPath)) {
+    refs.push({ url: opts.imagePath, path: opts.attachmentPath });
+  }
+  const resolved: ClientAttachment[] = [];
+  const dropped: string[] = [];
+  for (const ref of refs) {
+    const found = resolveUpload(runtime, ref);
+    if (!found) {
+      dropped.push(ref.url ?? ref.path ?? "(empty reference)");
+      continue;
+    }
+    // Same file referenced twice (a re-send of a queued message, say) stays
+    // one attachment.
+    if (!resolved.some((a) => a.path === found.path)) {
+      resolved.push(found);
+    }
+  }
+  // A dropped reference is how "I attached a file and the agent never saw it"
+  // happens, and it used to be entirely silent. The usual cause is a media id
+  // minted by a previous daemon run — `runtime.uploads` is per-run, so a
+  // client that staged a file before a restart and sent it after points at
+  // nothing.
+  if (dropped.length) {
+    logWarn(
+      "native",
+      `dropped ${dropped.length} unknown attachment reference(s) from /send: ${dropped.join(", ")} — re-upload the file (ids do not survive a daemon restart)`,
+    );
+  }
+  return resolved;
+}
+
 export function buildBridgeHandlers(
   runtime: NativeRuntime,
 ): BridgeServerHandlers {
@@ -49,29 +100,44 @@ export function buildBridgeHandlers(
     search: (query, chatId) => searchHistory(runtime, query, chatId),
     send: (id, text, opts) => {
       const entry = chats.get(id) ?? chats.ensure(id);
+      // Resolve the client's references into the records this daemon minted
+      // at upload time — dropping anything it can't account for.
+      const attachments = resolveAttachments(runtime, opts);
       // A turn is already running for this chat — don't interrupt it. Park the
       // message as the single queued follow-up (synced to every client); it
       // auto-sends when the running turn ends. `isBusy` reads `liveTurns`,
       // which `runTurn` sets synchronously, so even a rapid second /send from
       // any client is caught here rather than starting a concurrent turn.
       if (isBusy(runtime, entry.id)) {
-        setQueued(runtime, entry.id, {
-          text,
-          imagePath: opts?.imagePath,
-          attachmentPath: opts?.attachmentPath,
-        });
+        setQueued(runtime, entry.id, { text, attachments });
         return;
       }
-      startTurn(runtime, entry, text, opts);
+      startTurn(runtime, entry, text, { attachments });
     },
     queueMessage: (id, text) => {
-      // Edit/replace the queued follow-up (text-only). Empty clears it.
+      // Edit/replace the queued follow-up's text, keeping whatever files were
+      // queued with it. Empty text cancels the whole follow-up, attachments
+      // included — the client's queue editor offers no other way to drop it.
       const entry = chats.get(id);
-      if (entry) setQueued(runtime, entry.id, { text });
+      if (!entry) return;
+      const attachments = text.trim()
+        ? (runtime.queuedByChat.get(entry.id)?.attachments ?? [])
+        : [];
+      setQueued(runtime, entry.id, { text, attachments });
     },
-    upload: async (filename, _contentType, bytes) => {
-      const path = await saveUpload(runtime, filename, bytes);
-      return { imagePath: mediaUrl(registerMedia(runtime, path)), path };
+    upload: async (filename, contentType, body) => {
+      const saved = await saveUploadStream(
+        runtime,
+        filename,
+        body,
+        MAX_UPLOAD_BYTES,
+      );
+      return describeAttachment(runtime, {
+        path: saved.path,
+        name: filename,
+        size: saved.size,
+        contentType,
+      });
     },
     listModels: (chatId) => listModels(runtime, chatId),
     setModel: (id, model) => setModel(runtime, id, model),

package/src/frontend/native/history.ts

@@ -3,18 +3,21 @@
  * (attached images get a fresh /media URL, assistant rows their turn meta).
  */
 
+import { basename } from "node:path";
 import {
   getRecentHistory,
   getHistoryBefore,
   searchHistoryMessages,
   type HistoryMessage,
+  type MessageAttachment,
 } from "../../storage/history.js";
 import { isDeliveryTool } from "../../core/tools/index.js";
 import type { ChatEntry } from "./chats.js";
 import { refreshContext } from "./context.js";
-import { mediaUrl, registerMedia } from "./media.js";
+import { contentTypeFor, rehydrateAttachment } from "./media.js";
 import {
   historyToClientMessage,
+  type ClientAttachment,
   type ClientMessage,
   type SearchResult,
 } from "./protocol.js";
@@ -29,11 +32,32 @@ function hydrateHistoryRow(
   row: HistoryMessage,
 ): ClientMessage {
   const msg = historyToClientMessage(row, chatId);
-  // Re-hydrate an attached image: re-register its on-disk path into
-  // the media map and hand back a fresh /media URL so the image shows
-  // in reloaded history (survives restarts as long as the file exists).
-  if (row.mediaType === "photo" && row.filePath) {
-    msg.imagePath = mediaUrl(registerMedia(runtime, row.filePath));
+  // Re-hydrate attached files: media ids are per-daemon-run, so each stored
+  // attachment is re-registered and handed a fresh /media URL. Rows written
+  // before multi-file attachments carry only mediaType + filePath, which is
+  // projected into the same one-element list so every client renders history
+  // the same way regardless of when it was recorded.
+  const stored: ClientAttachment[] = row.attachments?.length
+    ? row.attachments.map((a: MessageAttachment) =>
+        rehydrateAttachment(runtime, { ...a, url: "" }),
+      )
+    : row.filePath &&
+        (row.mediaType === "photo" || row.mediaType === "document")
+      ? [
+          rehydrateAttachment(runtime, {
+            path: row.filePath,
+            name: basename(row.filePath),
+            size: 0,
+            mimeType: contentTypeFor(row.filePath),
+            image: row.mediaType === "photo",
+            url: "",
+          }),
+        ]
+      : [];
+  if (stored.length) {
+    msg.attachments = stored;
+    const firstImage = stored.find((a) => a.image);
+    if (firstImage) msg.imagePath = firstImage.url;
   }
   // Re-hydrate turn meta (tool timeline + stats) for assistant rows.
   if (msg.role === "assistant") {