@openacp/cli 2026.401.2 → 2026.401.3

package/dist/index.d.ts

@@ -291,6 +291,7 @@ interface SessionRecord<P = Record<string, unknown>> {
 interface TelegramPlatformData {
     topicId: number;
     skillMsgId?: number;
+    controlMsgId?: number;
 }
 interface UsageRecord {
     id: string;
@@ -2016,6 +2017,9 @@ interface EventBusEvents {
         attachments?: unknown[];
     }) => void;
     "usage:recorded": (data: UsageRecordEvent) => void;
+    "session:configChanged": (data: {
+        sessionId: string;
+    }) => void;
     "session:agentSwitch": (data: {
         sessionId: string;
         fromAgent: string;
@@ -3243,6 +3247,12 @@ declare class TelegramAdapter extends MessagingAdapter {
     private callbackCounter;
     /** Pending skill commands queued when session.threadId was not yet set */
     private _pendingSkillCommands;
+    /** Control message IDs per session (for updating status text/buttons) */
+    private controlMsgIds;
+    /** Store control message ID in memory + persist to session record */
+    private storeControlMsgId;
+    /** Get control message ID (from Map, with fallback to session record) */
+    private getControlMsgId;
     private getThreadId;
     private getOrCreateTracker;
     constructor(core: OpenACPCore, config: TelegramChannelConfig, saveTopicIds?: (updates: {
@@ -3284,6 +3294,12 @@ declare class TelegramAdapter extends MessagingAdapter {
     protected handleUsage(sessionId: string, content: OutgoingMessage, verbosity: DisplayVerbosity): Promise<void>;
     protected handleAttachment(sessionId: string, content: OutgoingMessage): Promise<void>;
     protected handleSessionEnd(sessionId: string, _content: OutgoingMessage): Promise<void>;
+    protected handleConfigUpdate(sessionId: string, _content: OutgoingMessage): Promise<void>;
+    /**
+     * Edit the pinned control message to reflect current session state
+     * (model, thought level, mode, bypass status).
+     */
+    updateControlMessage(sessionId: string): Promise<void>;
     protected handleError(sessionId: string, content: OutgoingMessage): Promise<void>;
     protected handleSystem(sessionId: string, content: OutgoingMessage): Promise<void>;
     sendPermissionRequest(sessionId: string, request: PermissionRequest): Promise<void>;

package/dist/index.js

@@ -295,6 +295,7 @@ function resolveInstanceRoot(opts) {
   if (opts.global) return path2.join(os2.homedir(), ".openacp");
   const localRoot = path2.join(cwd, ".openacp");
   if (fs2.existsSync(localRoot)) return localRoot;
+  if (process.env.OPENACP_INSTANCE_ROOT) return process.env.OPENACP_INSTANCE_ROOT;
   return null;
 }
 function getGlobalRoot() {
@@ -12317,31 +12318,38 @@ init_log();
 import { InlineKeyboard } from "grammy";
 init_log();
 var log18 = createChildLogger({ module: "telegram-cmd-admin" });
+function isBypassActive(session) {
+  const modeOpt = session.getConfigByCategory("mode");
+  return modeOpt?.type === "select" && isPermissionBypass(String(modeOpt.currentValue)) || !!session.clientOverrides.bypassPermissions;
+}
 function setupDangerousModeCallbacks(bot, core) {
   bot.callbackQuery(/^d:/, async (ctx) => {
     const sessionId = ctx.callbackQuery.data.slice(2);
     const session = core.sessionManager.getSession(sessionId);
     if (session) {
-      const newDangerousMode2 = !session.clientOverrides.bypassPermissions;
-      session.clientOverrides.bypassPermissions = newDangerousMode2;
-      log18.info(
-        { sessionId, dangerousMode: newDangerousMode2 },
-        "Bypass permissions toggled via button"
-      );
-      core.sessionManager.patchRecord(sessionId, { clientOverrides: session.clientOverrides }).catch(() => {
-      });
-      const toastText2 = newDangerousMode2 ? "\u2620\uFE0F Bypass enabled \u2014 permissions auto-approved" : "\u{1F510} Bypass disabled \u2014 approvals required";
+      const wantOn = !isBypassActive(session);
+      const toastText2 = wantOn ? "\u2620\uFE0F Bypass Permissions enabled \u2014 permissions auto-approved" : "\u{1F510} Bypass Permissions disabled \u2014 approvals required";
       try {
         await ctx.answerCallbackQuery({ text: toastText2 });
       } catch {
       }
+      const registry = core.lifecycleManager?.serviceRegistry?.get("command-registry");
+      if (registry) {
+        await registry.execute(wantOn ? "/bypass on" : "/bypass off", {
+          raw: wantOn ? "on" : "off",
+          sessionId,
+          channelId: "telegram",
+          userId: String(ctx.from?.id ?? ""),
+          reply: async () => {
+          }
+        }).catch(() => {
+        });
+      }
+      log18.info({ sessionId, wantOn }, "Bypass permissions toggled via button");
       try {
-        await ctx.editMessageReplyMarkup({
-          reply_markup: buildSessionControlKeyboard(
-            sessionId,
-            newDangerousMode2,
-            session.voiceMode === "on"
-          )
+        await ctx.editMessageText(buildSessionStatusText(session), {
+          parse_mode: "HTML",
+          reply_markup: buildSessionControlKeyboard(sessionId, isBypassActive(session), session.voiceMode === "on")
         });
       } catch {
       }
@@ -12364,7 +12372,7 @@ function setupDangerousModeCallbacks(bot, core) {
       { sessionId, dangerousMode: newDangerousMode },
       "Bypass permissions toggled via button (store-only, session not in memory)"
     );
-    const toastText = newDangerousMode ? "\u2620\uFE0F Bypass enabled \u2014 permissions auto-approved" : "\u{1F510} Bypass disabled \u2014 approvals required";
+    const toastText = newDangerousMode ? "\u2620\uFE0F Bypass Permissions enabled \u2014 permissions auto-approved" : "\u{1F510} Bypass Permissions disabled \u2014 approvals required";
     try {
       await ctx.answerCallbackQuery({ text: toastText });
     } catch {
@@ -12424,7 +12432,7 @@ async function handleEnableDangerous(ctx, core) {
     });
   }
   await ctx.reply(
-    `\u2620\uFE0F <b>Bypass enabled</b>
+    `\u2620\uFE0F <b>Bypass Permissions enabled</b>
 
 All permission requests will be auto-approved \u2014 the agent can run any action without asking.
 
@@ -12475,19 +12483,42 @@ async function handleDisableDangerous(ctx, core) {
     });
   }
   await ctx.reply(
-    "\u{1F510} <b>Bypass disabled</b>\n\nYou will be asked to approve risky actions.",
+    "\u{1F510} <b>Bypass Permissions disabled</b>\n\nYou will be asked to approve risky actions.",
     { parse_mode: "HTML" }
   );
 }
 function buildSessionControlKeyboard(sessionId, dangerousMode, voiceMode) {
   return new InlineKeyboard().text(
-    dangerousMode ? "\u{1F510} Disable Bypass" : "\u2620\uFE0F Enable Bypass",
+    dangerousMode ? "\u{1F510} Disable Bypass Permissions" : "\u2620\uFE0F Enable Bypass Permissions",
     `d:${sessionId}`
   ).row().text(
     voiceMode ? "\u{1F50A} Text to Speech" : "\u{1F507} Text to Speech",
     `v:${sessionId}`
   );
 }
+function buildSessionStatusText(session, heading = "\u2705 New chat (same agent &amp; workspace)") {
+  const lines = [heading];
+  lines.push(`<b>Agent:</b> ${escapeHtml(session.agentName)}`);
+  lines.push(`<b>Workspace:</b> <code>${escapeHtml(session.workingDirectory)}</code>`);
+  const modelOpt = session.getConfigByCategory("model");
+  if (modelOpt && modelOpt.type === "select") {
+    const choice = modelOpt.options.flatMap((o) => "group" in o ? o.options : [o]).find((c2) => c2.value === modelOpt.currentValue);
+    lines.push(`<b>Model:</b> ${escapeHtml(choice?.name ?? modelOpt.currentValue)}`);
+  }
+  const thoughtOpt = session.getConfigByCategory("thought_level");
+  if (thoughtOpt && thoughtOpt.type === "select") {
+    const choice = thoughtOpt.options.flatMap((o) => "group" in o ? o.options : [o]).find((c2) => c2.value === thoughtOpt.currentValue);
+    lines.push(`<b>Thinking:</b> ${escapeHtml(choice?.name ?? thoughtOpt.currentValue)}`);
+  }
+  const modeOpt = session.getConfigByCategory("mode");
+  if (isBypassActive(session)) {
+    lines.push(`<b>Mode:</b> \u2620\uFE0F Bypass Permissions enabled`);
+  } else if (modeOpt && modeOpt.type === "select") {
+    const choice = modeOpt.options.flatMap((o) => "group" in o ? o.options : [o]).find((c2) => c2.value === modeOpt.currentValue);
+    lines.push(`<b>Mode:</b> ${escapeHtml(choice?.name ?? modeOpt.currentValue)}`);
+  }
+  return lines.join("\n");
+}
 function setupTTSCallbacks(bot, core) {
   bot.callbackQuery(/^v:/, async (ctx) => {
     const sessionId = ctx.callbackQuery.data.slice(2);
@@ -12518,12 +12549,14 @@ function setupTTSCallbacks(bot, core) {
     } catch {
     }
     try {
-      await ctx.editMessageReplyMarkup({
-        reply_markup: buildSessionControlKeyboard(
-          sessionId,
-          session.clientOverrides.bypassPermissions ?? false,
-          newMode === "on"
-        )
+      const keyboard = buildSessionControlKeyboard(
+        sessionId,
+        isBypassActive(session),
+        newMode === "on"
+      );
+      await ctx.editMessageText(buildSessionStatusText(session), {
+        parse_mode: "HTML",
+        reply_markup: keyboard
       });
     } catch {
     }
@@ -12747,14 +12780,14 @@ function cleanupPending(userId) {
 function botFromCtx(ctx) {
   return { api: ctx.api };
 }
-async function handleNew(ctx, core, chatId, assistant) {
+async function handleNew(ctx, core, chatId, assistant, onControlMessage) {
   const rawMatch = ctx.match;
   const matchStr = typeof rawMatch === "string" ? rawMatch : "";
   const args = matchStr.split(" ").filter(Boolean);
   const agentName = args[0];
   const workspace = args[1];
   if (agentName && workspace) {
-    await createSessionDirect(ctx, core, chatId, agentName, workspace);
+    await createSessionDirect(ctx, core, chatId, agentName, workspace, onControlMessage);
     return;
   }
   const currentThreadId = ctx.message?.message_thread_id;
@@ -12832,7 +12865,7 @@ async function startConfirmStep(ctx, chatId, userId, agentName, workspace) {
     timer: setTimeout(() => pendingNewSessions.delete(userId), PENDING_TIMEOUT_MS)
   });
 }
-async function createSessionDirect(ctx, core, chatId, agentName, workspace) {
+async function createSessionDirect(ctx, core, chatId, agentName, workspace, onControlMessage) {
   log19.info({ userId: ctx.from?.id, agentName, workspace }, "New session command (direct)");
   let threadId;
   try {
@@ -12850,19 +12883,19 @@ async function createSessionDirect(ctx, core, chatId, agentName, workspace) {
       await ctx.api.editForumTopic(chatId, threadId, { name: finalName });
     } catch {
     }
-    await ctx.api.sendMessage(
+    const controlMsg = await ctx.api.sendMessage(
       chatId,
-      `\u2705 <b>Session started</b>
-<b>Agent:</b> ${escapeHtml(session.agentName)}
-<b>Workspace:</b> <code>${escapeHtml(session.workingDirectory)}</code>
-
-This is your coding session \u2014 chat here to work with the agent.`,
+      buildSessionStatusText(session, `\u2705 <b>Session started</b>`),
       {
         message_thread_id: threadId,
         parse_mode: "HTML",
         reply_markup: buildSessionControlKeyboard(session.id, false, false)
       }
     );
+    onControlMessage?.(session.id, controlMsg.message_id);
+    await core.sessionManager.patchRecord(session.id, {
+      platform: { topicId: threadId }
+    });
     return threadId ?? null;
   } catch (err) {
     log19.error({ err }, "Session creation failed");
@@ -12877,7 +12910,7 @@ This is your coding session \u2014 chat here to work with the agent.`,
     return null;
   }
 }
-async function handleNewChat(ctx, core, chatId) {
+async function handleNewChat(ctx, core, chatId, onControlMessage) {
   const threadId = ctx.message?.message_thread_id;
   if (!threadId) {
     await ctx.reply(
@@ -12932,17 +12965,19 @@ async function handleNewChat(ctx, core, chatId) {
     await core.sessionManager.patchRecord(session.id, { platform: {
       topicId: newThreadId
     } });
-    await ctx.api.sendMessage(
+    const controlMsg = await ctx.api.sendMessage(
       chatId,
-      `\u2705 New chat (same agent &amp; workspace)
-<b>Agent:</b> ${escapeHtml(session.agentName)}
-<b>Workspace:</b> <code>${escapeHtml(session.workingDirectory)}</code>`,
+      buildSessionStatusText(session, `\u2705 New chat (same agent &amp; workspace)`),
       {
         message_thread_id: newThreadId,
         parse_mode: "HTML",
         reply_markup: buildSessionControlKeyboard(session.id, false, false)
       }
     );
+    onControlMessage?.(session.id, controlMsg.message_id);
+    await core.sessionManager.patchRecord(session.id, {
+      platform: { topicId: newThreadId }
+    });
   } catch (err) {
     if (newThreadId) {
       try {
@@ -13935,7 +13970,7 @@ Choose the repo that has Entire checkpoints enabled:`;
     timer: setTimeout(() => pendingResumes.delete(userId), PENDING_TIMEOUT_MS2)
   });
 }
-async function executeResume(ctx, core, chatId, query, repoPath) {
+async function executeResume(ctx, core, chatId, query, repoPath, onControlMessage) {
   const provider = await core.contextManager.getProvider(repoPath);
   if (!provider) {
     await ctx.reply(
@@ -13993,22 +14028,23 @@ Repo: <code>${escapeHtml(repoPath)}</code>`,
         { parse_mode: "HTML" }
       );
     }
-    await ctx.api.sendMessage(
-      chatId,
-      `\u2705 <b>Session resumed with context</b>
-<b>Agent:</b> ${escapeHtml(session.agentName)}
-<b>Workspace:</b> <code>${escapeHtml(session.workingDirectory)}</code>
+    const resumeHeading = `\u2705 <b>Session resumed with context</b>
 <b>Sessions loaded:</b> ${sessionCount}
 <b>Mode:</b> ${escapeHtml(mode)}
-<b>~Tokens:</b> ${tokens.toLocaleString()}
-
-Context is ready \u2014 chat here to continue working with the agent.`,
+<b>~Tokens:</b> ${tokens.toLocaleString()}`;
+    const controlMsg = await ctx.api.sendMessage(
+      chatId,
+      buildSessionStatusText(session, resumeHeading),
       {
         message_thread_id: threadId,
         parse_mode: "HTML",
         reply_markup: buildSessionControlKeyboard(session.id, false, false)
       }
     );
+    onControlMessage?.(session.id, controlMsg.message_id);
+    await core.sessionManager.patchRecord(session.id, {
+      platform: { topicId: threadId }
+    });
   } catch (err) {
     log21.error({ err }, "Resume session creation failed");
     if (threadId) {
@@ -14021,7 +14057,7 @@ Context is ready \u2014 chat here to continue working with the agent.`,
     await ctx.reply(`\u274C ${escapeHtml(message)}`, { parse_mode: "HTML" });
   }
 }
-async function handleResume(ctx, core, chatId, assistant) {
+async function handleResume(ctx, core, chatId, assistant, onControlMessage) {
   const rawMatch = ctx.match;
   const matchStr = typeof rawMatch === "string" ? rawMatch : "";
   const parsed = parseResumeArgs(matchStr);
@@ -14046,7 +14082,7 @@ Usage examples:
   if (!userId) return;
   await showWorkspacePicker(ctx, core, chatId, userId, query);
 }
-async function handlePendingResumeInput(ctx, core, chatId, assistantTopicId) {
+async function handlePendingResumeInput(ctx, core, chatId, assistantTopicId, onControlMessage) {
   const userId = ctx.from?.id;
   if (!userId) return false;
   const pending = pendingResumes.get(userId);
@@ -14066,10 +14102,10 @@ async function handlePendingResumeInput(ctx, core, chatId, assistantTopicId) {
   }
   const resolved = core.configManager.resolveWorkspace(workspace);
   cleanupPending2(userId);
-  await executeResume(ctx, core, chatId, pending.query, resolved);
+  await executeResume(ctx, core, chatId, pending.query, resolved, onControlMessage);
   return true;
 }
-function setupResumeCallbacks(bot, core, chatId) {
+function setupResumeCallbacks(bot, core, chatId, onControlMessage) {
   bot.callbackQuery(/^m:resume:/, async (ctx) => {
     const data = ctx.callbackQuery.data;
     const userId = ctx.from?.id;
@@ -14088,7 +14124,7 @@ function setupResumeCallbacks(bot, core, chatId) {
         await ctx.api.editMessageText(chatId, pending.messageId, `\u23F3 Using <code>${escapeHtml(resolved)}</code>...`, { parse_mode: "HTML" });
       } catch {
       }
-      await executeResume(ctx, core, chatId, pending.query, resolved);
+      await executeResume(ctx, core, chatId, pending.query, resolved, onControlMessage);
       return;
     }
     if (data === "m:resume:ws:custom") {
@@ -14119,7 +14155,7 @@ Or just the folder name (will use workspace baseDir)`,
         await ctx.api.editMessageText(chatId, pending.messageId, `\u23F3 Using <code>${escapeHtml(resolved)}</code>...`, { parse_mode: "HTML" });
       } catch {
       }
-      await executeResume(ctx, core, chatId, pending.query, resolved);
+      await executeResume(ctx, core, chatId, pending.query, resolved, onControlMessage);
       return;
     }
   });
@@ -14722,8 +14758,9 @@ Switch to <b>${escapeHtml(agentName)}</b> anyway?`,
 init_menu();
 init_menu();
 function setupCommands(bot, core, chatId, assistant) {
-  bot.command("new", (ctx) => handleNew(ctx, core, chatId, assistant));
-  bot.command("newchat", (ctx) => handleNewChat(ctx, core, chatId));
+  const onControlMessage = assistant?.setControlMessage;
+  bot.command("new", (ctx) => handleNew(ctx, core, chatId, assistant, onControlMessage));
+  bot.command("newchat", (ctx) => handleNewChat(ctx, core, chatId, onControlMessage));
   bot.command("cancel", (ctx) => handleCancel(ctx, core, assistant));
   bot.command("status", (ctx) => handleStatus(ctx, core));
   bot.command("sessions", (ctx) => handleTopics(ctx, core));
@@ -14744,12 +14781,12 @@ function setupCommands(bot, core, chatId, assistant) {
   bot.command("text_to_speech", (ctx) => handleTTS(ctx, core));
   bot.command("verbosity", (ctx) => handleVerbosity(ctx, core));
   bot.command("outputmode", (ctx) => handleOutputMode(ctx, core));
-  bot.command("resume", (ctx) => handleResume(ctx, core, chatId, assistant));
+  bot.command("resume", (ctx) => handleResume(ctx, core, chatId, assistant, onControlMessage));
   bot.command("switch", (ctx) => handleSwitch(ctx, core));
 }
-function setupAllCallbacks(bot, core, chatId, systemTopicIds, getAssistantSession) {
+function setupAllCallbacks(bot, core, chatId, systemTopicIds, getAssistantSession, onControlMessage) {
   setupNewSessionCallbacks(bot, core, chatId);
-  setupResumeCallbacks(bot, core, chatId);
+  setupResumeCallbacks(bot, core, chatId, onControlMessage);
   setupSessionCallbacks(bot, core, chatId, systemTopicIds);
   setupSettingsCallbacks(bot, core, getAssistantSession ?? (() => void 0));
   setupDoctorCallbacks(bot);
@@ -16128,6 +16165,29 @@ var TelegramAdapter = class extends MessagingAdapter {
   callbackCounter = 0;
   /** Pending skill commands queued when session.threadId was not yet set */
   _pendingSkillCommands = /* @__PURE__ */ new Map();
+  /** Control message IDs per session (for updating status text/buttons) */
+  controlMsgIds = /* @__PURE__ */ new Map();
+  /** Store control message ID in memory + persist to session record */
+  storeControlMsgId(sessionId, msgId) {
+    this.storeControlMsgId(sessionId, msgId);
+    this.core.sessionManager.patchRecord(sessionId, {
+      platform: { controlMsgId: msgId }
+    }).catch(() => {
+    });
+  }
+  /** Get control message ID (from Map, with fallback to session record) */
+  getControlMsgId(sessionId) {
+    let msgId = this.controlMsgIds.get(sessionId);
+    if (!msgId) {
+      const record = this.core.sessionManager.getSessionRecord(sessionId);
+      const platform2 = record?.platform;
+      if (platform2?.controlMsgId) {
+        msgId = platform2.controlMsgId;
+        this.storeControlMsgId(sessionId, msgId);
+      }
+    }
+    return msgId;
+  }
   getThreadId(sessionId) {
     const threadId = this._sessionThreadIds.get(sessionId);
     if (threadId === void 0) {
@@ -16334,7 +16394,26 @@ var TelegramAdapter = class extends MessagingAdapter {
         });
         await ctx.answerCallbackQuery();
         if (response.type !== "silent") {
-          await this.renderCommandResponse(response, chatId, topicId);
+          if (response.type === "menu") {
+            const keyboard = response.options.map((opt) => [
+              {
+                text: `${opt.label}${opt.hint ? ` \u2014 ${opt.hint}` : ""}`,
+                callback_data: this.toCallbackData(opt.command)
+              }
+            ]);
+            try {
+              await ctx.editMessageText(response.title, {
+                reply_markup: { inline_keyboard: keyboard }
+              });
+            } catch {
+            }
+          } else if (response.type === "text" || response.type === "error") {
+            const text3 = response.type === "text" ? response.text : `\u274C ${response.message}`;
+            try {
+              await ctx.editMessageText(text3, { parse_mode: "Markdown" });
+            } catch {
+            }
+          }
         }
       } catch {
         await ctx.answerCallbackQuery({ text: "Command failed" });
@@ -16364,6 +16443,9 @@ var TelegramAdapter = class extends MessagingAdapter {
           topicId: this.assistantTopicId,
           enqueuePrompt: (p) => this.assistantSession.enqueuePrompt(p)
         };
+      },
+      (sessionId, msgId) => {
+        this.storeControlMsgId(sessionId, msgId);
       }
     );
     setupCommands(
@@ -16373,6 +16455,9 @@ var TelegramAdapter = class extends MessagingAdapter {
       {
         topicId: this.assistantTopicId,
         getSession: () => this.assistantSession,
+        setControlMessage: (sessionId, msgId) => {
+          this.storeControlMsgId(sessionId, msgId);
+        },
         respawn: async () => {
           if (this.assistantSession) {
             await this.assistantSession.destroy();
@@ -16436,6 +16521,10 @@ var TelegramAdapter = class extends MessagingAdapter {
         }
       );
     });
+    this.core.eventBus.on("session:configChanged", ({ sessionId }) => {
+      this.updateControlMessage(sessionId).catch(() => {
+      });
+    });
     this.setupRoutes();
     this.bot.start({
       allowed_updates: ["message", "callback_query"],
@@ -16640,7 +16729,10 @@ ${lines.join("\n")}`;
         ctx,
         this.core,
         this.telegramConfig.chatId,
-        this.assistantTopicId
+        this.assistantTopicId,
+        (sessionId2, msgId) => {
+          this.storeControlMsgId(sessionId2, msgId);
+        }
       )) {
         return;
       }
@@ -17019,6 +17111,41 @@ Task completed.
       );
     }
   }
+  async handleConfigUpdate(sessionId, _content) {
+    await this.updateControlMessage(sessionId);
+  }
+  /**
+   * Edit the pinned control message to reflect current session state
+   * (model, thought level, mode, bypass status).
+   */
+  async updateControlMessage(sessionId) {
+    const session = this.core.sessionManager.getSession(sessionId);
+    if (!session) return;
+    const controlMsgId = this.getControlMsgId(sessionId);
+    if (!controlMsgId) return;
+    const threadId = Number(session.threadId);
+    if (!threadId || isNaN(threadId)) return;
+    const text3 = buildSessionStatusText(session);
+    const keyboard = buildSessionControlKeyboard(
+      sessionId,
+      isBypassActive(session),
+      session.voiceMode === "on"
+    );
+    try {
+      await this.bot.api.editMessageText(
+        this.telegramConfig.chatId,
+        controlMsgId,
+        text3,
+        { parse_mode: "HTML" }
+      );
+      await this.bot.api.editMessageReplyMarkup(
+        this.telegramConfig.chatId,
+        controlMsgId,
+        { reply_markup: keyboard }
+      );
+    } catch {
+    }
+  }
   async handleError(sessionId, content) {
     this.getTracer(sessionId)?.log("telegram", { action: "handle:error", sessionId, text: content.text });
     const threadId = this.getThreadId(sessionId);