@llblab/pi-telegram 0.10.8 → 0.11.0

package/lib/extension-sections.ts

@@ -6,10 +6,17 @@
 
 import type { TelegramInlineKeyboardMarkup } from "./keyboard.ts";
 
+const SECTION_REGISTRY_KEY = "__piTelegramSectionRegistry__";
+
 // --- Core Types ---
 
+/** @internal */
 export type TelegramSectionId = string;
+
+/** @internal */
 export type TelegramSectionToken = string;
+
+/** @internal */
 export type TelegramSectionCallbackResult = "handled" | "pass";
 
 export interface TelegramSectionView {
@@ -34,6 +41,7 @@ export interface TelegramSectionRegistration {
   id: TelegramSectionId;
   label: string;
   order?: number;
+  getLabel?: () => string;
   render: (
     ctx: TelegramSectionContext,
   ) => TelegramSectionView | Promise<TelegramSectionView>;
@@ -71,6 +79,7 @@ export interface TelegramSectionCallbackContext {
   deleteMessage(): Promise<void>;
 }
 
+/** @internal */
 export interface RegisteredTelegramSection {
   id: TelegramSectionId;
   token: TelegramSectionToken;
@@ -79,6 +88,7 @@ export interface RegisteredTelegramSection {
   registration: TelegramSectionRegistration;
 }
 
+/** @internal */
 export interface TelegramSectionDiagnostic {
   id: TelegramSectionId;
   token: TelegramSectionToken;
@@ -87,6 +97,7 @@ export interface TelegramSectionDiagnostic {
   lastError?: string;
 }
 
+/** @internal */
 export interface TelegramSectionRegistry {
   register(section: TelegramSectionRegistration): () => void;
   getSections(): RegisteredTelegramSection[];
@@ -97,11 +108,13 @@ export interface TelegramSectionRegistry {
   clear(): void;
 }
 
+/** @internal */
 export interface TelegramSectionMainMenuRow {
   text: string;
   callback_data: string;
 }
 
+/** @internal */
 export interface TelegramSectionSettingsRow {
   label: string;
   callback_data: string;
@@ -109,6 +122,7 @@ export interface TelegramSectionSettingsRow {
 
 // --- Runtime Port Builders ---
 
+/** @internal */
 export interface TelegramSectionRuntimeDeps {
   answerCallbackQuery: (id: string, text?: string) => Promise<void>;
   editInteractiveMessage: (
@@ -229,17 +243,11 @@ function buildTelegramSectionCallbackContext(
 
 // --- GlobalThis Bridge ---
 
-const GLOBAL_SECTION_REGISTRY_KEY = "__piTelegramSectionRegistry__" as const;
-
-declare global {
-  // eslint-disable-next-line no-var
-  var __piTelegramSectionRegistry__: TelegramSectionRegistry | undefined;
-}
-
+/** @internal */
 export function setGlobalTelegramSectionRegistry(
   registry: TelegramSectionRegistry,
 ): void {
-  globalThis[GLOBAL_SECTION_REGISTRY_KEY] = registry;
+  (globalThis as Record<string, unknown>)[SECTION_REGISTRY_KEY] = registry;
 }
 
 /**
@@ -249,20 +257,26 @@ export function setGlobalTelegramSectionRegistry(
 export function registerTelegramSection(
   section: TelegramSectionRegistration,
 ): () => void {
-  const registry = globalThis[GLOBAL_SECTION_REGISTRY_KEY];
+  const registry = (globalThis as Record<string, unknown>)[
+    SECTION_REGISTRY_KEY
+  ] as TelegramSectionRegistry | undefined;
   if (!registry) {
     throw new Error(
-      "Telegram section registry not available. Is pi-telegram loaded?",
+      "Telegram section registry not available. Is pi-telegram loaded and initialized?",
     );
   }
+
   return registry.register(section);
 }
 
 /**
  * Get current section diagnostics. Returns empty array when registry is absent.
  */
+/** @internal */
 export function getTelegramSectionDiagnostics(): TelegramSectionDiagnostic[] {
-  const registry = globalThis[GLOBAL_SECTION_REGISTRY_KEY];
+  const registry = (globalThis as Record<string, unknown>)[
+    SECTION_REGISTRY_KEY
+  ] as TelegramSectionRegistry | undefined;
   return registry ? registry.getDiagnostics() : [];
 }
 
@@ -298,6 +312,7 @@ function prependBackRow(
   };
 }
 
+/** @internal */
 export function createTelegramExtensionSectionRegistry(): TelegramSectionRegistry {
   const sections = new Map<TelegramSectionToken, RegisteredTelegramSection>();
   const errors = new Map<TelegramSectionToken, string>();
@@ -351,15 +366,7 @@ export function createTelegramExtensionSectionRegistry(): TelegramSectionRegistr
   return { register, getSections, getByToken, getDiagnostics, clear };
 }
 
-export function getTelegramSectionMainMenuRows(
-  registry: TelegramSectionRegistry,
-): TelegramSectionMainMenuRow[] {
-  return registry.getSections().map((s) => ({
-    text: s.label,
-    callback_data: `section:${s.token}:open`,
-  }));
-}
-
+/** @internal */
 export function getTelegramExtensionSettingsRows(
   registry: TelegramSectionRegistry,
 ): TelegramSectionSettingsRow[] {
@@ -379,6 +386,17 @@ export function getTelegramExtensionSettingsRows(
     }));
 }
 
+/** @internal */
+export function getTelegramSectionMainMenuRows(
+  registry: TelegramSectionRegistry,
+): TelegramSectionMainMenuRow[] {
+  return registry.getSections().map((s) => ({
+    text: s.registration.getLabel?.() ?? s.label,
+    callback_data: `section:${s.token}:open`,
+  }));
+}
+
+/** @internal */
 export function parseTelegramSectionCallback(
   data: string,
 ): { token: string; action: string; payload: string } | undefined {
@@ -399,6 +417,7 @@ export function parseTelegramSectionCallback(
   };
 }
 
+/** @internal */
 export interface TelegramSectionCallbackHandlerDeps {
   answerCallbackQuery: (id: string, text?: string) => Promise<void>;
   editInteractiveMessage: (

package/lib/external-handlers.ts

@@ -155,10 +155,9 @@ export function createTelegramExternalHandleUpdate<TUpdate, TContext>(
  * off();
  * ```
  *
- * Extensions that prefer zero coupling can also reach the registry directly
- * via `globalThis.__piTelegramExternalHandlerRegistry__` (versioned object,
- * see {@link TelegramExternalHandlerRegistry}). This avoids importing
- * `@llblab/pi-telegram` and tolerates either install order.
+ * Extensions that prefer zero coupling can also reach the versioned registry
+ * directly on `globalThis`. This avoids importing `@llblab/pi-telegram` and
+ * tolerates either install order.
  */
 export function onTelegramExternalUpdate(
   handler: TelegramExternalHandler,

package/lib/inbound-handlers.ts

@@ -14,8 +14,10 @@ import {
   type CommandTemplateConfig,
   type CommandTemplateObjectConfig,
 } from "./command-templates.ts";
+import { getTelegramVoiceTranscriptionProviders } from "./voice.ts";
 
 const DEFAULT_INBOUND_HANDLER_TIMEOUT_MS = 120_000;
+const INBOUND_HANDLER_REGISTRY_KEY = "__piTelegramInboundHandlers__";
 
 type TelegramInboundCommandTemplateConfig =
   | string
@@ -96,6 +98,27 @@ export interface TelegramInboundHandlerRuntime<TContext> {
   ) => Promise<TelegramInboundHandlerProcessResult<TFile>>;
 }
 
+export type TelegramInboundProgrammaticHandlerResult =
+  | string
+  | { text: string }
+  | undefined;
+
+export interface TelegramInboundProgrammaticHandlerInput {
+  kind: string;
+  text?: string;
+  file?: TelegramInboundHandlerFile;
+  mimeType?: string;
+}
+
+export type TelegramInboundProgrammaticHandler = (
+  input: TelegramInboundProgrammaticHandlerInput,
+  options?: { cwd?: string },
+) => Promise<TelegramInboundProgrammaticHandlerResult>;
+
+export interface TelegramInboundHandlerRegistry {
+  handlers: Map<string, TelegramInboundProgrammaticHandler[]>;
+}
+
 interface InboundHandlerInvocation {
   command: string;
   args: string[];
@@ -103,6 +126,74 @@ interface InboundHandlerInvocation {
 
 const BUILT_IN_TEXT_ATTACHMENT_MAX_BYTES = 1_000_000;
 
+function getOrCreateInboundHandlerRegistry(): TelegramInboundHandlerRegistry {
+  const existing = (globalThis as Record<string, unknown>)[
+    INBOUND_HANDLER_REGISTRY_KEY
+  ];
+  if (
+    existing &&
+    typeof existing === "object" &&
+    existing !== null &&
+    "handlers" in existing &&
+    existing.handlers instanceof Map
+  ) {
+    return existing as TelegramInboundHandlerRegistry;
+  }
+  const registry: TelegramInboundHandlerRegistry = {
+    handlers: new Map(),
+  };
+  (globalThis as Record<string, unknown>)[INBOUND_HANDLER_REGISTRY_KEY] =
+    registry;
+  return registry;
+}
+
+export function registerTelegramInboundHandler(
+  kind: string,
+  handler: TelegramInboundProgrammaticHandler,
+): () => void {
+  const normalizedKind = kind.trim() || "*";
+  const registry = getOrCreateInboundHandlerRegistry();
+  const list = registry.handlers.get(normalizedKind) ?? [];
+  list.push(handler);
+  registry.handlers.set(normalizedKind, list);
+  return () => {
+    const updated = registry.handlers.get(normalizedKind) ?? [];
+    const index = updated.indexOf(handler);
+    if (index !== -1) {
+      updated.splice(index, 1);
+      registry.handlers.set(normalizedKind, updated);
+    }
+  };
+}
+
+export function getTelegramInboundProgrammaticHandlers(
+  kind: string,
+): TelegramInboundProgrammaticHandler[] {
+  const registry = getOrCreateInboundHandlerRegistry();
+  return [
+    ...(registry.handlers.get(kind) ?? []),
+    ...(kind === "*" ? [] : (registry.handlers.get("*") ?? [])),
+  ];
+}
+
+export function hasTelegramInboundHandler(kind?: string): boolean {
+  const registry = getOrCreateInboundHandlerRegistry();
+  if (kind !== undefined) return (registry.handlers.get(kind)?.length ?? 0) > 0;
+  return Array.from(registry.handlers.values()).some((list) => list.length > 0);
+}
+
+export function clearTelegramInboundHandlers(): void {
+  getOrCreateInboundHandlerRegistry().handlers.clear();
+}
+
+function normalizeInboundProgrammaticHandlerText(
+  result: TelegramInboundProgrammaticHandlerResult,
+): string | undefined {
+  const text = typeof result === "string" ? result : result?.text;
+  const normalized = text?.trim();
+  return normalized || undefined;
+}
+
 function normalizeStringList(value: string | string[] | undefined): string[] {
   if (Array.isArray(value)) {
     return value
@@ -467,9 +558,84 @@ async function processTelegramTextHandlers(options: {
       });
     }
   }
+  for (const handler of getTelegramInboundProgrammaticHandlers("text")) {
+    try {
+      const output = normalizeInboundProgrammaticHandlerText(
+        await handler(
+          { kind: "text", text, mimeType: "text/plain" },
+          { cwd: options.cwd },
+        ),
+      );
+      if (output) text = output;
+    } catch (error) {
+      options.recordRuntimeEvent?.("inbound-programmatic-handler", error, {
+        kind: "text",
+      });
+    }
+  }
   return text;
 }
 
+function isTelegramVoiceLikeFile(file: TelegramInboundHandlerFile): boolean {
+  return (
+    file.kind === "voice" ||
+    file.kind === "audio" ||
+    matchesWildcard("audio/*", file.mimeType)
+  );
+}
+
+async function processTelegramFileWithProgrammaticHandlers(
+  file: TelegramInboundHandlerFile,
+  options: {
+    cwd: string;
+    recordRuntimeEvent?: TelegramInboundHandlerRuntimeDeps<unknown>["recordRuntimeEvent"];
+  },
+): Promise<string | undefined> {
+  const kind = file.kind || "*";
+  for (const handler of getTelegramInboundProgrammaticHandlers(kind)) {
+    try {
+      const output = normalizeInboundProgrammaticHandlerText(
+        await handler(
+          {
+            kind,
+            file,
+            mimeType: file.mimeType,
+          },
+          { cwd: options.cwd },
+        ),
+      );
+      if (output) return output;
+    } catch (error) {
+      options.recordRuntimeEvent?.("inbound-programmatic-handler", error, {
+        fileName: file.fileName || basename(file.path),
+        kind,
+      });
+    }
+  }
+  return undefined;
+}
+
+async function transcribeTelegramVoiceFileWithProviders(
+  file: TelegramInboundHandlerFile,
+  options: {
+    recordRuntimeEvent?: TelegramInboundHandlerRuntimeDeps<unknown>["recordRuntimeEvent"];
+  },
+): Promise<string | undefined> {
+  if (!isTelegramVoiceLikeFile(file)) return undefined;
+  for (const provider of getTelegramVoiceTranscriptionProviders()) {
+    try {
+      const result = await provider(file, {});
+      const text = typeof result === "string" ? result : result?.text;
+      if (text?.trim()) return text.trim();
+    } catch (error) {
+      options.recordRuntimeEvent?.("voice-transcription-provider", error, {
+        fileName: file.fileName || basename(file.path),
+      });
+    }
+  }
+  return undefined;
+}
+
 async function readBuiltInTelegramTextAttachment(
   file: TelegramInboundHandlerFile,
 ): Promise<string | undefined> {
@@ -564,6 +730,37 @@ export async function processTelegramInboundHandlers<
         });
       }
     }
+    if (!hasOutput) {
+      try {
+        const output = await processTelegramFileWithProgrammaticHandlers(file, {
+          cwd: options.cwd,
+          recordRuntimeEvent: options.recordRuntimeEvent,
+        });
+        if (output) {
+          outputs.push({ file, output, handler: { type: "programmatic" } });
+          hasOutput = true;
+        }
+      } catch (error) {
+        options.recordRuntimeEvent?.("inbound-programmatic-handler", error, {
+          fileName: file.fileName || basename(file.path),
+        });
+      }
+    }
+    if (!hasOutput) {
+      try {
+        const output = await transcribeTelegramVoiceFileWithProviders(file, {
+          recordRuntimeEvent: options.recordRuntimeEvent,
+        });
+        if (output) {
+          outputs.push({ file, output, handler: { type: "voice-provider" } });
+          hasOutput = true;
+        }
+      } catch (error) {
+        options.recordRuntimeEvent?.("voice-transcription-provider", error, {
+          fileName: file.fileName || basename(file.path),
+        });
+      }
+    }
     if (!hasOutput) {
       try {
         const output = await readBuiltInTelegramTextAttachment(file);

package/lib/media.ts

@@ -463,6 +463,7 @@ export function collectTelegramFileInfos(
         isImage: false,
       });
     }
+    // Generic audio files (e.g. MP3 uploads) — can also trigger voice replies in "mirror" mode
     if (message.audio) {
       const fileName =
         message.audio.file_name ||
@@ -478,6 +479,8 @@ export function collectTelegramFileInfos(
         isImage: false,
       });
     }
+
+    // Voice messages (recorded via microphone) — primary trigger for "mirror" voice reply mode
     if (message.voice) {
       files.push({
         file_id: message.voice.file_id,

package/lib/menu-settings.ts

@@ -11,15 +11,21 @@ import {
 import type { TelegramInlineKeyboardMarkup } from "./keyboard.ts";
 import type { TelegramModelMenuState } from "./menu-model.ts";
 import type { MenuModel } from "./model.ts";
+import type { TelegramVoiceReplyMode } from "./voice.ts";
 
 export type TelegramSettingsMenuReplyMarkup = TelegramInlineKeyboardMarkup;
 
 export interface TelegramSettingsStateDeps {
   isProactivePushEnabled: () => boolean;
+  getVoiceReplyMode: () => TelegramVoiceReplyMode;
+  isVoiceReplyModeConfigured: () => boolean;
 }
 
 export interface TelegramSettingsMutationDeps extends TelegramSettingsStateDeps {
   setProactivePushEnabled: (enabled: boolean) => Promise<void>;
+  setVoiceReplyMode: (
+    mode: TelegramVoiceReplyMode | undefined,
+  ) => Promise<void>;
 }
 
 export interface TelegramSettingsMenuOpenDeps<
@@ -106,6 +112,20 @@ export interface TelegramSettingsMenuRuntimeDeps<
 
 export const SETTINGS_MENU_TITLE = "<b>⚙️ Settings:</b>";
 export const PROACTIVE_PUSH_SETTINGS_TITLE = "<b>Proactive push:</b>";
+export const VOICE_REPLY_MODE_SETTINGS_TITLE = "<b>Voice reply mode:</b>";
+
+type TelegramVoiceReplyModeSetting = TelegramVoiceReplyMode | "hidden";
+
+function getVoiceReplyModeLabel(mode: TelegramVoiceReplyModeSetting): string {
+  return mode;
+}
+
+function getVoiceReplyModeSetting(
+  mode: TelegramVoiceReplyMode,
+  configured: boolean,
+): TelegramVoiceReplyModeSetting {
+  return configured ? mode : "hidden";
+}
 
 export function buildTelegramSettingsMenuText(): string {
   return SETTINGS_MENU_TITLE;
@@ -119,9 +139,24 @@ export function buildProactivePushSettingsText(): string {
   ].join("\n");
 }
 
+export function buildVoiceReplyModeSettingsText(): string {
+  return [
+    VOICE_REPLY_MODE_SETTINGS_TITLE,
+    "",
+    "Controls when pi-telegram converts assistant text replies into Telegram voice messages.",
+    "",
+    "<code>-</code> <code>hidden</code> (default): same behavior as 'manual', but no voice policy is added to prompt context.",
+    "<code>-</code> <code>manual</code>: agent decides; explicit 'telegram_voice' markup still works and reply mode is visible in prompt context.",
+    "<code>-</code> <code>mirror</code>: voice input prefers a voice reply; text input gracefully follows 'manual' behavior.",
+    "<code>-</code> <code>always</code>: every reply is converted to voice when delivery succeeds.",
+  ].join("\n");
+}
+
 export function buildTelegramSettingsMenuReplyMarkup(
   proactivePushEnabled: boolean,
+  voiceReplyMode: TelegramVoiceReplyMode,
   sectionRegistry?: TelegramSectionRegistry,
+  voiceReplyModeConfigured = true,
 ): TelegramSettingsMenuReplyMarkup {
   const rows: Array<Array<{ text: string; callback_data: string }>> = [
     [{ text: "⬆️ Main menu", callback_data: "menu:back" }],
@@ -133,12 +168,22 @@ export function buildTelegramSettingsMenuReplyMarkup(
       rows.push([{ text: row.label, callback_data: row.callback_data }]);
     }
   }
-  rows.push([
-    {
-      text: `${proactivePushEnabled ? "🟢" : "⚫️"} Proactive push`,
-      callback_data: "settings:open:proactive",
-    },
-  ]);
+  rows.push(
+    [
+      {
+        text: `👄 Voice reply: ${getVoiceReplyModeLabel(
+          getVoiceReplyModeSetting(voiceReplyMode, voiceReplyModeConfigured),
+        )}`,
+        callback_data: "settings:open:voice-reply",
+      },
+    ],
+    [
+      {
+        text: `${proactivePushEnabled ? "🟢" : "⚫️"} Proactive push`,
+        callback_data: "settings:open:proactive",
+      },
+    ],
+  );
   return { inline_keyboard: rows };
 }
 
@@ -154,7 +199,9 @@ export async function openTelegramSettingsMenu<
     buildTelegramSettingsMenuText(),
     buildTelegramSettingsMenuReplyMarkup(
       deps.isProactivePushEnabled(),
+      deps.getVoiceReplyMode(),
       sectionRegistry,
+      deps.isVoiceReplyModeConfigured(),
     ),
   );
   if (messageId === undefined) return;
@@ -171,11 +218,11 @@ export function buildProactivePushSettingsReplyMarkup(
       [{ text: "⬆️ Back", callback_data: "settings:list" }],
       [
         {
-          text: proactivePushEnabled ? "🟢 On" : "⚫️ On",
+          text: proactivePushEnabled ? "🟢 on" : "⚫️ on",
           callback_data: "settings:set:proactive:on",
         },
         {
-          text: proactivePushEnabled ? "⚫️ Off" : "🟡 Off",
+          text: proactivePushEnabled ? "⚫️ off" : "🟡 off",
           callback_data: "settings:set:proactive:off",
         },
       ],
@@ -183,6 +230,30 @@ export function buildProactivePushSettingsReplyMarkup(
   };
 }
 
+export function buildVoiceReplyModeSettingsReplyMarkup(
+  mode: TelegramVoiceReplyMode,
+  configured = true,
+): TelegramSettingsMenuReplyMarkup {
+  const activeMode = getVoiceReplyModeSetting(mode, configured);
+  const modes: TelegramVoiceReplyModeSetting[] = [
+    "hidden",
+    "manual",
+    "mirror",
+    "always",
+  ];
+  return {
+    inline_keyboard: [
+      [{ text: "⬆️ Back", callback_data: "settings:list" }],
+      ...modes.map((value) => [
+        {
+          text: `${value === activeMode ? "🟢 " : ""}${getVoiceReplyModeLabel(value)}`,
+          callback_data: `settings:set:voice-reply:${value}`,
+        },
+      ]),
+    ],
+  };
+}
+
 export async function updateTelegramSettingsMenuMessage(
   deps: TelegramSettingsMenuMessageUpdateDeps,
   sectionRegistry?: TelegramSectionRegistry,
@@ -191,7 +262,9 @@ export async function updateTelegramSettingsMenuMessage(
     buildTelegramSettingsMenuText(),
     buildTelegramSettingsMenuReplyMarkup(
       deps.isProactivePushEnabled(),
+      deps.getVoiceReplyMode(),
       sectionRegistry,
+      deps.isVoiceReplyModeConfigured(),
     ),
   );
 }
@@ -205,6 +278,18 @@ export async function updateProactivePushSettingsMessage(
   );
 }
 
+export async function updateVoiceReplyModeSettingsMessage(
+  deps: TelegramSettingsMenuCallbackDeps,
+): Promise<void> {
+  await deps.updateSettingsMessage(
+    buildVoiceReplyModeSettingsText(),
+    buildVoiceReplyModeSettingsReplyMarkup(
+      deps.getVoiceReplyMode(),
+      deps.isVoiceReplyModeConfigured(),
+    ),
+  );
+}
+
 export async function handleTelegramSettingsMenuCallbackAction(
   callbackQueryId: string,
   data: string | undefined,
@@ -221,6 +306,28 @@ export async function handleTelegramSettingsMenuCallbackAction(
     await deps.answerCallbackQuery(callbackQueryId);
     return true;
   }
+  if (data === "settings:open:voice-reply") {
+    await updateVoiceReplyModeSettingsMessage(deps);
+    await deps.answerCallbackQuery(callbackQueryId);
+    return true;
+  }
+  if (data.startsWith("settings:set:voice-reply:")) {
+    const mode = data.slice("settings:set:voice-reply:".length);
+    if (
+      mode === "hidden" ||
+      mode === "manual" ||
+      mode === "mirror" ||
+      mode === "always"
+    ) {
+      await deps.setVoiceReplyMode(mode === "hidden" ? undefined : mode);
+      await updateVoiceReplyModeSettingsMessage(deps);
+      await deps.answerCallbackQuery(
+        callbackQueryId,
+        `Voice reply mode: ${mode}`,
+      );
+      return true;
+    }
+  }
   if (
     data === "settings:set:proactive:on" ||
     data === "settings:set:proactive:off"
@@ -251,6 +358,8 @@ export function createTelegramSettingsMenuRuntime<
         {
           getModelMenuState: () => deps.getModelMenuState(chatId, ctx),
           isProactivePushEnabled: deps.isProactivePushEnabled,
+          getVoiceReplyMode: deps.getVoiceReplyMode,
+          isVoiceReplyModeConfigured: deps.isVoiceReplyModeConfigured,
           sendSettingsMenu: (state, text, replyMarkup) =>
             deps.sendInteractiveMessage(
               state.chatId,
@@ -266,6 +375,8 @@ export function createTelegramSettingsMenuRuntime<
       updateTelegramSettingsMenuMessage(
         {
           isProactivePushEnabled: deps.isProactivePushEnabled,
+          getVoiceReplyMode: deps.getVoiceReplyMode,
+          isVoiceReplyModeConfigured: deps.isVoiceReplyModeConfigured,
           updateSettingsMessage: (text, replyMarkup) =>
             deps.editInteractiveMessage(
               state.chatId,
@@ -281,6 +392,18 @@ export function createTelegramSettingsMenuRuntime<
       if (!query.data?.startsWith("settings:")) return false;
       const state = deps.getStoredModelMenuState(query.message?.message_id);
       if (!state) {
+        const mode = query.data.slice("settings:set:voice-reply:".length);
+        if (
+          query.data.startsWith("settings:set:voice-reply:") &&
+          (mode === "hidden" ||
+            mode === "manual" ||
+            mode === "mirror" ||
+            mode === "always")
+        ) {
+          await deps.setVoiceReplyMode(mode === "hidden" ? undefined : mode);
+          await deps.answerCallbackQuery(query.id, `Voice reply mode: ${mode}`);
+          return true;
+        }
         await deps.answerCallbackQuery(
           query.id,
           "Interactive message expired.",
@@ -289,7 +412,10 @@ export function createTelegramSettingsMenuRuntime<
       }
       return handleTelegramSettingsMenuCallbackAction(query.id, query.data, {
         isProactivePushEnabled: deps.isProactivePushEnabled,
+        getVoiceReplyMode: deps.getVoiceReplyMode,
+        isVoiceReplyModeConfigured: deps.isVoiceReplyModeConfigured,
         setProactivePushEnabled: deps.setProactivePushEnabled,
+        setVoiceReplyMode: deps.setVoiceReplyMode,
         updateSettingsMessage: (text, replyMarkup) =>
           deps.editInteractiveMessage(
             state.chatId,