@llblab/pi-kit 0.27.6 → 0.28.0

package/node_modules/@llblab/pi-telegram/dist/lib/logging.js

@@ -4,8 +4,8 @@
  * Owns bounded JSONL runtime evidence files, previous-log preservation, and profile-aware log paths without becoming routing state
  */
 import { copyFileSync, existsSync, mkdirSync, statSync, writeFileSync, appendFileSync, } from "node:fs";
-import { dirname } from "node:path";
-import { resolveAgentDir, resolveTelegramProfileTempFilePath, } from "./paths.js";
+import { basename, dirname, join } from "node:path";
+import { resolveAgentDir, resolveTelegramProfileTempFilePath, resolveTelegramRuntimeLogPath, resolveTelegramPreviousSharedRuntimeLogPath, } from "./paths.js";
 import { withTelegramFileTransaction } from "./locks.js";
 import * as Status from "./status.js";
 const DEFAULT_MAX_LOG_BYTES = 5 * 1024 * 1024;
@@ -27,15 +27,19 @@ function safeJsonLine(value) {
     });
 }
 export function createTelegramRuntimeJsonlLog(options = {}) {
-    const resolvePath = () => typeof options.path === "function"
-        ? options.path()
-        : (options.path ?? getTelegramRuntimeLogPath());
+    const shared = options.sharedProfiles ? { ...options.sharedProfiles } : undefined;
+    const pathSource = options.path, previousSource = options.previousPath;
+    const canReset = options.canReset, commitReset = options.commitReset;
+    const resolvePath = () => 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;
@@ -43,6 +47,15 @@ export function createTelegramRuntimeJsonlLog(options = {}) {
     let pending = Promise.resolve();
     let appendScheduled = false;
     let queuedAppends = [];
+    const getProfile = () => shared?.getProfileName() ?? "default";
+    const transactionPath = (path) => shared ? join(dirname(path), "runtime", `${basename(path)}.transaction`) : `${path}.transaction`;
+    const captureRotation = (path, previousPath, profile) => {
+        if (!shared)
+            return undefined;
+        const authority = shared.captureAuthority();
+        return () => authority?.() === true && resolvePath() === path && resolvePreviousPath() === previousPath && getProfile() === profile;
+    };
+    const scopeStorageKey = (path, profile) => shared ? JSON.stringify([path, profile]) : path;
     const ensureParent = (path) => {
         mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
     };
@@ -52,42 +65,64 @@ export function createTelegramRuntimeJsonlLog(options = {}) {
         mkdirSync(dirname(previousPath), { recursive: true, mode: 0o700 });
         copyFileSync(path, previousPath);
     };
-    const writeResetLocked = (path, previousPath, reason, scope) => {
-        ensureParent(path);
-        preserveCurrentLog(path, previousPath);
-        writeFileSync(path, safeJsonLine({
+    const writeResetLocked = (path, previousPath, reason, scope, profile, isCurrent) => {
+        const line = safeJsonLine({
             at: getNowMs(),
             kind: "reset",
             reason,
             scope,
             previousPath,
-        }) + "\n", { mode: 0o600 });
+            ...(shared ? { profile } : {}),
+        }) + "\n";
+        if (shared && !isCurrent?.())
+            return false;
+        ensureParent(path);
+        preserveCurrentLog(path, previousPath);
+        if (shared && !isCurrent?.())
+            return false;
+        writeFileSync(path, line, { mode: 0o600 });
+        return true;
     };
-    const writeReset = (reason, scope) => {
-        if (options.canReset && !options.canReset())
+    const writeReset = (reason, scope, path, profile) => {
+        const previousPath = resolvePreviousPath();
+        const isCurrent = captureRotation(path, previousPath, profile);
+        if (canReset && !canReset())
             return false;
-        const path = resolvePath();
         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) => {
-        queuedAppends.push({
-            path: resolvePath(),
-            previousPath: resolvePreviousPath(),
-            line,
-        });
+    const appendEvent = (event) => {
+        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;
@@ -101,14 +136,14 @@ export function createTelegramRuntimeJsonlLog(options = {}) {
                 const key = `${entry.path}\u0000${entry.previousPath}`;
                 const group = groups.get(key);
                 if (group)
-                    group.lines.push(entry.line);
+                    group.entries.push(entry);
                 else
-                    groups.set(key, { ...entry, lines: [entry.line] });
+                    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;
@@ -122,28 +157,32 @@ export function createTelegramRuntimeJsonlLog(options = {}) {
                             chunk = "";
                             chunkBytes = 0;
                         };
-                        const rotate = () => {
-                            if (options.canReset && !options.canReset())
+                        const rotate = (entry) => {
+                            if (canReset && !canReset())
+                                return false;
+                            if (shared && !entry.rotationCurrent?.())
                                 return false;
                             let rotated = false;
                             const commit = () => {
-                                writeResetLocked(group.path, group.previousPath, "max-bytes", { maxBytes });
-                                rotated = true;
+                                if (shared && !entry.rotationCurrent?.())
+                                    return;
+                                rotated = writeResetLocked(group.path, group.previousPath, "max-bytes", { maxBytes }, entry.profile, entry.rotationCurrent);
                             };
-                            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;
@@ -161,10 +200,10 @@ export function createTelegramRuntimeJsonlLog(options = {}) {
     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 {
@@ -172,12 +211,12 @@ export function createTelegramRuntimeJsonlLog(options = {}) {
             }
         },
         resetIfScopeChanged(nextScopeKey, reason, scope) {
-            const path = resolvePath();
-            if (scopeKeys.get(path) === nextScopeKey)
+            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.
@@ -185,7 +224,7 @@ export function createTelegramRuntimeJsonlLog(options = {}) {
         },
         record(event) {
             try {
-                appendLine(safeJsonLine({ kind: "event", ...event }) + "\n");
+                appendEvent(event);
             }
             catch {
                 // Diagnostics must never break Telegram runtime behavior.
@@ -193,19 +232,22 @@ export function createTelegramRuntimeJsonlLog(options = {}) {
         },
     };
 }
-export function createTelegramRuntimeDiagnosticsRuntime() {
+export function createTelegramRuntimeDiagnosticsRuntime(options = {}) {
+    const sharedFile = options.sharedFile === true;
     let getBotToken = () => undefined;
     let getProfileName = () => undefined;
     let canReset = () => false;
     let commitReset = (_commit) => false;
+    let captureAuthority = () => undefined;
     let statusPorts;
-    let requestSnapshotPersist = () => { };
     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),
     });
@@ -216,11 +258,34 @@ export function createTelegramRuntimeDiagnosticsRuntime() {
             jsonl.record(latestEvent);
         requestSnapshotPersist();
     };
-    const persistCurrentSnapshot = async () => {
-        if (!statusPorts)
-            return;
-        await statusPorts.persistSnapshot(Status.createTelegramStatusSnapshot(statusPorts.getStatusState()));
+    const captureSnapshotScope = () => {
+        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) {
         if (!statusPorts)
             return;
@@ -238,21 +303,17 @@ 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)
+            if (!statusPorts || statusPorts.session?.isCurrent(ctx) === false)
                 return;
             statusPorts.updateStatus(ctx, error);
             updateRuntimeLogScope("status-scope-change");
@@ -260,11 +321,7 @@ export function createTelegramRuntimeDiagnosticsRuntime() {
         getStatusLines(options) {
             if (!statusPorts)
                 return [];
-            void persistCurrentSnapshot().catch((error) => {
-                recordRuntimeEvent("telegram", error, {
-                    phase: "status-snapshot-persist",
-                });
-            });
+            requestSnapshotPersist();
             return Status.buildTelegramBridgeStatusLines(statusPorts.getStatusState(), options);
         },
         scheduleSnapshotPersist() {

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

@@ -61,9 +61,16 @@ 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;
@@ -125,9 +132,29 @@ export interface TelegramMediaGroupControllerOptions {
     clearTimer?: (timer: ReturnType<typeof setTimeout>) => void;
 }
 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;
@@ -147,20 +174,16 @@ export interface DownloadedTelegramMessageFile {
     kind?: TelegramAttachmentKind;
 }
 export interface DownloadTelegramMessageFilesDeps {
-    downloadFile: (fileId: string, fileName: string) => Promise<string>;
+    downloadFile: (fileId: string, fileName: string, source?: TelegramAttachmentSource) => Promise<string>;
 }
-export declare function guessExtensionFromMime(mimeType: string | undefined, fallback: string): string;
 export declare function guessMediaType(path: string): string | undefined;
 export declare function extractTelegramMessageText(message: TelegramMediaMessage): string;
 export declare function extractTelegramForwardContextText(message: TelegramMediaMessage, allowedUserId?: number): string;
-export declare function extractTelegramReplyContextText(message: TelegramMediaMessage): string;
 export declare function buildTelegramReplyContextBlock(message: TelegramMediaMessage, replyFiles?: Pick<DownloadedTelegramFile, "path">[], replyOutputs?: readonly string[]): string;
-export declare function appendTelegramReplyContext(text: string, replyContext: string): string;
 export declare function extractTelegramMessagePromptText(message: TelegramMediaMessage): string;
 export declare function extractTelegramMessagesText(messages: TelegramMediaMessage[]): string;
 export declare function extractTelegramMessagesPromptText(messages: TelegramMediaMessage[]): string;
 export declare function extractFirstTelegramMessageText(messages: TelegramMediaMessage[]): string;
-export declare function hasTelegramMessagePromptContent(message: TelegramMediaMessage): boolean;
 export declare function hasTelegramMessagesPromptContent(messages: TelegramMediaMessage[]): boolean;
 export declare function collectTelegramMessageIds(messages: TelegramMediaMessage[]): number[];
 export declare function getTelegramMediaGroupKey(message: TelegramMediaGroupMessage): string | undefined;

package/node_modules/@llblab/pi-telegram/dist/lib/media.js

@@ -6,7 +6,7 @@
 import { basename, dirname } from "node:path";
 const TELEGRAM_MEDIA_GROUP_DEBOUNCE_MS = 1200;
 const TELEGRAM_REPLY_CONTEXT_MAX_LENGTH = 1000;
-export function guessExtensionFromMime(mimeType, fallback) {
+function guessExtensionFromMime(mimeType, fallback) {
     if (!mimeType)
         return fallback;
     const normalized = mimeType.toLowerCase();
@@ -162,7 +162,7 @@ export function extractTelegramForwardContextText(message, allowedUserId) {
         return "";
     return `from: ${origin}`;
 }
-export function extractTelegramReplyContextText(message) {
+function extractTelegramReplyContextText(message) {
     const quoted = (extractTelegramRichMessageText(message.reply_to_message?.rich_message) ||
         message.reply_to_message?.text ||
         message.reply_to_message?.caption ||
@@ -195,7 +195,7 @@ export function buildTelegramReplyContextBlock(message, replyFiles = [], replyOu
     }
     return "";
 }
-export function appendTelegramReplyContext(text, replyContext) {
+function appendTelegramReplyContext(text, replyContext) {
     if (!replyContext)
         return text;
     return text ? `${text}\n\n${replyContext}` : `_\n\n${replyContext}`;
@@ -216,7 +216,7 @@ export function extractTelegramMessagesPromptText(messages) {
 export function extractFirstTelegramMessageText(messages) {
     return messages.map(extractTelegramMessageText).find(Boolean) ?? "";
 }
-export function hasTelegramMessagePromptContent(message) {
+function hasTelegramMessagePromptContent(message) {
     return (!!extractTelegramMessageText(message) ||
         (Array.isArray(message.photo) && message.photo.length > 0) ||
         !!message.document ||
@@ -422,7 +422,7 @@ export async function downloadTelegramMessageFiles(messages, deps) {
     const downloaded = [];
     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,
@@ -463,6 +463,7 @@ function collectTelegramRichBlockFileInfos(blocks, messageId) {
                         files.push({
                             file_id: photo.file_id,
                             fileName: `photo-${messageId}-${mediaIndex}.jpg`,
+                            index: mediaIndex,
                             mimeType: "image/jpeg",
                             kind: "photo",
                             isImage: true,
@@ -489,6 +490,8 @@ function collectTelegramRichBlockFileInfos(blocks, messageId) {
                     const fallbackExtension = kind === "voice" ? ".ogg" : kind === "audio" ? ".mp3" : ".mp4";
                     files.push({
                         file_id: fileId,
+                        index: mediaIndex,
+                        ...(typeof fileName === "string" ? { userFileName: fileName } : {}),
                         fileName: typeof fileName === "string"
                             ? fileName
                             : `${kind}-${messageId}-${mediaIndex}${guessExtensionFromMime(typeof mimeType === "string" ? mimeType : undefined, fallbackExtension)}`,
@@ -512,6 +515,7 @@ function collectTelegramRichBlockFileInfos(blocks, messageId) {
 export function collectTelegramFileInfos(messages) {
     const files = [];
     for (const message of messages) {
+        const firstOfMessage = files.length;
         files.push(...collectTelegramRichBlockFileInfos(message.rich_message?.blocks, message.message_id));
         if (Array.isArray(message.photo) && message.photo.length > 0) {
             const photo = [...message.photo]
@@ -533,6 +537,7 @@ export function collectTelegramFileInfos(messages) {
             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),
@@ -544,6 +549,7 @@ export function collectTelegramFileInfos(messages) {
             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,
@@ -556,6 +562,7 @@ export function collectTelegramFileInfos(messages) {
             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,
@@ -577,20 +584,31 @@ export function collectTelegramFileInfos(messages) {
             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();
     return files.filter((file) => {

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

@@ -177,7 +177,6 @@ export interface TelegramModelMenuRuntime<TModel extends MenuModel = MenuModel>
 export declare const TELEGRAM_MODEL_PAGE_SIZE = 6;
 export declare const MODEL_MENU_TITLE = "<b>\uD83E\uDD16 Choose a model:</b>";
 export declare const MODEL_PAGE_MENU_TITLE = "<b>Choose a page:</b>";
-export declare const MODEL_DETAIL_MENU_TITLE = "<b>\uD83E\uDD16 Model:</b>";
 export declare function formatScopedModelButtonText<TModel extends MenuModel = MenuModel>(entry: ScopedTelegramModel<TModel>, currentModel: TModel | undefined): string;
 export declare function formatStatusButtonLabel(label: string, value: string): string;
 export declare function getModelMenuItems<TModel extends MenuModel = MenuModel>(state: TelegramModelMenuState<TModel>): ScopedTelegramModel<TModel>[];
@@ -195,21 +194,11 @@ export declare function buildTelegramModelMenuStateRuntime<TContext extends Tele
 export declare function applyTelegramModelScopeSelection(state: TelegramModelMenuState, value: string | undefined): TelegramMenuMutationResult;
 export declare function applyTelegramModelPageSelection(state: TelegramModelMenuState, value: string | undefined): TelegramMenuMutationResult;
 export declare function getTelegramModelSelection<TModel extends MenuModel = MenuModel>(state: TelegramModelMenuState<TModel>, value: string | undefined): TelegramMenuSelectionResult<TModel>;
-export declare function applyTelegramModelDetailSelection(state: TelegramModelMenuState, value: string | undefined): TelegramMenuMutationResult;
-export declare function getTelegramSelectedDetailModel<TModel extends MenuModel = MenuModel>(state: TelegramModelMenuState<TModel>): TelegramMenuSelectionResult<TModel>;
-export declare function isTelegramModelScoped(state: TelegramModelMenuState, model: MenuModel): boolean;
-export declare function focusTelegramModelListPage(state: TelegramModelMenuState, model: MenuModel, pageSize?: number): void;
-export declare function setTelegramModelScope(state: TelegramModelMenuState, model: MenuModel, enabled: boolean): {
-    patterns: string[];
-    enabled: boolean;
-};
 export declare function buildTelegramModelCallbackPlan<TModel extends MenuModel = MenuModel>(params: BuildTelegramModelCallbackPlanParams<TModel>): TelegramModelCallbackPlan<TModel>;
 export declare function openTelegramModelMenu<TModel extends MenuModel = MenuModel>(deps: TelegramModelMenuOpenDeps<TModel>): Promise<void>;
 export declare function handleTelegramModelMenuCallbackAction<TModel extends MenuModel = MenuModel>(callbackQueryId: string, params: BuildTelegramModelCallbackPlanParams<TModel>, deps: TelegramModelMenuCallbackDeps<TModel>): Promise<boolean>;
 export declare function getTelegramModelMenuPage(state: TelegramModelMenuState, pageSize: number): TelegramModelMenuPage;
 export declare function buildModelMenuReplyMarkup(state: TelegramModelMenuState, currentModel: MenuModel | undefined, pageSize: number): TelegramReplyMarkup;
-export declare function buildModelDetailMenuReplyMarkup(state: TelegramModelMenuState, currentModel: MenuModel | undefined): TelegramReplyMarkup;
-export declare function buildModelDetailMenuText(state: TelegramModelMenuState): string;
 export declare function buildModelPageMenuReplyMarkup(state: TelegramModelMenuState, pageSize: number): TelegramReplyMarkup;
 export declare function buildTelegramModelPageMenuRenderPayload(state: TelegramModelMenuState): TelegramMenuRenderPayload;
 export declare function buildTelegramModelMenuRenderPayload(state: TelegramModelMenuState, activeModel: MenuModel | undefined): TelegramMenuRenderPayload;

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

@@ -11,7 +11,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, maxLength = 56) {
     return label.length <= maxLength
         ? label
@@ -249,7 +249,7 @@ export function getTelegramModelSelection(state, value) {
         return { kind: "missing" };
     return { kind: "selected", selection };
 }
-export function applyTelegramModelDetailSelection(state, value) {
+function applyTelegramModelDetailSelection(state, value) {
     const index = Number(value);
     if (!Number.isFinite(index))
         return "invalid";
@@ -261,7 +261,7 @@ export function applyTelegramModelDetailSelection(state, value) {
     state.mode = "model-detail";
     return "changed";
 }
-export function getTelegramSelectedDetailModel(state) {
+function getTelegramSelectedDetailModel(state) {
     const indexedSelection = getTelegramModelSelection(state, state.selectedModelIndex?.toString());
     if (indexedSelection.kind === "selected") {
         if (!state.selectedModelKey)
@@ -279,11 +279,11 @@ export function getTelegramSelectedDetailModel(state) {
     }
     return indexedSelection;
 }
-export function isTelegramModelScoped(state, model) {
+function isTelegramModelScoped(state, model) {
     const key = getCanonicalModelId(model);
     return state.scopedModels.some((entry) => getCanonicalModelId(entry.model) === key);
 }
-export function focusTelegramModelListPage(state, model, pageSize = TELEGRAM_MODEL_PAGE_SIZE) {
+function focusTelegramModelListPage(state, model, pageSize = TELEGRAM_MODEL_PAGE_SIZE) {
     const key = getCanonicalModelId(model).toLowerCase();
     const index = getModelMenuItems(state).findIndex((entry) => getCanonicalModelId(entry.model).toLowerCase() === key);
     state.page = index < 0 ? 0 : Math.floor(index / pageSize);
@@ -293,7 +293,7 @@ function formatScopedModelPattern(entry) {
     const key = getCanonicalModelId(entry.model);
     return entry.thinkingLevel ? `${key}:${entry.thinkingLevel}` : key;
 }
-export function setTelegramModelScope(state, model, enabled) {
+function setTelegramModelScope(state, model, enabled) {
     const key = getCanonicalModelId(model);
     const lowerKey = key.toLowerCase();
     const scopedModelPatterns = state.scopedModelPatterns ?? [];
@@ -583,7 +583,7 @@ export function buildModelMenuReplyMarkup(state, currentModel, pageSize) {
     ]));
     return { inline_keyboard: rows };
 }
-export function buildModelDetailMenuReplyMarkup(state, currentModel) {
+function buildModelDetailMenuReplyMarkup(state, currentModel) {
     const selection = getTelegramSelectedDetailModel(state);
     if (selection.kind !== "selected") {
         return {
@@ -617,7 +617,7 @@ export function buildModelDetailMenuReplyMarkup(state, currentModel) {
         ],
     };
 }
-export function buildModelDetailMenuText(state) {
+function buildModelDetailMenuText(state) {
     const selection = getTelegramSelectedDetailModel(state);
     if (selection.kind !== "selected")
         return MODEL_DETAIL_MENU_TITLE;