@openacp/cli 0.2.24 → 0.2.26

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

@@ -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] };
+        }
       }
     }
   }
@@ -1588,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();
@@ -1626,34 +1633,48 @@ 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,
-          {
+        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),
-            {
+          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;
         }
@@ -1661,7 +1682,7 @@ var MessageDraft = class {
       }
     }
   }
-  async finalize(replyMarkup) {
+  async finalize() {
     if (this.flushTimer) {
       clearTimeout(this.flushTimer);
       this.flushTimer = void 0;
@@ -1673,38 +1694,25 @@ 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",
-              ...markup
-            }
-          );
+          await this.bot.api.editMessageText(this.chatId, this.messageId, chunk, {
+            parse_mode: "HTML"
+          });
         } else {
           const msg = await this.bot.api.sendMessage(this.chatId, chunk, {
             message_thread_id: this.threadId,
             parse_mode: "HTML",
-            disable_notification: true,
-            ...markup
+            disable_notification: true
           });
           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 {
       }
     }
@@ -1713,9 +1721,6 @@ var MessageDraft = class {
   getMessageId() {
     return this.messageId;
   }
-  getBuffer() {
-    return this.buffer;
-  }
 };
 
 // src/adapters/telegram/topics.ts
@@ -1753,10 +1758,10 @@ function buildDeepLink(chatId, messageId) {
 import { InlineKeyboard } from "grammy";
 import { nanoid as nanoid2 } from "nanoid";
 var log6 = createChildLogger({ module: "telegram-commands" });
-function setupCommands(bot, core, chatId) {
-  bot.command("new", (ctx) => handleNew(ctx, core, chatId));
+function setupCommands(bot, core, chatId, assistant) {
+  bot.command("new", (ctx) => handleNew(ctx, core, chatId, assistant));
   bot.command("new_chat", (ctx) => handleNewChat(ctx, core, chatId));
-  bot.command("cancel", (ctx) => handleCancel(ctx, core));
+  bot.command("cancel", (ctx) => handleCancel(ctx, core, assistant));
   bot.command("status", (ctx) => handleStatus(ctx, core));
   bot.command("agents", (ctx) => handleAgents(ctx, core));
   bot.command("help", (ctx) => handleHelp(ctx));
@@ -1801,12 +1806,21 @@ Choose an action:`, {
     reply_markup: buildMenuKeyboard()
   });
 }
-async function handleNew(ctx, core, chatId) {
+async function handleNew(ctx, core, chatId, assistant) {
   const rawMatch = ctx.match;
   const matchStr = typeof rawMatch === "string" ? rawMatch : "";
   const args = matchStr.split(" ").filter(Boolean);
   const agentName = args[0];
   const workspace = args[1];
+  const currentThreadId = ctx.message?.message_thread_id;
+  if (assistant && currentThreadId === assistant.topicId && (!agentName || !workspace)) {
+    const assistantSession = assistant.getSession();
+    if (assistantSession) {
+      const prompt = agentName ? `User wants to create a new session with agent "${agentName}" but didn't specify a workspace. Ask them which workspace to use.` : `User wants to create a new session. Ask them which agent and workspace to use.`;
+      await assistantSession.enqueuePrompt(prompt);
+      return;
+    }
+  }
   log6.info({ userId: ctx.from?.id, agentName }, "New session command");
   let threadId;
   try {
@@ -1900,9 +1914,18 @@ async function handleNewChat(ctx, core, chatId) {
     await ctx.reply(`\u274C ${escapeHtml(message)}`, { parse_mode: "HTML" });
   }
 }
-async function handleCancel(ctx, core) {
+async function handleCancel(ctx, core, assistant) {
   const threadId = ctx.message?.message_thread_id;
   if (!threadId) return;
+  if (assistant && threadId === assistant.topicId) {
+    const assistantSession = assistant.getSession();
+    if (assistantSession) {
+      await assistantSession.enqueuePrompt(
+        "User wants to cancel a session. Confirm which session to cancel."
+      );
+      return;
+    }
+  }
   const session = core.sessionManager.getSessionByThread(
     "telegram",
     String(threadId)
@@ -2190,6 +2213,39 @@ 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";
@@ -2354,6 +2410,7 @@ var TelegramAdapter = class extends ChannelAdapter {
   bot;
   telegramConfig;
   sessionDrafts = /* @__PURE__ */ new Map();
+  sessionTextBuffers = /* @__PURE__ */ new Map();
   toolCallMessages = /* @__PURE__ */ new Map();
   // sessionId → (toolCallId → state)
   permissionHandler;
@@ -2362,6 +2419,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;
@@ -2372,6 +2430,22 @@ var TelegramAdapter = class extends ChannelAdapter {
       const rootCause = err.error instanceof Error ? err.error : err;
       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") {
         const p = payload;
@@ -2423,7 +2497,11 @@ var TelegramAdapter = class extends ChannelAdapter {
     setupCommands(
       this.bot,
       this.core,
-      this.telegramConfig.chatId
+      this.telegramConfig.chatId,
+      {
+        topicId: this.assistantTopicId,
+        getSession: () => this.assistantSession
+      }
     );
     this.permissionHandler.setupCallbackHandler();
     this.setupRoutes();
@@ -2519,24 +2597,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());
@@ -2562,11 +2648,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 {
           }
@@ -2575,31 +2663,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.finalizeDraft(sessionId);
-        await this.bot.api.sendMessage(
-          this.telegramConfig.chatId,
-          formatUsage(
-            content.metadata
-          ),
-          {
-            message_thread_id: threadId,
-            parse_mode: "HTML",
-            disable_notification: true
-          }
+        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;
       }
@@ -2608,27 +2700,31 @@ 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;
       }
@@ -2640,7 +2736,9 @@ Workspace: <code>${workspace}</code>
       sessionId
     );
     if (!session) return;
-    await this.permissionHandler.sendPermissionRequest(session, request);
+    await this.sendQueue.enqueue(
+      () => this.permissionHandler.sendPermissionRequest(session, request)
+    );
   }
   async sendNotification(notification) {
     log8.info(
@@ -2662,11 +2760,13 @@ 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) {
     log8.info({ sessionId, name }, "Session topic created");
@@ -2714,15 +2814,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(
@@ -2778,19 +2880,29 @@ Workspace: <code>${workspace}</code>
   async finalizeDraft(sessionId) {
     const draft = this.sessionDrafts.get(sessionId);
     if (!draft) return;
-    let keyboard;
+    const finalMsgId = await draft.finalize();
+    this.sessionDrafts.delete(sessionId);
     if (sessionId === this.assistantSession?.id) {
-      const fullText = draft.getBuffer();
-      if (fullText) {
+      const fullText = this.sessionTextBuffers.get(sessionId);
+      this.sessionTextBuffers.delete(sessionId);
+      if (fullText && finalMsgId) {
         const detected = detectAction(fullText);
         if (detected) {
           const actionId = storeAction(detected);
-          keyboard = buildActionKeyboard(actionId, 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);
     }
-    await draft.finalize(keyboard);
-    this.sessionDrafts.delete(sessionId);
   }
 };
 
@@ -2808,4 +2920,4 @@ export {
   ApiServer,
   TelegramAdapter
 };
-//# sourceMappingURL=chunk-IX63F4JG.js.map
+//# sourceMappingURL=chunk-HHQW27DT.js.map