@llblab/pi-kit 0.29.2 → 0.30.0

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

@@ -1,87 +1,8 @@
 /**
- * Telegram disposable runtime recovery classification
+ * Telegram runtime storage housekeeping
  * Zones: filesystem diagnostics, unclean-shutdown recovery
- * Owns fail-safe classification of temporary ownership and routing artifacts
+ * Owns best-effort removal of obsolete recovery folders and orphaned session journal families
  */
-import { type TelegramFileTransactionOptions } from "./locks.ts";
-export type TelegramRuntimeArtifactKind = "owners" | "state" | "transaction";
-export interface TelegramRuntimeCorruptArtifact {
-    kind: TelegramRuntimeArtifactKind;
-    path: string;
-    reason: string;
-}
-export type TelegramRuntimeRecoveryClassification = {
-    kind: "clean";
-} | {
-    kind: "recoverable-corruption";
-    artifacts: TelegramRuntimeCorruptArtifact[];
-} | {
-    kind: "blocked-live-owner";
-    artifacts: TelegramRuntimeCorruptArtifact[];
-    livePids: number[];
-};
-export interface TelegramRuntimeRecoveryClassificationOptions {
-    ownersPath: string;
-    statePaths?: readonly string[];
-    transactionPath?: string;
-    isProcessAlive?: (pid: number) => boolean;
-    nowMs?: number;
-    staleHeartbeatMs?: number;
-    ignoredTransactionPids?: readonly number[];
-}
-export type TelegramRuntimeRecoveryResult = {
-    kind: "not-needed";
-} | {
-    kind: "blocked-live-owner";
-    livePids: number[];
-    deletedPaths?: string[];
-} | {
-    kind: "recovered";
-    artifacts: TelegramRuntimeCorruptArtifact[];
-    /** Damaged disposable artifacts deleted per the approved corruption policy; nothing is quarantined. */
-    deletedPaths: string[];
-};
-export interface TelegramRuntimeRecoveryOptions extends TelegramRuntimeRecoveryClassificationOptions {
-    recoveryTransactionPath?: string;
-    pid?: number;
-    getNowMs?: () => number;
-    /** Fault-injection seam; production uses bounded-retry recursive removal. */
-    removePath?: (path: string) => void;
-    transactionOptions?: TelegramFileTransactionOptions;
-}
-export type TelegramPollingStartRecoveryDecision = {
-    kind: "unhandled";
-} | {
-    kind: "retry";
-    message: string;
-} | {
-    kind: "blocked";
-    message: string;
-};
-export interface TelegramPollingStartRecoveryHandlerDeps {
-    getOwnersPath: () => string;
-    getStatePaths: () => readonly string[];
-    suspendPolling: () => Promise<unknown>;
-    releaseOwnership?: () => unknown | Promise<unknown>;
-    recordRuntimeEvent?: (category: string, error: unknown, details?: Record<string, unknown>) => void;
-}
-/**
- * Classify disposable runtime corruption without mutating any artifact.
- *
- * Corruption remains recoverable only when neither owners.json nor a
- * verifiable transaction marker identifies a process that is still alive.
- */
-export declare function classifyTelegramRuntimeRecovery(options: TelegramRuntimeRecoveryClassificationOptions): TelegramRuntimeRecoveryClassification;
-/**
- * Delete classifier-approved disposable corruption under two guards.
- *
- * A dedicated recovery transaction serializes recoverers. The ownership
- * transaction then prevents a new Telegram owner from appearing between the
- * final classification and mutation. Damaged ownership debris and canonical
- * state are deleted (operator policy: unfinished Restores in unreadable state
- * are acceptable loss). Durable config and diagnostics never enter the set.
- */
-export declare function recoverTelegramRuntimeState(options: TelegramRuntimeRecoveryOptions): TelegramRuntimeRecoveryResult;
 /**
  * Remove recovery folders written by earlier releases (runtime root and session folders).
  * Current releases delete damaged files instead of quarantining them; nothing reads these copies.
@@ -102,5 +23,3 @@ export interface TelegramSessionFolderSweeperDeps {
 export declare function createTelegramSessionFolderSweeper(deps: TelegramSessionFolderSweeperDeps): {
     sweep: () => string[];
 };
-/** Build the `/telegram-connect` recovery boundary around runtime artifacts. */
-export declare function createTelegramPollingStartRecoveryHandler(deps: TelegramPollingStartRecoveryHandlerDeps): () => Promise<TelegramPollingStartRecoveryDecision>;

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

