@llblab/pi-telegram 0.20.3 → 0.20.5

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/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/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/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/lib/threads.ts

@@ -183,6 +183,9 @@ export interface TelegramTopicTargetStore {
   load: () => Promise<void>;
   persist: () => Promise<void>;
   list: () => TelegramTopicTargetRecord[];
+  getFollowerRecoveryHintByTarget?: (
+    target: TelegramTarget,
+  ) => { slot?: string; threadName?: string } | undefined;
   listReservations: () => TelegramThreadReservation[];
   listPendingProvisions: () => TelegramThreadPendingProvision[];
   listSyncObservations: () => TelegramTopicSyncObservation[];
@@ -266,6 +269,7 @@ export function reconcileTelegramFreshAllocationCursor(
 export interface TelegramTopicTargetStoreOptions {
   path: string | (() => string);
   getNowMs?: () => number;
+  canPersist?: () => boolean;
 }
 
 export interface TelegramTopicTargetProvisionerDeps {
@@ -869,6 +873,54 @@ function targetMatches(left: TelegramTarget, right: TelegramTarget): boolean {
   return left.chatId === right.chatId && left.threadId === right.threadId;
 }
 
+function getTargetRecoveryHintKey(target: TelegramTarget): string {
+  return `${target.chatId}:${target.threadId ?? "private"}`;
+}
+
+function parseFollowerRecoveryHints(
+  value: unknown,
+): Map<string, { slot?: string; threadName?: string }> {
+  const hints = new Map<string, { slot?: string; threadName?: string }>();
+  if (!value || typeof value !== "object" || Array.isArray(value)) return hints;
+  const liveRoster = (value as Record<string, unknown>).liveRoster;
+  if (!liveRoster || typeof liveRoster !== "object" || Array.isArray(liveRoster))
+    return hints;
+  const followers = (liveRoster as Record<string, unknown>).busFollowers;
+  if (!Array.isArray(followers)) return hints;
+  for (const follower of followers) {
+    if (!follower || typeof follower !== "object" || Array.isArray(follower))
+      continue;
+    const record = follower as Record<string, unknown>;
+    const target = record.target;
+    if (!target || typeof target !== "object" || Array.isArray(target)) continue;
+    const targetRecord = target as Record<string, unknown>;
+    if (typeof targetRecord.chatId !== "number") continue;
+    const normalizedTarget: TelegramTarget = {
+      chatId: targetRecord.chatId,
+      ...(typeof targetRecord.threadId === "number"
+        ? { threadId: targetRecord.threadId }
+        : {}),
+    };
+    const slot =
+      typeof targetRecord.slot === "string" && /^[A-Z]$/.test(targetRecord.slot)
+        ? targetRecord.slot
+        : typeof record.slot === "string" && /^[A-Z]$/.test(record.slot)
+          ? record.slot
+          : undefined;
+    const threadName =
+      typeof targetRecord.threadName === "string"
+        ? targetRecord.threadName
+        : typeof record.threadName === "string"
+          ? record.threadName
+          : undefined;
+    hints.set(getTargetRecoveryHintKey(normalizedTarget), {
+      ...(slot ? { slot } : {}),
+      ...(threadName ? { threadName } : {}),
+    });
+  }
+  return hints;
+}
+
 function getInstanceProcessKey(
   instanceId: string | undefined,
 ): string | undefined {
@@ -905,6 +957,10 @@ export function createTelegramTopicTargetStore(
   let reservations: TelegramThreadReservation[] = [];
   let pendingProvisions: TelegramThreadPendingProvision[] = [];
   let syncObservations: TelegramTopicSyncObservation[] = [];
+  let followerRecoveryHints = new Map<
+    string,
+    { slot?: string; threadName?: string }
+  >();
   let loaded = false;
   let loadedPath: string | undefined;
   let dirty = false;
@@ -939,6 +995,7 @@ export function createTelegramTopicTargetStore(
     reservations = [];
     pendingProvisions = [];
     syncObservations = [];
+    followerRecoveryHints = new Map();
     statusSnapshot = {};
     loaded = false;
     dirty = false;
@@ -955,11 +1012,14 @@ export function createTelegramTopicTargetStore(
       reservations = [];
       pendingProvisions = [];
       syncObservations = [];
+      followerRecoveryHints = new Map();
       loaded = true;
       return;
     }
     const content = await readFile(path, "utf8");
-    const file = parseTopicTargetFile(JSON.parse(content));
+    const rawFile: unknown = JSON.parse(content);
+    const file = parseTopicTargetFile(rawFile);
+    followerRecoveryHints = parseFollowerRecoveryHints(rawFile);
     botState = file.bot;
     records = new Map(
       file.threads.map((record) => [
@@ -993,6 +1053,7 @@ export function createTelegramTopicTargetStore(
       target: { ...observation.target },
     }));
     loaded = true;
+    dirty = false;
   };
 
   return {
@@ -1003,7 +1064,11 @@ export function createTelegramTopicTargetStore(
     async persist() {
       const path = getPath();
       if (loadedPath !== path && !dirty) resetForPath(path);
-      if (!loaded && !dirty) await loadFromDisk();
+      if (options.canPersist && !options.canPersist()) {
+        await loadFromDisk();
+        return;
+      }
+      if (!dirty || !loaded) await loadFromDisk();
       await mkdir(dirname(path), { recursive: true });
       const tempPath = `${path}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`;
       const nowMs = getNowMs();
@@ -1058,6 +1123,10 @@ export function createTelegramTopicTargetStore(
     list() {
       return Array.from(records.values()).map(cloneRecord);
     },
+    getFollowerRecoveryHintByTarget(target) {
+      const hint = followerRecoveryHints.get(getTargetRecoveryHintKey(target));
+      return hint ? { ...hint } : undefined;
+    },
     listReservations() {
       const nowMs = getNowMs();
       return reservations
@@ -1962,6 +2031,48 @@ export async function provisionOwnBusTopic(
   };
 }
 
+export interface TelegramInstanceThreadIdentityCandidate {
+  target?: TelegramTarget;
+  slot?: string;
+  threadName?: string;
+}
+
+export function resolveTelegramInstanceThreadIdentity(options: {
+  target?: TelegramTarget;
+  follower?: TelegramInstanceThreadIdentityCandidate;
+  leader?: TelegramInstanceThreadIdentityCandidate;
+  record?: TelegramTopicTargetRecord;
+}): TelegramInstanceThreadIdentityCandidate {
+  const targetMatchesCandidate = (
+    candidate: TelegramInstanceThreadIdentityCandidate | undefined,
+  ) => {
+    if (!candidate) return false;
+    if (!options.target) return true;
+    return !!candidate.target && targetMatches(candidate.target, options.target);
+  };
+  const local = targetMatchesCandidate(options.follower)
+    ? options.follower
+    : targetMatchesCandidate(options.leader)
+      ? options.leader
+      : undefined;
+  const record =
+    options.record &&
+    (!options.target || targetMatches(options.record.target, options.target))
+      ? options.record
+      : undefined;
+  return {
+    ...(local?.target ?? record?.target
+      ? { target: local?.target ?? record?.target }
+      : {}),
+    ...(local?.slot ?? record?.slot
+      ? { slot: local?.slot ?? record?.slot }
+      : {}),
+    ...(local?.threadName ?? record?.threadName
+      ? { threadName: local?.threadName ?? record?.threadName }
+      : {}),
+  };
+}
+
 export function findCurrentTelegramInstanceThreadRecord(options: {
   records: readonly TelegramTopicTargetRecord[];
   instanceId: string;

package/package.json

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