talon-agent 3.12.0 → 3.12.1

package/package.json

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

package/src/core/engine/gateway-actions/index.ts

@@ -31,7 +31,7 @@ import { scriptHandlers } from "./scripts.js";
 import { skillHandlers } from "./skills.js";
 import { pluginHandlers } from "./plugins.js";
 import { modelHandlers } from "./models.js";
-import { meshHandlers } from "./mesh.js";
+import { meshHandlers, chatFreeActions } from "./mesh.js";
 import { nativeHandlers } from "./native.js";
 
 // Null-prototype so a request `action` of "toString" / "constructor" / etc.
@@ -62,4 +62,29 @@ export async function handleSharedAction(
   return handler(body, chatId, backend);
 }
 
+/**
+ * True when the action needs no chat context at all (see `chatFreeActions`).
+ * The gateway checks this before resolving a chat so mesh tools stay reachable
+ * from heartbeat/background runs.
+ */
+export function isChatFreeAction(action: string): boolean {
+  return chatFreeActions.has(action);
+}
+
+/**
+ * Dispatch a chat-free action. The handler signature still takes a chatId
+ * (they all share one type); chat-free handlers ignore it, and `0` is passed
+ * as an explicit "no chat" sentinel rather than a real id.
+ */
+export async function handleChatFreeAction(
+  body: Record<string, unknown>,
+): Promise<ActionResult | null> {
+  const action = body.action as string;
+  if (!isChatFreeAction(action)) return null;
+  const handler = handlers[action];
+  if (!handler) return null;
+  return handler(body, 0);
+}
+
+export { chatFreeActions };
 export type { SharedActionHandler, SharedActionHandlers } from "./types.js";

package/src/core/engine/gateway-actions/mesh.ts

@@ -78,3 +78,36 @@ export const meshHandlers: SharedActionHandlers = {
       body.bridge_url,
     ),
 };
+
+/**
+ * Mesh actions are chat-free: every handler above reads `body` and the
+ * daemon-wide mesh registry, and not one of them takes the `chatId` the
+ * gateway threads through. Requiring an active chat context to reach them is
+ * therefore incidental to the transport, not a property of the action — and
+ * it makes the whole mesh unreachable from heartbeat/background runs, which
+ * have no ambient chat and no `chat_id` parameter on these tools to promote.
+ *
+ * The gateway consults this set before chat resolution so `list_devices`,
+ * `device_exec` and friends work from any run mode. Kept as an explicit
+ * export (rather than `Object.keys(meshHandlers)`) so adding a handler that
+ * *does* need a chat is a deliberate opt-out rather than a silent inclusion.
+ */
+export const chatFreeActions: ReadonlySet<string> = new Set([
+  "list_devices",
+  "get_device_location",
+  "get_device_history",
+  "ring_device",
+  "remove_device",
+  "get_device_status",
+  "device_exec",
+  "device_list_dir",
+  "device_stat",
+  "device_read_file",
+  "device_write_file",
+  "device_pull_file",
+  "device_push_file",
+  "update_device",
+  "update_node",
+  "get_node_binary",
+  "make_node_install_link",
+]);

package/src/core/engine/gateway.ts

@@ -20,7 +20,11 @@ import { Loom, getActiveLoom, type ContextRegistry } from "../weaver/index.js";
 import { getHealthStatus } from "../../util/watchdog.js";
 import { getActiveSessionCount } from "../../storage/sessions.js";
 import { log, logError, logDebug } from "../../util/log.js";
-import { handleSharedAction } from "./gateway-actions/index.js";
+import {
+  handleSharedAction,
+  handleChatFreeAction,
+  isChatFreeAction,
+} from "./gateway-actions/index.js";
 import {
   handleHubRequest,
   getHubSessionCount,
@@ -249,6 +253,31 @@ export class Gateway {
     // active-context-required check — the action handler will reach the
     // chat directly via the Telegram Bot API. The legacy context-required
     // path remains for chat-mode calls where `chat_id` is absent.
+    // Chat-free actions (the device mesh) short-circuit routing entirely:
+    // they read daemon-wide state, ignore chatId, and are the only command
+    // channel a heartbeat run has to a remote box. Gating them behind an
+    // active chat made the whole mesh unreachable from background runs —
+    // and unlike send/react they carry no `chat_id` param to promote.
+    const requestedAction =
+      typeof body.action === "string" ? body.action : undefined;
+    if (requestedAction && isChatFreeAction(requestedAction)) {
+      const t0 = Date.now();
+      try {
+        const result = await handleChatFreeAction(body);
+        if (result) {
+          logDebug(
+            "gateway",
+            `${requestedAction} chat=none ${Date.now() - t0}ms (chat-free)`,
+          );
+          return result;
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logError("gateway", `${requestedAction} (chat-free) failed: ${msg}`);
+        return { ok: false, error: `${requestedAction}: ${msg}` };
+      }
+    }
+
     const rawChatId = body._chatId ? String(body._chatId) : "";
     const numericId = Number(rawChatId);
     const explicitChatIdProvided = typeof body.chat_id !== "undefined";