@@ -1,216 +1,11 @@
 /**
- * Telegram disposable runtime recovery classification
+ * Telegram runtime storage housekeeping
  * Zones: filesystem diagnostics, unclean-shutdown recovery
- * Owns fail-safe classification of temporary ownership and routing artifacts
+ * Owns best-effort removal of obsolete recovery folders and orphaned session journal families
  */
-import { existsSync, lstatSync, readFileSync, readdirSync, rmdirSync, rmSync, } from "node:fs";
-import { basename, dirname, join } from "node:path";
-import { decodeTelegramSessionDirectoryName, getTelegramProfilePathSuffix } from "./paths.js";
-import { isProcessAlive as defaultIsProcessAlive, parseTelegramLockEntry, TELEGRAM_BUS_LEADER_STALE_HEARTBEAT_MS, withTelegramFileTransaction, } from "./locks.js";
-const OWNER_FILE_PATTERN = /^owner\.([A-Za-z0-9-]+)\.json$/u;
-const RECLAIM_FILE_PATTERN = /^owner\.reclaim\.(\d+)\.([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.json$/u;
-function corruption(kind, path, reason) {
-    return { source: kind, corrupt: { kind, path, reason }, ownerPids: [] };
-}
-function inspectOwners(path, nowMs, staleHeartbeatMs) {
-    if (!existsSync(path))
-        return { source: "owners", ownerPids: [] };
-    let value;
-    try {
-        value = JSON.parse(readFileSync(path, "utf8"));
-    }
-    catch {
-        return corruption("owners", path, "owners.json is not valid JSON");
-    }
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        return corruption("owners", path, "owners.json is not an object");
-    }
-    const ownerPids = Object.values(value).flatMap((candidate) => {
-        const entry = parseTelegramLockEntry(candidate);
-        if (!entry ||
-            (typeof entry.heartbeatMs === "number" &&
-                nowMs - entry.heartbeatMs > staleHeartbeatMs)) {
-            return [];
-        }
-        return [entry.pid];
-    });
-    return { source: "owners", ownerPids };
-}
-function inspectState(path) {
-    if (!existsSync(path))
-        return { source: "state", ownerPids: [] };
-    try {
-        const stat = lstatSync(path);
-        if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1 || stat.size > 8 * 1024 * 1024)
-            return corruption("state", path, `${basename(path)} cannot be safely inspected`);
-        JSON.parse(readFileSync(path, "utf8"));
-        return { source: "state", ownerPids: [] };
-    }
-    catch {
-        return corruption("state", path, `${basename(path)} is not valid JSON`);
-    }
-}
-function parseTransactionOwner(path) {
-    const value = JSON.parse(readFileSync(path, "utf8"));
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        return undefined;
-    }
-    const pid = value.pid;
-    const acquiredAtMs = value.acquiredAtMs;
-    const generation = value.generation;
-    return typeof pid === "number" &&
-        typeof acquiredAtMs === "number" &&
-        typeof generation === "string"
-        ? pid
-        : undefined;
-}
-function inspectTransaction(path) {
-    if (!existsSync(path))
-        return { source: "transaction", ownerPids: [] };
-    try {
-        const stat = lstatSync(path);
-        let ownerPath;
-        let expectedOwnerPid;
-        if (stat.isDirectory()) {
-            const entries = readdirSync(path);
-            if (entries.length !== 1) {
-                return corruption("transaction", path, "transaction guard has an unverifiable directory shape");
-            }
-            const entry = entries[0];
-            const ownerMatch = OWNER_FILE_PATTERN.exec(entry);
-            const reclaimMatch = RECLAIM_FILE_PATTERN.exec(entry);
-            if (!ownerMatch && !reclaimMatch) {
-                return corruption("transaction", path, "transaction guard has an unrecognized owner marker");
-            }
-            ownerPath = join(path, entry);
-            expectedOwnerPid = reclaimMatch ? Number(reclaimMatch[1]) : undefined;
-            const ownerPid = parseTransactionOwner(ownerPath);
-            if (ownerPid === undefined) {
-                return corruption("transaction", path, "transaction guard owner metadata is invalid");
-            }
-            if (ownerMatch) {
-                const value = JSON.parse(readFileSync(ownerPath, "utf8"));
-                if (value.generation !== ownerMatch[1]) {
-                    return corruption("transaction", path, "transaction guard generation does not match its owner marker");
-                }
-            }
-            return {
-                source: "transaction",
-                ownerPids: [expectedOwnerPid ?? ownerPid],
-            };
-        }
-        if (!stat.isFile()) {
-            return corruption("transaction", path, "transaction guard has an unsupported filesystem type");
-        }
-        ownerPath = path;
-        const ownerPid = parseTransactionOwner(ownerPath);
-        return ownerPid === undefined
-            ? corruption("transaction", path, "legacy transaction guard owner metadata is invalid")
-            : { source: "transaction", ownerPids: [ownerPid] };
-    }
-    catch {
-        return corruption("transaction", path, "transaction guard cannot be inspected");
-    }
-}
-/**
- * Classify disposable runtime corruption without mutating any artifact.
- *
- * Corruption remains recoverable only when neither owners.json nor a
- * verifiable transaction marker identifies a process that is still alive.
- */
-export function classifyTelegramRuntimeRecovery(options) {
-    const transactionPath = options.transactionPath ?? `${options.ownersPath}.transaction`;
-    const inspections = [
-        inspectOwners(options.ownersPath, options.nowMs ?? Date.now(), options.staleHeartbeatMs ?? TELEGRAM_BUS_LEADER_STALE_HEARTBEAT_MS),
-        ...(options.statePaths ?? []).map(inspectState),
-        inspectTransaction(transactionPath),
-    ];
-    const artifacts = inspections.flatMap((inspection) => inspection.corrupt ? [inspection.corrupt] : []);
-    if (artifacts.length === 0)
-        return { kind: "clean" };
-    const processAlive = options.isProcessAlive ?? defaultIsProcessAlive;
-    const ignoredTransactionPids = new Set(options.ignoredTransactionPids ?? []);
-    const livePids = [
-        ...new Set(inspections.flatMap((inspection) => inspection.ownerPids.filter((pid) => !(inspection.source === "transaction" &&
-            ignoredTransactionPids.has(pid)) && processAlive(pid)))),
-    ].sort((left, right) => left - right);
-    return livePids.length > 0
-        ? { kind: "blocked-live-owner", artifacts, livePids }
-        : { kind: "recoverable-corruption", artifacts };
-}
-/**
- * Delete classifier-approved disposable corruption under two guards.
- *
- * A dedicated recovery transaction serializes recoverers. The ownership
- * transaction then prevents a new Telegram owner from appearing between the
- * final classification and mutation. Damaged ownership debris and canonical
- * state are deleted (operator policy: unfinished Restores in unreadable state
- * are acceptable loss). Durable config and diagnostics never enter the set.
- */
-export function recoverTelegramRuntimeState(options) {
-    const transactionPath = options.transactionPath ?? `${options.ownersPath}.transaction`;
-    const recoveryTransactionPath = options.recoveryTransactionPath ??
-        join(dirname(options.ownersPath), "runtime-recovery.transaction");
-    const removePath = options.removePath ?? ((path) => rmSync(path, { recursive: true, force: true, maxRetries: 3, retryDelay: 50 }));
-    const classificationOptions = {
-        ownersPath: options.ownersPath,
-        statePaths: options.statePaths,
-        transactionPath,
-        isProcessAlive: options.isProcessAlive,
-        nowMs: options.nowMs ?? options.getNowMs?.(),
-        staleHeartbeatMs: options.staleHeartbeatMs,
-    };
-    return withTelegramFileTransaction(recoveryTransactionPath, () => {
-        const initial = classifyTelegramRuntimeRecovery(classificationOptions);
-        if (initial.kind === "clean")
-            return { kind: "not-needed" };
-        if (initial.kind === "blocked-live-owner") {
-            return {
-                kind: "blocked-live-owner",
-                livePids: initial.livePids,
-            };
-        }
-        const deletedPaths = [];
-        const recoveredArtifacts = [];
-        const deleteArtifact = (artifact) => {
-            if (!existsSync(artifact.path))
-                return;
-            removePath(artifact.path);
-            deletedPaths.push(artifact.path);
-            recoveredArtifacts.push(artifact);
-        };
-        for (const artifact of initial.artifacts) {
-            if (artifact.kind === "transaction")
-                deleteArtifact(artifact);
-        }
-        return withTelegramFileTransaction(transactionPath, () => {
-            const current = classifyTelegramRuntimeRecovery({
-                ...classificationOptions,
-                ignoredTransactionPids: [process.pid],
-            });
-            if (current.kind === "blocked-live-owner") {
-                return {
-                    kind: "blocked-live-owner",
-                    livePids: current.livePids,
-                    ...(deletedPaths.length > 0 ? { deletedPaths } : {}),
-                };
-            }
-            if (current.kind === "recoverable-corruption") {
-                for (const artifact of current.artifacts) {
-                    if (artifact.kind !== "transaction")
-                        deleteArtifact(artifact);
-                }
-            }
-            return recoveredArtifacts.length > 0
-                ? {
-                    kind: "recovered",
-                    artifacts: recoveredArtifacts,
-                    deletedPaths,
-                }
-                : { kind: "not-needed" };
-        }, options.transactionOptions);
-    }, options.transactionOptions);
-}
+import { lstatSync, readdirSync, rmdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { decodeTelegramSessionDirectoryName, getTelegramProfilePathSuffix, } from "./paths.js";
 /**
  * Remove recovery folders written by earlier releases (runtime root and session folders).
  * Current releases delete damaged files instead of quarantining them; nothing reads these copies.
@@ -221,7 +16,12 @@ export function removeTelegramLegacyRecoveryStorage(runtimeDir) {
         try {
             if (!lstatSync(path).isDirectory())
                 return;
-            rmSync(path, { recursive: true, force: true, maxRetries: 3, retryDelay: 50 });
+            rmSync(path, {
+                recursive: true,
+                force: true,
+                maxRetries: 3,
+                retryDelay: 50,
+            });
             removed.push(path);
         }
         catch {
@@ -233,7 +33,9 @@ export function removeTelegramLegacyRecoveryStorage(runtimeDir) {
     try {
         sessions = readdirSync(join(runtimeDir, "sessions"));
     }
-    catch { /* no sessions yet */ }
+    catch {
+        /* no sessions yet */
+    }
     for (const session of sessions)
         remove(join(runtimeDir, "sessions", session, "recovery"));
     return removed;
