talon-agent 3.12.1 → 3.12.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "talon-agent",
-  "version": "3.12.1",
+  "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/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;