@llblab/pi-telegram 0.2.10 → 0.4.0

package/lib/replies.ts

@@ -3,10 +3,75 @@
  * Owns rendered-message delivery, reply transport wiring, and plain or markdown final replies
  */
 
-import type { TelegramRenderedChunk, TelegramRenderMode } from "./rendering.ts";
+import type { TelegramReplyParameters, TelegramSentMessage } from "./api.ts";
+import {
+  renderTelegramMessage,
+  type TelegramRenderedChunk,
+  type TelegramRenderMode,
+} from "./rendering.ts";
 
-export interface TelegramSentMessageLike {
-  message_id: number;
+export function buildTelegramReplyParameters(
+  messageId: number | undefined,
+): TelegramReplyParameters | undefined {
+  if (messageId === undefined) return undefined;
+  return { message_id: messageId, allow_sending_without_reply: true };
+}
+
+export function buildTelegramMultipartReplyParameters(
+  messageId: number | undefined,
+): string | undefined {
+  const parameters = buildTelegramReplyParameters(messageId);
+  return parameters ? JSON.stringify(parameters) : undefined;
+}
+
+function getAgentMessageField(message: unknown, field: string): unknown {
+  if (typeof message !== "object" || message === null || !(field in message)) {
+    return undefined;
+  }
+  return Reflect.get(message, field);
+}
+
+export function isAssistantAgentMessage(message: unknown): boolean {
+  return getAgentMessageField(message, "role") === "assistant";
+}
+
+function extractAgentTextContent(content: unknown): string {
+  const blocks = Array.isArray(content) ? content : [];
+  return blocks
+    .filter(
+      (block): block is { type: string; text?: string } =>
+        typeof block === "object" && block !== null && "type" in block,
+    )
+    .filter((block) => block.type === "text" && typeof block.text === "string")
+    .map((block) => block.text as string)
+    .join("")
+    .trim();
+}
+
+export function getAgentMessageText(message: unknown): string {
+  return extractAgentTextContent(getAgentMessageField(message, "content"));
+}
+
+export function extractLatestAssistantMessageText(
+  messages: readonly unknown[],
+): {
+  text?: string;
+  stopReason?: string;
+  errorMessage?: string;
+} {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (!message || !isAssistantAgentMessage(message)) continue;
+    const rawStopReason = getAgentMessageField(message, "stopReason");
+    const rawErrorMessage = getAgentMessageField(message, "errorMessage");
+    const stopReason =
+      typeof rawStopReason === "string" ? rawStopReason : undefined;
+    const errorMessage =
+      typeof rawErrorMessage === "string" ? rawErrorMessage : undefined;
+    const text = getAgentMessageText(message);
+    return { text: text || undefined, stopReason, errorMessage };
+  }
+  return {};
 }
 
 export interface TelegramReplyDeliveryDeps<TReplyMarkup> {
@@ -15,21 +80,22 @@ export interface TelegramReplyDeliveryDeps<TReplyMarkup> {
     text: string;
     parse_mode?: "HTML";
     reply_markup?: TReplyMarkup;
-  }) => Promise<TelegramSentMessageLike>;
+    reply_parameters?: TelegramReplyParameters;
+  }) => Promise<TelegramSentMessage>;
   editMessage: (body: {
     chat_id: number;
     message_id: number;
     text: string;
     parse_mode?: "HTML";
     reply_markup?: TReplyMarkup;
-  }) => Promise<void>;
+  }) => Promise<unknown>;
 }
 
 export interface TelegramReplyTransport<TReplyMarkup> {
   sendRenderedChunks: (
     chatId: number,
     chunks: TelegramRenderedChunk[],
-    options?: { replyMarkup?: TReplyMarkup },
+    options?: { replyMarkup?: TReplyMarkup; replyToMessageId?: number },
   ) => Promise<number | undefined>;
   editRenderedMessage: (
     chatId: number,
@@ -62,16 +128,21 @@ export async function sendTelegramRenderedChunks<TReplyMarkup>(
   chatId: number,
   chunks: TelegramRenderedChunk[],
   deps: TelegramReplyDeliveryDeps<TReplyMarkup>,
-  options?: { replyMarkup?: TReplyMarkup },
+  options?: { replyMarkup?: TReplyMarkup; replyToMessageId?: number },
 ): Promise<number | undefined> {
   let lastMessageId: number | undefined;
   for (const [index, chunk] of chunks.entries()) {
+    const replyParameters =
+      index === 0
+        ? buildTelegramReplyParameters(options?.replyToMessageId)
+        : undefined;
     const sent = await deps.sendMessage({
       chat_id: chatId,
       text: chunk.text,
       parse_mode: chunk.parseMode,
       reply_markup:
         index === chunks.length - 1 ? options?.replyMarkup : undefined,
+      ...(replyParameters ? { reply_parameters: replyParameters } : {}),
     });
     lastMessageId = sent.message_id;
   }
@@ -96,7 +167,9 @@ export async function editTelegramRenderedMessage<TReplyMarkup>(
       remainingChunks.length === 0 ? options?.replyMarkup : undefined,
   });
   if (remainingChunks.length > 0) {
-    return sendTelegramRenderedChunks(chatId, remainingChunks, deps, options);
+    return sendTelegramRenderedChunks(chatId, remainingChunks, deps, {
+      replyMarkup: options?.replyMarkup,
+    });
   }
   return messageId;
 }
@@ -132,3 +205,120 @@ export async function sendTelegramMarkdownReply(
   }
   return deps.sendRenderedChunks(chunks);
 }
