@llblab/pi-telegram 0.6.2 → 0.7.0

package/lib/model.ts

@@ -1,5 +1,6 @@
 /**
  * Telegram model control domain helpers
+ * Zones: pi agent model control, telegram controls, queue continuation
  * Owns model identity, thinking levels, scoped resolution, current-model state, and in-flight model switching
  */
 

package/lib/outbound-handlers.ts

@@ -1,5 +1,6 @@
 /**
  * Telegram outbound handler helpers
+ * Zones: telegram outbound, assistant markup, command templates, callback routing
  * Owns assistant-authored outbound markup extraction, configured artifact generation, callback actions, and Telegram outbound delivery
  */
 
@@ -8,6 +9,7 @@ import { mkdir } from "node:fs/promises";
 import { homedir } from "node:os";
 import { basename, join, resolve } from "node:path";
 
+import type { TelegramInlineKeyboardMarkup } from "./keyboard.ts";
 import type { PendingTelegramTurn } from "./queue.ts";
 import { buildTelegramMultipartReplyParameters } from "./replies.ts";
 import { truncateTelegramQueueSummary } from "./turns.ts";
@@ -52,6 +54,7 @@ export interface TelegramVoiceExecOptions {
   timeout?: number;
   signal?: AbortSignal;
   stdin?: string;
+  retry?: number;
 }
 
 export interface TelegramVoiceExecResult {
@@ -106,6 +109,16 @@ interface TelegramTopLevelFenceState {
   length: number;
 }
 
+function isTelegramActionCommentContent(content: string): boolean {
+  const normalizedContent = content.replace(/^\s+/, "");
+  const [head = ""] = normalizedContent.split(/\r?\n/, 1);
+  return ["telegram_voice", "telegram_button"].some((command) => {
+    if (!head.startsWith(command)) return false;
+    const nextChar = head[command.length];
+    return nextChar === undefined || /\s|:/.test(nextChar);
+  });
+}
+
 function getMarkdownLineEnd(markdown: string, offset: number): number {
   const newlineIndex = markdown.indexOf("\n", offset);
   return newlineIndex === -1 ? markdown.length : newlineIndex + 1;
@@ -144,6 +157,28 @@ function isTopLevelClosingFence(
   );
 }
 
+function collectInlineClosedTelegramActionBody(
+  markdown: string,
+  bodyStart: number,
+  commentContent: string,
+): { content: string; end: number } | undefined {
+  const bodyLineEnd = getMarkdownLineEnd(markdown, bodyStart);
+  const bodyLine = getMarkdownLineText(markdown, bodyStart, bodyLineEnd);
+  const closeLineEnd = getMarkdownLineEnd(markdown, bodyLineEnd);
+  const closeLine = getMarkdownLineText(markdown, bodyLineEnd, closeLineEnd);
+  const hasRecoverableBody =
+    isTelegramActionCommentContent(commentContent) &&
+    bodyLine.trim() !== "" &&
+    !bodyLine.startsWith("<!--") &&
+    !bodyLine.startsWith("-->") &&
+    closeLine === "-->";
+  if (!hasRecoverableBody) return undefined;
+  return {
+    content: `${commentContent.trimEnd()}\n${bodyLine}`,
+    end: bodyLineEnd + 3,
+  };
+}
+
 function collectTopLevelHtmlComments(markdown: string): {
   comments: TelegramTopLevelHtmlComment[];
   openCommentStart?: number;
@@ -168,9 +203,23 @@ function collectTopLevelHtmlComments(markdown: string): {
     if (line.startsWith("<!--")) {
       const closeIndex = markdown.indexOf("-->", offset + 4);
       if (closeIndex === -1) return { comments, openCommentStart: offset };
-      const end = closeIndex + 3;
-      const raw = markdown.slice(offset, end);
-      comments.push({ raw, content: raw.slice(4, -3), start: offset, end });
+      let end = closeIndex + 3;
+      let raw = markdown.slice(offset, end);
+      let content = raw.slice(4, -3);
+      const closeColumn = closeIndex - offset;
+      const closesOnOpeningLine = closeIndex < lineEnd;
+      const hasOnlyWhitespaceAfterClose =
+        line.slice(closeColumn + 3).trim() === "";
+      const inlineBody =
+        closesOnOpeningLine && hasOnlyWhitespaceAfterClose
+          ? collectInlineClosedTelegramActionBody(markdown, lineEnd, content)
+          : undefined;
+      if (inlineBody) {
+        end = inlineBody.end;
+        raw = markdown.slice(offset, end);
+        content = inlineBody.content;
+      }
+      comments.push({ raw, content, start: offset, end });
       offset = getMarkdownLineEnd(markdown, end);
       continue;
     }
@@ -239,18 +288,29 @@ function parseTopLevelTelegramComment(
   };
 }
 
+function parseTelegramCommentAttributes(input: string): Record<string, string> {
+  const attributes: Record<string, string> = {};
+  for (const match of input.matchAll(
+    /([A-Za-z_][A-Za-z0-9_-]*)=(?:"([^"]*)"|'([^']*)'|(\S+))/g,
+  )) {
+    const key = match[1];
+    const value = (match[2] ?? match[3] ?? match[4] ?? "").trim();
+    if (value) attributes[key] = value;
+  }
+  return attributes;
+}
+
 function parseVoiceReplyAttributes(input: string): {
   lang?: string;
   rate?: string;
+  text?: string;
 } {
-  const attributes: { lang?: string; rate?: string } = {};
-  for (const token of input.trim().split(/\s+/).filter(Boolean)) {
-    const [rawKey, ...valueParts] = token.split("=");
-    const value = valueParts.join("=").trim();
-    if (rawKey === "lang" && value) attributes.lang = value;
-    if (rawKey === "rate" && value) attributes.rate = value;
-  }
-  return attributes;
+  const attributes = parseTelegramCommentAttributes(input);
+  return {
+    ...(attributes.lang ? { lang: attributes.lang } : {}),
+    ...(attributes.rate ? { rate: attributes.rate } : {}),
+    ...(attributes.text ? { text: attributes.text } : {}),
+  };
 }
 
 function parseVoiceCommentBody(
@@ -267,7 +327,8 @@ function parseVoiceCommentBody(
   if (trimmedHead.startsWith(":")) {
     return { attrs: "", text: trimmedHead.slice(1).trim() };
   }
-  return { attrs: trimmedHead, text: "" };
+  const attrs = parseVoiceReplyAttributes(trimmedHead);
+  return { attrs: trimmedHead, text: attrs.text ?? "" };
 }
 
 function normalizeMarkdownAfterVoiceExtraction(markdown: string): string {
@@ -415,6 +476,7 @@ async function runVoiceReplyCommand(
     {
       cwd: options.cwd,
       timeout: options.timeout,
+      ...(typeof config === "object" && config.retry !== undefined ? { retry: config.retry } : {}),
       ...(options.stdin !== undefined ? { stdin: options.stdin } : {}),
     },
   );
@@ -539,22 +601,27 @@ async function generateTelegramVoiceReplyFileWithHandler(
     const startedAt = Date.now();
     let stdout = "";
     for (const [index, step] of steps.entries()) {
-      const result = await runVoiceReplyCommand(
-        `Outbound voice template step ${index + 1}`,
-        step,
-        values,
-        {
-          cwd: options.cwd,
-          timeout: getVoiceReplyCompositionStepTimeout(
-            options.timeout,
-            step,
-            startedAt,
-          ),
-          execCommand: options.execCommand,
-          ...(index === 0 ? {} : { stdin: stdout }),
-        },
-      );
-      stdout = result.stdout;
+      try {
+        const result = await runVoiceReplyCommand(
+          `Outbound voice template step ${index + 1}`,
+          step,
+          values,
+          {
+            cwd: options.cwd,
+            timeout: getVoiceReplyCompositionStepTimeout(
+              options.timeout,
+              step,
+              startedAt,
+            ),
+            execCommand: options.execCommand,
+            ...(index === 0 ? {} : { stdin: stdout }),
+          },
+        );
+        stdout = result.stdout;
+      } catch (error) {
+        if (typeof step === "object" && step.critical) throw error;
+        stdout = "";
+      }
     }
     return getVoiceReplyOutputPath(options.handler, values, stdout);
   }
@@ -664,9 +731,7 @@ export interface TelegramOutboundButtonStoredAction extends TelegramOutboundButt
   createdAt: number;
 }
 
-export interface TelegramOutboundButtonMarkup {
-  inline_keyboard: Array<Array<{ text: string; callback_data: string }>>;
-}
+export type TelegramOutboundButtonMarkup = TelegramInlineKeyboardMarkup;
 
 export interface TelegramButtonReplyPlan {
   markdown: string;
@@ -712,26 +777,36 @@ function normalizeMarkdownAfterButtonExtraction(markdown: string): string {
   return markdown.replace(/\n{3,}/g, "\n\n").trim();
 }
 
-function parseButtonsCommentAttributes(input: string): { label?: string } {
-  const attributes: { label?: string } = {};
-  for (const match of input.matchAll(
-    /([A-Za-z_][A-Za-z0-9_-]*)=(?:"([^"]*)"|'([^']*)'|(\S+))/g,
-  )) {
-    const key = match[1];
-    const value = match[2] ?? match[3] ?? match[4] ?? "";
-    if (key === "label" && value.trim()) attributes.label = value.trim();
-  }
-  return attributes;
+function parseButtonsCommentAttributes(input: string): {
+  label?: string;
+  prompt?: string;
+} {
+  const attributes = parseTelegramCommentAttributes(input);
+  return {
+    ...(attributes.label ? { label: attributes.label } : {}),
+    ...(attributes.prompt ? { prompt: attributes.prompt } : {}),
+  };
 }
 
 function parseButtonsCommentRows(
   head: string,
   body: string | undefined,
 ): TelegramOutboundButtonAction[][] {
-  const attributes = parseButtonsCommentAttributes(head);
-  if (!attributes.label) return [];
-  const prompt = body?.trim() || attributes.label;
-  return [[{ text: attributes.label, prompt }]];
+  const trimmedHead = head.trim();
+  if (body === undefined) {
+    if (trimmedHead.startsWith(":")) {
+      const label = trimmedHead.slice(1).trim();
+      return label ? [[{ text: label, prompt: label }]] : [];
+    }
+    const attributes = parseButtonsCommentAttributes(head);
+    return attributes.label && attributes.prompt
+      ? [[{ text: attributes.label, prompt: attributes.prompt }]]
+      : [];
+  }
+  const label = parseButtonsCommentAttributes(head).label;
+  const prompt = body.trim();
+  if (!label || !prompt) return [];
+  return [[{ text: label, prompt }]];
 }
 
 export function createTelegramButtonActionStore(

package/lib/pi.ts

@@ -1,5 +1,6 @@
 /**
  * pi SDK adapter boundary
+ * Zones: pi agent sdk boundary, shared adapters
  * Owns direct pi SDK imports and exposes narrow bridge-facing helpers/types for the extension composition layer
  */
 
@@ -12,6 +13,7 @@ import {
   type ExtensionContext,
   type SessionShutdownEvent,
   type SessionStartEvent,
+  type SlashCommandInfo,
   SettingsManager,
 } from "@mariozechner/pi-coding-agent";
 
@@ -24,6 +26,7 @@ export type {
   ExtensionContext,
   SessionShutdownEvent,
   SessionStartEvent,
+  SlashCommandInfo,
 };
 
 export interface PiSettingsManager {
@@ -31,9 +34,12 @@ export interface PiSettingsManager {
   getEnabledModels: () => string[] | undefined;
 }
 
+export type PiSlashCommandInfo = SlashCommandInfo;
+
 export interface PiExtensionApiRuntimePorts {
   sendUserMessage: ExtensionAPI["sendUserMessage"];
   exec: ExtensionAPI["exec"];
+  getCommands: ExtensionAPI["getCommands"];
   getThinkingLevel: ExtensionAPI["getThinkingLevel"];
   setThinkingLevel: ExtensionAPI["setThinkingLevel"];
   setModel: ExtensionAPI["setModel"];
@@ -44,6 +50,7 @@ export function createExtensionApiRuntimePorts(
     ExtensionAPI,
     | "sendUserMessage"
     | "exec"
+    | "getCommands"
     | "getThinkingLevel"
     | "setThinkingLevel"
     | "setModel"
@@ -52,6 +59,7 @@ export function createExtensionApiRuntimePorts(
   return {
     sendUserMessage: (content) => api.sendUserMessage(content),
     exec: (command, args, options) => api.exec(command, args, options),
+    getCommands: () => api.getCommands(),
     getThinkingLevel: () => api.getThinkingLevel(),
     setThinkingLevel: (level) => api.setThinkingLevel(level),
     setModel: (model) => api.setModel(model),

package/lib/polling.ts

@@ -1,5 +1,6 @@
 /**
  * Telegram polling domain helpers
+ * Zones: telegram transport, polling runtime
  * Owns polling request builders, stop conditions, and the long-poll loop runtime for Telegram updates
  */
 

package/lib/preview.ts

@@ -1,5 +1,6 @@
 /**
  * Telegram preview streaming helpers
+ * Zones: telegram outbound, streaming preview, rendering
  * Owns preview transport selection, runtime updates, and preview finalization
  */
 
@@ -44,9 +45,11 @@ export interface TelegramPreviewRuntimeState extends TelegramPreviewState {
 }
 
 export type TelegramSentPreviewMessage = TelegramSentMessage;
-export type TelegramPreviewReplyMarkup = any;
+export type TelegramPreviewReplyMarkup = unknown;
 
-export interface TelegramPreviewRuntimeDeps {
+export interface TelegramPreviewRuntimeDeps<
+  TReplyMarkup = TelegramPreviewReplyMarkup,
+> {
   getState: () => TelegramPreviewRuntimeState | undefined;
   setState: (state: TelegramPreviewRuntimeState | undefined) => void;
   clearScheduledFlush: (state: TelegramPreviewRuntimeState) => void;
@@ -78,13 +81,13 @@ export interface TelegramPreviewRuntimeDeps {
   sendRenderedChunks: (
     chatId: number,
     chunks: TelegramRenderedChunk[],
-    options?: { replyMarkup?: TelegramPreviewReplyMarkup },
+    options?: { replyMarkup?: TReplyMarkup },
   ) => Promise<number | undefined>;
   editRenderedMessage: (
     chatId: number,
     messageId: number,
     chunks: TelegramRenderedChunk[],
-    options?: { replyMarkup?: TelegramPreviewReplyMarkup },
+    options?: { replyMarkup?: TReplyMarkup },
   ) => Promise<number | undefined>;
 }
 
@@ -92,7 +95,10 @@ export interface TelegramPreviewActiveTurn {
   chatId: number;
 }
 
-export interface TelegramAssistantMessagePreviewStartDeps<TMessage> {
+export interface TelegramAssistantMessagePreviewStartDeps<
+  TMessage,
+  TReplyMarkup = TelegramPreviewReplyMarkup,
+> {
   getActiveTurn: () => TelegramPreviewActiveTurn | undefined;
   isAssistantMessage: (message: TMessage) => boolean;
   getState: () => TelegramPreviewRuntimeState | undefined;
@@ -102,6 +108,8 @@ export interface TelegramAssistantMessagePreviewStartDeps<TMessage> {
   finalizeMarkdownPreview: (
     chatId: number,
     markdown: string,
+    replyToMessageId?: number,
+    options?: { replyMarkup?: TReplyMarkup },
   ) => Promise<boolean>;
 }
 
@@ -115,9 +123,11 @@ export interface TelegramAssistantMessagePreviewUpdateDeps<TMessage> {
   schedulePreviewFlush: (chatId: number) => void;
 }
 
-export type TelegramAssistantMessagePreviewHookDeps<TMessage> =
-  TelegramAssistantMessagePreviewStartDeps<TMessage> &
-    TelegramAssistantMessagePreviewUpdateDeps<TMessage>;
+export type TelegramAssistantMessagePreviewHookDeps<
+  TMessage,
+  TReplyMarkup = TelegramPreviewReplyMarkup,
+> = TelegramAssistantMessagePreviewStartDeps<TMessage, TReplyMarkup> &
+  TelegramAssistantMessagePreviewUpdateDeps<TMessage>;
 
 export interface TelegramAssistantMessagePreviewHookEvent<TMessage> {
   message: TMessage;
@@ -132,7 +142,9 @@ export interface TelegramAssistantMessagePreviewHooks<TMessage> {
   ) => Promise<void>;
 }
 
-export interface TelegramPreviewControllerDeps {
+export interface TelegramPreviewControllerDeps<
+  TReplyMarkup = TelegramPreviewReplyMarkup,
+> {
   getDefaultReplyToMessageId?: () => number | undefined;
   maxMessageLength?: number;
   renderPreviewText?: (markdown: string) => string;
@@ -162,13 +174,13 @@ export interface TelegramPreviewControllerDeps {
     chatId: number,
     chunks: TelegramRenderedChunk[],
     replyToMessageId: number | undefined,
-    options?: { replyMarkup?: TelegramPreviewReplyMarkup },
+    options?: { replyMarkup?: TReplyMarkup },
   ) => Promise<number | undefined>;
   editRenderedMessage: (
     chatId: number,
     messageId: number,
     chunks: TelegramRenderedChunk[],
-    options?: { replyMarkup?: TelegramPreviewReplyMarkup },
+    options?: { replyMarkup?: TReplyMarkup },
   ) => Promise<number | undefined>;
   throttleMs?: number;
   maxDraftId?: number;
@@ -179,7 +191,9 @@ export interface TelegramPreviewControllerDeps {
   clearTimer?: (timer: ReturnType<typeof setTimeout>) => void;
 }
 
-export interface TelegramPreviewController {
+export interface TelegramPreviewController<
+  TReplyMarkup = TelegramPreviewReplyMarkup,
+> {
   getState: () => TelegramPreviewRuntimeState | undefined;
   setState: (state: TelegramPreviewRuntimeState | undefined) => void;
   setPendingText: (text: string) => void;
@@ -193,7 +207,7 @@ export interface TelegramPreviewController {
     chatId: number,
     markdown: string,
     replyToMessageId?: number,
-    options?: { replyMarkup?: TelegramPreviewReplyMarkup },
+    options?: { replyMarkup?: TReplyMarkup },
   ) => Promise<boolean>;
 }
 
@@ -230,27 +244,31 @@ export function createTelegramPreviewMessageTransport(
   };
 }
 
-export interface TelegramPreviewRenderedChunkTransportDeps {
+export interface TelegramPreviewRenderedChunkTransportDeps<
+  TReplyMarkup = TelegramPreviewReplyMarkup,
+> {
   sendRenderedChunks: (
     chatId: number,
     chunks: TelegramRenderedChunk[],
     options?: {
       replyToMessageId?: number;
-      replyMarkup?: TelegramPreviewReplyMarkup;
+      replyMarkup?: TReplyMarkup;
     },
   ) => Promise<number | undefined>;
   editRenderedMessage: (
     chatId: number,
     messageId: number,
     chunks: TelegramRenderedChunk[],
-    options?: { replyMarkup?: TelegramPreviewReplyMarkup },
+    options?: { replyMarkup?: TReplyMarkup },
   ) => Promise<number | undefined>;
 }
 
-export function createTelegramPreviewRenderedChunkTransport(
-  deps: TelegramPreviewRenderedChunkTransportDeps,
+export function createTelegramPreviewRenderedChunkTransport<
+  TReplyMarkup = TelegramPreviewReplyMarkup,
+>(
+  deps: TelegramPreviewRenderedChunkTransportDeps<TReplyMarkup>,
 ): Pick<
-  TelegramPreviewControllerDeps,
+  TelegramPreviewControllerDeps<TReplyMarkup>,
   "sendRenderedChunks" | "editRenderedMessage"
 > {
   return {
@@ -264,19 +282,23 @@ export function createTelegramPreviewRenderedChunkTransport(
   };
 }
 
-export type TelegramPreviewControllerRuntimeDeps = Omit<
-  TelegramPreviewControllerDeps,
+export type TelegramPreviewControllerRuntimeDeps<
+  TReplyMarkup = TelegramPreviewReplyMarkup,
+> = Omit<
+  TelegramPreviewControllerDeps<TReplyMarkup>,
   | "sendMessage"
   | "editMessageText"
   | "sendRenderedChunks"
   | "editRenderedMessage"
 > &
   TelegramPreviewMessageTransportDeps &
-  TelegramPreviewRenderedChunkTransportDeps;
+  TelegramPreviewRenderedChunkTransportDeps<TReplyMarkup>;
 
-export function createTelegramPreviewControllerRuntime(
-  deps: TelegramPreviewControllerRuntimeDeps,
-): TelegramPreviewController {
+export function createTelegramPreviewControllerRuntime<
+  TReplyMarkup = TelegramPreviewReplyMarkup,
+>(
+  deps: TelegramPreviewControllerRuntimeDeps<TReplyMarkup>,
+): TelegramPreviewController<TReplyMarkup> {
   return createTelegramPreviewController({
     getDefaultReplyToMessageId: deps.getDefaultReplyToMessageId,
     maxMessageLength: deps.maxMessageLength,
@@ -302,18 +324,25 @@ export function createTelegramPreviewControllerRuntime(
 
 export interface TelegramAssistantPreviewRuntimeDeps<
   TMessage,
-> extends TelegramPreviewControllerRuntimeDeps {
+  TReplyMarkup = TelegramPreviewReplyMarkup,
+> extends TelegramPreviewControllerRuntimeDeps<TReplyMarkup> {
   getActiveTurn: () => TelegramPreviewActiveTurn | undefined;
   isAssistantMessage: (message: TMessage) => boolean;
   getMessageText: (message: TMessage) => string;
 }
 
-export type TelegramAssistantPreviewRuntime<TMessage> =
-  TelegramPreviewController & TelegramAssistantMessagePreviewHooks<TMessage>;
+export type TelegramAssistantPreviewRuntime<
+  TMessage,
+  TReplyMarkup = TelegramPreviewReplyMarkup,
+> = TelegramPreviewController<TReplyMarkup> &
+  TelegramAssistantMessagePreviewHooks<TMessage>;
 
-export function createTelegramAssistantPreviewRuntime<TMessage>(
-  deps: TelegramAssistantPreviewRuntimeDeps<TMessage>,
-): TelegramAssistantPreviewRuntime<TMessage> {
+export function createTelegramAssistantPreviewRuntime<
+  TMessage,
+  TReplyMarkup = TelegramPreviewReplyMarkup,
+>(
+  deps: TelegramAssistantPreviewRuntimeDeps<TMessage, TReplyMarkup>,
+): TelegramAssistantPreviewRuntime<TMessage, TReplyMarkup> {
   const controller = createTelegramPreviewControllerRuntime(deps);
   return {
     ...controller,
@@ -331,9 +360,11 @@ export function createTelegramAssistantPreviewRuntime<TMessage>(
   };
 }
 
-export function createTelegramPreviewController(
-  deps: TelegramPreviewControllerDeps,
-): TelegramPreviewController {
+export function createTelegramPreviewController<
+  TReplyMarkup = TelegramPreviewReplyMarkup,
+>(
+  deps: TelegramPreviewControllerDeps<TReplyMarkup>,
+): TelegramPreviewController<TReplyMarkup> {
   let state: TelegramPreviewRuntimeState | undefined;
   const clearTimer = deps.clearTimer ?? clearTimeout;
   const setTimer =
@@ -349,7 +380,7 @@ export function createTelegramPreviewController(
   let nextDraftId = 0;
   const getRuntimeDeps = (
     replyToMessageId?: number,
-  ): TelegramPreviewRuntimeDeps => ({
+  ): TelegramPreviewRuntimeDeps<TReplyMarkup> => ({
     getState: () => state,
     setState: (nextState) => {
       state = nextState;
@@ -420,8 +451,11 @@ export function createTelegramPreviewController(
   };
 }
 
-export function createTelegramAssistantMessagePreviewHooks<TMessage>(
-  deps: TelegramAssistantMessagePreviewHookDeps<TMessage>,
+export function createTelegramAssistantMessagePreviewHooks<
+  TMessage,
+  TReplyMarkup = TelegramPreviewReplyMarkup,
+>(
+  deps: TelegramAssistantMessagePreviewHookDeps<TMessage, TReplyMarkup>,
 ): TelegramAssistantMessagePreviewHooks<TMessage> {
   return {
     onMessageStart: async (
@@ -437,9 +471,12 @@ export function createTelegramAssistantMessagePreviewHooks<TMessage>(
   };
 }
 
-export async function handleTelegramAssistantMessagePreviewStart<TMessage>(
+export async function handleTelegramAssistantMessagePreviewStart<
+  TMessage,
+  TReplyMarkup = TelegramPreviewReplyMarkup,
+>(
   message: TMessage,
-  deps: TelegramAssistantMessagePreviewStartDeps<TMessage>,
+  deps: TelegramAssistantMessagePreviewStartDeps<TMessage, TReplyMarkup>,
 ): Promise<void> {
   const turn = deps.getActiveTurn();
   if (!turn || !deps.isAssistantMessage(message)) return;
@@ -517,9 +554,11 @@ export function shouldUseTelegramDraftPreview(options: {
   );
 }
 
-export async function clearTelegramPreview(
+export async function clearTelegramPreview<
+  TReplyMarkup = TelegramPreviewReplyMarkup,
+>(
   chatId: number,
-  deps: TelegramPreviewRuntimeDeps,
+  deps: TelegramPreviewRuntimeDeps<TReplyMarkup>,
 ): Promise<void> {
   void chatId;
   const state = deps.getState();
@@ -528,10 +567,12 @@ export async function clearTelegramPreview(
   deps.setState(undefined);
 }
 
-async function performTelegramPreviewFlush(
+async function performTelegramPreviewFlush<
+  TReplyMarkup = TelegramPreviewReplyMarkup,
+>(
   chatId: number,
   state: TelegramPreviewRuntimeState,
-  deps: TelegramPreviewRuntimeDeps,
+  deps: TelegramPreviewRuntimeDeps<TReplyMarkup>,
 ): Promise<void> {
   const snapshot = buildTelegramPreviewSnapshot({
     state,
@@ -580,9 +621,11 @@ async function performTelegramPreviewFlush(
   state.lastSentStrategy = snapshot.strategy;
 }
 
-export async function flushTelegramPreview(
+export async function flushTelegramPreview<
+  TReplyMarkup = TelegramPreviewReplyMarkup,
+>(
   chatId: number,
-  deps: TelegramPreviewRuntimeDeps,
+  deps: TelegramPreviewRuntimeDeps<TReplyMarkup>,
 ): Promise<void> {
   const state = deps.getState();
   if (!state) return;
@@ -607,9 +650,11 @@ export async function flushTelegramPreview(
   }
 }
 
-export async function finalizeTelegramPreview(
+export async function finalizeTelegramPreview<
+  TReplyMarkup = TelegramPreviewReplyMarkup,
+>(
   chatId: number,
-  deps: TelegramPreviewRuntimeDeps,
+  deps: TelegramPreviewRuntimeDeps<TReplyMarkup>,
 ): Promise<boolean> {
   const state = deps.getState();
   if (!state) return false;
@@ -628,11 +673,13 @@ export async function finalizeTelegramPreview(
   return state.messageId !== undefined;
 }
 
-export async function finalizeTelegramMarkdownPreview(
+export async function finalizeTelegramMarkdownPreview<
+  TReplyMarkup = TelegramPreviewReplyMarkup,
+>(
   chatId: number,
   markdown: string,
-  deps: TelegramPreviewRuntimeDeps,
-  options?: { replyMarkup?: TelegramPreviewReplyMarkup },
+  deps: TelegramPreviewRuntimeDeps<TReplyMarkup>,
+  options?: { replyMarkup?: TReplyMarkup },
 ): Promise<boolean> {
   const state = deps.getState();
   if (!state) return false;