@openacp/cli 0.2.23 → 0.2.24

package/dist/{chunk-EIBLQU3H.js → chunk-IX63F4JG.js}

@@ -1,7 +1,7 @@
 import {
   createChildLogger,
   createSessionLogger
-} from "./chunk-ZATQZUJT.js";
+} from "./chunk-MNJDYDGH.js";
 
 // src/core/streams.ts
 function nodeToWebWritable(nodeStream) {
@@ -580,6 +580,7 @@ var Session = class {
     try {
       const start = Date.now();
       await this.agentInstance.prompt('Reply with only "ready".');
+      this.status = "active";
       this.log.info({ durationMs: Date.now() - start }, "Warm-up complete");
     } catch (err) {
       this.log.error({ err }, "Warm-up failed");
@@ -1259,6 +1260,187 @@ var ChannelAdapter = class {
   }
 };
 
+// src/core/api-server.ts
+import * as http from "http";
+import * as fs3 from "fs";
+import * as path4 from "path";
+import * as os2 from "os";
+var log4 = createChildLogger({ module: "api-server" });
+var DEFAULT_PORT_FILE = path4.join(os2.homedir(), ".openacp", "api.port");
+var ApiServer = class {
+  constructor(core, config, portFilePath) {
+    this.core = core;
+    this.config = config;
+    this.portFilePath = portFilePath ?? DEFAULT_PORT_FILE;
+  }
+  server = null;
+  actualPort = 0;
+  portFilePath;
+  async start() {
+    this.server = http.createServer((req, res) => this.handleRequest(req, res));
+    await new Promise((resolve, reject) => {
+      this.server.on("error", (err) => {
+        if (err.code === "EADDRINUSE") {
+          log4.warn({ port: this.config.port }, "API port in use, continuing without API server");
+          this.server = null;
+          resolve();
+        } else {
+          reject(err);
+        }
+      });
+      this.server.listen(this.config.port, this.config.host, () => {
+        const addr = this.server.address();
+        if (addr && typeof addr === "object") {
+          this.actualPort = addr.port;
+        }
+        this.writePortFile();
+        log4.info({ host: this.config.host, port: this.actualPort }, "API server listening");
+        resolve();
+      });
+    });
+  }
+  async stop() {
+    this.removePortFile();
+    if (this.server) {
+      await new Promise((resolve) => {
+        this.server.close(() => resolve());
+      });
+      this.server = null;
+    }
+  }
+  getPort() {
+    return this.actualPort;
+  }
+  writePortFile() {
+    const dir = path4.dirname(this.portFilePath);
+    fs3.mkdirSync(dir, { recursive: true });
+    fs3.writeFileSync(this.portFilePath, String(this.actualPort));
+  }
+  removePortFile() {
+    try {
+      fs3.unlinkSync(this.portFilePath);
+    } catch {
+    }
+  }
+  async handleRequest(req, res) {
+    const method = req.method?.toUpperCase();
+    const url = req.url || "";
+    try {
+      if (method === "POST" && url === "/api/sessions") {
+        await this.handleCreateSession(req, res);
+      } else if (method === "DELETE" && url.match(/^\/api\/sessions\/(.+)$/)) {
+        const sessionId = url.match(/^\/api\/sessions\/(.+)$/)[1];
+        await this.handleCancelSession(sessionId, res);
+      } else if (method === "GET" && url === "/api/sessions") {
+        await this.handleListSessions(res);
+      } else if (method === "GET" && url === "/api/agents") {
+        await this.handleListAgents(res);
+      } else {
+        this.sendJson(res, 404, { error: "Not found" });
+      }
+    } catch (err) {
+      log4.error({ err }, "API request error");
+      this.sendJson(res, 500, { error: "Internal server error" });
+    }
+  }
+  async handleCreateSession(req, res) {
+    const body = await this.readBody(req);
+    let agent;
+    let workspace;
+    if (body) {
+      try {
+        const parsed = JSON.parse(body);
+        agent = parsed.agent;
+        workspace = parsed.workspace;
+      } catch {
+        this.sendJson(res, 400, { error: "Invalid JSON body" });
+        return;
+      }
+    }
+    const config = this.core.configManager.get();
+    const activeSessions = this.core.sessionManager.listSessions().filter((s) => s.status === "active" || s.status === "initializing");
+    if (activeSessions.length >= config.security.maxConcurrentSessions) {
+      this.sendJson(res, 429, {
+        error: `Max concurrent sessions (${config.security.maxConcurrentSessions}) reached. Cancel a session first.`
+      });
+      return;
+    }
+    const [adapterId, adapter] = this.core.adapters.entries().next().value ?? [null, null];
+    const channelId = adapterId ?? "api";
+    const session = await this.core.handleNewSession(channelId, agent, workspace);
+    if (adapter) {
+      try {
+        const threadId = await adapter.createSessionThread(session.id, `\u{1F504} ${session.agentName} \u2014 New Session`);
+        session.threadId = threadId;
+        this.core.wireSessionEvents(session, adapter);
+      } catch (err) {
+        log4.warn({ err, sessionId: session.id }, "Failed to create session thread on adapter, running headless");
+      }
+    }
+    if (!adapter) {
+      session.agentInstance.onPermissionRequest = async (request) => {
+        const allowOption = request.options.find((o) => o.isAllow);
+        log4.debug({ sessionId: session.id, permissionId: request.id, option: allowOption?.id }, "Auto-approving permission for API session");
+        return allowOption?.id ?? request.options[0]?.id ?? "";
+      };
+    }
+    session.warmup().catch((err) => log4.warn({ err, sessionId: session.id }, "API session warmup failed"));
+    this.sendJson(res, 200, {
+      sessionId: session.id,
+      agent: session.agentName,
+      status: session.status,
+      workspace: session.workingDirectory
+    });
+  }
+  async handleCancelSession(sessionId, res) {
+    const session = this.core.sessionManager.getSession(sessionId);
+    if (!session) {
+      this.sendJson(res, 404, { error: `Session "${sessionId}" not found` });
+      return;
+    }
+    await session.cancel();
+    this.sendJson(res, 200, { ok: true });
+  }
+  async handleListSessions(res) {
+    const sessions = this.core.sessionManager.listSessions();
+    this.sendJson(res, 200, {
+      sessions: sessions.map((s) => ({
+        id: s.id,
+        agent: s.agentName,
+        status: s.status,
+        name: s.name ?? null,
+        workspace: s.workingDirectory
+      }))
+    });
+  }
+  async handleListAgents(res) {
+    const agents = this.core.agentManager.getAvailableAgents();
+    const defaultAgent = this.core.configManager.get().defaultAgent;
+    this.sendJson(res, 200, {
+      agents: agents.map((a) => ({
+        name: a.name,
+        command: a.command,
+        args: a.args
+      })),
+      default: defaultAgent
+    });
+  }
+  sendJson(res, status, data) {
+    res.writeHead(status, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(data));
+  }
+  readBody(req) {
+    return new Promise((resolve) => {
+      let data = "";
+      req.on("data", (chunk) => {
+        data += chunk;
+      });
+      req.on("end", () => resolve(data));
+      req.on("error", () => resolve(""));
+    });
+  }
+};
+
 // src/adapters/telegram/adapter.ts
 import { Bot } from "grammy";
 
@@ -1453,24 +1635,33 @@ var MessageDraft = class {
         });
         this.messageId = msg.message_id;
       } else {
-        await this.bot.api.editMessageText(this.chatId, this.messageId, truncated, {
-          parse_mode: "HTML"
-        });
+        await this.bot.api.editMessageText(
+          this.chatId,
+          this.messageId,
+          truncated,
+          {
+            parse_mode: "HTML"
+          }
+        );
       }
     } catch {
       try {
         if (!this.messageId) {
-          const msg = await this.bot.api.sendMessage(this.chatId, this.buffer.slice(0, 4096), {
-            message_thread_id: this.threadId,
-            disable_notification: true
-          });
+          const msg = await this.bot.api.sendMessage(
+            this.chatId,
+            this.buffer.slice(0, 4096),
+            {
+              message_thread_id: this.threadId,
+              disable_notification: true
+            }
+          );
           this.messageId = msg.message_id;
         }
       } catch {
       }
     }
   }
