@llblab/pi-telegram 0.49.0 → 0.50.1

package/lib/menu-queue.ts

@@ -31,6 +31,8 @@ type TelegramQueueMenuReplyMarkup = TelegramInlineKeyboardMarkup;
 interface TelegramQueueMenuItem {
   chatId: number;
   replyToMessageId: number;
+  queueOrder: number;
+  isGuest: boolean;
   queuePosition: number;
   isPriority: boolean;
   priorityEmoji?: string;
@@ -60,6 +62,8 @@ function toTelegramQueueMenuItems<Context>(
     return {
       chatId: item.chatId,
       replyToMessageId: item.replyToMessageId,
+      queueOrder: item.queueOrder,
+      isGuest: item.kind === "prompt" && item.guestQueryId !== undefined,
       queuePosition: index + 1,
       isPriority: item.queueLane === "priority",
       priorityEmoji: item.kind === "prompt" ? item.priorityEmoji : undefined,
@@ -106,7 +110,9 @@ function buildTelegramQueueMenuReplyMarkup(
     return [
       {
         text: label,
-        callback_data: `queue:pick:${item.chatId}:${item.replyToMessageId}`,
+        callback_data: item.isGuest
+          ? `queue:guest-pick:${item.queueOrder}`
+          : `queue:pick:${item.chatId}:${item.replyToMessageId}`,
       },
     ];
   });
@@ -178,6 +184,22 @@ function getTelegramQueueMenuItemText(item: TelegramQueueMenuItem): string {
   return `${heading}\n${preview}`;
 }
 
+function buildTelegramGuestQueueItemSubmenuReplyMarkup(
+  queueOrder: number,
+): TelegramQueueMenuReplyMarkup {
+  return {
+    inline_keyboard: [
+      [{ text: "⬆️ Back", callback_data: "queue:list" }],
+      [
+        {
+          text: "🔴 Skip",
+          callback_data: `queue:guest-skip:${queueOrder}`,
+        },
+      ],
+    ],
+  };
+}
+
 function buildTelegramQueueItemSubmenuReplyMarkup(
   chatId: number,
   replyToMessageId: number,
@@ -217,6 +239,8 @@ interface TelegramQueueMenuCallbackDeps<Context = unknown> {
     chatId: number,
     replyToMessageId: number,
   ) => TelegramQueueMenuItem | undefined;
+  findGuestItem: (queueOrder: number) => TelegramQueueMenuItem | undefined;
+  skipGuest: (queueOrder: number, ctx: Context) => Promise<boolean>;
   togglePriority: (chatId: number, replyToMessageId: number) => boolean;
   setPriority: (
     chatId: number,
@@ -275,6 +299,38 @@ async function handleTelegramQueueMenuCallback<Context>(
     );
     return true;
   }
+  const guestPickMatch = data.match(/^queue:guest-pick:(\d+)$/);
+  if (guestPickMatch) {
+    await handleTelegramGuestQueueMenuPick(
+      callbackQueryId,
+      replyChatId,
+      replyMessageId,
+      Number(guestPickMatch[1]),
+      deps,
+    );
+    return true;
+  }
+  const guestSkipMatch = data.match(/^queue:guest-skip:(\d+)$/);
+  if (guestSkipMatch) {
+    const skipped = await deps.skipGuest(Number(guestSkipMatch[1]), ctx);
+    if (!skipped) {
+      await refreshStaleTelegramQueueMenuItem(
+        callbackQueryId,
+        replyChatId,
+        replyMessageId,
+        deps,
+      );
+      return true;
+    }
+    await updateTelegramQueueMenuList(
+      callbackQueryId,
+      replyChatId,
+      replyMessageId,
+      deps,
+      "Guest prompt skipped.",
+    );
+    return true;
+  }
   const pickMatch = data.match(/^queue:pick:(\d+):(\d+)$/);
   if (pickMatch) {
     await handleTelegramQueueMenuPick(
@@ -379,6 +435,31 @@ async function refreshStaleTelegramQueueMenuItem<Context>(
   );
 }
 
+async function handleTelegramGuestQueueMenuPick<Context>(
+  callbackQueryId: string,
+  replyChatId: number,
+  replyMessageId: number,
+  queueOrder: number,
+  deps: TelegramQueueMenuCallbackDeps<Context>,
+): Promise<void> {
+  const item = deps.findGuestItem(queueOrder);
+  if (!item) {
+    return refreshStaleTelegramQueueMenuItem(
+      callbackQueryId,
+      replyChatId,
+      replyMessageId,
+      deps,
+    );
+  }
+  await deps.updateQueueMessage(
+    replyChatId,
+    replyMessageId,
+    getTelegramQueueMenuItemText(item),
+    buildTelegramGuestQueueItemSubmenuReplyMarkup(queueOrder),
+  );
+  await deps.answerCallbackQuery(callbackQueryId);
+}
+
 async function handleTelegramQueueMenuPick<Context>(
   callbackQueryId: string,
   replyChatId: number,
@@ -606,6 +687,7 @@ export function createTelegramQueueMenuRuntime<
     ctx: Context,
   ) => Promise<void>;
   updateStatus: (ctx: Context) => void;
+  dismissGuestPlaceholder?: (inlineMessageId: string) => Promise<void>;
 }): TelegramQueueMenuRuntime<Context> {
   const sendQueueMenuMessage = createQueueMenuSendMessageAdapter(
     deps.sendInteractiveMessage,
@@ -628,6 +710,7 @@ export function createTelegramQueueMenuRuntime<
       updateStatusMessage: deps.updateStatusMessage,
       answerCallbackQuery: deps.answerCallbackQuery,
       updateStatus: deps.updateStatus,
+      dismissGuestPlaceholder: deps.dismissGuestPlaceholder,
     }),
   };
 }
