@llblab/pi-telegram 0.17.4 → 0.18.0

package/lib/menu.ts

@@ -4,13 +4,6 @@
  * Owns app-menu/status state, inline UI text, and callback composition while model/thinking/queue menu details live in dedicated domains
  */
 
-import {
-  handleTelegramSectionCallback,
-  handleTelegramSectionOpen,
-  handleTelegramSectionSettingsOpen,
-  parseTelegramSectionCallback,
-  type TelegramSectionRegistry,
-} from "./sections.ts";
 import {
   createTelegramModelMenuStateBuilder,
   handleTelegramModelMenuCallbackAction,
@@ -39,6 +32,13 @@ import {
   type ScopedTelegramModel,
   type ThinkingLevel,
 } from "./model.ts";
+import {
+  handleTelegramSectionCallback,
+  handleTelegramSectionOpen,
+  handleTelegramSectionSettingsOpen,
+  parseTelegramSectionCallback,
+  type TelegramSectionRegistry,
+} from "./sections.ts";
 
 export {
   applyTelegramModelPageSelection,
@@ -150,7 +150,11 @@ export interface TelegramMenuCallbackEntryDeps {
 export interface MenuCallbackQuery {
   id: string;
   data?: string;
-  message?: { message_id?: number };
+  message?: {
+    message_id?: number;
+    message_thread_id?: number;
+    chat?: { id?: number };
+  };
 }
 
 export interface StoredTelegramMenuCallbackDeps<
@@ -158,6 +162,7 @@ export interface StoredTelegramMenuCallbackDeps<
 > {
   getStoredModelMenuState: (
     messageId: number | undefined,
+    chatId?: number,
   ) => TelegramModelMenuState<TModel> | undefined;
   handleStatusAction: (
     state: TelegramModelMenuState<TModel>,
@@ -180,6 +185,7 @@ export interface TelegramMenuCallbackRuntimeDeps<
 > {
   getStoredModelMenuState: (
     messageId: number | undefined,
+    chatId?: number,
   ) => TelegramModelMenuState<TModel> | undefined;
   getActiveModel: (ctx: TContext) => TModel | undefined;
   getThinkingLevel: () => ThinkingLevel;
@@ -236,8 +242,13 @@ export interface TelegramMenuCallbackRuntimeDeps<
     text: string,
     mode: "markdown" | "html" | "plain",
     replyMarkup: TelegramReplyMarkup,
+    options?: { target?: { chatId: number; threadId?: number } },
   ) => Promise<number | undefined>;
-  enqueueSectionPrompt?: (prompt: string, ctx: TContext) => Promise<void>;
+  enqueueSectionPrompt?: (
+    prompt: string,
+    ctx: TContext,
+    target?: { chatId: number; threadId?: number },
+  ) => Promise<void>;
   deleteMessage?: (chatId: number, messageId: number) => Promise<void>;
   isVoiceReplyActive?: () => boolean;
 }
@@ -249,6 +260,7 @@ export interface TelegramMenuActionRuntimeDeps<
   getModelMenuState: (
     chatId: number,
     ctx: TContext,
+    threadId?: number,
   ) => Promise<TelegramModelMenuState<TModel>>;
   getActiveModel: (ctx: TContext) => TModel | undefined;
   getThinkingLevel: () => ThinkingLevel;
@@ -261,6 +273,7 @@ export interface TelegramMenuActionRuntimeDeps<
     chatId: number,
     replyToMessageId: number,
     text: string,
+    options?: { target?: { chatId: number; threadId?: number } },
   ) => Promise<unknown>;
   sectionRegistry?: TelegramSectionRegistry;
   isVoiceReplyActive?: () => boolean;
@@ -286,11 +299,13 @@ export interface TelegramMenuActionRuntime<
     chatId: number,
     replyToMessageId: number,
     ctx: TContext,
+    threadId?: number,
   ) => Promise<void>;
   openModelMenu: (
     chatId: number,
     replyToMessageId: number,
     ctx: TContext,
+    threadId?: number,
   ) => Promise<void>;
   openThinkingMenu: (
     chatId: number,
@@ -392,7 +407,10 @@ export async function handleStoredTelegramMenuCallback<
   query: MenuCallbackQuery,
   deps: StoredTelegramMenuCallbackDeps<TModel>,
 ): Promise<void> {
-  const state = deps.getStoredModelMenuState(query.message?.message_id);
+  const state = deps.getStoredModelMenuState(
+    query.message?.message_id,
+    query.message?.chat?.id,
+  );
   await handleTelegramMenuCallbackEntry(query.id, query.data, state, {
     handleStatusAction: async () => {
       if (!state) return false;
@@ -416,6 +434,7 @@ export interface TelegramMenuCallbackRuntimeAdapterDeps<
 > {
   getStoredModelMenuState: (
     messageId: number | undefined,
+    chatId?: number,
   ) => TelegramModelMenuState<TModel> | undefined;
   getActiveModel: (ctx: TContext) => TModel | undefined;
   getThinkingLevel: () => ThinkingLevel;
@@ -472,8 +491,13 @@ export interface TelegramMenuCallbackRuntimeAdapterDeps<
     text: string,
     mode: "markdown" | "html" | "plain",
     replyMarkup: TelegramReplyMarkup,
+    options?: { target?: { chatId: number; threadId?: number } },
   ) => Promise<number | undefined>;
-  enqueueSectionPrompt?: (prompt: string, ctx: TContext) => Promise<void>;
+  enqueueSectionPrompt?: (
+    prompt: string,
+    ctx: TContext,
+    target?: { chatId: number; threadId?: number },
+  ) => Promise<void>;
   deleteMessage?: (chatId: number, messageId: number) => Promise<void>;
 }
 
@@ -532,7 +556,10 @@ export async function handleTelegramMenuCallbackRuntime<
   deps: TelegramMenuCallbackRuntimeDeps<TContext, TModel>,
 ): Promise<void> {
   if (query.data === "menu:back") {
-    const state = deps.getStoredModelMenuState(query.message?.message_id);
+    const state = deps.getStoredModelMenuState(
+      query.message?.message_id,
+      query.message?.chat?.id,
+    );
     if (!state) {
       await deps.answerCallbackQuery(query.id, "Interactive message expired.");
       return;
@@ -545,14 +572,19 @@ export async function handleTelegramMenuCallbackRuntime<
   if (deps.sectionRegistry && query.data?.startsWith("section:")) {
     const parsed = parseTelegramSectionCallback(query.data);
     if (parsed) {
-      const chatId = (query as { message?: { chat?: { id?: number } } }).message
-        ?.chat?.id;
-      const messageId = (query as { message?: { message_id?: number } }).message
-        ?.message_id;
+      const message = query.message;
+      const chatId = message?.chat?.id;
+      const messageId = message?.message_id;
+      const target =
+        typeof chatId === "number"
+          ? typeof message?.message_thread_id === "number"
+            ? { chatId, threadId: message.message_thread_id }
+            : { chatId }
+          : undefined;
       if (typeof chatId === "number" && typeof messageId === "number") {
         const { token, action, payload } = parsed;
         if (action === "open") {
-          const state = deps.getStoredModelMenuState(messageId);
+          const state = deps.getStoredModelMenuState(messageId, chatId);
           if (!state) {
             await deps.answerCallbackQuery(
               query.id,
@@ -568,12 +600,14 @@ export async function handleTelegramMenuCallbackRuntime<
             query.id,
             {
               answerCallbackQuery: deps.answerCallbackQuery,
+              target,
               editInteractiveMessage:
                 deps.editInteractiveMessage ?? (async () => {}),
               sendInteractiveMessage:
                 deps.sendInteractiveMessage ?? (async () => undefined),
               enqueuePrompt: deps.enqueueSectionPrompt
-                ? (prompt: string) => deps.enqueueSectionPrompt!(prompt, ctx)
+                ? (prompt: string) =>
+                    deps.enqueueSectionPrompt!(prompt, ctx, target)
                 : async () => {},
               deleteMessage: deps.deleteMessage ?? (async () => {}),
             },
@@ -589,12 +623,14 @@ export async function handleTelegramMenuCallbackRuntime<
               query.id,
               {
                 answerCallbackQuery: deps.answerCallbackQuery,
+                target,
                 editInteractiveMessage:
                   deps.editInteractiveMessage ?? (async () => {}),
                 sendInteractiveMessage:
                   deps.sendInteractiveMessage ?? (async () => undefined),
                 enqueuePrompt: deps.enqueueSectionPrompt
-                  ? (prompt: string) => deps.enqueueSectionPrompt!(prompt, ctx)
+                  ? (prompt: string) =>
+                      deps.enqueueSectionPrompt!(prompt, ctx, target)
                   : async () => {},
                 deleteMessage: deps.deleteMessage ?? (async () => {}),
               },
@@ -612,12 +648,14 @@ export async function handleTelegramMenuCallbackRuntime<
             query.id,
             {
               answerCallbackQuery: deps.answerCallbackQuery,
+              target,
               editInteractiveMessage:
                 deps.editInteractiveMessage ?? (async () => {}),
               sendInteractiveMessage:
                 deps.sendInteractiveMessage ?? (async () => undefined),
               enqueuePrompt: deps.enqueueSectionPrompt
-                ? (prompt: string) => deps.enqueueSectionPrompt!(prompt, ctx)
+                ? (prompt: string) =>
+                    deps.enqueueSectionPrompt!(prompt, ctx, target)
                 : async () => {},
               deleteMessage: deps.deleteMessage ?? (async () => {}),
             },
@@ -770,17 +808,18 @@ export function createTelegramMenuActionRuntime<
         deps.sectionRegistry,
         deps.isVoiceReplyActive?.(),
       ),
-    sendStatusMessage: (chatId, replyToMessageId, ctx) =>
+    sendStatusMessage: (chatId, replyToMessageId, ctx, threadId) =>
       openTelegramStatusMenu({
         isIdle: () => deps.isIdle(ctx),
         sendBusyMessage: async () => {
           await deps.sendTextReply(
             chatId,
             replyToMessageId,
-            "Cannot open status while π is busy. Send /abort, /next, or /stop.",
+            "Cannot open status while Pi is busy. Send /abort, /next, or /stop.",
+            { target: { chatId, threadId } },
           );
         },
-        getModelMenuState: () => deps.getModelMenuState(chatId, ctx),
+        getModelMenuState: () => deps.getModelMenuState(chatId, ctx, threadId),
         buildStatusHtml: () => deps.buildStatusHtml(ctx),
         getActiveModel: () => deps.getActiveModel(ctx),
         getThinkingLevel: deps.getThinkingLevel,
@@ -804,7 +843,7 @@ export function createTelegramMenuActionRuntime<
           ),
         storeModelMenuState: deps.storeModelMenuState,
       }),
-    openModelMenu: (chatId, replyToMessageId, ctx) =>
+    openModelMenu: (chatId, replyToMessageId, ctx, threadId) =>
       openTelegramModelMenu({
         isIdle: () => deps.isIdle(ctx),
         canOfferInFlightModelSwitch: () =>
@@ -813,7 +852,8 @@ export function createTelegramMenuActionRuntime<
           await deps.sendTextReply(
             chatId,
             replyToMessageId,
-            "Cannot switch model while π is busy. Send /abort, /next, or /stop.",
+            "Cannot switch model while Pi is busy. Send /abort, /next, or /stop.",
+            { target: { chatId, threadId } },
           );
         },
         sendNoModelsMessage: async () => {
@@ -821,9 +861,10 @@ export function createTelegramMenuActionRuntime<
             chatId,
             replyToMessageId,
             "No available models with configured auth.",
+            { target: { chatId, threadId } },
           );
         },
-        getModelMenuState: () => deps.getModelMenuState(chatId, ctx),
+        getModelMenuState: () => deps.getModelMenuState(chatId, ctx, threadId),
         getActiveModel: () => deps.getActiveModel(ctx),
         sendModelMenu: (state, activeModel) =>
           sendTelegramModelMenuMessage(state, activeModel, deps),

package/lib/outbound-attachments.ts

@@ -11,6 +11,10 @@ import { Type } from "@sinclair/typebox";
 
 import type { ExtensionAPI } from "./pi.ts";
 import { buildTelegramMultipartReplyParameters } from "./replies.ts";
+import {
+  getTelegramTargetThreadParams,
+  type TelegramTarget,
+} from "./target.ts";
 
 const MAX_ATTACHMENTS_PER_TURN = 10;
 
@@ -54,6 +58,7 @@ export interface TelegramOutboundAttachmentToolRegistrationDeps extends Telegram
   maxAttachmentSizeBytes?: number;
   getActiveTurn: () => TelegramOutboundAttachmentQueueTargetView | undefined;
   getDefaultChatId?: () => number | undefined;
+  getDefaultTarget?: () => TelegramTarget | undefined;
   canSendDirect?: () => boolean;
   sendMultipart?: TelegramQueuedOutboundAttachmentDeliveryDeps["sendMultipart"];
   statPath?: (path: string) => Promise<{ isFile(): boolean; size?: number }>;
@@ -66,12 +71,13 @@ export interface TelegramOutboundMessagePlan {
 
 export interface TelegramOutboundMessageToolRegistrationDeps extends TelegramOutboundAttachmentRuntimeEventRecorderPort {
   getDefaultChatId: () => number | undefined;
+  getDefaultTarget?: () => TelegramTarget | undefined;
   canSendDirect: () => boolean;
   planMessage: (markdown: string) => TelegramOutboundMessagePlan;
   sendMarkdownMessage: (
     chatId: number,
     markdown: string,
-    options?: { replyMarkup?: unknown },
+    options?: { replyMarkup?: unknown; target?: TelegramTarget },
   ) => Promise<number | undefined>;
 }
 
@@ -87,6 +93,7 @@ export interface TelegramOutboundAttachmentQueueTargetView {
 export interface TelegramQueuedOutboundAttachmentTurnView extends TelegramOutboundAttachmentQueueTargetView {
   chatId: number;
   replyToMessageId: number;
+  target?: TelegramTarget;
 }
 
 function isTelegramOutboundPhotoAttachmentPath(path: string): boolean {
@@ -113,7 +120,7 @@ function formatTelegramOutboundAttachmentToolResultText(
   count: number,
   mode: "queued" | "sent" = "queued",
 ): string {
-  // Pi's compact tool rows need an empty first line to visually separate header and result
+  // Pi's compact tool rows need one leading newline to visually separate header and result.
   const verb = mode === "queued" ? "Queued" : "Sent";
   return ["", `${verb} ${count} Telegram attachment(s).`].join("\n");
 }
@@ -122,26 +129,55 @@ function formatTelegramOutboundMessageToolResultText(chatId: number): string {
   return ["", `Sent Telegram message to ${chatId}.`].join("\n");
 }
 
+function getTelegramMultipartTargetFields(
+  target: TelegramTarget | undefined,
+): Record<string, string> {
+  if (!target) return {};
+  return Object.fromEntries(
+    Object.entries(getTelegramTargetThreadParams(target)).map(
+      ([key, value]) => [key, String(value)],
+    ),
+  );
+}
+
 function assertTelegramDirectDeliveryAllowed(
   canSendDirect: (() => boolean) | undefined,
 ): void {
   if (canSendDirect?.()) return;
   throw new Error(
-    "Telegram direct delivery requires this π instance to own /telegram-connect",
+    "Telegram direct delivery requires this Pi instance to own /telegram-connect or be registered with the Telegram multi-instance bus",
   );
 }
 
-function resolveTelegramOutboundChatId(options: {
+function resolveTelegramOutboundTarget(options: {
   chatId?: number;
+  threadId?: number;
+  target?: TelegramTarget;
   getDefaultChatId?: () => number | undefined;
-}): number {
-  const chatId = options.chatId ?? options.getDefaultChatId?.();
-  if (chatId === undefined) {
+  getDefaultTarget?: () => TelegramTarget | undefined;
+}): { chatId: number; target?: TelegramTarget } {
+  if (options.target)
+    return { chatId: options.target.chatId, target: options.target };
+  if (options.chatId !== undefined) {
+    return {
+      chatId: options.chatId,
+      target:
+        options.threadId !== undefined
+          ? { chatId: options.chatId, threadId: options.threadId }
+          : undefined,
+    };
+  }
+  const defaultTarget = options.getDefaultTarget?.();
+  if (defaultTarget) {
+    return { chatId: defaultTarget.chatId, target: defaultTarget };
+  }
+  const defaultChatId = options.getDefaultChatId?.();
+  if (defaultChatId === undefined) {
     throw new Error(
       "Telegram chat_id is required when no paired/default Telegram chat is available",
     );
   }
-  return chatId;
+  return { chatId: defaultChatId };
 }
 
 async function buildTelegramOutboundAttachmentViews(options: {
@@ -194,6 +230,7 @@ export function registerTelegramOutboundAttachmentTool(
     promptGuidelines: [
       "When handling a [telegram] message and the user asked for a file or generated artifact, call telegram_attach with the local path instead of only mentioning the path in text.",
       "When a local/TUI user explicitly asks to send a generated file to Telegram, telegram_attach can deliver it to the paired/default Telegram chat even without an active Telegram turn.",
+      "For an explicit thread target, provide chat_id plus thread_id; registered multi-instance followers default to their assigned thread target.",
     ],
     parameters: Type.Object({
       paths: Type.Array(
@@ -206,6 +243,12 @@ export function registerTelegramOutboundAttachmentTool(
             "Optional Telegram chat id for immediate delivery when no Telegram turn is active",
         }),
       ),
+      thread_id: Type.Optional(
+        Type.Number({
+          description:
+            "Optional Telegram topic thread id for immediate delivery with chat_id",
+        }),
+      ),
       caption: Type.Optional(
         Type.String({
           description:
@@ -219,11 +262,13 @@ export function registerTelegramOutboundAttachmentTool(
           activeTurn: deps.getActiveTurn(),
           paths: params.paths,
           chatId: params.chat_id,
+          threadId: params.thread_id,
           caption: params.caption,
           maxAttachmentsPerTurn,
           maxAttachmentSizeBytes,
           sendMultipart: deps.sendMultipart,
           getDefaultChatId: deps.getDefaultChatId,
+          getDefaultTarget: deps.getDefaultTarget,
           canSendDirect: deps.canSendDirect,
           statPath: deps.statPath,
         });
@@ -251,6 +296,7 @@ export function registerTelegramOutboundMessageTool(
       "Send direct Telegram Markdown text when the user explicitly asks for Telegram delivery outside the normal reply flow.",
     promptGuidelines: [
       "Use telegram_message only when the user explicitly asks to send a message to Telegram from the local/TUI side, or names a concrete Telegram delivery target.",
+      "For an explicit thread target, provide chat_id plus thread_id; registered multi-instance followers default to their assigned thread target.",
       "Add buttons by embedding the same top-level telegram_button HTML comments used in normal Telegram replies; Telegram does not support standalone buttons.",
       "Do not use this tool for ordinary Telegram-originated replies; answer normally so the bridge can deliver the active turn reply.",
     ],
@@ -259,13 +305,20 @@ export function registerTelegramOutboundMessageTool(
       chat_id: Type.Optional(
         Type.Number({ description: "Optional Telegram chat id" }),
       ),
+      thread_id: Type.Optional(
+        Type.Number({
+          description: "Optional Telegram topic thread id with chat_id",
+        }),
+      ),
     }),
     async execute(_toolCallId, params) {
       try {
         return await sendTelegramOutboundMessage({
           text: params.text,
           chatId: params.chat_id,
+          threadId: params.thread_id,
           getDefaultChatId: deps.getDefaultChatId,
+          getDefaultTarget: deps.getDefaultTarget,
           canSendDirect: deps.canSendDirect,
           planMessage: deps.planMessage,
           sendMarkdownMessage: deps.sendMarkdownMessage,
@@ -290,6 +343,7 @@ export interface TelegramQueuedOutboundAttachmentDeliveryDeps {
     chatId: number,
     replyToMessageId: number,
     text: string,
+    options?: { target?: TelegramTarget },
   ) => Promise<unknown>;
   recordRuntimeEvent?: (
     category: string,
@@ -304,11 +358,13 @@ export async function queueTelegramOutboundAttachments(options: {
   activeTurn: TelegramOutboundAttachmentQueueTargetView | undefined;
   paths: string[];
   chatId?: number;
+  threadId?: number;
   caption?: string;
   maxAttachmentsPerTurn: number;
   maxAttachmentSizeBytes?: number;
   sendMultipart?: TelegramQueuedOutboundAttachmentDeliveryDeps["sendMultipart"];
   getDefaultChatId?: () => number | undefined;
+  getDefaultTarget?: () => TelegramTarget | undefined;
   canSendDirect?: () => boolean;
   statPath?: (path: string) => Promise<{ isFile(): boolean; size?: number }>;
 }): Promise<TelegramOutboundAttachmentToolResult> {
@@ -321,11 +377,13 @@ export async function queueTelegramOutboundAttachments(options: {
     return sendTelegramOutboundFiles({
       paths: options.paths,
       chatId: options.chatId,
+      threadId: options.threadId,
       caption: options.caption,
       maxAttachmentsPerTurn: options.maxAttachmentsPerTurn,
       maxAttachmentSizeBytes: options.maxAttachmentSizeBytes,
       sendMultipart: options.sendMultipart,
       getDefaultChatId: options.getDefaultChatId,
+      getDefaultTarget: options.getDefaultTarget,
       canSendDirect: options.canSendDirect,
       statPath: options.statPath,
     });
@@ -359,29 +417,41 @@ export async function queueTelegramOutboundAttachments(options: {
 export async function sendTelegramOutboundMessage(options: {
   text: string;
   chatId?: number;
+  threadId?: number;
+  target?: TelegramTarget;
   getDefaultChatId?: () => number | undefined;
+  getDefaultTarget?: () => TelegramTarget | undefined;
   canSendDirect: () => boolean;
   planMessage: (markdown: string) => TelegramOutboundMessagePlan;
   sendMarkdownMessage: (
     chatId: number,
     markdown: string,
-    options?: { replyMarkup?: unknown },
+    options?: { replyMarkup?: unknown; target?: TelegramTarget },
   ) => Promise<number | undefined>;
 }): Promise<{
   content: Array<{ type: "text"; text: string }>;
   details: { chatId: number; messageId?: number };
 }> {
   assertTelegramDirectDeliveryAllowed(options.canSendDirect);
-  const chatId = resolveTelegramOutboundChatId({
+  const { chatId, target } = resolveTelegramOutboundTarget({
     chatId: options.chatId,
+    threadId: options.threadId,
+    target: options.target,
     getDefaultChatId: options.getDefaultChatId,
+    getDefaultTarget: options.getDefaultTarget,
   });
   const plan = options.planMessage(options.text);
   const messageId = await options.sendMarkdownMessage(chatId, plan.markdown, {
     replyMarkup: plan.replyMarkup,
+    target,
   });
   return {
-    content: [{ type: "text", text: formatTelegramOutboundMessageToolResultText(chatId) }],
+    content: [
+      {
+        type: "text",
+        text: formatTelegramOutboundMessageToolResultText(chatId),
+      },
+    ],
     details: { chatId, messageId },
   };
 }
@@ -389,23 +459,33 @@ export async function sendTelegramOutboundMessage(options: {
 export async function sendTelegramOutboundFiles(options: {
   paths: string[];
   chatId?: number;
+  threadId?: number;
+  target?: TelegramTarget;
   caption?: string;
   maxAttachmentsPerTurn: number;
   maxAttachmentSizeBytes?: number;
   sendMultipart: TelegramQueuedOutboundAttachmentDeliveryDeps["sendMultipart"];
   getDefaultChatId?: () => number | undefined;
+  getDefaultTarget?: () => TelegramTarget | undefined;
   canSendDirect?: () => boolean;
   statPath?: (path: string) => Promise<{ isFile(): boolean; size?: number }>;
-}): Promise<TelegramOutboundAttachmentToolResult & { details: { paths: string[]; chatId: number } }> {
+}): Promise<
+  TelegramOutboundAttachmentToolResult & {
+    details: { paths: string[]; chatId: number };
+  }
+> {
   assertTelegramDirectDeliveryAllowed(options.canSendDirect);
   if (options.paths.length > options.maxAttachmentsPerTurn) {
     throw new Error(
       `Attachment limit reached (${options.maxAttachmentsPerTurn})`,
     );
   }
-  const chatId = resolveTelegramOutboundChatId({
+  const { chatId, target } = resolveTelegramOutboundTarget({
     chatId: options.chatId,
+    threadId: options.threadId,
+    target: options.target,
     getDefaultChatId: options.getDefaultChatId,
+    getDefaultTarget: options.getDefaultTarget,
   });
   const pendingAttachments = await buildTelegramOutboundAttachmentViews({
     paths: options.paths,
@@ -421,6 +501,7 @@ export async function sendTelegramOutboundFiles(options: {
       {
         chat_id: String(chatId),
         ...(options.caption && index === 0 ? { caption: options.caption } : {}),
+        ...getTelegramMultipartTargetFields(target),
       },
       fieldName,
       attachment.path,
@@ -432,7 +513,10 @@ export async function sendTelegramOutboundFiles(options: {
     content: [
       {
         type: "text",
-        text: formatTelegramOutboundAttachmentToolResultText(added.length, "sent"),
+        text: formatTelegramOutboundAttachmentToolResultText(
+          added.length,
+          "sent",
+        ),
       },
     ],
     details: { paths: added, chatId },
@@ -442,9 +526,7 @@ export async function sendTelegramOutboundFiles(options: {
 export function createTelegramQueuedOutboundAttachmentSender(
   deps: TelegramQueuedOutboundAttachmentDeliveryDeps,
 ) {
-  return async function sendQueuedAttachments(
-    turn: TelegramQueuedOutboundAttachmentTurnView,
-  ): Promise<void> {
+  return async (turn: TelegramQueuedOutboundAttachmentTurnView): Promise<void> => {
     await sendQueuedTelegramOutboundAttachments(turn, {
       ...deps,
       maxAttachmentSizeBytes:
@@ -476,12 +558,14 @@ export async function sendQueuedTelegramOutboundAttachments(
       const replyParameters = buildTelegramMultipartReplyParameters(
         turn.chatId,
         turn.replyToMessageId,
+        turn.target,
       );
       await deps.sendMultipart(
         method,
         {
           chat_id: String(turn.chatId),
           ...(replyParameters ? { reply_parameters: replyParameters } : {}),
+          ...getTelegramMultipartTargetFields(turn.target),
         },
         fieldName,
         attachment.path,
@@ -496,6 +580,7 @@ export async function sendQueuedTelegramOutboundAttachments(
         turn.chatId,
         turn.replyToMessageId,
         `Failed to send attachment ${attachment.fileName}: ${message}`,
+        { target: turn.target },
       );
     }
   }

package/lib/outbound-buttons.ts

@@ -14,6 +14,7 @@ import {
 } from "./outbound-markup.ts";
 import {
   type PendingTelegramTurn,
+  type TelegramQueueTarget,
   truncateTelegramQueueSummary,
 } from "./queue.ts";
 
@@ -48,6 +49,7 @@ export interface TelegramButtonCallbackQuery {
   data?: string;
   message?: {
     message_id?: number;
+    message_thread_id?: number;
     chat?: { id?: number };
   };
 }
@@ -114,11 +116,11 @@ export function createTelegramButtonActionStore(
 ): TelegramButtonActionStore {
   const ttlMs = options.ttlMs ?? TELEGRAM_BUTTON_ACTION_TTL_MS;
   const actions = new Map<string, TelegramOutboundButtonStoredAction>();
-  function cleanup(currentTime: number): void {
+  const cleanup = (currentTime: number): void => {
     for (const [key, action] of actions) {
       if (currentTime - action.createdAt > ttlMs) actions.delete(key);
     }
-  }
+  };
   return {
     register: (action) => {
       const currentTime = nowMs();
@@ -180,11 +182,13 @@ export function createTelegramButtonPromptTurn(options: {
   replyToMessageId: number;
   queueOrder: number;
   action: TelegramOutboundButtonAction;
+  target?: TelegramQueueTarget;
 }): PendingTelegramTurn {
   const prompt = `[telegram] ${options.action.prompt}`;
   return {
     kind: "prompt",
     chatId: options.chatId,
+    ...(options.target ? { target: options.target } : {}),
     replyToMessageId: options.replyToMessageId,
     sourceMessageIds: [options.replyToMessageId],
     queueOrder: options.queueOrder,