@openacp/cli 0.2.23 → 0.2.25

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

@@ -1,7 +1,7 @@
 import {
   createChildLogger,
   createSessionLogger
-} from "./chunk-ZATQZUJT.js";
+} from "./chunk-MNJDYDGH.js";
 
 // src/core/streams.ts
 function nodeToWebWritable(nodeStream) {
@@ -54,33 +54,35 @@ import { randomUUID } from "crypto";
 import { ClientSideConnection, ndJsonStream } from "@agentclientprotocol/sdk";
 var log = createChildLogger({ module: "agent-instance" });
 function resolveAgentCommand(cmd) {
-  const packageDirs = [
-    path.resolve(
-      process.cwd(),
-      "node_modules",
-      "@zed-industries",
-      cmd,
-      "dist",
-      "index.js"
-    ),
-    path.resolve(process.cwd(), "node_modules", cmd, "dist", "index.js")
-  ];
-  for (const jsPath of packageDirs) {
-    if (fs.existsSync(jsPath)) {
-      return { command: process.execPath, args: [jsPath] };
-    }
-  }
-  const localBin = path.resolve(process.cwd(), "node_modules", ".bin", cmd);
-  if (fs.existsSync(localBin)) {
-    const content = fs.readFileSync(localBin, "utf-8");
-    if (content.startsWith("#!/usr/bin/env node")) {
-      return { command: process.execPath, args: [localBin] };
-    }
-    const match = content.match(/"([^"]+\.js)"/);
-    if (match) {
-      const target = path.resolve(path.dirname(localBin), match[1]);
-      if (fs.existsSync(target)) {
-        return { command: process.execPath, args: [target] };
+  const searchRoots = [process.cwd()];
+  const ownDir = path.resolve(import.meta.dirname, "..", "..");
+  if (ownDir !== process.cwd()) {
+    searchRoots.push(ownDir);
+  }
+  for (const root of searchRoots) {
+    const packageDirs = [
+      path.resolve(root, "node_modules", "@zed-industries", cmd, "dist", "index.js"),
+      path.resolve(root, "node_modules", cmd, "dist", "index.js")
+    ];
+    for (const jsPath of packageDirs) {
+      if (fs.existsSync(jsPath)) {
+        return { command: process.execPath, args: [jsPath] };
+      }
+    }
+  }
+  for (const root of searchRoots) {
+    const localBin = path.resolve(root, "node_modules", ".bin", cmd);
+    if (fs.existsSync(localBin)) {
+      const content = fs.readFileSync(localBin, "utf-8");
+      if (content.startsWith("#!/usr/bin/env node")) {
+        return { command: process.execPath, args: [localBin] };
+      }
+      const match = content.match(/"([^"]+\.js)"/);
+      if (match) {
+        const target = path.resolve(path.dirname(localBin), match[1]);
+        if (fs.existsSync(target)) {
+          return { command: process.execPath, args: [target] };
+        }
       }
     }
   }
@@ -580,6 +582,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 +1262,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";
 
@@ -1406,20 +1590,25 @@ function splitMessage(text, maxLength = 4096) {
 }
 
 // src/adapters/telegram/streaming.ts
+var nextDraftId = 1;
 var MessageDraft = class {
-  // 1 second throttle
-  constructor(bot, chatId, threadId) {
+  // Only set in fallback mode (sendMessageDraft returns true, not Message)
+  constructor(bot, chatId, threadId, throttleMs = 200, sendQueue) {
     this.bot = bot;
     this.chatId = chatId;
     this.threadId = threadId;
+    this.sendQueue = sendQueue;
+    this.draftId = nextDraftId++;
+    this.minInterval = throttleMs;
   }
-  messageId;
+  draftId;
   buffer = "";
   lastFlush = 0;
   flushTimer;
   flushPromise = Promise.resolve();
-  // serialize flushes
-  minInterval = 1e3;
+  minInterval;
+  useFallback = false;
+  messageId;
   append(text) {
     this.buffer += text;
     this.scheduleFlush();
@@ -1444,26 +1633,49 @@ var MessageDraft = class {
     const html = markdownToTelegramHtml(this.buffer);
     const truncated = html.length > 4096 ? html.slice(0, 4090) + "\n..." : html;
     if (!truncated) return;
+    if (this.useFallback) {
+      await this.flushFallback(truncated);
+      return;
+    }
+    try {
+      await this.bot.api.sendMessageDraft(this.chatId, this.draftId, truncated, {
+        message_thread_id: this.threadId,
+        parse_mode: "HTML"
+      });
+    } catch {
+      this.useFallback = true;
+      this.minInterval = 1e3;
+      await this.flushFallback(truncated);
+    }
+  }
+  async flushFallback(html) {
+    const exec = this.sendQueue ? (fn) => this.sendQueue.enqueue(fn) : (fn) => fn();
     try {
       if (!this.messageId) {
-        const msg = await this.bot.api.sendMessage(this.chatId, truncated, {
-          message_thread_id: this.threadId,
-          parse_mode: "HTML",
-          disable_notification: true
-        });
+        const msg = await exec(
+          () => this.bot.api.sendMessage(this.chatId, html, {
+            message_thread_id: this.threadId,
+            parse_mode: "HTML",
+            disable_notification: true
+          })
+        );
         this.messageId = msg.message_id;
       } else {
-        await this.bot.api.editMessageText(this.chatId, this.messageId, truncated, {
-          parse_mode: "HTML"
-        });
+        await exec(
+          () => this.bot.api.editMessageText(this.chatId, this.messageId, html, {
+            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 exec(
+            () => 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 {
@@ -1545,7 +1757,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 +1812,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 +1845,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 +1899,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 +1913,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 +2021,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 +2069,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 +2129,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 +2195,186 @@ 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/send-queue.ts
+var TelegramSendQueue = class {
+  queue = Promise.resolve();
+  lastExec = 0;
+  minInterval;
+  constructor(minInterval = 100) {
+    this.minInterval = minInterval;
+  }
+  enqueue(fn) {
+    let resolve;
+    let reject;
+    const resultPromise = new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    this.queue = this.queue.then(async () => {
+      const elapsed = Date.now() - this.lastExec;
+      if (elapsed < this.minInterval) {
+        await new Promise((r) => setTimeout(r, this.minInterval - elapsed));
+      }
+      try {
+        const result = await fn();
+        resolve(result);
+      } catch (err) {
+        reject(err);
+      } finally {
+        this.lastExec = Date.now();
+      }
+    });
+    return resultPromise;
+  }
+};
+
+// 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();
@@ -1966,6 +2392,7 @@ var TelegramAdapter = class extends ChannelAdapter {
   bot;
   telegramConfig;
   sessionDrafts = /* @__PURE__ */ new Map();
+  sessionTextBuffers = /* @__PURE__ */ new Map();
   toolCallMessages = /* @__PURE__ */ new Map();
   // sessionId → (toolCallId → state)
   permissionHandler;
@@ -1974,6 +2401,7 @@ var TelegramAdapter = class extends ChannelAdapter {
   assistantTopicId;
   skillMessages = /* @__PURE__ */ new Map();
   // sessionId → pinned messageId
+  sendQueue = new TelegramSendQueue();
   constructor(core, config) {
     super(core, config);
     this.telegramConfig = config;
@@ -1982,7 +2410,23 @@ 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(async (prev, method, payload, signal) => {
+      const maxRetries = 3;
+      for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        const result = await prev(method, payload, signal);
+        if (result.ok || result.error_code !== 429 || attempt === maxRetries) {
+          return result;
+        }
+        const retryAfter = (result.parameters?.retry_after ?? 5) + 1;
+        log8.warn(
+          { method, retryAfter, attempt: attempt + 1 },
+          "Rate limited by Telegram, retrying"
+        );
+        await new Promise((r) => setTimeout(r, retryAfter * 1e3));
+      }
+      return prev(method, payload, signal);
     });
     this.bot.api.config.use((prev, method, payload, signal) => {
       if (method === "getUpdates") {
@@ -2021,6 +2465,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 +2485,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 +2497,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 +2518,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 +2526,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 +2544,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 +2555,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 ---
@@ -2125,24 +2575,32 @@ Workspace: <code>${workspace}</code>
           draft = new MessageDraft(
             this.bot,
             this.telegramConfig.chatId,
-            threadId
+            threadId,
+            this.telegramConfig.streamThrottleMs,
+            this.sendQueue
           );
           this.sessionDrafts.set(sessionId, draft);
         }
         draft.append(content.text);
+        this.sessionTextBuffers.set(
+          sessionId,
+          (this.sessionTextBuffers.get(sessionId) ?? "") + content.text
+        );
         break;
       }
       case "tool_call": {
         await this.finalizeDraft(sessionId);
         const meta = content.metadata;
-        const msg = await this.bot.api.sendMessage(
-          this.telegramConfig.chatId,
-          formatToolCall(meta),
-          {
-            message_thread_id: threadId,
-            parse_mode: "HTML",
-            disable_notification: true
-          }
+        const msg = await this.sendQueue.enqueue(
+          () => this.bot.api.sendMessage(
+            this.telegramConfig.chatId,
+            formatToolCall(meta),
+            {
+              message_thread_id: threadId,
+              parse_mode: "HTML",
+              disable_notification: true
+            }
+          )
         );
         if (!this.toolCallMessages.has(sessionId)) {
           this.toolCallMessages.set(sessionId, /* @__PURE__ */ new Map());
@@ -2168,11 +2626,13 @@ Workspace: <code>${workspace}</code>
             viewerLinks
           };
           try {
-            await this.bot.api.editMessageText(
-              this.telegramConfig.chatId,
-              toolState.msgId,
-              formatToolUpdate(merged),
-              { parse_mode: "HTML" }
+            await this.sendQueue.enqueue(
+              () => this.bot.api.editMessageText(
+                this.telegramConfig.chatId,
+                toolState.msgId,
+                formatToolUpdate(merged),
+                { parse_mode: "HTML" }
+              )
             );
           } catch {
           }
@@ -2181,30 +2641,35 @@ Workspace: <code>${workspace}</code>
       }
       case "plan": {
         await this.finalizeDraft(sessionId);
-        await this.bot.api.sendMessage(
-          this.telegramConfig.chatId,
-          formatPlan(
-            content.metadata
-          ),
-          {
-            message_thread_id: threadId,
-            parse_mode: "HTML",
-            disable_notification: true
-          }
+        await this.sendQueue.enqueue(
+          () => this.bot.api.sendMessage(
+            this.telegramConfig.chatId,
+            formatPlan(
+              content.metadata
+            ),
+            {
+              message_thread_id: threadId,
+              parse_mode: "HTML",
+              disable_notification: true
+            }
+          )
         );
         break;
       }
       case "usage": {
-        await this.bot.api.sendMessage(
-          this.telegramConfig.chatId,
-          formatUsage(
-            content.metadata
-          ),
-          {
-            message_thread_id: threadId,
-            parse_mode: "HTML",
-            disable_notification: true
-          }
+        await this.finalizeDraft(sessionId);
+        await this.sendQueue.enqueue(
+          () => this.bot.api.sendMessage(
+            this.telegramConfig.chatId,
+            formatUsage(
+              content.metadata
+            ),
+            {
+              message_thread_id: threadId,
+              parse_mode: "HTML",
+              disable_notification: true
+            }
+          )
         );
         break;
       }
@@ -2213,42 +2678,48 @@ Workspace: <code>${workspace}</code>
         this.sessionDrafts.delete(sessionId);
         this.toolCallMessages.delete(sessionId);
         await this.cleanupSkillCommands(sessionId);
-        await this.bot.api.sendMessage(
-          this.telegramConfig.chatId,
-          `\u2705 <b>Done</b>`,
-          {
-            message_thread_id: threadId,
-            parse_mode: "HTML",
-            disable_notification: true
-          }
+        await this.sendQueue.enqueue(
+          () => this.bot.api.sendMessage(
+            this.telegramConfig.chatId,
+            `\u2705 <b>Done</b>`,
+            {
+              message_thread_id: threadId,
+              parse_mode: "HTML",
+              disable_notification: true
+            }
+          )
         );
         break;
       }
       case "error": {
         await this.finalizeDraft(sessionId);
-        await this.bot.api.sendMessage(
-          this.telegramConfig.chatId,
-          `\u274C <b>Error:</b> ${escapeHtml(content.text)}`,
-          {
-            message_thread_id: threadId,
-            parse_mode: "HTML",
-            disable_notification: true
-          }
+        await this.sendQueue.enqueue(
+          () => this.bot.api.sendMessage(
+            this.telegramConfig.chatId,
+            `\u274C <b>Error:</b> ${escapeHtml(content.text)}`,
+            {
+              message_thread_id: threadId,
+              parse_mode: "HTML",
+              disable_notification: true
+            }
+          )
         );
         break;
       }
     }
   }
   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
     );
     if (!session) return;
-    await this.permissionHandler.sendPermissionRequest(session, request);
+    await this.sendQueue.enqueue(
+      () => this.permissionHandler.sendPermissionRequest(session, request)
+    );
   }
   async sendNotification(notification) {
-    log7.info(
+    log8.info(
       { sessionId: notification.sessionId, type: notification.type },
       "Notification sent"
     );
@@ -2267,14 +2738,16 @@ Workspace: <code>${workspace}</code>
 
 <a href="${notification.deepLink}">\u2192 Go to message</a>`;
     }
-    await this.bot.api.sendMessage(this.telegramConfig.chatId, text, {
-      message_thread_id: this.notificationTopicId,
-      parse_mode: "HTML",
-      disable_notification: false
-    });
+    await this.sendQueue.enqueue(
+      () => this.bot.api.sendMessage(this.telegramConfig.chatId, text, {
+        message_thread_id: this.notificationTopicId,
+        parse_mode: "HTML",
+        disable_notification: false
+      })
+    );
   }
   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)
     );
@@ -2319,15 +2792,17 @@ Workspace: <code>${workspace}</code>
       }
     }
     try {
-      const msg = await this.bot.api.sendMessage(
-        this.telegramConfig.chatId,
-        text,
-        {
-          message_thread_id: threadId,
-          parse_mode: "HTML",
-          reply_markup: keyboard,
-          disable_notification: true
-        }
+      const msg = await this.sendQueue.enqueue(
+        () => this.bot.api.sendMessage(
+          this.telegramConfig.chatId,
+          text,
+          {
+            message_thread_id: threadId,
+            parse_mode: "HTML",
+            reply_markup: keyboard,
+            disable_notification: true
+          }
+        )
       );
       this.skillMessages.set(sessionId, msg.message_id);
       await this.bot.api.pinChatMessage(
@@ -2338,7 +2813,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 +2844,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,9 +2857,29 @@ 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;
+    const finalMsgId = await draft.finalize();
+    this.sessionDrafts.delete(sessionId);
+    if (sessionId === this.assistantSession?.id) {
+      const fullText = this.sessionTextBuffers.get(sessionId);
+      this.sessionTextBuffers.delete(sessionId);
+      if (fullText && finalMsgId) {
+        const detected = detectAction(fullText);
+        if (detected) {
+          const actionId = storeAction(detected);
+          const keyboard = buildActionKeyboard(actionId, detected);
+          try {
+            await this.bot.api.editMessageReplyMarkup(
+              this.telegramConfig.chatId,
+              finalMsgId,
+              { reply_markup: keyboard }
+            );
+          } catch {
+          }
+        }
+      }
+    } else {
+      this.sessionTextBuffers.delete(sessionId);
     }
   }
 };
@@ -2400,6 +2895,7 @@ export {
   NotificationManager,
   OpenACPCore,
   ChannelAdapter,
+  ApiServer,
   TelegramAdapter
 };
-//# sourceMappingURL=chunk-EIBLQU3H.js.map
+//# sourceMappingURL=chunk-S5MPFOR3.js.map