talon-agent 3.12.1 → 3.12.3

package/package.json

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

@@ -52,8 +52,18 @@ function isWellFormedHtml(html: string): boolean {
   return stack.length === 0;
 }
 
+/** `\x00URLn\x00` → the stashed URL, or undefined when it isn't a placeholder. */
+function resolveUrlPlaceholder(
+  target: string,
+  urls: string[],
+): string | undefined {
+  // oxlint-disable-next-line no-control-regex
+  const match = /^\x00URL(\d+)\x00$/.exec(target);
+  return match ? urls[Number(match[1])] : undefined;
+}
+
 /** Apply the inline delimiter passes to already-escaped text. */
-function applyInlineFormatting(input: string): string {
+function applyInlineFormatting(input: string, urls: string[]): string {
   let out = input;
   // Bold+italic: ***text*** — must run before the ** and * passes, which
   // would otherwise split it into the crossed pair `<b><i>x</b></i>`.
@@ -64,13 +74,16 @@ function applyInlineFormatting(input: string): string {
   out = out.replace(/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g, "<i>$1</i>");
   // Italic: _text_ (surrounded by non-word or start/end)
   out = out.replace(/(?<!\w)_(.+?)_(?!\w)/g, "<i>$1</i>");
-  // Links: [text](url) — only safe URL schemes become anchors. Both text
-  // and url were already HTML-escaped by step 3 (quotes included, so the
-  // href attribute can't be broken out of); escaping again here corrupted
-  // every & in a query string into &amp;amp;.
-  out = out.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_, text, url) =>
-    /^https?:\/\//i.test(url) ? `<a href="${url}">${text}</a>` : text,
-  );
+  // Links: [text](url) — only safe URL schemes become anchors. The target
+  // arrives as a `\x00URLn\x00` placeholder (step 2b), so the passes above
+  // never saw the URL's own punctuation; resolve it back here. Both text and
+  // url were already HTML-escaped (quotes included, so the href attribute
+  // can't be broken out of); escaping again here corrupted every & in a
+  // query string into &amp;amp;.
+  out = out.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_, text, target) => {
+    const url = resolveUrlPlaceholder(target, urls) ?? target;
+    return /^https?:\/\//i.test(url) ? `<a href="${url}">${text}</a>` : text;
+  });
   // Strikethrough: ~~text~~
   out = out.replace(/~~(.+?)~~/g, "<s>$1</s>");
   return out;
@@ -110,6 +123,23 @@ export function markdownToTelegramHtml(text: string): string {
     return placeholder;
   });
 
+  // Step 2b: Stash link targets. The emphasis passes run before the link
+  // pass and have no idea what a URL is, so punctuation inside the target
+  // used to be consumed as a delimiter: a Chomikuj path like
+  // `Jak+Si*c4*99+Bawi*c4*85+Ludzie.mp3` reads as two italic runs, the
+  // resulting tags cross, and the well-formedness guard then discards the
+  // formatting for the *whole* message. Placeholders carry no delimiters,
+  // so the URL is invisible to every pass but the link one.
+  const urls: string[] = [];
+  processed = processed.replace(
+    /(\[[^\]\n]*\])\(([^()\s]+)\)/g,
+    (_match, label: string, url: string) => {
+      const placeholder = `\x00URL${urls.length}\x00`;
+      urls.push(escapeHtml(url));
+      return `${label}(${placeholder})`;
+    },
+  );
+
   // Step 3: Escape HTML in remaining plain text (before applying formatting).
   // Escape HTML in plain text segments (skip placeholders marked with \x00)
   // oxlint-disable-next-line no-control-regex
@@ -119,11 +149,18 @@ export function markdownToTelegramHtml(text: string): string {
   // actually parseable. `processed` at this point holds escaped text plus
   // tag-free placeholders, so it is a safe unformatted fallback.
   const unformatted = processed;
-  processed = applyInlineFormatting(processed);
+  processed = applyInlineFormatting(processed, urls);
   if (!isWellFormedHtml(processed)) {
     processed = unformatted;
   }
 
+  // Step 4b: Restore any link target that never became an anchor — a
+  // non-http scheme, or the unformatted fallback above. Anchors already
+  // resolved their placeholder inline.
+  for (let i = 0; i < urls.length; i++) {
+    processed = processed.replace(`\x00URL${i}\x00`, () => urls[i]!);
+  }
+
   // Steps 5+6: Restore code spans and fenced blocks. The replacement MUST
   // go through a function: with a string, String.replace interprets $-
   // substitution patterns in the *code content* ($& re-inserts the

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;