@llblab/pi-telegram 0.20.4 → 0.20.6

package/lib/outbound-attachments.ts

@@ -88,6 +88,7 @@ export interface TelegramQueuedOutboundAttachmentView {
 
 export interface TelegramOutboundAttachmentQueueTargetView {
   queuedAttachments: TelegramQueuedOutboundAttachmentView[];
+  guestQueryId?: string;
 }
 
 export interface TelegramQueuedOutboundAttachmentTurnView extends TelegramOutboundAttachmentQueueTargetView {
@@ -96,6 +97,42 @@ export interface TelegramQueuedOutboundAttachmentTurnView extends TelegramOutbou
   target?: TelegramTarget;
 }
 
+export type TelegramGuestCachedAttachmentResult =
+  | {
+      type: "document";
+      id: string;
+      title: string;
+      document_file_id: string;
+      caption?: string;
+    }
+  | {
+      type: "photo";
+      id: string;
+      photo_file_id: string;
+      caption?: string;
+    }
+  | {
+      type: "audio";
+      id: string;
+      audio_file_id: string;
+      caption?: string;
+    }
+  | {
+      type: "voice";
+      id: string;
+      voice_file_id: string;
+      title: string;
+      caption?: string;
+    };
+
+interface TelegramGuestStagingMessage {
+  message_id?: number;
+  document?: { file_id?: string };
+  photo?: Array<{ file_id?: string; file_size?: number }>;
+  audio?: { file_id?: string };
+  voice?: { file_id?: string };
+}
+
 function isTelegramOutboundPhotoAttachmentPath(path: string): boolean {
   const normalized = path.toLowerCase();
   return (
@@ -107,6 +144,27 @@ function isTelegramOutboundPhotoAttachmentPath(path: string): boolean {
   );
 }
 
+function getTelegramGuestAttachmentTransport(path: string): {
+  method: "sendDocument" | "sendPhoto" | "sendAudio" | "sendVoice";
+  fileField: "document" | "photo" | "audio" | "voice";
+} {
+  const normalized = path.toLowerCase();
+  if (
+    normalized.endsWith(".jpg") ||
+    normalized.endsWith(".jpeg") ||
+    normalized.endsWith(".png")
+  ) {
+    return { method: "sendPhoto", fileField: "photo" };
+  }
+  if (normalized.endsWith(".ogg") || normalized.endsWith(".opus")) {
+    return { method: "sendVoice", fileField: "voice" };
+  }
+  if (normalized.endsWith(".mp3")) {
+    return { method: "sendAudio", fileField: "audio" };
+  }
+  return { method: "sendDocument", fileField: "document" };
+}
+
 function formatTelegramOutboundAttachmentSizeLimitError(
   size: number,
   maxSize: number,
@@ -388,6 +446,14 @@ export async function queueTelegramOutboundAttachments(options: {
       statPath: options.statPath,
     });
   }
+  if (
+    options.activeTurn.guestQueryId &&
+    options.activeTurn.queuedAttachments.length + options.paths.length > 1
+  ) {
+    throw new Error(
+      "Telegram Guest Mode supports one attachment per reply; no attachment was queued",
+    );
+  }
   if (
     options.activeTurn.queuedAttachments.length + options.paths.length >
     options.maxAttachmentsPerTurn
@@ -414,6 +480,110 @@ export async function queueTelegramOutboundAttachments(options: {
   };
 }
 
+export async function deliverTelegramGuestCachedAttachment(options: {
+  guestQueryId: string;
+  stagingChatId: number;
+  stagingTarget?: TelegramTarget;
+  attachment: TelegramQueuedOutboundAttachmentView;
+  caption?: string;
+  sendMultipart: TelegramQueuedOutboundAttachmentDeliveryDeps["sendMultipart"];
+  answerGuestQuery: (
+    guestQueryId: string,
+    result: TelegramGuestCachedAttachmentResult,
+  ) => Promise<void>;
+  answerGuestText?: (guestQueryId: string, text: string) => Promise<void>;
+  fallbackText?: string;
+  deleteMessage: (chatId: number, messageId: number) => Promise<void>;
+  recordRuntimeEvent?: TelegramOutboundAttachmentRuntimeEventRecorderPort["recordRuntimeEvent"];
+}): Promise<void> {
+  const transport = getTelegramGuestAttachmentTransport(options.attachment.path);
+  let stagingMessageId: number | undefined;
+  let answerAttempted = false;
+  try {
+    const message = (await options.sendMultipart(
+      transport.method,
+      {
+        chat_id: String(options.stagingChatId),
+        ...getTelegramMultipartTargetFields(options.stagingTarget),
+      },
+      transport.fileField,
+      options.attachment.path,
+      options.attachment.fileName,
+    )) as TelegramGuestStagingMessage;
+    stagingMessageId = message.message_id;
+    const caption = options.caption
+      ? Array.from(options.caption).slice(0, 1024).join("")
+      : undefined;
+    let result: TelegramGuestCachedAttachmentResult;
+    if (transport.fileField === "photo") {
+      const photo = [...(message.photo ?? [])]
+        .sort((left, right) => (left.file_size ?? 0) - (right.file_size ?? 0))
+        .at(-1);
+      if (!photo?.file_id) throw new Error("Guest staging upload returned no photo file_id");
+      result = {
+        type: "photo",
+        id: "attachment-1",
+        photo_file_id: photo.file_id,
+        ...(caption ? { caption } : {}),
+      };
+    } else if (transport.fileField === "audio") {
+      if (!message.audio?.file_id)
+        throw new Error("Guest staging upload returned no audio file_id");
+      result = {
+        type: "audio",
+        id: "attachment-1",
+        audio_file_id: message.audio.file_id,
+        ...(caption ? { caption } : {}),
+      };
+    } else if (transport.fileField === "voice") {
+      if (!message.voice?.file_id)
+        throw new Error("Guest staging upload returned no voice file_id");
+      result = {
+        type: "voice",
+        id: "attachment-1",
+        voice_file_id: message.voice.file_id,
+        title: options.attachment.fileName,
+        ...(caption ? { caption } : {}),
+      };
+    } else {
+      if (!message.document?.file_id)
+        throw new Error("Guest staging upload returned no document file_id");
+      result = {
+        type: "document",
+        id: "attachment-1",
+        title: options.attachment.fileName,
+        document_file_id: message.document.file_id,
+        ...(caption ? { caption } : {}),
+      };
+    }
+    answerAttempted = true;
+    await options.answerGuestQuery(options.guestQueryId, result);
+  } catch (error) {
+    if (
+      !answerAttempted &&
+      options.answerGuestText &&
+      options.fallbackText
+    ) {
+      answerAttempted = true;
+      await options.answerGuestText(options.guestQueryId, options.fallbackText);
+    } else {
+      throw error;
+    }
+  } finally {
+    if (stagingMessageId !== undefined) {
+      try {
+        await options.deleteMessage(options.stagingChatId, stagingMessageId);
+      } catch (error) {
+        options.recordRuntimeEvent?.("attachment", error, {
+          phase: "guest-staging-cleanup",
+          chatId: options.stagingChatId,
+          messageId: stagingMessageId,
+        });
+      }
+    }
+  }
+}
+
 export async function sendTelegramOutboundMessage(options: {
   text: string;
   chatId?: number;

package/lib/outbound-markup.ts

@@ -64,6 +64,36 @@ function isTopLevelClosingFence(
   );
 }
 
+function collectPairedTelegramVoiceActionBody(
+  markdown: string,
+  bodyStart: number,
+  commentContent: string,
+): { content: string; end: number } | undefined {
+  const normalizedContent = commentContent.trim();
+  if (
+    !normalizedContent.startsWith("telegram_voice") ||
+    !isTelegramActionCommentContent(commentContent)
+  ) {
+    return undefined;
+  }
+  let offset = bodyStart;
+  while (offset < markdown.length) {
+    const lineEnd = getMarkdownLineEnd(markdown, offset);
+    const line = getMarkdownLineText(markdown, offset, lineEnd);
+    if (line === "<!-- /telegram_voice -->") {
+      const body = markdown.slice(bodyStart, offset).trim();
+      if (!body) return undefined;
+      return {
+        content: `${commentContent.trimEnd()}\n${body}`,
+        end: lineEnd,
+      };
+    }
+    if (line.startsWith("<!--")) return undefined;
+    offset = lineEnd;
+  }
+  return undefined;
+}
+
 function collectInlineClosedTelegramActionBody(
   markdown: string,
   bodyStart: number,
@@ -117,14 +147,19 @@ export function collectTopLevelHtmlComments(markdown: string): {
       const closesOnOpeningLine = closeIndex < lineEnd;
       const hasOnlyWhitespaceAfterClose =
         line.slice(closeColumn + 3).trim() === "";
-      const inlineBody =
+      const pairedVoiceBody =
         closesOnOpeningLine && hasOnlyWhitespaceAfterClose
+          ? collectPairedTelegramVoiceActionBody(markdown, lineEnd, content)
+          : undefined;
+      const inlineBody =
+        !pairedVoiceBody && closesOnOpeningLine && hasOnlyWhitespaceAfterClose
           ? collectInlineClosedTelegramActionBody(markdown, lineEnd, content)
           : undefined;
-      if (inlineBody) {
-        end = inlineBody.end;
+      const recoveredBody = pairedVoiceBody ?? inlineBody;
+      if (recoveredBody) {
+        end = recoveredBody.end;
         raw = markdown.slice(offset, end);
-        content = inlineBody.content;
+        content = recoveredBody.content;
       }
       comments.push({ raw, content, start: offset, end });
       offset = getMarkdownLineEnd(markdown, end);

package/lib/paths.ts

@@ -76,9 +76,10 @@ export function getTelegramDiagnosticsDisplayPaths(profileName?: string): {
   logs: string;
 } {
   const suffix = getTelegramProfilePathSuffix(profileName);
+  const profileSlug = suffix.slice(1);
   return {
     state: `~/.pi/agent/tmp/telegram/state${suffix}.json`,
-    logs: `~/.pi/agent/tmp/telegram/logs${suffix}.jsonl`,
+    logs: `~/.pi/agent/tmp/telegram/logs${profileSlug ? `.${profileSlug}` : ""}.jsonl`,
   };
 }
 

package/lib/prompts.ts

@@ -16,7 +16,7 @@ Telegram bridge available. Do not use it from local/TUI prompts unless explicitl
 
 const TELEGRAM_TURN_SYSTEM_PROMPT_SUFFIX = `
 
-Telegram turn note: If context was compacted or you need the pi-telegram bridge contract, call tool \`telegram_help\`; hidden comments are valid only for explicit \`telegram_voice\` or \`telegram_button\` actions with payload.`;
+Telegram turn note: If context was compacted or you need the pi-telegram bridge contract, call tool \`telegram_help\`; hidden comments are valid only for explicit \`telegram_voice\` or \`telegram_button\` actions with payload. For voice use a top-level HTML action: \`<!-- telegram_voice: Speak this. -->\`, multiline \`<!-- telegram_voice lang=ru\nSpeak this.\n-->\`, or paired \`<!-- telegram_voice lang=ru -->\nSpeak this.\n<!-- /telegram_voice -->\`.`;
 
 function buildTelegramHelpText(profileName?: string): string {
   const diagnosticsPaths = getTelegramDiagnosticsDisplayPaths(profileName);
@@ -37,7 +37,8 @@ How to answer Telegram turns:
 Assistant-authored Telegram actions:
 - \`telegram_voice\` and \`telegram_button\` are hidden top-level HTML comments, not Pi tools.
 - Put action comments at column zero, outside code, quotes, lists, and indented examples.
-- Voice forms: \`<!-- telegram_voice text="Short summary" -->\` or \`<!-- telegram_voice: Short summary -->\`.
+- Voice forms: \`<!-- telegram_voice text="Short summary" -->\`, \`<!-- telegram_voice: Short summary -->\`, multiline \`<!-- telegram_voice lang=ru\nShort summary.\n-->\`, or paired \`<!-- telegram_voice lang=ru -->\nShort summary.\n<!-- /telegram_voice -->\`.
+- Keep the complete action at top level and include a non-empty voice payload.
 - Keep voice text TTS-friendly; avoid raw Markdown, code, and tables in voice text.
 - Voice delivery generates and attaches OGG automatically; do not also call \`telegram_attach\` for the same audio.
 - Button forms: \`<!-- telegram_button: OK -->\`, \`<!-- telegram_button label=Continue prompt="Continue with the current plan." -->\`, or multiline \`<!-- telegram_button label="Show risks"\nList the main risks first.\n-->\`.

package/lib/queue.ts

@@ -899,6 +899,16 @@ export interface TelegramAgentEndRuntimeDeps<
     options?: { parseMode?: string },
   ) => Promise<void>;
   sendGuestReply?: (guestQueryId: string, markdown: string) => Promise<void>;
+  sendGuestAttachment?: (
+    turn: TTurn,
+    attachment: QueuedAttachment,
+    caption?: string,
+  ) => Promise<void>;
+  sendGuestVoiceReply?: (
+    turn: TTurn,
+    plan: TelegramAgentEndOutboundReplyPlan<TReplyMarkup>,
+    caption?: string,
+  ) => Promise<void>;
   planOutboundReply?: (
     markdown: string,
   ) => TelegramAgentEndOutboundReplyPlan<TReplyMarkup>;
@@ -958,6 +968,8 @@ export interface TelegramAgentEndHookRuntimeDeps<
   sendQueuedAttachments: (turn: TTurn) => Promise<void>;
   answerGuestQuery?: TelegramAgentEndRuntimeDeps<TTurn>["answerGuestQuery"];
   sendGuestReply?: TelegramAgentEndRuntimeDeps<TTurn>["sendGuestReply"];
+  sendGuestAttachment?: TelegramAgentEndRuntimeDeps<TTurn>["sendGuestAttachment"];
+  sendGuestVoiceReply?: TelegramAgentEndRuntimeDeps<TTurn>["sendGuestVoiceReply"];
   planOutboundReply?: TelegramAgentEndRuntimeDeps<
     TTurn,
     TReplyMarkup
@@ -1083,6 +1095,8 @@ export function createTelegramAgentEndHook<
       sendQueuedAttachments: deps.sendQueuedAttachments,
       answerGuestQuery: deps.answerGuestQuery,
       sendGuestReply: deps.sendGuestReply,
+      sendGuestAttachment: deps.sendGuestAttachment,
+      sendGuestVoiceReply: deps.sendGuestVoiceReply,
       planOutboundReply: deps.planOutboundReply,
       sendOutboundReplyArtifacts: deps.sendOutboundReplyArtifacts,
       getDefaultChatId: deps.getDefaultChatId,
@@ -1181,7 +1195,38 @@ export async function handleTelegramAgentEndRuntime<
       if (endPlan.shouldDispatchNext) deps.dispatchNextQueuedTelegramTurn();
       return;
     }
-    if (finalText) {
+    const [guestAttachment] = turn.queuedAttachments;
+    if (guestAttachment && deps.sendGuestAttachment) {
+      try {
+        await deps.sendGuestAttachment(
+          turn,
+          guestAttachment,
+          finalText || undefined,
+        );
+      } catch (error) {
+        deps.recordRuntimeEvent?.("delivery", error, {
+          phase: "guest-attachment",
+          guestQueryId: turn.guestQueryId,
+        });
+      }
+    } else if (
+      outboundReply &&
+      (outboundReply.voiceText || outboundReply.voiceReplies?.length) &&
+      deps.sendGuestVoiceReply
+    ) {
+      try {
+        await deps.sendGuestVoiceReply(
+          turn,
+          outboundReply,
+          finalText || undefined,
+        );
+      } catch (error) {
+        deps.recordRuntimeEvent?.("delivery", error, {
+          phase: "guest-voice",
+          guestQueryId: turn.guestQueryId,
+        });
+      }
+    } else if (finalText) {
       if (deps.sendGuestReply) {
         await deps.sendGuestReply(turn.guestQueryId, finalText);
       } else {

package/lib/routing.ts

@@ -21,10 +21,67 @@ import * as TextGroups from "./text-groups.ts";
 import * as ThreadReconciler from "./thread-reconciler.ts";
 import * as Turns from "./turns.ts";
 
-function formatTelegramPromptPeer(user: { id?: unknown; username?: unknown } | undefined): string | undefined {
-  if (!user) return undefined;
-  if (typeof user.username === "string" && user.username.length > 0) return user.username;
-  return typeof user.id === "number" ? String(user.id) : undefined;
+interface TelegramPromptPeerView {
+  id?: unknown;
+  username?: unknown;
+  first_name?: unknown;
+  last_name?: unknown;
+  title?: unknown;
+}
+
+function formatTelegramPromptPeer(
+  peer: TelegramPromptPeerView | undefined,
+): string | undefined {
+  if (!peer) return undefined;
+  if (typeof peer.username === "string" && peer.username.length > 0) {
+    return peer.username;
+  }
+  const displayName = [peer.first_name, peer.last_name]
+    .filter(
+      (part): part is string =>
+        typeof part === "string" && part.length > 0,
+    )
+    .join(" ");
+  if (displayName) return displayName;
+  if (typeof peer.title === "string" && peer.title.length > 0) {
+    return peer.title;
+  }
+  return typeof peer.id === "number" ? String(peer.id) : undefined;
+}
+
+function isTelegramPromptOwnerPeer(
+  peer: TelegramPromptPeerView | undefined,
+  ownerUserId: number | undefined,
+): boolean {
+  return ownerUserId !== undefined && peer?.id === ownerUserId;
+}
+
+export function resolveTelegramGuestPromptPeer(input: {
+  chatType?: string;
+  chat?: TelegramPromptPeerView;
+  from?: TelegramPromptPeerView;
+  replyFrom?: TelegramPromptPeerView;
+  guestBotCallerUser?: TelegramPromptPeerView;
+  guestBotCallerChat?: TelegramPromptPeerView;
+  ownerUserId?: number;
+}): string | undefined {
+  if (input.chatType !== "private") {
+    return formatTelegramPromptPeer(input.chat);
+  }
+  if (!isTelegramPromptOwnerPeer(input.from, input.ownerUserId)) {
+    return formatTelegramPromptPeer(input.from);
+  }
+  for (const candidate of [
+    input.replyFrom,
+    input.chat,
+    input.guestBotCallerUser,
+    input.guestBotCallerChat,
+  ]) {
+    if (isTelegramPromptOwnerPeer(candidate, input.ownerUserId)) continue;
+    const peer = formatTelegramPromptPeer(candidate);
+    if (peer) return peer;
+  }
+  return undefined;
 }
 
 function appendTelegramSourceAttachmentSection(
@@ -1812,22 +1869,43 @@ export function createTelegramInboundRouteRuntime<
     const gm = guestMessage as unknown as Record<string, unknown>;
     // Build telegram prefix with guest context
     const chatRaw = gm.chat as Record<string, unknown>;
-    const chatTitle = chatRaw?.title as string | undefined;
     const chatType = chatRaw?.type as string;
     const fromRaw = gm.from as Record<string, unknown> | undefined;
     const replyMsg = gm.reply_to_message as Record<string, unknown> | undefined;
     const replyFromRaw = replyMsg?.from as Record<string, unknown> | undefined;
-    const fromPeer = formatTelegramPromptPeer(fromRaw);
+    const guestBotCallerUser = gm.guest_bot_caller_user as
+      | Record<string, unknown>
+      | undefined;
+    const guestBotCallerChat = gm.guest_bot_caller_chat as
+      | Record<string, unknown>
+      | undefined;
+    const ownerUserId = deps.configStore.getAllowedUserId();
     const replyPeer = formatTelegramPromptPeer(replyFromRaw);
-    const fromIsOwner = fromRaw?.id === deps.configStore.getAllowedUserId();
-    const guestPeer = chatType === "private" && fromIsOwner && replyPeer
-      ? replyPeer
-      : fromPeer;
+    const guestPeer = resolveTelegramGuestPromptPeer({
+      chatType,
+      chat: chatRaw,
+      from: fromRaw,
+      replyFrom: replyFromRaw,
+      guestBotCallerUser,
+      guestBotCallerChat,
+      ownerUserId,
+    });
     const prefixParts = ["telegram"];
-    if (chatType !== "private" && chatTitle) {
-      prefixParts.push(`guest:${chatTitle}`);
-    } else if (chatType === "private" && guestPeer) {
+    if (guestPeer) {
       prefixParts.push(`guest:${guestPeer}`);
+    } else if (chatType === "private") {
+      deps.recordRuntimeEvent?.(
+        "guest",
+        new Error("Private Guest Mode remote peer could not be resolved"),
+        {
+          phase: "peer-attribution",
+          chatId: typeof chatRaw?.id === "number" ? chatRaw.id : undefined,
+          fromId: typeof fromRaw?.id === "number" ? fromRaw.id : undefined,
+          hasReplyFrom: !!replyFromRaw,
+          hasCallerUser: !!guestBotCallerUser,
+          hasCallerChat: !!guestBotCallerChat,
+        },
+      );
     }
     const telegramPrefix = `[${prefixParts.join("|")}]`;
     // Extract reply context

package/lib/setup.ts

@@ -197,8 +197,14 @@ export function createTelegramSetupPromptRuntime<
         promptEditor: (label, value) => ctx.ui.editor(label, value),
         getMe: deps.getMe,
         persistConfig: async (config) => {
-          await deps.persistConfig(config);
+          const previousConfig = deps.getConfig();
           deps.setConfig(config);
+          try {
+            await deps.persistConfig(config);
+          } catch (error) {
+            deps.setConfig(previousConfig);
+            throw error;
+          }
         },
         notify: (message, level) => ctx.ui.notify(message, level),
         startPolling: () => deps.startPolling(ctx),

package/lib/status.ts

@@ -181,6 +181,7 @@ export interface TelegramBridgeStatusLineState {
   hasBotToken?: boolean;
   botUsername?: string;
   activeProfileName?: string;
+  diagnosticPaths?: { state: string; logs: string };
   allowedUserId?: number;
   botThreadMode?: "unknown" | "enabled" | "disabled";
   botThreadModeUpdatedAtMs?: number;
@@ -259,6 +260,9 @@ export interface TelegramBridgeStatusRuntimeDeps<
   statusKey?: string;
   getConfig: () => TelegramBridgeStatusConfig;
   getActiveProfileName?: () => string | undefined;
+  getDiagnosticPaths?: (
+    profileName?: string,
+  ) => { state: string; logs: string };
   isPollingActive: () => boolean;
   getActiveSourceMessageIds: () => number[] | undefined;
   hasActiveTurn: () => boolean;
@@ -620,10 +624,12 @@ export function createTelegramBridgeStatusRuntime<
     getBridgeStatusLineState: () => {
       const config = deps.getConfig();
       const botThreadMode = deps.getBotThreadMode?.();
+      const activeProfileName = deps.getActiveProfileName?.();
       return {
         hasBotToken: Boolean(config.botToken),
         botUsername: config.botUsername,
-        activeProfileName: deps.getActiveProfileName?.(),
+        activeProfileName,
+        diagnosticPaths: deps.getDiagnosticPaths?.(activeProfileName),
         allowedUserId: config.allowedUserId,
         botThreadMode: botThreadMode?.threadMode,
         botThreadModeUpdatedAtMs: botThreadMode?.updatedAtMs,
@@ -774,9 +780,6 @@ export function buildTelegramStatusBarText(
     return `${label} ${theme.fg("warning", "electing")}${queued}`;
   if (!state.pollingActive && state.busRole !== "follower")
     return `${theme.fg("accent", "telegram")} ${theme.fg("muted", "disconnected")}${queued}`;
-  if (state.compactionInProgress) {
-    return `${label} ${theme.fg("warning", "compacting")}${queued}`;
-  }
   if (state.processing) {
     const processingStatus = state.queuedStatus
       ? "active"
@@ -1058,19 +1061,18 @@ function buildTelegramBridgeCompactStatusLines(
       ? ` (control=${controlQueueCount}, priority=${priorityQueueCount}, default=${defaultQueueCount})`
       : ""
   }`;
-  const executionState = state.compactionInProgress
-    ? "compacting"
-    : state.pendingDispatch
-      ? "pending dispatch"
-      : state.activeSourceMessageIds?.length
-        ? "active"
-        : "idle";
+  const executionState = state.pendingDispatch
+    ? "pending dispatch"
+    : state.activeSourceMessageIds?.length
+      ? "active"
+      : "idle";
   const profileSuffix = state.activeProfileName
     ? `.${state.activeProfileName.replace(/[^a-zA-Z0-9._-]+/g, "_")}`
     : "";
-  const diagnosticsPaths = {
+  const profileSlug = profileSuffix.slice(1);
+  const diagnosticsPaths = state.diagnosticPaths ?? {
     state: `~/.pi/agent/tmp/telegram/state${profileSuffix}.json`,
-    logs: `~/.pi/agent/tmp/telegram/logs${profileSuffix}.jsonl`,
+    logs: `~/.pi/agent/tmp/telegram/logs${profileSlug ? `.${profileSlug}` : ""}.jsonl`,
   };
   return [
     "connection:",
@@ -1251,7 +1253,6 @@ function buildContextSummary(
 }
 
 function buildStatusSummary(ctx: TelegramStatusContext): string {
-  if (ctx.isCompactionInProgress?.()) return "compacting";
   if (ctx.hasPendingMessages?.()) return "pending";
   if (ctx.isIdle?.() === false) return "active";
   if (ctx.isIdle?.() === true) return "idle";

package/lib/telegram-api.ts

@@ -287,6 +287,44 @@ export interface TelegramFileDownloadOptions {
   maxFileSizeBytes?: number;
 }
 
+export type TelegramGuestCachedMediaResult =
+  | {
+      type: "document";
+      id: string;
+      title: string;
+      document_file_id: string;
+      caption?: string;
+      parse_mode?: string;
+    }
+  | {
+      type: "photo";
+      id: string;
+      photo_file_id: string;
+      caption?: string;
+      parse_mode?: string;
+    }
+  | {
+      type: "audio";
+      id: string;
+      audio_file_id: string;
+      caption?: string;
+      parse_mode?: string;
+    }
+  | {
+      type: "voice";
+      id: string;
+      voice_file_id: string;
+      title: string;
+      caption?: string;
+      parse_mode?: string;
+    };
+
+export interface TelegramAnswerGuestQueryOptions {
+  parseMode?: string;
+  richMessage?: TelegramInputRichMessage;
+  result?: TelegramGuestCachedMediaResult;
+}
+
 export interface TelegramAnswerCallbackQueryOptions {
   recordRuntimeEvent?: (
     kind: "api",
@@ -322,7 +360,7 @@ export interface TelegramApiClient {
   answerGuestQuery?: (
     guestQueryId: string,
     text?: string,
-    options?: { parseMode?: string; richMessage?: TelegramInputRichMessage },
+    options?: TelegramAnswerGuestQueryOptions,
   ) => Promise<void>;
 }
 
@@ -401,7 +439,7 @@ export interface TelegramBridgeApiRuntime {
   answerGuestQuery: (
     guestQueryId: string,
     text?: string,
-    options?: { parseMode?: string; richMessage?: TelegramInputRichMessage },
+    options?: TelegramAnswerGuestQueryOptions,
   ) => Promise<void>;
   deleteMessage: (chatId: number, messageId: number) => Promise<void>;
   prepareTempDir: () => Promise<number>;
@@ -1312,12 +1350,12 @@ export function createTelegramBridgeApiRuntime(
     answerGuestQuery: (
       guestQueryId: string,
       text: string | undefined,
-      options:
-        | { parseMode?: string; richMessage?: TelegramInputRichMessage }
-        | undefined,
+      options: TelegramAnswerGuestQueryOptions | undefined,
     ) => {
       const body: Record<string, unknown> = { guest_query_id: guestQueryId };
-      if (text !== undefined || options?.richMessage) {
+      if (options?.result) {
+        body.result = options.result;
+      } else if (text !== undefined || options?.richMessage) {
         const inputContent: Record<string, unknown> = options?.richMessage
           ? { rich_message: options.richMessage }
           : { message_text: text };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-telegram",
-  "version": "0.20.4",
+  "version": "0.20.6",
   "private": false,
   "publishConfig": {
     "access": "public"