@llblab/pi-telegram 0.2.8 → 0.2.10

package/lib/replies.ts

@@ -1,187 +1,10 @@
 /**
- * Telegram reply and preview domain helpers
- * Owns preview text decisions, preview runtime behavior, rendered-message delivery, and plain or markdown reply sending
+ * Telegram reply delivery helpers
+ * Owns rendered-message delivery, reply transport wiring, and plain or markdown final replies
  */
 
 import type { TelegramRenderedChunk, TelegramRenderMode } from "./rendering.ts";
 
-// --- Preview ---
-
-export interface TelegramPreviewStateLike {
-  mode: "draft" | "message";
-  draftId?: number;
-  messageId?: number;
-  pendingText: string;
-  lastSentText: string;
-}
-
-export interface TelegramPreviewRuntimeState extends TelegramPreviewStateLike {
-  flushTimer?: ReturnType<typeof setTimeout>;
-}
-
-export interface TelegramPreviewRuntimeDeps {
-  getState: () => TelegramPreviewRuntimeState | undefined;
-  setState: (state: TelegramPreviewRuntimeState | undefined) => void;
-  clearScheduledFlush: (state: TelegramPreviewRuntimeState) => void;
-  maxMessageLength: number;
-  renderPreviewText: (markdown: string) => string;
-  getDraftSupport: () => "unknown" | "supported" | "unsupported";
-  setDraftSupport: (support: "unknown" | "supported" | "unsupported") => void;
-  allocateDraftId: () => number;
-  sendDraft: (chatId: number, draftId: number, text: string) => Promise<void>;
-  sendMessage: (
-    chatId: number,
-    text: string,
-  ) => Promise<TelegramSentMessageLike>;
-  editMessageText: (
-    chatId: number,
-    messageId: number,
-    text: string,
-  ) => Promise<void>;
-  renderTelegramMessage: (
-    text: string,
-    options?: { mode?: TelegramRenderMode },
-  ) => TelegramRenderedChunk[];
-  sendRenderedChunks: (
-    chatId: number,
-    chunks: TelegramRenderedChunk[],
-  ) => Promise<number | undefined>;
-  editRenderedMessage: (
-    chatId: number,
-    messageId: number,
-    chunks: TelegramRenderedChunk[],
-  ) => Promise<number | undefined>;
-}
-
-export function buildTelegramPreviewFlushText(options: {
-  state: TelegramPreviewStateLike;
-  maxMessageLength: number;
-  renderPreviewText: (markdown: string) => string;
-}): string | undefined {
-  const rawText = options.state.pendingText.trim();
-  const previewText = options.renderPreviewText(rawText).trim();
-  if (!previewText || previewText === options.state.lastSentText) {
-    return undefined;
-  }
-  return previewText.length > options.maxMessageLength
-    ? previewText.slice(0, options.maxMessageLength)
-    : previewText;
-}
-
-export function buildTelegramPreviewFinalText(
-  state: TelegramPreviewStateLike,
-): string | undefined {
-  const finalText = (state.pendingText.trim() || state.lastSentText).trim();
-  return finalText || undefined;
-}
-
-export function shouldUseTelegramDraftPreview(options: {
-  draftSupport: "unknown" | "supported" | "unsupported";
-}): boolean {
-  return options.draftSupport !== "unsupported";
-}
-
-export async function clearTelegramPreview(
-  chatId: number,
-  deps: TelegramPreviewRuntimeDeps,
-): Promise<void> {
-  const state = deps.getState();
-  if (!state) return;
-  deps.clearScheduledFlush(state);
-  deps.setState(undefined);
-  if (state.mode !== "draft" || state.draftId === undefined) return;
-  try {
-    await deps.sendDraft(chatId, state.draftId, "");
-  } catch {
-    // ignore
-  }
-}
-
-export async function flushTelegramPreview(
-  chatId: number,
-  deps: TelegramPreviewRuntimeDeps,
-): Promise<void> {
-  const state = deps.getState();
-  if (!state) return;
-  state.flushTimer = undefined;
-  const truncated = buildTelegramPreviewFlushText({
-    state,
-    maxMessageLength: deps.maxMessageLength,
-    renderPreviewText: deps.renderPreviewText,
-  });
-  if (!truncated) return;
-  if (shouldUseTelegramDraftPreview({ draftSupport: deps.getDraftSupport() })) {
-    const draftId = state.draftId ?? deps.allocateDraftId();
-    state.draftId = draftId;
-    try {
-      await deps.sendDraft(chatId, draftId, truncated);
-      deps.setDraftSupport("supported");
-      state.mode = "draft";
-      state.lastSentText = truncated;
-      return;
-    } catch {
-      deps.setDraftSupport("unsupported");
-    }
-  }
-  if (state.messageId === undefined) {
-    const sent = await deps.sendMessage(chatId, truncated);
-    state.messageId = sent.message_id;
-    state.mode = "message";
-    state.lastSentText = truncated;
-    return;
-  }
-  await deps.editMessageText(chatId, state.messageId, truncated);
-  state.mode = "message";
-  state.lastSentText = truncated;
-}
-
-export async function finalizeTelegramPreview(
-  chatId: number,
-  deps: TelegramPreviewRuntimeDeps,
-): Promise<boolean> {
-  const state = deps.getState();
-  if (!state) return false;
-  await flushTelegramPreview(chatId, deps);
-  const finalText = buildTelegramPreviewFinalText(state);
-  if (!finalText) {
-    await clearTelegramPreview(chatId, deps);
-    return false;
-  }
-  if (state.mode === "draft") {
-    await deps.sendMessage(chatId, finalText);
-    await clearTelegramPreview(chatId, deps);
-    return true;
-  }
-  deps.setState(undefined);
-  return state.messageId !== undefined;
-}
-
-export async function finalizeTelegramMarkdownPreview(
-  chatId: number,
-  markdown: string,
-  deps: TelegramPreviewRuntimeDeps,
-): Promise<boolean> {
-  const state = deps.getState();
-  if (!state) return false;
-  await flushTelegramPreview(chatId, deps);
-  const chunks = deps.renderTelegramMessage(markdown, { mode: "markdown" });
-  if (chunks.length === 0) {
-    await clearTelegramPreview(chatId, deps);
-    return false;
-  }
-  if (state.mode === "draft") {
-    await deps.sendRenderedChunks(chatId, chunks);
-    await clearTelegramPreview(chatId, deps);
-    return true;
-  }
-  if (state.messageId === undefined) return false;
-  await deps.editRenderedMessage(chatId, state.messageId, chunks);
-  deps.setState(undefined);
-  return true;
-}
-
-// --- Delivery ---
-
 export interface TelegramSentMessageLike {
   message_id: number;
 }
