@llblab/pi-kit 0.27.6 → 0.28.0

package/node_modules/@llblab/pi-telegram/lib/logging.ts

@@ -12,33 +12,40 @@ import {
   writeFileSync,
   appendFileSync,
 } from "node:fs";
-import { dirname } from "node:path";
+import { basename, dirname, join } from "node:path";
 import {
   resolveAgentDir,
   resolveTelegramProfileTempFilePath,
+  resolveTelegramRuntimeLogPath,
+  resolveTelegramPreviousSharedRuntimeLogPath,
 } from "./paths.ts";
 import { withTelegramFileTransaction } from "./locks.ts";
 import * as Status from "./status.ts";
 
-export type TelegramLogPathInput = string | (() => string);
+type TelegramLogPathInput = string | (() => string);
 
-export interface TelegramRuntimeJsonlEvent {
+interface TelegramRuntimeJsonlEvent {
   at: number;
   category: string;
   message: string;
   details?: Record<string, unknown>;
 }
 
-export interface TelegramRuntimeJsonlLogOptions {
+interface TelegramRuntimeJsonlLogOptions {
   path?: TelegramLogPathInput;
   previousPath?: TelegramLogPathInput;
   maxBytes?: number;
   getNowMs?: () => number;
   canReset?: () => boolean;
   commitReset?: (commit: () => void) => boolean;
+  /** Explicit shared-file protocol; profile-labelled scope reset is an append, never truncation. */
+  sharedProfiles?: {
+    getProfileName: () => string | undefined;
+    captureAuthority: () => (() => boolean) | undefined;
+  };
 }
 
-export interface TelegramRuntimeJsonlLog {
+interface TelegramRuntimeJsonlLog {
   getPath: () => string;
   reset: (reason: string, scope?: Record<string, unknown>) => void;
   resetIfScopeChanged: (
@@ -88,15 +95,18 @@ function safeJsonLine(value: unknown): string {
 export function createTelegramRuntimeJsonlLog(
   options: TelegramRuntimeJsonlLogOptions = {},
 ): TelegramRuntimeJsonlLog {
+  const shared = options.sharedProfiles ? { ...options.sharedProfiles } : undefined;
+  const pathSource = options.path, previousSource = options.previousPath;
+  const canReset = options.canReset, commitReset = options.commitReset;
   const resolvePath = () =>
-    typeof options.path === "function"
-      ? options.path()
-      : (options.path ?? getTelegramRuntimeLogPath());
+    typeof pathSource === "function"
+      ? pathSource()
+      : (pathSource ?? getTelegramRuntimeLogPath());
   const resolvePreviousPath = () => {
-    if (typeof options.previousPath === "function")
-      return options.previousPath();
-    if (options.previousPath) return options.previousPath;
-    return resolvePath().replace(/\.jsonl$/u, "._prev.jsonl");
+    if (typeof previousSource === "function") return previousSource();
+    if (previousSource) return previousSource;
+    return shared ? join(dirname(resolvePath()), "logs", `${basename(resolvePath(), ".jsonl")}._prev.jsonl`)
+      : resolvePath().replace(/\.jsonl$/u, "._prev.jsonl");
   };
   const maxBytes = options.maxBytes ?? DEFAULT_MAX_LOG_BYTES;
   const getNowMs = options.getNowMs ?? Date.now;
@@ -107,7 +117,17 @@ export function createTelegramRuntimeJsonlLog(
     path: string;
     previousPath: string;
     line: string;
+    profile?: string;
+    rotationCurrent?: () => boolean;
   }[] = [];
+  const getProfile = () => shared?.getProfileName() ?? "default";
+  const transactionPath = (path: string) => shared ? join(dirname(path), "runtime", `${basename(path)}.transaction`) : `${path}.transaction`;
+  const captureRotation = (path: string, previousPath: string, profile: string): (() => boolean) | undefined => {
+    if (!shared) return undefined;
+    const authority = shared.captureAuthority();
+    return () => authority?.() === true && resolvePath() === path && resolvePreviousPath() === previousPath && getProfile() === profile;
+  };
+  const scopeStorageKey = (path: string, profile: string) => shared ? JSON.stringify([path, profile]) : path;
 
   const ensureParent = (path: string) => {
     mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
@@ -124,49 +144,63 @@ export function createTelegramRuntimeJsonlLog(
     previousPath: string,
     reason: string,
     scope?: Record<string, unknown>,
-  ) => {
+    profile?: string,
+    isCurrent?: () => boolean,
+  ): boolean => {
+    const line = safeJsonLine({
+      at: getNowMs(),
+      kind: "reset",
+      reason,
+      scope,
+      previousPath,
+      ...(shared ? { profile } : {}),
+    }) + "\n";
+    if (shared && !isCurrent?.()) return false;
     ensureParent(path);
     preserveCurrentLog(path, previousPath);
-    writeFileSync(
-      path,
-      safeJsonLine({
-        at: getNowMs(),
-        kind: "reset",
-        reason,
-        scope,
-        previousPath,
-      }) + "\n",
-      { mode: 0o600 },
-    );
+    if (shared && !isCurrent?.()) return false;
+    writeFileSync(path, line, { mode: 0o600 });
+    return true;
   };
 
   const writeReset = (
     reason: string,
-    scope?: Record<string, unknown>,
+    scope: Record<string, unknown> | undefined,
+    path: string,
+    profile: string,
   ): boolean => {
-    if (options.canReset && !options.canReset()) return false;
-    const path = resolvePath();
+    const previousPath = resolvePreviousPath();
+    const isCurrent = captureRotation(path, previousPath, profile);
+    if (canReset && !canReset()) return false;
     let didReset = false;
-    withTelegramFileTransaction(`${path}.transaction`, () => {
+    withTelegramFileTransaction(transactionPath(path), () => {
       const commit = () => {
-        writeResetLocked(path, resolvePreviousPath(), reason, scope);
-        didReset = true;
+        if (shared && !isCurrent?.()) return;
+        if (shared) {
+          const line = safeJsonLine({ at: getNowMs(), kind: "reset", reason, scope, profile }) + "\n";
+          if (!isCurrent?.()) return;
+          ensureParent(path);
+          if (existsSync(path) && statSync(path).size + Buffer.byteLength(line) > maxBytes &&
+              !writeResetLocked(path, previousPath, "max-bytes", { maxBytes }, profile, isCurrent)) return;
+          if (!isCurrent?.()) return;
+          appendFileSync(path, line, { mode: 0o600 });
+          didReset = true;
+        } else didReset = writeResetLocked(path, previousPath, reason, scope);
       };
-      if (options.commitReset) {
-        options.commitReset(commit);
+      if (commitReset) {
+        commitReset(commit);
       } else {
         commit();
       }
     });
-    return didReset;
+    return didReset && (!shared || isCurrent?.() === true);
   };
 
-  const appendLine = (line: string) => {
-    queuedAppends.push({
-      path: resolvePath(),
-      previousPath: resolvePreviousPath(),
-      line,
-    });
+  const appendEvent = (event: TelegramRuntimeJsonlEvent) => {
+    const path = resolvePath(), previousPath = resolvePreviousPath(), profile = getProfile();
+    const rotationCurrent = captureRotation(path, previousPath, profile);
+    const line = safeJsonLine({ kind: "event", ...event, ...(shared ? { profile } : {}) }) + "\n";
+    queuedAppends.push({ path, previousPath, line, ...(shared ? { profile, rotationCurrent } : {}) });
     if (appendScheduled) return;
     appendScheduled = true;
     pending = pending
@@ -176,18 +210,18 @@ export function createTelegramRuntimeJsonlLog(
         queuedAppends = [];
         const groups = new Map<
           string,
-          { path: string; previousPath: string; lines: string[] }
+          { path: string; previousPath: string; entries: typeof queuedAppends }
         >();
         for (const entry of batch) {
           const key = `${entry.path}\u0000${entry.previousPath}`;
           const group = groups.get(key);
-          if (group) group.lines.push(entry.line);
-          else groups.set(key, { ...entry, lines: [entry.line] });
+          if (group) group.entries.push(entry);
+          else groups.set(key, { ...entry, entries: [entry] });
         }
         for (const group of groups.values()) {
           try {
             ensureParent(group.path);
-            withTelegramFileTransaction(`${group.path}.transaction`, () => {
+            withTelegramFileTransaction(transactionPath(group.path), () => {
               let currentSize = existsSync(group.path)
                 ? statSync(group.path).size
                 : 0;
@@ -200,31 +234,35 @@ export function createTelegramRuntimeJsonlLog(
                 chunk = "";
                 chunkBytes = 0;
               };
-              const rotate = (): boolean => {
-                if (options.canReset && !options.canReset()) return false;
+              const rotate = (entry: typeof queuedAppends[number]): boolean => {
+                if (canReset && !canReset()) return false;
+                if (shared && !entry.rotationCurrent?.()) return false;
                 let rotated = false;
                 const commit = () => {
-                  writeResetLocked(
+                  if (shared && !entry.rotationCurrent?.()) return;
+                  rotated = writeResetLocked(
                     group.path,
                     group.previousPath,
                     "max-bytes",
                     { maxBytes },
+                    entry.profile,
+                    entry.rotationCurrent,
                   );
-                  rotated = true;
                 };
-                if (options.commitReset) options.commitReset(commit);
+                if (commitReset) commitReset(commit);
                 else commit();
                 if (rotated) currentSize = statSync(group.path).size;
                 return rotated;
               };
-              for (const line of group.lines) {
+              for (const entry of group.entries) {
+                const line = entry.line;
                 const lineBytes = Buffer.byteLength(line);
                 if (
                   currentSize + chunkBytes > 0 &&
                   currentSize + chunkBytes + lineBytes > maxBytes
                 ) {
                   flushChunk();
-                  rotate();
+                  rotate(entry);
                 }
                 chunk += line;
                 chunkBytes += lineBytes;
@@ -242,27 +280,27 @@ export function createTelegramRuntimeJsonlLog(
   return {
     getPath: resolvePath,
     reset(reason, scope) {
-      const path = resolvePath();
+      const path = resolvePath(), profile = getProfile();
       try {
-        if (writeReset(reason, scope)) {
-          scopeKeys.set(path, scope ? safeJsonLine(scope) : undefined);
+        if (writeReset(reason, scope, path, profile)) {
+          scopeKeys.set(scopeStorageKey(path, profile), scope ? safeJsonLine(scope) : undefined);
         }
       } catch {
         // Diagnostics must never break Telegram runtime behavior.
       }
     },
     resetIfScopeChanged(nextScopeKey, reason, scope) {
-      const path = resolvePath();
-      if (scopeKeys.get(path) === nextScopeKey) return;
+      const path = resolvePath(), profile = getProfile(), key = scopeStorageKey(path, profile);
+      if (scopeKeys.get(key) === nextScopeKey) return;
       try {
-        if (writeReset(reason, scope)) scopeKeys.set(path, nextScopeKey);
+        if (writeReset(reason, scope, path, profile)) scopeKeys.set(key, nextScopeKey);
       } catch {
         // Diagnostics must never break Telegram runtime behavior.
       }
     },
     record(event) {
       try {
-        appendLine(safeJsonLine({ kind: "event", ...event }) + "\n");
+        appendEvent(event);
       } catch {
         // Diagnostics must never break Telegram runtime behavior.
       }
@@ -270,7 +308,19 @@ export function createTelegramRuntimeJsonlLog(
   };
 }
 
-export interface TelegramRuntimeDiagnosticsRuntime<TContext> {
+interface TelegramRuntimeDiagnosticsStatusPorts<TContext> {
+  instanceId: string;
+  updateStatus(ctx: TContext, error?: string): void;
+  getStatusState(): Status.TelegramBridgeStatusLineState;
+  persistSnapshot(snapshot: ReturnType<typeof Status.createTelegramStatusSnapshot>): Promise<void>;
+  session?: {
+    get(): TContext | undefined;
+    getGeneration(): number;
+    isCurrent(ctx: TContext, generation?: number): boolean;
+  };
+}
+
+interface TelegramRuntimeDiagnosticsRuntime<TContext> {
   events: Status.TelegramRuntimeEventRecorder;
   recordRuntimeEvent(
     category: string,
@@ -282,15 +332,11 @@ export interface TelegramRuntimeDiagnosticsRuntime<TContext> {
     getProfileName(): string | undefined;
     canReset(): boolean;
     commitReset(commit: () => void): boolean;
+    captureAuthority?: () => (() => boolean) | undefined;
   }): void;
-  bindStatus(ports: {
-    instanceId: string;
-    updateStatus(ctx: TContext, error?: string): void;
-    getStatusState(): Status.TelegramBridgeStatusLineState;
-    persistSnapshot(
-      snapshot: ReturnType<typeof Status.createTelegramStatusSnapshot>,
-    ): Promise<void>;
-  }): void;
+  bindStatus(ports: TelegramRuntimeDiagnosticsStatusPorts<TContext>): void;
+  onSessionStart(): void;
+  onSessionShutdown(): Promise<void>;
   updateStatus(ctx: TContext, error?: string): void;
   getStatusLines(options?: Status.TelegramBridgeStatusLineOptions): string[];
   scheduleSnapshotPersist(): void;
@@ -298,29 +344,25 @@ export interface TelegramRuntimeDiagnosticsRuntime<TContext> {
 
 export function createTelegramRuntimeDiagnosticsRuntime<
   TContext,
->(): TelegramRuntimeDiagnosticsRuntime<TContext> {
+>(options: {
+  sharedFile?: boolean;
+  snapshotTimer?: Pick<Parameters<typeof Status.createTelegramRuntimeDiagnosticsSnapshotScheduler>[0], "setTimer" | "clearTimer">;
+} = {}): TelegramRuntimeDiagnosticsRuntime<TContext> {
+  const sharedFile = options.sharedFile === true;
   let getBotToken = (): string | undefined => undefined;
   let getProfileName = (): string | undefined => undefined;
   let canReset = (): boolean => false;
   let commitReset = (_commit: () => void): boolean => false;
-  let statusPorts:
-    | {
-        instanceId: string;
-        updateStatus(ctx: TContext, error?: string): void;
-        getStatusState(): Status.TelegramBridgeStatusLineState;
-        persistSnapshot(
-          snapshot: ReturnType<typeof Status.createTelegramStatusSnapshot>,
-        ): Promise<void>;
-      }
-    | undefined;
-  let requestSnapshotPersist = (): void => {};
+  let captureAuthority = (): (() => boolean) | undefined => undefined;
+  let statusPorts: TelegramRuntimeDiagnosticsStatusPorts<TContext> | undefined;
   const events = Status.createTelegramRuntimeEventRecorder({
     getBotToken: () => getBotToken(),
   });
   const jsonl = createTelegramRuntimeJsonlLog({
-    path: () => getTelegramRuntimeLogPath(undefined, getProfileName()),
-    previousPath: () =>
-      getTelegramPreviousRuntimeLogPath(undefined, getProfileName()),
+    path: () => sharedFile ? resolveTelegramRuntimeLogPath() : getTelegramRuntimeLogPath(undefined, getProfileName()),
+    previousPath: () => sharedFile ? resolveTelegramPreviousSharedRuntimeLogPath()
+      : getTelegramPreviousRuntimeLogPath(undefined, getProfileName()),
+    ...(sharedFile ? { sharedProfiles: { getProfileName: () => getProfileName(), captureAuthority: () => captureAuthority() } } : {}),
     canReset: () => canReset(),
     commitReset: (commit) => commitReset(commit),
   });
@@ -334,12 +376,29 @@ export function createTelegramRuntimeDiagnosticsRuntime<
     if (latestEvent) jsonl.record(latestEvent);
     requestSnapshotPersist();
   };
-  const persistCurrentSnapshot = async (): Promise<void> => {
-    if (!statusPorts) return;
-    await statusPorts.persistSnapshot(
-      Status.createTelegramStatusSnapshot(statusPorts.getStatusState()),
-    );
+  const captureSnapshotScope = (): (() => boolean) | undefined => {
+    const ports = statusPorts;
+    if (!ports) return undefined;
+    if (!ports.session) return () => statusPorts === ports;
+    const session = ports.session, ctx = session.get(), generation = session.getGeneration();
+    if (ctx === undefined || !session.isCurrent(ctx, generation)) return undefined;
+    return () => statusPorts === ports && session.isCurrent(ctx, generation);
   };
+  const requestSnapshotPersist = Status.createTelegramRuntimeDiagnosticsSnapshotScheduler({
+    ...options.snapshotTimer,
+    captureScope: captureSnapshotScope,
+    async persistSnapshot(isCurrent) {
+      const ports = statusPorts;
+      // Projection may acquire journal guards or recover a snapshot: fence before reading it.
+      if (!ports || !isCurrent()) return;
+      const snapshot = Status.createTelegramStatusSnapshot(ports.getStatusState());
+      if (!isCurrent()) return;
+      await ports.persistSnapshot(snapshot);
+    },
+    recordError(error) {
+      events.record("telegram", error, { phase: "runtime-diagnostics-snapshot-persist" });
+    },
+  });
   const updateRuntimeLogScope = function (reason: string): void {
     if (!statusPorts) return;
     const scope = Status.createTelegramRuntimeLogScope({
@@ -356,31 +415,22 @@ export function createTelegramRuntimeDiagnosticsRuntime<
       getProfileName = ports.getProfileName;
       canReset = ports.canReset;
       commitReset = ports.commitReset;
+      captureAuthority = ports.captureAuthority ?? (() => undefined);
     },
     bindStatus(ports) {
       statusPorts = ports;
-      requestSnapshotPersist =
-        Status.createTelegramRuntimeDiagnosticsSnapshotScheduler({
-          persistSnapshot: persistCurrentSnapshot,
-          recordError(error) {
-            events.record("telegram", error, {
-              phase: "runtime-diagnostics-snapshot-persist",
-            });
-          },
-        });
+      if (ports.session) void requestSnapshotPersist.suspend();
     },
+    onSessionStart: requestSnapshotPersist.resume,
+    onSessionShutdown: requestSnapshotPersist.suspend,
     updateStatus(ctx, error) {
-      if (!statusPorts) return;
+      if (!statusPorts || statusPorts.session?.isCurrent(ctx) === false) return;
       statusPorts.updateStatus(ctx, error);
       updateRuntimeLogScope("status-scope-change");
     },
     getStatusLines(options) {
       if (!statusPorts) return [];
-      void persistCurrentSnapshot().catch((error) => {
-        recordRuntimeEvent("telegram", error, {
-          phase: "status-snapshot-persist",
-        });
-      });
+      requestSnapshotPersist();
       return Status.buildTelegramBridgeStatusLines(
         statusPorts.getStatusState(),
         options,

package/node_modules/@llblab/pi-telegram/lib/media.ts

@@ -67,10 +67,13 @@ export interface TelegramReplyToMessage {
 
 export interface TelegramSticker {
   file_id: string;
+  is_video?: boolean;
+  is_animated?: boolean;
 }
 
 export interface TelegramMediaMessage {
   message_id: number;
+  chat?: { id: number; type?: string; username?: string };
   from?: TelegramMessageUser;
   forward_origin?: TelegramMessageForwardOrigin;
   forward_from?: TelegramMessageUser;
@@ -154,9 +157,26 @@ export interface TelegramMediaGroupControllerOptions {
 export type TelegramAttachmentKind =
   "photo" | "document" | "video" | "audio" | "voice" | "animation" | "sticker";
 
+/** Where an inbound attachment came from; the download layer turns it into a scoped file name. */
+export interface TelegramAttachmentSource {
+  kind: string;
+  messageId: number;
+  index?: number;
+  /** Sender-chosen file name, kept as a trailing readable segment. */
+  userFileName?: string;
+  chat?: { id: number; type?: string; username?: string };
+  /** Explicit source scope, e.g. a Guest Mode peer whose message IDs are not the bot chat's. */
+  scope?: string;
+}
+
 export interface TelegramFileInfo {
   file_id: string;
   fileName: string;
+  /** Present only when the sender chose the name. */
+  userFileName?: string;
+  /** Position inside a rich message. */
+  index?: number;
+  source?: TelegramAttachmentSource;
   mimeType?: string;
   kind: TelegramAttachmentKind;
   isImage: boolean;
@@ -179,10 +199,14 @@ export interface DownloadedTelegramMessageFile {
 }
 
 export interface DownloadTelegramMessageFilesDeps {
-  downloadFile: (fileId: string, fileName: string) => Promise<string>;
+  downloadFile: (
+    fileId: string,
+    fileName: string,
+    source?: TelegramAttachmentSource,
+  ) => Promise<string>;
 }
 
-export function guessExtensionFromMime(
+function guessExtensionFromMime(
   mimeType: string | undefined,
   fallback: string,
 ): string {
@@ -351,7 +375,7 @@ export function extractTelegramForwardContextText(
   return `from: ${origin}`;
 }
 
-export function extractTelegramReplyContextText(
+function extractTelegramReplyContextText(
   message: TelegramMediaMessage,
 ): string {
   const quoted = (
@@ -396,7 +420,7 @@ export function buildTelegramReplyContextBlock(
   return "";
 }
 
-export function appendTelegramReplyContext(
+function appendTelegramReplyContext(
   text: string,
   replyContext: string,
 ): string {
@@ -437,7 +461,7 @@ export function extractFirstTelegramMessageText(
   return messages.map(extractTelegramMessageText).find(Boolean) ?? "";
 }
 
-export function hasTelegramMessagePromptContent(
+function hasTelegramMessagePromptContent(
   message: TelegramMediaMessage,
 ): boolean {
   return (
@@ -712,7 +736,7 @@ export async function downloadTelegramMessageFiles(
   const downloaded: DownloadedTelegramMessageFile[] = [];
   for (const file of collectTelegramFileInfos(messages)) {
     downloaded.push({
-      path: await deps.downloadFile(file.file_id, file.fileName),
+      path: await deps.downloadFile(file.file_id, file.fileName, file.source),
       fileName: file.fileName,
       isImage: file.isImage,
       mimeType: file.mimeType,
@@ -759,6 +783,7 @@ function collectTelegramRichBlockFileInfos(
             files.push({
               file_id: photo.file_id,
               fileName: `photo-${messageId}-${mediaIndex}.jpg`,
+              index: mediaIndex,
               mimeType: "image/jpeg",
               kind: "photo",
               isImage: true,
@@ -788,6 +813,8 @@ function collectTelegramRichBlockFileInfos(
             kind === "voice" ? ".ogg" : kind === "audio" ? ".mp3" : ".mp4";
           files.push({
             file_id: fileId,
+            index: mediaIndex,
+            ...(typeof fileName === "string" ? { userFileName: fileName } : {}),
             fileName:
               typeof fileName === "string"
                 ? fileName
@@ -817,6 +844,7 @@ export function collectTelegramFileInfos(
 ): TelegramFileInfo[] {
   const files: TelegramFileInfo[] = [];
   for (const message of messages) {
+    const firstOfMessage = files.length;
     files.push(
       ...collectTelegramRichBlockFileInfos(
         message.rich_message?.blocks,
@@ -847,6 +875,7 @@ export function collectTelegramFileInfos(
       files.push({
         file_id: message.document.file_id,
         fileName,
+        ...(message.document.file_name ? { userFileName: message.document.file_name } : {}),
         mimeType: message.document.mime_type,
         kind: "document",
         isImage: isImageMimeType(message.document.mime_type),
@@ -862,6 +891,7 @@ export function collectTelegramFileInfos(
       files.push({
         file_id: message.video.file_id,
         fileName,
+        ...(message.video.file_name ? { userFileName: message.video.file_name } : {}),
         mimeType: message.video.mime_type,
         kind: "video",
         isImage: false,
@@ -878,6 +908,7 @@ export function collectTelegramFileInfos(
       files.push({
         file_id: message.audio.file_id,
         fileName,
+        ...(message.audio.file_name ? { userFileName: message.audio.file_name } : {}),
         mimeType: message.audio.mime_type,
         kind: "audio",
         isImage: false,
@@ -907,20 +938,31 @@ export function collectTelegramFileInfos(
       files.push({
         file_id: message.animation.file_id,
         fileName,
+        ...(message.animation.file_name ? { userFileName: message.animation.file_name } : {}),
         mimeType: message.animation.mime_type,
         kind: "animation",
         isImage: false,
       });
     }
     if (message.sticker) {
+      // Sticker format is defined by Bot API flags, not a documented MIME field.
+      const video = message.sticker.is_video === true;
+      const animated = message.sticker.is_animated === true;
+      const extension = video ? ".webm" : animated ? ".tgs" : ".webp";
       files.push({
         file_id: message.sticker.file_id,
-        fileName: `sticker-${message.message_id}.webp`,
-        mimeType: "image/webp",
+        fileName: `sticker-${message.message_id}${extension}`,
+        mimeType: video ? "video/webm" : animated ? "application/x-tgsticker" : "image/webp",
         kind: "sticker",
-        isImage: true,
+        isImage: !video && !animated,
       });
     }
+    for (const file of files.slice(firstOfMessage)) {
+      file.source = { kind: file.kind, messageId: message.message_id,
+        ...(file.index !== undefined ? { index: file.index } : {}),
+        ...(file.userFileName ? { userFileName: file.userFileName } : {}),
+        ...(message.chat ? { chat: message.chat } : {}) };
+    }
   }
   const seenFileIds = new Set<string>();
   return files.filter((file) => {

package/node_modules/@llblab/pi-telegram/lib/menu-model.ts

@@ -267,7 +267,7 @@ export const TELEGRAM_MODEL_PAGE_SIZE = 6;
 const TELEGRAM_MODEL_PAGE_PICKER_ROW_SIZE = 4;
 export const MODEL_MENU_TITLE = "<b>🤖 Choose a model:</b>";
 export const MODEL_PAGE_MENU_TITLE = "<b>Choose a page:</b>";
-export const MODEL_DETAIL_MENU_TITLE = "<b>🤖 Model:</b>";
+const MODEL_DETAIL_MENU_TITLE = "<b>🤖 Model:</b>";
 
 function truncateTelegramButtonLabel(label: string, maxLength = 56): string {
   return label.length <= maxLength
@@ -647,7 +647,7 @@ export function getTelegramModelSelection<TModel extends MenuModel = MenuModel>(
   return { kind: "selected", selection };
 }
 
-export function applyTelegramModelDetailSelection(
+function applyTelegramModelDetailSelection(
   state: TelegramModelMenuState,
   value: string | undefined,
 ): TelegramMenuMutationResult {
@@ -661,7 +661,7 @@ export function applyTelegramModelDetailSelection(
   return "changed";
 }
 
-export function getTelegramSelectedDetailModel<
+function getTelegramSelectedDetailModel<
   TModel extends MenuModel = MenuModel,
 >(state: TelegramModelMenuState<TModel>): TelegramMenuSelectionResult<TModel> {
   const indexedSelection = getTelegramModelSelection(
@@ -687,7 +687,7 @@ export function getTelegramSelectedDetailModel<
   return indexedSelection;
 }
 
-export function isTelegramModelScoped(
+function isTelegramModelScoped(
   state: TelegramModelMenuState,
   model: MenuModel,
 ): boolean {
@@ -697,7 +697,7 @@ export function isTelegramModelScoped(
   );
 }
 
-export function focusTelegramModelListPage(
+function focusTelegramModelListPage(
   state: TelegramModelMenuState,
   model: MenuModel,
   pageSize = TELEGRAM_MODEL_PAGE_SIZE,
@@ -715,7 +715,7 @@ function formatScopedModelPattern(entry: ScopedTelegramModel): string {
   return entry.thinkingLevel ? `${key}:${entry.thinkingLevel}` : key;
 }
 
-export function setTelegramModelScope(
+function setTelegramModelScope(
   state: TelegramModelMenuState,
   model: MenuModel,
   enabled: boolean,
@@ -1062,7 +1062,7 @@ export function buildModelMenuReplyMarkup(
   return { inline_keyboard: rows };
 }
 
-export function buildModelDetailMenuReplyMarkup(
+function buildModelDetailMenuReplyMarkup(
   state: TelegramModelMenuState,
   currentModel: MenuModel | undefined,
 ): TelegramReplyMarkup {
@@ -1100,7 +1100,7 @@ export function buildModelDetailMenuReplyMarkup(
   };
 }
 
-export function buildModelDetailMenuText(
+function buildModelDetailMenuText(
   state: TelegramModelMenuState,
 ): string {
   const selection = getTelegramSelectedDetailModel(state);