talon-agent 3.12.0 → 3.12.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "talon-agent",
-  "version": "3.12.0",
+  "version": "3.12.2",
   "description": "Multi-frontend AI agent with full tool access, streaming, cron jobs, and plugin system",
   "author": "Dylan Neve",
   "license": "MIT",
@@ -102,7 +102,7 @@
     "@grammyjs/transformer-throttler": "^1.2.1",
     "@kilocode/sdk": "^7.2.22",
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@openai/agents": "^0.13.0",
+    "@openai/agents": "^0.14.0",
     "@openai/codex-sdk": "^0.145.0",
     "@opencode-ai/sdk": "^1.17.4",
     "@playwright/mcp": "0.0.78",

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";

package/src/frontend/telegram/actions/messaging.ts

@@ -15,7 +15,12 @@ import {
   MAX_OVERDUE_MS,
   type ScheduledMessage,
 } from "../../../storage/scheduled-store.js";
-import { sendText, toPositiveId } from "./shared.js";
+import {
+  noteRichMessageFailure,
+  richMessagesAvailable,
+  sendText,
+  toPositiveId,
+} from "./shared.js";
 import { TELEGRAM_MAX_TEXT, type TelegramActionHandlers } from "./types.js";
 
 // ── Inline keyboards ─────────────────────────────────────────────────────────
@@ -135,10 +140,8 @@ async function fireScheduled(bot: Bot, entry: ScheduledMessage): Promise<void> {
       return;
     }
     const keyboard = built.keyboard;