@@ -278,8 +101,6 @@ export async function editTelegramRenderedMessage<TReplyMarkup>(
   return messageId;
 }
 
-// --- Reply Runtime ---
-
 export interface TelegramReplyRuntimeDeps {
   renderTelegramMessage: (
     text: string,

package/lib/turns.ts

@@ -89,6 +89,92 @@ export function buildTelegramTurnPrompt(options: {
   return prompt;
 }
 
+function splitTelegramPromptAttachmentSuffix(prompt: string): {
+  promptWithoutAttachments: string;
+  attachmentSuffix: string;
+  attachmentFiles: DownloadedTelegramTurnFileLike[];
+} {
+  const marker = "\n\nTelegram attachments were saved locally:";
+  const markerIndex = prompt.indexOf(marker);
+  if (markerIndex === -1) {
+    return {
+      promptWithoutAttachments: prompt,
+      attachmentSuffix: "",
+      attachmentFiles: [],
+    };
+  }
+  const promptWithoutAttachments = prompt.slice(0, markerIndex);
+  const attachmentSuffix = prompt.slice(markerIndex);
+  const attachmentFiles = attachmentSuffix
+    .split("\n")
+    .map((line) => line.match(/^- (.+)$/)?.[1]?.trim())
+    .filter((path): path is string => !!path)
+    .map((path) => ({ path, fileName: basename(path), isImage: false }));
+  return { promptWithoutAttachments, attachmentSuffix, attachmentFiles };
+}
+
+function buildEditedTelegramPromptText(options: {
+  existingPrompt: string;
+  telegramPrefix: string;
+  rawText: string;
+}): { text: string; attachmentFiles: DownloadedTelegramTurnFileLike[] } {
+  const { promptWithoutAttachments, attachmentSuffix, attachmentFiles } =
+    splitTelegramPromptAttachmentSuffix(options.existingPrompt);
+  const currentMessageMarker = "Current Telegram message:";
+  const currentMessageIndex = promptWithoutAttachments.lastIndexOf(
+    currentMessageMarker,
+  );
+  if (currentMessageIndex !== -1) {
+    const prefix = promptWithoutAttachments.slice(
+      0,
+      currentMessageIndex + currentMessageMarker.length,
+    );
+    const separator = options.rawText.length > 0 ? "\n" : "";
+    return {
+      text: `${prefix}${separator}${options.rawText}${attachmentSuffix}`,
+      attachmentFiles,
+    };
+  }
+  const promptText =
+    options.rawText.length > 0
+      ? `${options.telegramPrefix} ${options.rawText}`
+      : options.telegramPrefix;
+  return {
+    text: `${promptText}${attachmentSuffix}`,
+    attachmentFiles,
+  };
+}
+
+export function updateTelegramPromptTurnText(options: {
+  turn: PendingTelegramTurn;
+  telegramPrefix: string;
+  rawText: string;
+}): PendingTelegramTurn {
+  let attachmentFiles: DownloadedTelegramTurnFileLike[] = [];
+  const nextContent = options.turn.content.map((block, index) => {
+    if (index !== 0 || block.type !== "text") return block;
+    const updated = buildEditedTelegramPromptText({
+      existingPrompt: block.text,
+      telegramPrefix: options.telegramPrefix,
+      rawText: options.rawText,
+    });
+    attachmentFiles = updated.attachmentFiles;
+    return {
+      ...block,
+      text: updated.text,
+    };
+  });
+  return {
+    ...options.turn,
+    content: nextContent,
+    historyText: formatTelegramHistoryText(options.rawText, attachmentFiles),
+    statusSummary: formatTelegramTurnStatusSummary(
+      options.rawText,
+      attachmentFiles,
+    ),
+  };
+}
+
 export async function buildTelegramPromptTurn(options: {
   telegramPrefix: string;
   messages: TelegramTurnMessageLike[];

package/lib/types.ts

@@ -0,0 +1,137 @@
+/**
+ * Telegram Bot API transport shape types
+ * Centralizes Telegram update, message, callback, reaction, and response shapes used by the runtime
+ */
+
+export interface TelegramApiResponse<T> {
+  ok: boolean;
+  result?: T;
+  description?: string;
+  error_code?: number;
+}
+
+export interface TelegramUser {
+  id: number;
+  is_bot: boolean;
+  first_name: string;
+  username?: string;
+}
+
+export interface TelegramChat {
+  id: number;
+  type: string;
+}
+
+export interface TelegramPhotoSize {
+  file_id: string;
+  file_size?: number;
+}
+
+export interface TelegramDocument {
+  file_id: string;
+  file_name?: string;
+  mime_type?: string;
+  file_size?: number;
+}
+
+export interface TelegramVideo {
+  file_id: string;
+  file_name?: string;
+  mime_type?: string;
+  file_size?: number;
+}
+
+export interface TelegramAudio {
+  file_id: string;
+  file_name?: string;
+  mime_type?: string;
+  file_size?: number;
+}
+
+export interface TelegramVoice {
+  file_id: string;
+  mime_type?: string;
+  file_size?: number;
+}
+
+export interface TelegramAnimation {
+  file_id: string;
+  file_name?: string;
+  mime_type?: string;
+  file_size?: number;
+}
+
+export interface TelegramSticker {
+  file_id: string;
+  emoji?: string;
+}
+
+export interface TelegramMessage {
+  message_id: number;
+  chat: TelegramChat;
+  from?: TelegramUser;
+  text?: string;
+  caption?: string;
+  media_group_id?: string;
+  photo?: TelegramPhotoSize[];
+  document?: TelegramDocument;
+  video?: TelegramVideo;
+  audio?: TelegramAudio;
+  voice?: TelegramVoice;
+  animation?: TelegramAnimation;
+  sticker?: TelegramSticker;
+}
+
+export interface TelegramCallbackQuery {
+  id: string;
+  from: TelegramUser;
+  message?: TelegramMessage;
+  data?: string;
+}
+
+export interface TelegramReactionTypeEmoji {
+  type: "emoji";
+  emoji: string;
+}
+
+export interface TelegramReactionTypeCustomEmoji {
+  type: "custom_emoji";
+  custom_emoji_id: string;
+}
+
+export interface TelegramReactionTypePaid {
+  type: "paid";
+}
+
+export type TelegramReactionType =
+  | TelegramReactionTypeEmoji
+  | TelegramReactionTypeCustomEmoji
+  | TelegramReactionTypePaid;
+
+export interface TelegramMessageReactionUpdated {
+  chat: TelegramChat;
+  message_id: number;
+  user?: TelegramUser;
+  actor_chat?: TelegramChat;
+  old_reaction: TelegramReactionType[];
+  new_reaction: TelegramReactionType[];
+  date: number;
+}
+
+export interface TelegramUpdate {
+  update_id: number;
+  message?: TelegramMessage;
+  edited_message?: TelegramMessage;
+  callback_query?: TelegramCallbackQuery;
+  message_reaction?: TelegramMessageReactionUpdated;
+  deleted_business_messages?: { message_ids?: unknown };
+}
+
+export interface TelegramSentMessage {
+  message_id: number;
+}
+
+export interface TelegramBotCommand {
+  command: string;
+  description: string;
+}

package/lib/updates.ts

@@ -119,7 +119,22 @@ export function getAuthorizedTelegramCallbackQuery(
 export function getAuthorizedTelegramMessage(
   update: TelegramUpdateRoutingLike,
 ): TelegramMessageLike | undefined {
-  const message = update.message || update.edited_message;
+  const message = update.message;
+  if (
+    !message ||
+    message.chat.type !== "private" ||
+    !message.from ||
+    message.from.is_bot
+  ) {
+    return undefined;
+  }
+  return message;
+}
+
+export function getAuthorizedTelegramEditedMessage(
+  update: TelegramUpdateRoutingLike,
+): TelegramMessageLike | undefined {
+  const message = update.edited_message;
   if (
     !message ||
     message.chat.type !== "private" ||
@@ -156,6 +171,11 @@ export type TelegramUpdateFlowAction =
       kind: "message";
       message: TelegramMessageLike & { from: TelegramUserLike };
       authorization: TelegramAuthorizationState;
+    }
+  | {
+      kind: "edited-message";
+      message: TelegramMessageLike & { from: TelegramUserLike };
+      authorization: TelegramAuthorizationState;
     };
 
 export function buildTelegramUpdateFlowAction(
@@ -191,6 +211,19 @@ export function buildTelegramUpdateFlowAction(
       ),
     };
   }
+  const editedMessage = getAuthorizedTelegramEditedMessage(update);
+  if (editedMessage?.from) {
+    return {
+      kind: "edited-message",
+      message: editedMessage as TelegramMessageLike & {
+        from: TelegramUserLike;
+      },
+      authorization: getTelegramAuthorizationState(
+        editedMessage.from.id,
+        allowedUserId,
+      ),
+    };
+  }
   return { kind: "ignore" };
 }
 
@@ -215,6 +248,12 @@ export type TelegramUpdateExecutionPlan =
       shouldPair: boolean;
       shouldNotifyPaired: boolean;
       shouldDeny: boolean;
+    }
+  | {
+      kind: "edited-message";
+      message: TelegramMessageLike & { from: TelegramUserLike };
+      shouldPair: boolean;
+      shouldDeny: boolean;
     };
 
 export function buildTelegramUpdateExecutionPlan(
@@ -242,6 +281,13 @@ export function buildTelegramUpdateExecutionPlan(
         shouldNotifyPaired: action.authorization.kind === "pair",
         shouldDeny: action.authorization.kind === "deny",
       };
+    case "edited-message":
+      return {
+        kind: "edited-message",
+        message: action.message,
+        shouldPair: action.authorization.kind === "pair",
+        shouldDeny: action.authorization.kind === "deny",
+      };
   }
 }
 
@@ -296,6 +342,13 @@ export interface TelegramUpdateRuntimeDeps {
     >["message"],
     ctx: ExtensionContext,
   ) => Promise<void>;
+  handleAuthorizedTelegramEditedMessage: (
+    message: Extract<
+      TelegramUpdateExecutionPlan,
+      { kind: "edited-message" }
+    >["message"],
+    ctx: ExtensionContext,
+  ) => Promise<void>;
 }
 
 function getTelegramCallbackQueryId(
@@ -368,7 +421,12 @@ export async function executeTelegramUpdatePlan(
     ? await deps.pairTelegramUserIfNeeded(plan.message.from.id, deps.ctx)
     : false;
   const replyTarget = getTelegramMessageReplyTarget(plan.message);
-  if (pairedNow && plan.shouldNotifyPaired && replyTarget) {
+  if (
+    plan.kind === "message" &&
+    pairedNow &&
+    plan.shouldNotifyPaired &&
+    replyTarget
+  ) {
     await deps.sendTextReply(
       replyTarget.chatId,
       replyTarget.messageId,
@@ -385,5 +443,9 @@ export async function executeTelegramUpdatePlan(
     }
     return;
   }
+  if (plan.kind === "edited-message") {
+    await deps.handleAuthorizedTelegramEditedMessage(plan.message, deps.ctx);
+    return;
+  }
   await deps.handleAuthorizedTelegramMessage(plan.message, deps.ctx);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-telegram",
-  "version": "0.2.8",
+  "version": "0.2.10",
   "private": false,
   "description": "Better Telegram DM bridge extension for pi",
   "type": "module",