@@ -277,7 +79,12 @@ export function createTelegramSessionFolderSweeper(deps) {
                         if (!family.test(entry))
                             continue;
                         const path = join(folder, entry);
-                        rmSync(path, { recursive: true, force: true, maxRetries: 3, retryDelay: 50 });
+                        rmSync(path, {
+                            recursive: true,
+                            force: true,
+                            maxRetries: 3,
+                            retryDelay: 50,
+                        });
                         removed.push(path);
                     }
                     if (readdirSync(folder).length === 0) {
@@ -293,64 +100,3 @@ export function createTelegramSessionFolderSweeper(deps) {
         },
     };
 }
-/** Build the `/telegram-connect` recovery boundary around runtime artifacts. */
-export function createTelegramPollingStartRecoveryHandler(deps) {
-    return async () => {
-        const ownersPath = deps.getOwnersPath();
-        const statePaths = deps.getStatePaths();
-        const classification = classifyTelegramRuntimeRecovery({
-            ownersPath,
-            statePaths,
-        });
-        if (classification.kind === "clean")
-            return { kind: "unhandled" };
-        if (classification.kind === "blocked-live-owner") {
-            return {
-                kind: "blocked",
-                message: `Telegram temporary state is damaged, but owner process ${classification.livePids.join(", ")} is still live. Restart that Pi instance, then run /telegram-connect again.`,
-            };
-        }
-        try {
-            await deps.suspendPolling();
-        }
-        catch (error) {
-            deps.recordRuntimeEvent?.("recovery", error, {
-                phase: "suspend-before-reset",
-            });
-            return {
-                kind: "blocked",
-                message: "Telegram polling could not stop safely, so temporary state was not reset. Restart this Pi instance and run /telegram-connect again.",
-            };
-        }
-        try {
-            await deps.releaseOwnership?.();
-        }
-        catch (error) {
-            deps.recordRuntimeEvent?.("recovery", error, {
-                phase: "release-before-reset",
-            });
-        }
-        try {
-            const recovery = recoverTelegramRuntimeState({ ownersPath, statePaths });
-            if (recovery.kind === "blocked-live-owner") {
-                return {
-                    kind: "blocked",
-                    message: `Telegram temporary state changed during recovery and is now protected by owner process ${recovery.livePids.join(", ")}. Restart that Pi instance, then run /telegram-connect again.`,
-                };
-            }
-            return {
-                kind: "retry",
-                message: recovery.kind === "recovered"
-                    ? "Telegram temporary state was damaged after an unclean shutdown and has been reset."
-                    : "Telegram temporary state was recovered by another Pi instance.",
-            };
-        }
-        catch (error) {
-            deps.recordRuntimeEvent?.("recovery", error, { phase: "runtime-reset" });
-            return {
-                kind: "blocked",
-                message: "Telegram temporary-state recovery failed. Restart this Pi instance and run /telegram-connect again.",
-            };
-        }
-    };
-}

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