-    await bot.api.sendMessage(chatId, markdownToTelegramHtml(entry.text), {
-      parse_mode: "HTML",
-      reply_markup: { inline_keyboard: keyboard },
-      reply_parameters: replyTo ? { message_id: replyTo } : undefined,
+    await sendText(bot, chatId, entry.text, replyTo, {
+      inline_keyboard: keyboard,
     });
   } else {
     await sendText(bot, chatId, entry.text, replyTo);
@@ -246,12 +249,24 @@ export const messagingHandlers: TelegramActionHandlers = {
         ok: false,
         error: `Text too long (max ${TELEGRAM_MAX_TEXT})`,
       };
-    const html = markdownToTelegramHtml(text);
     await withRetry(async () => {
+      if (richMessagesAvailable()) {
+        try {
+          await bot.api.editMessageText(chatId, Number(body.message_id), {
+            markdown: text,
+          });
+          return;
+        } catch (richErr) {
+          noteRichMessageFailure(richErr, `edit chat=${chatId}`);
+        }
+      }
       try {
-        await bot.api.editMessageText(chatId, Number(body.message_id), html, {
-          parse_mode: "HTML",
-        });
+        await bot.api.editMessageText(
+          chatId,
+          Number(body.message_id),
+          markdownToTelegramHtml(text),
+          { parse_mode: "HTML" },
+        );
       } catch {
         await bot.api.editMessageText(chatId, Number(body.message_id), text);
       }
@@ -309,24 +324,15 @@ export const messagingHandlers: TelegramActionHandlers = {
     const text = String(body.text ?? "");
     if (text.length > TELEGRAM_MAX_TEXT)
       return { ok: false, error: `Text too long` };
-    const html = markdownToTelegramHtml(text);
     const rows = body.rows as ButtonSpec[][];
     const built = buildInlineKeyboard(rows);
     if ("error" in built) return { ok: false, error: built.error };
     const keyboard = built.keyboard;
     gateway.incrementMessages(chatId);
-    try {
-      const sent = await bot.api.sendMessage(chatId, html, {
-        parse_mode: "HTML",
-        reply_markup: { inline_keyboard: keyboard },
-      });
-      return { ok: true, message_id: sent.message_id };
-    } catch {
-      const sent = await bot.api.sendMessage(chatId, text, {
-        reply_markup: { inline_keyboard: keyboard },
-      });
-      return { ok: true, message_id: sent.message_id };
-    }
+    const messageId = await sendText(bot, chatId, text, undefined, {
+      inline_keyboard: keyboard,
+    });
+    return { ok: true, message_id: messageId };
   },
 
   schedule_message: (body, chatId, { bot, scheduledMessages }) => {

package/src/frontend/telegram/actions/shared.ts

@@ -1,6 +1,6 @@
 /**
  * Shared helpers for Telegram action handlers: reply-parameter extraction and
- * the HTML-with-plain-fallback text sender.
+ * native Rich Markdown delivery with legacy fallbacks.
  */
 
 import type { Bot } from "grammy";
@@ -27,31 +27,97 @@ export function toPositiveId(v: unknown): number | undefined {
   return Number.isInteger(n) && n > 0 ? n : undefined;
 }
 
+/**
+ * Rich Messages arrived in Bot API 10.2. A self-hosted Bot API server (or a
+ * deployment pinned to an older release) rejects `sendRichMessage` outright,
+ * and retrying it per message would cost a doomed round-trip plus a warning
+ * line on every single send. Probe once and latch, mirroring the
+ * `draftsSupported` capability probe in `handlers/delivery.ts`.
+ */
+let richMessagesSupported = true;
+
+/** Telegram's shape for "this build doesn't have that method". */
+const METHOD_UNAVAILABLE_RE =
+  /method not found|not supported|unknown method|unsupported method/i;
+
+/** True while native Rich Markdown delivery is still worth attempting. */
+export function richMessagesAvailable(): boolean {
+  return richMessagesSupported;
+}
+
+/**
+ * Log a failed Rich Message call and latch the capability off when the failure
+ * says the method itself is missing. Payload-level rejections (a markdown
+ * string Telegram won't parse) stay one-off — the next message may be fine.
+ */
+export function noteRichMessageFailure(err: unknown, context: string): void {
+  const msg = err instanceof Error ? err.message : String(err);
+  if (METHOD_UNAVAILABLE_RE.test(msg)) {
+    richMessagesSupported = false;
+    logWarn(
+      "bot",
+      `Rich Messages unavailable on this Bot API server — using legacy HTML from now on (${context}): ${msg}`,
+    );
+    return;
+  }
+  logWarn(
+    "bot",
+    `Rich Markdown failed; falling back to HTML (${context}): ${msg}`,
+  );
+}
+
+/** Test seam: re-arm the capability probe between cases. */
+export function resetRichMessageSupport(): void {
+  richMessagesSupported = true;
+}
+
 export async function sendText(
   bot: Bot,
   chatId: number,
   text: string,
   replyTo?: number,
+  replyMarkup?: NonNullable<
+    Parameters<Bot["api"]["sendRichMessage"]>[2]
+  >["reply_markup"],
 ): Promise<number> {
   if (text.length > TELEGRAM_MAX_TEXT) {
     throw new Error(
       `Message too long (${text.length} chars, max ${TELEGRAM_MAX_TEXT}).`,
     );
   }
+
+  if (richMessagesSupported) {
+    try {
+      const sent = await bot.api.sendRichMessage(
+        chatId,
+        { markdown: text },
+        {
+          reply_parameters: replyTo ? { message_id: replyTo } : undefined,
+          reply_markup: replyMarkup,
+        },
+      );
+      return sent.message_id;
+    } catch (err) {
+      noteRichMessageFailure(err, `send chat=${chatId}`);
+    }
+  }
+
   const html = markdownToTelegramHtml(text);
   try {
     const sent = await bot.api.sendMessage(chatId, html, {
       parse_mode: "HTML",
       reply_parameters: replyTo ? { message_id: replyTo } : undefined,
+      reply_markup: replyMarkup,
     });
     return sent.message_id;
   } catch (err) {
     logWarn(
       "bot",
-      `sendText with parse_mode=HTML failed; retrying without parse_mode (chat=${chatId}): ${err instanceof Error ? err.message : err}`,
+      `Legacy HTML send failed; retrying as plain text (chat=${chatId}): ${err instanceof Error ? err.message : err}`,
     );
     const sent = await bot.api.sendMessage(chatId, text, {
       reply_parameters: replyTo ? { message_id: replyTo } : undefined,
+      reply_markup: replyMarkup,
     });
     return sent.message_id;
   }

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

@@ -5,12 +5,12 @@
 
 import type { Bot } from "grammy";
 import type { TalonConfig } from "../../../util/config.js";
-import { markdownToTelegramHtml } from "../formatting.js";
 import { execute } from "../../../core/engine/dispatcher.js";
 import { toolInputToRecord } from "../../../core/agent-runtime/events.js";
 import { appendDailyLogResponse } from "../../../storage/daily-log.js";
 import { stripMcpPrefix } from "../../../core/tools/index.js";
 import { logWarn } from "../../../util/log.js";
+import { sendText } from "../actions/shared.js";
 import { trackDmUser } from "./access.js";
 
 export async function sendHtml(
@@ -112,7 +112,7 @@ function createStreamCallbacks(
   };
 
   const onTextBlock = async (text: string) => {
-    await sendHtml(bot, chatId, markdownToTelegramHtml(text), _replyToId);
+    await sendText(bot, chatId, text, _replyToId);
     appendDailyLogResponse("Talon", text, { chatTitle });
     state.lastSentLength = 0;
     state.sentTextBlock = true;