+
+export interface TelegramRenderedMessageRuntimeDeps<TReplyMarkup> {
+  renderTelegramMessage: (
+    text: string,
+    options?: { mode?: TelegramRenderMode },
+  ) => TelegramRenderedChunk[];
+  replyTransport: TelegramReplyTransport<TReplyMarkup>;
+}
+
+export interface TelegramRenderedMessageRuntime<TReplyMarkup> {
+  sendTextReply: (
+    chatId: number,
+    replyToMessageId: number,
+    text: string,
+    options?: { parseMode?: "HTML" },
+  ) => Promise<number | undefined>;
+  sendMarkdownReply: (
+    chatId: number,
+    replyToMessageId: number,
+    markdown: string,
+  ) => Promise<number | undefined>;
+  editInteractiveMessage: (
+    chatId: number,
+    messageId: number,
+    text: string,
+    mode: TelegramRenderMode,
+    replyMarkup: TReplyMarkup,
+  ) => Promise<void>;
+  sendInteractiveMessage: (
+    chatId: number,
+    text: string,
+    mode: TelegramRenderMode,
+    replyMarkup: TReplyMarkup,
+  ) => Promise<number | undefined>;
+}
+
+export interface TelegramRenderedMessageDeliveryRuntime<
+  TReplyMarkup,
+> extends TelegramRenderedMessageRuntime<TReplyMarkup> {
+  replyTransport: TelegramReplyTransport<TReplyMarkup>;
+}
+
+export interface TelegramRenderedMessageDeliveryRuntimeDeps<
+  TReplyMarkup,
+> extends TelegramReplyDeliveryDeps<TReplyMarkup> {
+  renderTelegramMessage?: (
+    text: string,
+    options?: { mode?: TelegramRenderMode },
+  ) => TelegramRenderedChunk[];
+}
+
+export function createTelegramRenderedMessageDeliveryRuntime<TReplyMarkup>(
+  deps: TelegramRenderedMessageDeliveryRuntimeDeps<TReplyMarkup>,
+): TelegramRenderedMessageDeliveryRuntime<TReplyMarkup> {
+  const replyTransport = buildTelegramReplyTransport({
+    sendMessage: deps.sendMessage,
+    editMessage: deps.editMessage,
+  });
+  return {
+    replyTransport,
+    ...createTelegramRenderedMessageRuntime({
+      renderTelegramMessage:
+        deps.renderTelegramMessage ?? renderTelegramMessage,
+      replyTransport,
+    }),
+  };
+}
+
+export function createTelegramRenderedMessageRuntime<TReplyMarkup>(
+  deps: TelegramRenderedMessageRuntimeDeps<TReplyMarkup>,
+): TelegramRenderedMessageRuntime<TReplyMarkup> {
+  return {
+    sendTextReply: async (chatId, replyToMessageId, text, options) => {
+      return sendTelegramPlainReply(
+        text,
+        {
+          renderTelegramMessage: deps.renderTelegramMessage,
+          sendRenderedChunks: (chunks) =>
+            deps.replyTransport.sendRenderedChunks(chatId, chunks, {
+              replyToMessageId,
+            }),
+        },
+        options,
+      );
+    },
+    sendMarkdownReply: async (chatId, replyToMessageId, markdown) => {
+      return sendTelegramMarkdownReply(markdown, {
+        renderTelegramMessage: deps.renderTelegramMessage,
+        sendRenderedChunks: (chunks) =>
+          deps.replyTransport.sendRenderedChunks(chatId, chunks, {
+            replyToMessageId,
+          }),
+      });
+    },
+    editInteractiveMessage: async (
+      chatId,
+      messageId,
+      text,
+      mode,
+      replyMarkup,
+    ) => {
+      await deps.replyTransport.editRenderedMessage(
+        chatId,
+        messageId,
+        deps.renderTelegramMessage(text, { mode }),
+        { replyMarkup },
+      );
+    },
+    sendInteractiveMessage: async (chatId, text, mode, replyMarkup) => {
+      return deps.replyTransport.sendRenderedChunks(
+        chatId,
+        deps.renderTelegramMessage(text, { mode }),
+        { replyMarkup },
+      );
+    },
+  };
+}