@@ -3,25 +3,13 @@
  * Zones: telegram outbound, native rich markdown, UI/compat rendering transport
  * Owns native assistant replies, rendered UI delivery, guest placeholder rotation, reply transport wiring, and plain text replies
  */
-import { type TelegramTarget } from "./target.ts";
-import type { TelegramInputRichMessage, TelegramReplyParameters, TelegramSendRichMessageBody, TelegramSentMessage } from "./telegram-api.ts";
 import { renderTelegramMessage, type TelegramRenderedChunk, type TelegramRenderMode } from "./rendering.ts";
+import { type TelegramTarget } from "./target.ts";
+import type { TelegramApiCallOptions, TelegramInputRichMessage, TelegramReplyParameters, TelegramSendRichMessageBody, TelegramSentMessage } from "./telegram-api.ts";
 export { renderTelegramMessage, type TelegramRenderedChunk, type TelegramRenderMode, };
 export declare function renderTelegramMarkdownToHtmlDraft(markdown: string): string;
 export declare const TELEGRAM_RICH_MESSAGE_MAX_CHARS = 32768;
 export declare const TELEGRAM_RICH_MESSAGE_MAX_BLOCKS = 500;
-/** Non-persistent reply deduplication for a single agent turn.
- *  First reply to a prompt gets `reply_parameters.message_id`;
- *  subsequent replies in the same turn skip it to avoid stacking
- *  duplicate reply headers in the chat viewport. */
-export interface ReplyDedupRuntime {
-    /** Returns true if this is the first reply for the given prompt
-     *  message id in the current turn. Side-effect: marks it replied. */
-    shouldReply(promptMessageId: number): boolean;
-    /** Reset the tracker when a new prompt enters the queue. */
-    reset(): void;
-}
-export declare function createReplyDedupRuntime(): ReplyDedupRuntime;
 export declare function resetTransportReplyDedup(): void;
 /** Keeps a successfully published transition notice as the first reply of the
  * next agent turn. The following agent-start reset consumes this one-shot
@@ -67,7 +55,7 @@ export interface TelegramReplyDeliveryDeps<TReplyMarkup> {
         reply_parameters?: TelegramReplyParameters;
         reply_to_message_id?: number;
         message_thread_id?: number;
-    }) => Promise<TelegramSentMessage>;
+    }, options?: Pick<TelegramApiCallOptions, "assertAuthority">) => Promise<TelegramSentMessage>;
     editMessage: (body: {
         chat_id: number;
         message_id: number;
@@ -76,9 +64,9 @@ export interface TelegramReplyDeliveryDeps<TReplyMarkup> {
         parse_mode?: "HTML";
         reply_markup?: TReplyMarkup;
         message_thread_id?: number;
-    }) => Promise<unknown>;
+    }, options?: Pick<TelegramApiCallOptions, "assertAuthority">) => Promise<unknown>;
 }
-export interface TelegramReplyTargetOptions {
+export interface TelegramReplyTargetOptions extends Pick<TelegramApiCallOptions, "assertAuthority"> {
     target?: TelegramTarget;
     replyToMessageId?: number;
 }
@@ -109,11 +97,18 @@ export interface TelegramReplyRuntimeDeps<TReplyMarkup = unknown> {
     } & TelegramReplyTargetOptions) => Promise<number | undefined>;
 }
 export declare function sendTelegramPlainReply(text: string, deps: TelegramReplyRuntimeDeps, options?: TelegramTextReplyOptions): Promise<number | undefined>;
+/** An open fenced code block: its marker character and the minimum closing run length. */
+export interface TelegramMarkdownFence {
+    marker: "`" | "~";
+    length: number;
+}
+export declare function parseTelegramMarkdownFenceOpening(line: string): TelegramMarkdownFence | undefined;
+export declare function isTelegramMarkdownFenceClosing(line: string, fence: TelegramMarkdownFence): boolean;
 export declare function normalizeTelegramNativeMarkdown(markdown: string): string;
 export declare function splitTelegramNativeMarkdown(markdown: string): string[];
 export declare function sendTelegramNativeMarkdownReply<TReplyMarkup = unknown>(chatId: number, replyToMessageId: number | undefined, markdown: string, deps: {
     recordOwnership?: TelegramReplyOwnershipRecorder["record"];
-    sendRichMessage: (body: TelegramSendRichMessageBody) => Promise<TelegramSentMessage>;
+    sendRichMessage: (body: TelegramSendRichMessageBody, options?: Pick<TelegramApiCallOptions, "assertAuthority">) => Promise<TelegramSentMessage>;
 }, options?: TelegramReplyTargetOptions & {
     replyMarkup?: TReplyMarkup;
 }): Promise<number | undefined>;