-  async finalize() {
+  async finalize(replyMarkup) {
     if (this.flushTimer) {
       clearTimeout(this.flushTimer);
       this.flushTimer = void 0;
@@ -1482,25 +1673,38 @@ var MessageDraft = class {
     try {
       for (let i = 0; i < chunks.length; i++) {
         const chunk = chunks[i];
+        const isLast = i === chunks.length - 1;
+        const markup = isLast && replyMarkup ? { reply_markup: replyMarkup } : {};
         if (i === 0 && this.messageId) {
-          await this.bot.api.editMessageText(this.chatId, this.messageId, chunk, {
-            parse_mode: "HTML"
-          });
+          await this.bot.api.editMessageText(
+            this.chatId,
+            this.messageId,
+            chunk,
+            {
+              parse_mode: "HTML",
+              ...markup
+            }
+          );
         } else {
           const msg = await this.bot.api.sendMessage(this.chatId, chunk, {
             message_thread_id: this.threadId,
             parse_mode: "HTML",
-            disable_notification: true
+            disable_notification: true,
+            ...markup
           });
           this.messageId = msg.message_id;
         }
       }
     } catch {
       try {
-        await this.bot.api.sendMessage(this.chatId, this.buffer.slice(0, 4096), {
-          message_thread_id: this.threadId,
-          disable_notification: true
-        });
+        await this.bot.api.sendMessage(
+          this.chatId,
+          this.buffer.slice(0, 4096),
+          {
+            message_thread_id: this.threadId,
+            disable_notification: true
+          }
+        );
       } catch {
       }
     }
@@ -1509,6 +1713,9 @@ var MessageDraft = class {
   getMessageId() {
     return this.messageId;
   }
+  getBuffer() {
+    return this.buffer;
+  }
 };
 
 // src/adapters/telegram/topics.ts
@@ -1545,7 +1752,7 @@ function buildDeepLink(chatId, messageId) {
 // src/adapters/telegram/commands.ts
 import { InlineKeyboard } from "grammy";
 import { nanoid as nanoid2 } from "nanoid";
-var log5 = createChildLogger({ module: "telegram-commands" });
+var log6 = createChildLogger({ module: "telegram-commands" });
 function setupCommands(bot, core, chatId) {
   bot.command("new", (ctx) => handleNew(ctx, core, chatId));
   bot.command("new_chat", (ctx) => handleNewChat(ctx, core, chatId));
@@ -1600,7 +1807,7 @@ async function handleNew(ctx, core, chatId) {
   const args = matchStr.split(" ").filter(Boolean);
   const agentName = args[0];
   const workspace = args[1];
-  log5.info({ userId: ctx.from?.id, agentName }, "New session command");
+  log6.info({ userId: ctx.from?.id, agentName }, "New session command");
   let threadId;
   try {
     const topicName = `\u{1F504} New Session`;
@@ -1633,15 +1840,16 @@ async function handleNew(ctx, core, chatId) {
         parse_mode: "HTML"
       }
     );
-    session.warmup().catch((err) => log5.error({ err }, "Warm-up error"));
+    session.warmup().catch((err) => log6.error({ err }, "Warm-up error"));
   } catch (err) {
+    log6.error({ err }, "Session creation failed");
     if (threadId) {
       try {
         await ctx.api.deleteForumTopic(chatId, threadId);
       } catch {
       }
     }
-    const message = err instanceof Error ? err.message : String(err);
+    const message = err instanceof Error ? err.message : typeof err === "object" ? JSON.stringify(err) : String(err);
     await ctx.reply(`\u274C ${escapeHtml(message)}`, { parse_mode: "HTML" });
   }
 }
@@ -1686,7 +1894,7 @@ async function handleNewChat(ctx, core, chatId) {
         parse_mode: "HTML"
       }
     );
-    session.warmup().catch((err) => log5.error({ err }, "Warm-up error"));
+    session.warmup().catch((err) => log6.error({ err }, "Warm-up error"));
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     await ctx.reply(`\u274C ${escapeHtml(message)}`, { parse_mode: "HTML" });
@@ -1700,7 +1908,7 @@ async function handleCancel(ctx, core) {
     String(threadId)
   );
   if (session) {
-    log5.info({ sessionId: session.id }, "Cancel session command");
+    log6.info({ sessionId: session.id }, "Cancel session command");
     await session.cancel();
     await ctx.reply("\u26D4 Session cancelled.", { parse_mode: "HTML" });
   }
@@ -1808,6 +2016,41 @@ function setupSkillCallbacks(bot, core) {
     await session.enqueuePrompt(`/${entry.commandName}`);
   });
 }
+async function executeNewSession(bot, core, chatId, agentName, workspace) {
+  const threadId = await createSessionTopic(bot, chatId, "\u{1F504} New Session");
+  await bot.api.sendMessage(chatId, "\u23F3 Setting up session, please wait...", {
+    message_thread_id: threadId,
+    parse_mode: "HTML"
+  });
+  try {
+    const session = await core.handleNewSession(
+      "telegram",
+      agentName,
+      workspace
+    );
+    session.threadId = String(threadId);
+    await core.sessionManager.updateSessionPlatform(session.id, {
+      topicId: threadId
+    });
+    const finalName = `\u{1F504} ${session.agentName} \u2014 New Session`;
+    await renameSessionTopic(bot, chatId, threadId, finalName);
+    session.warmup().catch((err) => log6.error({ err }, "Warm-up error"));
+    return { session, threadId };
+  } catch (err) {
+    try {
+      await bot.api.deleteForumTopic(chatId, threadId);
+    } catch {
+    }
+    throw err;
+  }
+}
+async function executeCancelSession(core, excludeSessionId) {
+  const sessions = core.sessionManager.listSessions("telegram").filter((s) => s.status === "active" && s.id !== excludeSessionId).sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+  const session = sessions[0];
+  if (!session) return null;
+  await session.cancel();
+  return session;
+}
 var STATIC_COMMANDS = [
   { command: "new", description: "Create new session" },
   { command: "new_chat", description: "New chat, same agent & workspace" },
@@ -1821,7 +2064,7 @@ var STATIC_COMMANDS = [
 // src/adapters/telegram/permissions.ts
 import { InlineKeyboard as InlineKeyboard2 } from "grammy";
 import { nanoid as nanoid3 } from "nanoid";
-var log6 = createChildLogger({ module: "telegram-permissions" });
+var log7 = createChildLogger({ module: "telegram-permissions" });
 var PermissionHandler = class {
   constructor(bot, chatId, getSession, sendNotification) {
     this.bot = bot;
@@ -1881,7 +2124,7 @@ ${escapeHtml(request.description)}`,
       }
       const session = this.getSession(pending.sessionId);
       const isAllow = pending.options.find((o) => o.id === optionId)?.isAllow ?? false;
-      log6.info({ requestId: pending.requestId, optionId, isAllow }, "Permission responded");
+      log7.info({ requestId: pending.requestId, optionId, isAllow }, "Permission responded");
       if (session?.pendingPermission?.requestId === pending.requestId) {
         session.pendingPermission.resolve(optionId);
         session.pendingPermission = void 0;
@@ -1947,8 +2190,153 @@ function redirectToAssistant(chatId, assistantTopicId) {
   return `\u{1F4AC} Please use the <a href="${link}">\u{1F916} Assistant</a> topic to chat with OpenACP.`;
 }
 
+// src/adapters/telegram/action-detect.ts
+import { nanoid as nanoid4 } from "nanoid";
+import { InlineKeyboard as InlineKeyboard3 } from "grammy";
+var CMD_NEW_RE = /\/new(?:\s+([^\s\u0080-\uFFFF]+)(?:\s+([^\s\u0080-\uFFFF]+))?)?/;
+var CMD_CANCEL_RE = /\/cancel\b/;
+var KW_NEW_RE = /(?:tao|tạo|create|new)\s+session/i;
+var KW_CANCEL_RE = /(?:huy|huỷ|cancel|dung|dừng)\s+session/i;
+function detectAction(text) {
+  if (!text) return null;
+  const cancelCmd = CMD_CANCEL_RE.exec(text);
+  if (cancelCmd) return { action: "cancel_session" };
+  const newCmd = CMD_NEW_RE.exec(text);
+  if (newCmd) {
+    return {
+      action: "new_session",
+      agent: newCmd[1] || void 0,
+      workspace: newCmd[2] || void 0
+    };
+  }
+  if (KW_CANCEL_RE.test(text)) return { action: "cancel_session" };
+  if (KW_NEW_RE.test(text))
+    return { action: "new_session", agent: void 0, workspace: void 0 };
+  return null;
+}
+var ACTION_TTL_MS = 5 * 60 * 1e3;
+var actionMap = /* @__PURE__ */ new Map();
+function storeAction(action) {
+  const id = nanoid4(10);
+  actionMap.set(id, { action, createdAt: Date.now() });
+  for (const [key, entry] of actionMap) {
+    if (Date.now() - entry.createdAt > ACTION_TTL_MS) {
+      actionMap.delete(key);
+    }
+  }
+  return id;
+}
+function getAction(id) {
+  const entry = actionMap.get(id);
+  if (!entry) return void 0;
+  if (Date.now() - entry.createdAt > ACTION_TTL_MS) {
+    actionMap.delete(id);
+    return void 0;
+  }
+  return entry.action;
+}
+function removeAction(id) {
+  actionMap.delete(id);
+}
+function buildActionKeyboard(actionId, action) {
+  const keyboard = new InlineKeyboard3();
+  if (action.action === "new_session") {
+    keyboard.text("\u2705 T\u1EA1o session", `a:${actionId}`);
+    keyboard.text("\u274C Hu\u1EF7", `a:dismiss:${actionId}`);
+  } else {
+    keyboard.text("\u26D4 Hu\u1EF7 session", `a:${actionId}`);
+    keyboard.text("\u274C Kh\xF4ng", `a:dismiss:${actionId}`);
+  }
+  return keyboard;
+}
+function setupActionCallbacks(bot, core, chatId, getAssistantSessionId) {
+  bot.callbackQuery(/^a:dismiss:/, async (ctx) => {
+    const actionId = ctx.callbackQuery.data.replace("a:dismiss:", "");
+    removeAction(actionId);
+    try {
+      await ctx.editMessageReplyMarkup({
+        reply_markup: { inline_keyboard: [] }
+      });
+    } catch {
+    }
+    await ctx.answerCallbackQuery({ text: "\u0110\xE3 hu\u1EF7" });
+  });
+  bot.callbackQuery(/^a:(?!dismiss)/, async (ctx) => {
+    const actionId = ctx.callbackQuery.data.replace("a:", "");
+    const action = getAction(actionId);
+    if (!action) {
+      await ctx.answerCallbackQuery({ text: "Action \u0111\xE3 h\u1EBFt h\u1EA1n" });
+      return;
+    }
+    removeAction(actionId);
+    try {
+      if (action.action === "new_session") {
+        await ctx.answerCallbackQuery({ text: "\u23F3 \u0110ang t\u1EA1o session..." });
+        const { threadId } = await executeNewSession(
+          bot,
+          core,
+          chatId,
+          action.agent,
+          action.workspace
+        );
+        const topicLink = `https://t.me/c/${String(chatId).replace("-100", "")}/${threadId}`;
+        const originalText = ctx.callbackQuery.message?.text ?? "";
+        try {
+          await ctx.editMessageText(
+            originalText + `
+
+\u2705 Session created \u2192 <a href="${topicLink}">Go to topic</a>`,
+            { parse_mode: "HTML" }
+          );
+        } catch {
+          await ctx.editMessageReplyMarkup({
+            reply_markup: { inline_keyboard: [] }
+          });
+        }
+      } else if (action.action === "cancel_session") {
+        const assistantId = getAssistantSessionId();
+        const cancelled = await executeCancelSession(core, assistantId);
+        if (cancelled) {
+          await ctx.answerCallbackQuery({ text: "\u26D4 Session \u0111\xE3 hu\u1EF7" });
+          const originalText = ctx.callbackQuery.message?.text ?? "";
+          try {
+            await ctx.editMessageText(
+              originalText + `
+
+\u26D4 Session "${cancelled.name ?? cancelled.id}" \u0111\xE3 hu\u1EF7`,
+              { parse_mode: "HTML" }
+            );
+          } catch {
+            await ctx.editMessageReplyMarkup({
+              reply_markup: { inline_keyboard: [] }
+            });
+          }
+        } else {
+          await ctx.answerCallbackQuery({
+            text: "Kh\xF4ng c\xF3 session n\xE0o \u0111ang ch\u1EA1y"
+          });
+          try {
+            await ctx.editMessageReplyMarkup({
+              reply_markup: { inline_keyboard: [] }
+            });
+          } catch {
+          }
+        }
+      }
+    } catch {
+      await ctx.answerCallbackQuery({ text: "\u274C L\u1ED7i, th\u1EED l\u1EA1i sau" });
+      try {
+        await ctx.editMessageReplyMarkup({
+          reply_markup: { inline_keyboard: [] }
+        });
+      } catch {
+      }
+    }
+  });
+}
+
 // src/adapters/telegram/adapter.ts
-var log7 = createChildLogger({ module: "telegram" });
+var log8 = createChildLogger({ module: "telegram" });
 function patchedFetch(input, init) {
   if (init?.signal && !(init.signal instanceof AbortSignal)) {
     const nativeController = new AbortController();
@@ -1982,7 +2370,7 @@ var TelegramAdapter = class extends ChannelAdapter {
     this.bot = new Bot(this.telegramConfig.botToken, { client: { fetch: patchedFetch } });
     this.bot.catch((err) => {
       const rootCause = err.error instanceof Error ? err.error : err;
-      log7.error({ err: rootCause }, "Telegram bot error");
+      log8.error({ err: rootCause }, "Telegram bot error");
     });
     this.bot.api.config.use((prev, method, payload, signal) => {
       if (method === "getUpdates") {
@@ -2021,6 +2409,12 @@ var TelegramAdapter = class extends ChannelAdapter {
       (notification) => this.sendNotification(notification)
     );
     setupSkillCallbacks(this.bot, this.core);
+    setupActionCallbacks(
+      this.bot,
+      this.core,
+      this.telegramConfig.chatId,
+      () => this.assistantSession?.id
+    );
     setupMenuCallbacks(
       this.bot,
       this.core,
@@ -2035,7 +2429,7 @@ var TelegramAdapter = class extends ChannelAdapter {
     this.setupRoutes();
     this.bot.start({
       allowed_updates: ["message", "callback_query"],
-      onStart: () => log7.info(
+      onStart: () => log8.info(
         { chatId: this.telegramConfig.chatId },
         "Telegram bot started"
       )
@@ -2047,7 +2441,7 @@ var TelegramAdapter = class extends ChannelAdapter {
         this.assistantTopicId
       );
     } catch (err) {
-      log7.error({ err }, "Failed to spawn assistant");
+      log8.error({ err }, "Failed to spawn assistant");
     }
     try {
       const config = this.core.configManager.get();
@@ -2068,7 +2462,7 @@ Workspace: <code>${workspace}</code>
         reply_markup: buildMenuKeyboard()
       });
     } catch (err) {
-      log7.warn({ err }, "Failed to send welcome message");
+      log8.warn({ err }, "Failed to send welcome message");
     }
   }
   async stop() {
@@ -2076,7 +2470,7 @@ Workspace: <code>${workspace}</code>
       await this.assistantSession.destroy();
     }
     await this.bot.stop();
-    log7.info("Telegram bot stopped");
+    log8.info("Telegram bot stopped");
   }
   setupRoutes() {
     this.bot.on("message:text", async (ctx) => {
@@ -2094,7 +2488,7 @@ Workspace: <code>${workspace}</code>
         ctx.replyWithChatAction("typing").catch(() => {
         });
         handleAssistantMessage(this.assistantSession, ctx.message.text).catch(
-          (err) => log7.error({ err }, "Assistant error")
+          (err) => log8.error({ err }, "Assistant error")
         );
         return;
       }
@@ -2105,7 +2499,7 @@ Workspace: <code>${workspace}</code>
         threadId: String(threadId),
         userId: String(ctx.from.id),
         text: ctx.message.text
-      }).catch((err) => log7.error({ err }, "handleMessage error"));
+      }).catch((err) => log8.error({ err }, "handleMessage error"));
     });
   }
   // --- ChannelAdapter implementations ---
@@ -2195,6 +2589,7 @@ Workspace: <code>${workspace}</code>
         break;
       }
       case "usage": {
+        await this.finalizeDraft(sessionId);
         await this.bot.api.sendMessage(
           this.telegramConfig.chatId,
           formatUsage(
@@ -2240,7 +2635,7 @@ Workspace: <code>${workspace}</code>
     }
   }
   async sendPermissionRequest(sessionId, request) {
-    log7.info({ sessionId, requestId: request.id }, "Permission request sent");
+    log8.info({ sessionId, requestId: request.id }, "Permission request sent");
     const session = this.core.sessionManager.getSession(
       sessionId
     );
@@ -2248,7 +2643,7 @@ Workspace: <code>${workspace}</code>
     await this.permissionHandler.sendPermissionRequest(session, request);
   }
   async sendNotification(notification) {
-    log7.info(
+    log8.info(
       { sessionId: notification.sessionId, type: notification.type },
       "Notification sent"
     );
@@ -2274,7 +2669,7 @@ Workspace: <code>${workspace}</code>
     });
   }
   async createSessionThread(sessionId, name) {
-    log7.info({ sessionId, name }, "Session topic created");
+    log8.info({ sessionId, name }, "Session topic created");
     return String(
       await createSessionTopic(this.bot, this.telegramConfig.chatId, name)
     );
@@ -2338,7 +2733,7 @@ Workspace: <code>${workspace}</code>
         }
       );
     } catch (err) {
-      log7.error({ err, sessionId }, "Failed to send skill commands");
+      log8.error({ err, sessionId }, "Failed to send skill commands");
     }
     await this.updateCommandAutocomplete(session.agentName, commands);
   }