package/lib/routing.ts

@@ -0,0 +1,217 @@
+/**
+ * Telegram inbound routing composition
+ * Wires authorized updates into menus, commands, media grouping, and prompt queueing
+ */
+
+import * as Commands from "./commands.ts";
+import type { TelegramConfigStore } from "./config.ts";
+import type { TelegramAttachmentHandlerRuntime } from "./handlers.ts";
+import * as Media from "./media.ts";
+import * as Menu from "./menu.ts";
+import * as Model from "./model.ts";
+import * as Queue from "./queue.ts";
+import type { TelegramBridgeRuntime } from "./runtime.ts";
+import * as Turns from "./turns.ts";
+import * as Updates from "./updates.ts";
+
+export type TelegramRoutedMessage = Updates.TelegramUpdateMessage &
+  Media.TelegramMediaMessage &
+  Media.TelegramMediaGroupMessage &
+  Commands.TelegramCommandRuntimeMessage &
+  Turns.TelegramTurnMessage;
+
+export type TelegramRoutedCallbackQuery = Updates.TelegramCallbackQuery &
+  Menu.MenuCallbackQuery;
+
+export interface TelegramInboundRouteRuntimeDeps<
+  TUpdate extends Updates.TelegramUpdateFlow & {
+    message?: TMessage;
+    edited_message?: TMessage;
+    callback_query?: TCallbackQuery;
+  },
+  TMessage extends TelegramRoutedMessage,
+  TCallbackQuery extends TelegramRoutedCallbackQuery,
+  TContext,
+  TModel extends Model.MenuModel,
+> {
+  configStore: Pick<
+    TelegramConfigStore,
+    "getAllowedUserId" | "setAllowedUserId" | "persist"
+  >;
+  bridgeRuntime: TelegramBridgeRuntime;
+  activeTurnRuntime: Queue.TelegramActiveTurnStore;
+  mediaGroupRuntime: Media.TelegramMediaGroupController<TMessage>;
+  telegramQueueStore: Queue.TelegramQueueStateStore<TContext>;
+  queueMutationRuntime: Queue.TelegramQueueMutationController<TContext>;
+  modelMenuRuntime: Menu.TelegramModelMenuRuntime<TModel>;
+  currentModelRuntime: Model.CurrentModelRuntime<TContext, TModel>;
+  modelSwitchController: Model.TelegramModelSwitchController<
+    TContext,
+    Model.ScopedTelegramModel<TModel>
+  >;
+  menuActions: Menu.TelegramMenuActionRuntime<TContext, TModel>;
+  attachmentHandlerRuntime: TelegramAttachmentHandlerRuntime<TContext>;
+  updateStatus: (ctx: TContext, error?: string) => void;
+  dispatchNextQueuedTelegramTurn: (ctx: TContext) => void;
+  answerCallbackQuery: (
+    callbackQueryId: string,
+    text?: string,
+  ) => Promise<void>;
+  sendTextReply: (
+    chatId: number,
+    replyToMessageId: number,
+    text: string,
+  ) => Promise<number | undefined>;
+  setMyCommands: Commands.TelegramBotCommandRegistrationDeps["setMyCommands"];
+  downloadFile: Media.DownloadTelegramMessageFilesDeps["downloadFile"];
+  getThinkingLevel: () => Model.ThinkingLevel;
+  setThinkingLevel: (level: Model.ThinkingLevel) => void;
+  setModel: (model: TModel) => Promise<boolean>;
+  isIdle: (ctx: TContext) => boolean;
+  hasPendingMessages: (ctx: TContext) => boolean;
+  compact: (
+    ctx: TContext,
+    callbacks: { onComplete: () => void; onError: (error: unknown) => void },
+  ) => void;
+  recordRuntimeEvent?: (
+    category: string,
+    error: unknown,
+    details?: Record<string, unknown>,
+  ) => void;
+}
+
+export function createTelegramInboundRouteRuntime<
+  TUpdate extends Updates.TelegramUpdateFlow & {
+    message?: TMessage;
+    edited_message?: TMessage;
+    callback_query?: TCallbackQuery;
+  },
+  TMessage extends TelegramRoutedMessage,
+  TCallbackQuery extends TelegramRoutedCallbackQuery,
+  TContext,
+  TModel extends Model.MenuModel,
+>(
+  deps: TelegramInboundRouteRuntimeDeps<
+    TUpdate,
+    TMessage,
+    TCallbackQuery,
+    TContext,
+    TModel
+  >,
+): Updates.TelegramUpdateRuntimeController<TContext, TUpdate> {
+  const callbackHandler = Menu.createTelegramMenuCallbackHandlerForContext<
+    TCallbackQuery,
+    TContext,
+    TModel
+  >({
+    getStoredModelMenuState: deps.modelMenuRuntime.getState,
+    getActiveModel: deps.currentModelRuntime.get,
+    getThinkingLevel: deps.getThinkingLevel,
+    setThinkingLevel: deps.setThinkingLevel,
+    updateStatus: deps.updateStatus,
+    updateModelMenuMessage: deps.menuActions.updateModelMenuMessage,
+    updateThinkingMenuMessage: deps.menuActions.updateThinkingMenuMessage,
+    updateStatusMessage: deps.menuActions.updateStatusMessage,
+    answerCallbackQuery: deps.answerCallbackQuery,
+    isIdle: deps.isIdle,
+    hasActiveTelegramTurn: deps.activeTurnRuntime.has,
+    hasAbortHandler: deps.bridgeRuntime.abort.hasHandler,
+    getActiveToolExecutions: deps.bridgeRuntime.lifecycle.getActiveToolExecutions,
+    setModel: deps.setModel,
+    setCurrentModel: deps.currentModelRuntime.setCurrentModel,
+    stagePendingModelSwitch: deps.modelSwitchController.stagePendingSwitch,
+    restartInterruptedTelegramTurn:
+      deps.modelSwitchController.restartInterruptedTurn,
+  });
+  const commandHandler = Commands.createTelegramCommandHandlerTargetRuntime<
+    TMessage,
+    TContext
+  >({
+    hasAbortHandler: deps.bridgeRuntime.abort.hasHandler,
+    clearPendingModelSwitch: deps.modelSwitchController.clearPendingSwitch,
+    hasQueuedTelegramItems: deps.telegramQueueStore.hasQueuedItems,
+    setPreserveQueuedTurnsAsHistory:
+      deps.bridgeRuntime.lifecycle.setPreserveQueuedTurnsAsHistory,
+    abortCurrentTurn: deps.bridgeRuntime.abort.abortTurn,
+    isIdle: deps.isIdle,
+    hasPendingMessages: deps.hasPendingMessages,
+    hasActiveTelegramTurn: deps.activeTurnRuntime.has,
+    hasDispatchPending: deps.bridgeRuntime.lifecycle.hasDispatchPending,
+    isCompactionInProgress: deps.bridgeRuntime.lifecycle.isCompactionInProgress,
+    setCompactionInProgress: deps.bridgeRuntime.lifecycle.setCompactionInProgress,
+    updateStatus: deps.updateStatus,
+    dispatchNextQueuedTelegramTurn: deps.dispatchNextQueuedTelegramTurn,
+    compact: deps.compact,
+    allocateItemOrder: deps.bridgeRuntime.queue.allocateItemOrder,
+    allocateControlOrder: deps.bridgeRuntime.queue.allocateControlOrder,
+    appendControlItem: deps.queueMutationRuntime.append,
+    showStatus: deps.menuActions.sendStatusMessage,
+    openModelMenu: deps.menuActions.openModelMenu,
+    getAllowedUserId: deps.configStore.getAllowedUserId,
+    setAllowedUserId: deps.configStore.setAllowedUserId,
+    setMyCommands: deps.setMyCommands,
+    persistConfig: deps.configStore.persist,
+    sendTextReply: deps.sendTextReply,
+    recordRuntimeEvent: deps.recordRuntimeEvent,
+  });
+  const promptEnqueue = Queue.createTelegramPromptEnqueueController<
+    TMessage,
+    TContext
+  >({
+    ...deps.telegramQueueStore,
+    getPreserveQueuedTurnsAsHistory:
+      deps.bridgeRuntime.lifecycle.shouldPreserveQueuedTurnsAsHistory,
+    setPreserveQueuedTurnsAsHistory:
+      deps.bridgeRuntime.lifecycle.setPreserveQueuedTurnsAsHistory,
+    createTurn: Turns.createTelegramPromptTurnRuntimeBuilder<
+      TMessage,
+      TContext
+    >({
+      allocateQueueOrder: deps.bridgeRuntime.queue.allocateItemOrder,
+      downloadFile: deps.downloadFile,
+      processAttachments: deps.attachmentHandlerRuntime.process,
+    }),
+    updateStatus: deps.updateStatus,
+    dispatchNextQueuedTelegramTurn: deps.dispatchNextQueuedTelegramTurn,
+  }).enqueue;
+  const commandOrPrompt = Commands.createTelegramCommandOrPromptRuntime<
+    TMessage,
+    TContext
+  >({
+    extractRawText: Media.extractFirstTelegramMessageText,
+    handleCommand: commandHandler,
+    enqueueTurn: promptEnqueue,
+  });
+  const mediaDispatch = Media.createTelegramMediaGroupDispatchRuntime<
+    TMessage,
+    TContext
+  >({
+    mediaGroups: deps.mediaGroupRuntime,
+    dispatchMessages: commandOrPrompt.dispatchMessages,
+  });
+  const editRuntime = Turns.createTelegramQueuedPromptEditRuntime<
+    TMessage,
+    TContext
+  >({
+    ...deps.telegramQueueStore,
+    updateStatus: deps.updateStatus,
+  });
+  return Updates.createTelegramPairedUpdateRuntime<TContext, TUpdate>({
+    getAllowedUserId: deps.configStore.getAllowedUserId,
+    setAllowedUserId: deps.configStore.setAllowedUserId,
+    persistConfig: deps.configStore.persist,
+    updateStatus: deps.updateStatus,
+    removePendingMediaGroupMessages: deps.mediaGroupRuntime.removeMessages,
+    removeQueuedTelegramTurnsByMessageIds:
+      deps.queueMutationRuntime.removeByMessageIds,
+    clearQueuedTelegramTurnPriorityByMessageId:
+      deps.queueMutationRuntime.clearPriorityByMessageId,
+    prioritizeQueuedTelegramTurnByMessageId:
+      deps.queueMutationRuntime.prioritizeByMessageId,
+    answerCallbackQuery: deps.answerCallbackQuery,
+    handleAuthorizedTelegramCallbackQuery: callbackHandler,
+    sendTextReply: deps.sendTextReply,
+    handleAuthorizedTelegramMessage: mediaDispatch.handleMessage,
+    handleAuthorizedTelegramEditedMessage: editRuntime.updateFromEditedMessage,
+  });
+}