@@ -125,14 +120,14 @@ export interface TelegramRenderedMessageRuntimeDeps<TReplyMarkup> {
     replyTransport: TelegramReplyTransport<TReplyMarkup>;
     recordOwnership?: TelegramReplyOwnershipRecorder["record"];
     getAssistantRenderingMode?: () => TelegramAssistantRenderingMode;
-    sendRichMessage: (body: TelegramSendRichMessageBody) => Promise<TelegramSentMessage>;
+    sendRichMessage: (body: TelegramSendRichMessageBody, options?: Pick<TelegramApiCallOptions, "assertAuthority">) => Promise<TelegramSentMessage>;
 }
 export interface TelegramRenderedMessageRuntime<TReplyMarkup> {
     sendTextReply: (chatId: number, replyToMessageId: number | undefined, text: string, options?: TelegramTextReplyOptions) => Promise<number | undefined>;
     sendMarkdownReply: (chatId: number, replyToMessageId: number | undefined, markdown: string, options?: TelegramReplyTargetOptions & {
         replyMarkup?: TReplyMarkup;
     }) => Promise<number | undefined>;
-    editInteractiveMessage: (chatId: number, messageId: number, text: string, mode: TelegramRenderMode, replyMarkup: TReplyMarkup) => Promise<void>;
+    editInteractiveMessage: (chatId: number, messageId: number, text: string, mode: TelegramRenderMode, replyMarkup: TReplyMarkup, options?: TelegramReplyTargetOptions) => Promise<void>;
     sendInteractiveMessage: (chatId: number, text: string, mode: TelegramRenderMode, replyMarkup: TReplyMarkup, options?: TelegramReplyTargetOptions) => Promise<number | undefined>;
     sendSectionRichMessage: (chatId: number, message: TelegramInputRichMessage, options?: TelegramReplyTargetOptions) => Promise<number>;
 }