@@ -2369,12 +2764,12 @@ Workspace: <code>${workspace}</code>
       await this.bot.api.setMyCommands(all, {
         scope: { type: "chat", chat_id: this.telegramConfig.chatId }
       });
-      log7.info(
+      log8.info(
         { count: all.length, skills: validSkills.length },
         "Updated command autocomplete"
       );
     } catch (err) {
-      log7.error(
+      log8.error(
         { err, commands: all },
         "Failed to update command autocomplete"
       );
@@ -2382,10 +2777,20 @@ Workspace: <code>${workspace}</code>
   }
   async finalizeDraft(sessionId) {
     const draft = this.sessionDrafts.get(sessionId);
-    if (draft) {
-      await draft.finalize();
-      this.sessionDrafts.delete(sessionId);
+    if (!draft) return;
+    let keyboard;
+    if (sessionId === this.assistantSession?.id) {
+      const fullText = draft.getBuffer();
+      if (fullText) {
+        const detected = detectAction(fullText);
+        if (detected) {
+          const actionId = storeAction(detected);
+          keyboard = buildActionKeyboard(actionId, detected);
+        }
+      }
     }
+    await draft.finalize(keyboard);
+    this.sessionDrafts.delete(sessionId);
   }
 };
 
@@ -2400,6 +2805,7 @@ export {
   NotificationManager,
   OpenACPCore,
   ChannelAdapter,
+  ApiServer,
   TelegramAdapter
 };
-//# sourceMappingURL=chunk-EIBLQU3H.js.map
+//# sourceMappingURL=chunk-IX63F4JG.js.map