@@ -695,6 +778,7 @@ function createQueueMenuCallbackHandler<
     text?: string,
   ) => Promise<void>;
   updateStatus: (ctx: Context) => void;
+  dismissGuestPlaceholder?: (inlineMessageId: string) => Promise<void>;
 }) {
   return async (
     query: TelegramQueueMenuCallbackQuery,
@@ -737,6 +821,11 @@ function createQueueMenuCallbackHandler<
     const findItem = (cId: number, rId: number) => {
       return findTelegramQueueMenuItem(toMenuItems(), cId, rId);
     };
+    const findGuestItem = (queueOrder: number) => {
+      return toMenuItems().find((item) => {
+        return item.isGuest && item.queueOrder === queueOrder;
+      });
+    };
     return handleTelegramQueueMenuCallback(
       query.id,
       data,
@@ -746,6 +835,14 @@ function createQueueMenuCallbackHandler<
       {
         getQueuedItems: toMenuItems,
         findItem,
+        findGuestItem,
+        skipGuest: (queueOrder, callbackContext) => {
+          return skipQueuedTelegramGuestPrompt(queueOrder, callbackContext, {
+            getQueueSnapshot,
+            queueMutationRuntime: deps.queueMutationRuntime,
+            dismissGuestPlaceholder: deps.dismissGuestPlaceholder,
+          });
+        },
         togglePriority: (cId, rId) => {
           return toggleQueuedTelegramPromptPriority(cId, rId, ctx, {
             getQueueSnapshot,
@@ -772,6 +869,34 @@ function createQueueMenuCallbackHandler<
   };
 }
 
+async function skipQueuedTelegramGuestPrompt<Context>(
+  queueOrder: number,
+  ctx: Context,
+  deps: {
+    getQueueSnapshot: () => Queue.TelegramQueueItem<Context>[];
+    queueMutationRuntime: Queue.TelegramQueueMutationController<Context>;
+    dismissGuestPlaceholder?: (inlineMessageId: string) => Promise<void>;
+  },
+): Promise<boolean> {
+  const item = deps.getQueueSnapshot().find((candidate) => {
+    return candidate.kind === "prompt" &&
+      candidate.guestQueryId !== undefined &&
+      candidate.queueOrder === queueOrder;
+  });
+  if (!item || !deps.queueMutationRuntime.removeGuestPromptByQueueOrder) {
+    return false;
+  }
+  const removed = deps.queueMutationRuntime.removeGuestPromptByQueueOrder(
+    queueOrder,
+    ctx,
+  );
+  if (!removed) return false;
+  if (item.guestInlineMessageId && deps.dismissGuestPlaceholder) {
+    await deps.dismissGuestPlaceholder(item.guestInlineMessageId);
+  }
+  return true;
+}
+
 function getQueueMenuReactionDisposition<Context>(
   item: Queue.TelegramQueueItem<Context>,
   priority: boolean,

package/lib/queue.ts

@@ -922,6 +922,28 @@ export function removeTelegramQueueItemsByMessageIds<TContext = unknown>(
   };
 }
 
+export function removeTelegramQueuedGuestPromptByOrder<TContext = unknown>(
+  items: TelegramQueueItem<TContext>[],
+  queueOrder: number,
+): {
+  items: TelegramQueueItem<TContext>[];
+  removedItems: PendingTelegramTurn[];
+  removedCount: number;
+} {
+  const index = items.findIndex((item) => {
+    return isPendingTelegramTurn(item) &&
+      item.guestQueryId !== undefined &&
+      item.queueOrder === queueOrder;
+  });
+  if (index < 0) return { items, removedItems: [], removedCount: 0 };
+  const removedItem = items[index] as PendingTelegramTurn;
+  return {
+    items: [...items.slice(0, index), ...items.slice(index + 1)],
+    removedItems: [removedItem],
+    removedCount: 1,
+  };
+}
+
 export function applyTelegramQueuePromptReactionDisposition<
   TContext = unknown,
 >(
@@ -2331,6 +2353,10 @@ export interface TelegramQueueMutationController<TContext> {
     ctx: TContext,
     scope?: TelegramQueueMessageScope,
   ) => number;
+  removeGuestPromptByQueueOrder?: (
+    queueOrder: number,
+    ctx: TContext,
+  ) => boolean;
   applyReactionByMessageId: (
     messageId: number,
     disposition: TelegramQueueReactionDisposition,
@@ -2604,6 +2630,11 @@ export function createTelegramQueueMutationController<TContext>(
         buildRuntimeDeps(ctx),
         scope,
       ),
+    removeGuestPromptByQueueOrder: (queueOrder, ctx) =>
+      removeTelegramQueuedGuestPromptByOrderRuntime(
+        queueOrder,
+        buildRuntimeDeps(ctx),
+      ),
     applyReactionByMessageId: (messageId, disposition, ctx, scope) =>
       applyTelegramQueuePromptReactionDispositionRuntime(
         messageId,
@@ -2684,6 +2715,21 @@ export function removeTelegramQueueItemsByMessageIdsRuntime<TContext>(
   return removedCount;
 }
 
+export function removeTelegramQueuedGuestPromptByOrderRuntime<TContext>(
+  queueOrder: number,
+  deps: TelegramQueueMutationRuntimeDeps<TContext>,
+): boolean {
+  const { items, removedItems, removedCount } =
+    removeTelegramQueuedGuestPromptByOrder(deps.getQueuedItems(), queueOrder);
+  if (removedCount === 0) return false;
+  // A menu Skip means permanent discard, so settle durable admission before
+  // removing the live item. A failed settlement keeps the prompt retryable.
+  deps.onItemsDiscarded?.(removedItems, deps.ctx);
+  deps.setQueuedItems(items);
+  updateTelegramQueueStatusRuntime(deps);
+  return true;
+}
+
 export function applyTelegramQueuePromptReactionDispositionRuntime<TContext>(
   messageId: number,
   disposition: TelegramQueueReactionDisposition,

package/lib/replies.ts

@@ -1018,6 +1018,10 @@ export const TELEGRAM_GUEST_PLACEHOLDER_FRAMES = [
   "<b>🌏 Working on it...</b>",
 ] as const;
 
+// Telegram does not expose deletion for inline messages. This non-printing,
+// non-empty edit visually clears a guest placeholder after its query is skipped.
+export const TELEGRAM_DISMISSED_GUEST_PLACEHOLDER_TEXT = "\u2063";
+
 export function buildTelegramGuestPlaceholderFrame(step: number): string {
   const frames: readonly string[] = TELEGRAM_GUEST_PLACEHOLDER_FRAMES;
   const index = ((step % frames.length) + frames.length) % frames.length;
@@ -1052,6 +1056,8 @@ export interface TelegramGuestPlaceholderRuntime {
   stop: (inlineMessageId: string) => Promise<void>;
   /** Cancels every loop without waiting for in-flight edits (session shutdown). */
   stopAll: () => void;
+  /** Stops rotation and visually clears the inline placeholder. */
+  dismiss: (inlineMessageId: string) => Promise<void>;
 }
 
 interface TelegramGuestPlaceholderSession {
@@ -1202,5 +1208,18 @@ export function createTelegramGuestPlaceholderRuntime(
       }
       sessions.clear();
     },
+    async dismiss(inlineMessageId) {
+      await stop(inlineMessageId);
+      try {
+        await deps.editGuestInlineMessage(inlineMessageId, {
+          text: TELEGRAM_DISMISSED_GUEST_PLACEHOLDER_TEXT,
+          parseMode: "HTML",
+        });
+      } catch (error) {
+        deps.recordRuntimeEvent?.("guest", error, {
+          phase: "guest-placeholder-dismiss",
+        });
+      }
+    },
   };
 }

package/lib/sync.ts

@@ -684,7 +684,14 @@ export async function ensureTelegramLeaderThreadBinding(
     assertLeaderEpoch("before-workspace-persist");
     await deps.topicTargetStore.persist();
     assertLeaderEpoch("after-workspace-persist");
-    return { ...result, ...(committed.displayTitle ? { displayTitle: committed.displayTitle } : {}) };
+    const { target: _target, slot: _slot, threadName: _threadName, displayTitle: _displayTitle, ...rest } = result;
+    return {
+      ...rest,
+      target: { ...committed.target },
+      slot: committed.slot ?? result.slot,
+      ...(committed.threadName ? { threadName: committed.threadName } : {}),
+      ...(committed.displayTitle ? { displayTitle: committed.displayTitle } : {}),
+    };
   };
   try {
   const unavailableTargetKeys = new Set([

package/package.json

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