@@ -144,13 +139,10 @@ export interface TelegramRenderedMessageDeliveryRuntimeDeps<TReplyMarkup> extend
         mode?: TelegramRenderMode;
     }) => TelegramRenderedChunk[];
     getAssistantRenderingMode?: () => TelegramAssistantRenderingMode;
-    sendRichMessage: (body: TelegramSendRichMessageBody) => Promise<TelegramSentMessage>;
+    sendRichMessage: (body: TelegramSendRichMessageBody, options?: Pick<TelegramApiCallOptions, "assertAuthority">) => Promise<TelegramSentMessage>;
 }
 export declare function createTelegramRenderedMessageDeliveryRuntime<TReplyMarkup>(deps: TelegramRenderedMessageDeliveryRuntimeDeps<TReplyMarkup>): TelegramRenderedMessageDeliveryRuntime<TReplyMarkup>;
 export declare function createTelegramRenderedMessageRuntime<TReplyMarkup>(deps: TelegramRenderedMessageRuntimeDeps<TReplyMarkup>): TelegramRenderedMessageRuntime<TReplyMarkup>;
-/** Wrap a sendTextReply with reply dedup so only the first message
- *  in a turn carries reply metadata. */
-export declare function dedupSendTextReply(dedup: ReplyDedupRuntime, inner: (chatId: number, replyToMessageId: number | undefined, text: string, options?: TelegramTextReplyOptions) => Promise<number | undefined>): (chatId: number, replyToMessageId: number, text: string, options?: TelegramTextReplyOptions) => Promise<number | undefined>;
 /**
  * Guest reply sender: answers guest queries with native Rich Markdown content.
  * Guest queries use InlineQueryResult input_message_content rather than chat