@llblab/pi-telegram 0.2.10 → 0.4.0

package/lib/turns.ts

@@ -3,27 +3,34 @@
  * Owns prompt-turn summary and content construction so queued Telegram turns are assembled consistently
  */
 
-import { basename } from "node:path";
-
-import type { ImageContent, TextContent } from "@mariozechner/pi-ai";
+import { readFile } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
 
 import {
   collectTelegramMessageIds,
+  type DownloadedTelegramMessageFile,
+  type DownloadTelegramMessageFilesDeps,
+  downloadTelegramMessageFiles,
+  extractTelegramMessagesText,
   formatTelegramHistoryText,
+  guessMediaType,
+  type TelegramMediaMessage,
 } from "./media.ts";
-import type { PendingTelegramTurn } from "./queue.ts";
+import type {
+  PendingTelegramTurn,
+  TelegramPromptContent,
+  TelegramQueueItem,
+  TelegramQueueStore,
+} from "./queue.ts";
+
+export const TELEGRAM_PREFIX = "[telegram]";
 
-export interface TelegramTurnMessageLike {
+export interface TelegramTurnMessage {
   message_id: number;
   chat: { id: number };
 }
 
-export interface DownloadedTelegramTurnFileLike {
-  path: string;
-  fileName: string;
-  isImage: boolean;
-  mimeType?: string;
-}
+export type DownloadedTelegramTurnFile = DownloadedTelegramMessageFile;
 
 export function truncateTelegramQueueSummary(
   text: string,
@@ -45,10 +52,15 @@ export function truncateTelegramQueueSummary(
 
 export function formatTelegramTurnStatusSummary(
   rawText: string,
-  files: DownloadedTelegramTurnFileLike[],
+  files: DownloadedTelegramTurnFile[],
+  handlerOutputs: string[] = [],
 ): string {
   const textSummary = truncateTelegramQueueSummary(rawText);
   if (textSummary) return textSummary;
+  const handlerSummary = truncateTelegramQueueSummary(
+    handlerOutputs.join(" "),
+  );
+  if (handlerSummary) return handlerSummary;
   if (files.length === 1) {
     const fileName = basename(
       files[0]?.fileName || files[0]?.path || "attachment",
@@ -59,10 +71,37 @@ export function formatTelegramTurnStatusSummary(
   return "(empty message)";
 }
 
+function appendTelegramListSection(
+  text: string,
+  title: string,
+  items: string[],
+): string {
+  if (items.length === 0) return text;
+  const prefix = text.length > 0 ? `${text}\n\n` : "";
+  return `${prefix}[${title}]\n${items.map((item) => `- ${item}`).join("\n")}`;
+}
+
+function appendTelegramAttachmentSection(
+  text: string,
+  files: Pick<DownloadedTelegramTurnFile, "path">[],
+): string {
+  if (files.length === 0) return text;
+  const dirs = [...new Set(files.map((file) => dirname(file.path)))];
+  const sameDir = dirs.length === 1;
+  const header = sameDir ? `[attachments] ${dirs[0]}` : "[attachments]";
+  const items = sameDir
+    ? files.map((file) => `/${basename(file.path)}`)
+    : files.map((file) => file.path);
+  const prefix = text.length > 0 ? `${text}\n\n` : "";
+  return `${prefix}${header}\n${items.map((item) => `- ${item}`).join("\n")}`;
+}
+
 export function buildTelegramTurnPrompt(options: {
   telegramPrefix: string;
   rawText: string;
-  files: DownloadedTelegramTurnFileLike[];
+  files: DownloadedTelegramTurnFile[];
+  promptFiles?: DownloadedTelegramTurnFile[];
+  handlerOutputs?: string[];
   historyTurns?: Pick<PendingTelegramTurn, "historyText">[];
 }): string {
   let prompt = options.telegramPrefix;
@@ -80,21 +119,18 @@ export function buildTelegramTurnPrompt(options: {
         ? `\n${options.rawText}`
         : ` ${options.rawText}`;
   }
-  if (options.files.length > 0) {
-    prompt += "\n\nTelegram attachments were saved locally:";
-    for (const file of options.files) {
-      prompt += `\n- ${file.path}`;
-    }
-  }
+  const promptFiles = options.promptFiles ?? options.files;
+  prompt = appendTelegramAttachmentSection(prompt, promptFiles);
+  prompt = appendTelegramListSection(prompt, "outputs", options.handlerOutputs ?? []);
   return prompt;
 }
 
 function splitTelegramPromptAttachmentSuffix(prompt: string): {
   promptWithoutAttachments: string;
   attachmentSuffix: string;
-  attachmentFiles: DownloadedTelegramTurnFileLike[];
+  attachmentFiles: DownloadedTelegramTurnFile[];
 } {
-  const marker = "\n\nTelegram attachments were saved locally:";
+  const marker = "\n\n[attachments]";
   const markerIndex = prompt.indexOf(marker);
   if (markerIndex === -1) {
     return {
@@ -105,11 +141,30 @@ function splitTelegramPromptAttachmentSuffix(prompt: string): {
   }
   const promptWithoutAttachments = prompt.slice(0, markerIndex);
   const attachmentSuffix = prompt.slice(markerIndex);
-  const attachmentFiles = attachmentSuffix
-    .split("\n")
+  const attachmentLines: string[] = [];
+  let readingAttachments = false;
+  let attachmentDir: string | undefined;
+  for (const line of attachmentSuffix.split("\n")) {
+    const trimmed = line.trim();
+    const attachmentMatch = trimmed.match(/^\[attachments\](?:\s+(.+))?$/);
+    if (attachmentMatch) {
+      readingAttachments = true;
+      attachmentDir = attachmentMatch[1]?.trim();
+      continue;
+    }
+    if (readingAttachments && /^\[[^\]]+\](?:\s+.*)?$/.test(trimmed)) break;
+    if (readingAttachments) attachmentLines.push(line);
+  }
+  const attachmentFiles = attachmentLines
     .map((line) => line.match(/^- (.+)$/)?.[1]?.trim())
     .filter((path): path is string => !!path)
-    .map((path) => ({ path, fileName: basename(path), isImage: false }));
+    .map((path) => (attachmentDir ? join(attachmentDir, path.replace(/^\/+/, "")) : path))
+    .map((path) => ({
+      path,
+      fileName: basename(path),
+      isImage: false,
+      kind: "document" as const,
+    }));
   return { promptWithoutAttachments, attachmentSuffix, attachmentFiles };
 }
 
@@ -117,13 +172,12 @@ function buildEditedTelegramPromptText(options: {
   existingPrompt: string;
   telegramPrefix: string;
   rawText: string;
-}): { text: string; attachmentFiles: DownloadedTelegramTurnFileLike[] } {
+}): { text: string; attachmentFiles: DownloadedTelegramTurnFile[] } {
   const { promptWithoutAttachments, attachmentSuffix, attachmentFiles } =
     splitTelegramPromptAttachmentSuffix(options.existingPrompt);
   const currentMessageMarker = "Current Telegram message:";
-  const currentMessageIndex = promptWithoutAttachments.lastIndexOf(
-    currentMessageMarker,
-  );
+  const currentMessageIndex =
+    promptWithoutAttachments.lastIndexOf(currentMessageMarker);
   if (currentMessageIndex !== -1) {
     const prefix = promptWithoutAttachments.slice(
       0,
@@ -150,7 +204,7 @@ export function updateTelegramPromptTurnText(options: {
   telegramPrefix: string;
   rawText: string;
 }): PendingTelegramTurn {
-  let attachmentFiles: DownloadedTelegramTurnFileLike[] = [];
+  let attachmentFiles: DownloadedTelegramTurnFile[] = [];
   const nextContent = options.turn.content.map((block, index) => {
     if (index !== 0 || block.type !== "text") return block;
     const updated = buildEditedTelegramPromptText({
@@ -175,27 +229,140 @@ export function updateTelegramPromptTurnText(options: {
   };
 }
 
-export async function buildTelegramPromptTurn(options: {
+export function updateQueuedTelegramPromptTurnText<
+  TContext = unknown,
+>(options: {
+  items: TelegramQueueItem<TContext>[];
+  sourceMessageId: number | undefined;
   telegramPrefix: string;
-  messages: TelegramTurnMessageLike[];
+  rawText: string;
+}): { items: TelegramQueueItem<TContext>[]; changed: boolean } {
+  if (options.sourceMessageId === undefined) {
+    return { items: options.items, changed: false };
+  }
+  let changed = false;
+  const items = options.items.map((item) => {
+    if (
+      item.kind !== "prompt" ||
+      !item.sourceMessageIds.includes(options.sourceMessageId as number)
+    ) {
+      return item;
+    }
+    changed = true;
+    return updateTelegramPromptTurnText({
+      turn: item,
+      telegramPrefix: options.telegramPrefix,
+      rawText: options.rawText,
+    });
+  });
+  return { items, changed };
+}
+
+export interface TelegramQueuedPromptEditRuntimeDeps<
+  TContext = unknown,
+> extends TelegramQueueStore<TContext> {
+  updateStatus: (ctx: TContext) => void;
+}
+
+export function createTelegramQueuedPromptEditRuntime<
+  TMessage extends TelegramMediaMessage,
+  TContext = unknown,
+>(deps: TelegramQueuedPromptEditRuntimeDeps<TContext>) {
+  return {
+    updateFromEditedMessage: (message: TMessage, ctx: TContext): boolean => {
+      const { changed, items } = updateQueuedTelegramPromptTurnText({
+        items: deps.getQueuedItems(),
+        sourceMessageId: message.message_id,
+        telegramPrefix: TELEGRAM_PREFIX,
+        rawText: extractTelegramMessagesText([message]),
+      });
+      deps.setQueuedItems(items);
+      if (changed) deps.updateStatus(ctx);
+      return changed;
+    },
+  };
+}
+
+export interface BuildTelegramPromptTurnOptions {
+  telegramPrefix: string;
+  messages: TelegramTurnMessage[];
   historyTurns?: PendingTelegramTurn[];
   queueOrder: number;
   rawText: string;
-  files: DownloadedTelegramTurnFileLike[];
+  files: DownloadedTelegramTurnFile[];
+  promptFiles?: DownloadedTelegramTurnFile[];
+  handlerOutputs?: string[];
   readBinaryFile: (path: string) => Promise<Uint8Array>;
   inferImageMimeType: (path: string) => string | undefined;
-}): Promise<PendingTelegramTurn> {
+}
+
+export type BuildTelegramPromptTurnRuntimeOptions = Omit<
+  BuildTelegramPromptTurnOptions,
+  "readBinaryFile"
+>;
+
+export interface TelegramPromptTurnRuntimeBuilderDeps<TContext = unknown>
+  extends DownloadTelegramMessageFilesDeps {
+  allocateQueueOrder: () => number;
+  processAttachments?: (
+    files: DownloadedTelegramTurnFile[],
+    rawText: string,
+    ctx: TContext,
+  ) => Promise<{
+    rawText: string;
+    promptFiles?: DownloadedTelegramTurnFile[];
+    handlerOutputs?: string[];
+  }>;
+}
+
+export function createTelegramPromptTurnRuntimeBuilder<
+  TMessage extends TelegramTurnMessage & TelegramMediaMessage,
+  TContext = unknown,
+>(
+  deps: TelegramPromptTurnRuntimeBuilderDeps<TContext>,
+): (
+  messages: TMessage[],
+  historyTurns?: PendingTelegramTurn[],
+  ctx?: TContext,
+) => Promise<PendingTelegramTurn> {
+  return async (messages, historyTurns = [], ctx) => {
+    const rawText = extractTelegramMessagesText(messages);
+    const files = await downloadTelegramMessageFiles(messages, {
+      downloadFile: deps.downloadFile,
+    });
+    const processed = deps.processAttachments
+      ? await deps.processAttachments(files, rawText, ctx as TContext)
+      : { rawText, promptFiles: files };
+    return buildTelegramPromptTurnRuntime({
+      telegramPrefix: TELEGRAM_PREFIX,
+      messages,
+      historyTurns,
+      queueOrder: deps.allocateQueueOrder(),
+      rawText: processed.rawText,
+      files,
+      promptFiles: processed.promptFiles,
+      handlerOutputs: processed.handlerOutputs,
+      inferImageMimeType: guessMediaType,
+    });
+  };
+}
+
+export async function buildTelegramPromptTurn(
+  options: BuildTelegramPromptTurnOptions,
+): Promise<PendingTelegramTurn> {
   const firstMessage = options.messages[0];
   if (!firstMessage) {
     throw new Error("Missing Telegram message for turn creation");
   }
-  const content: Array<TextContent | ImageContent> = [
+  const content: TelegramPromptContent[] = [
     {
       type: "text",
       text: buildTelegramTurnPrompt({
         telegramPrefix: options.telegramPrefix,
         rawText: options.rawText,
         files: options.files,
+        promptFiles: options.promptFiles,
+        handlerOutputs: options.handlerOutputs,
         historyTurns: options.historyTurns,
       }),
     },
@@ -221,10 +388,24 @@ export async function buildTelegramPromptTurn(options: {
     laneOrder: options.queueOrder,
     queuedAttachments: [],
     content,
-    historyText: formatTelegramHistoryText(options.rawText, options.files),
+    historyText: formatTelegramHistoryText(
+      options.rawText,
+      options.promptFiles ?? options.files,
+      options.handlerOutputs,
+    ),
     statusSummary: formatTelegramTurnStatusSummary(
       options.rawText,
-      options.files,
+      options.promptFiles ?? options.files,
+      options.handlerOutputs,
     ),
   };
 }
+
+export async function buildTelegramPromptTurnRuntime(
+  options: BuildTelegramPromptTurnRuntimeOptions,
+): Promise<PendingTelegramTurn> {
+  return buildTelegramPromptTurn({
+    ...options,
+    readBinaryFile: readFile,
+  });
+}