@openacp/cli 2026.327.1 → 2026.327.2

package/dist/{chunk-FDLQ5M6W.js → chunk-LP45RCA4.js}

@@ -1,8 +1,13 @@
 import {
-  PRODUCT_GUIDE,
-  SendQueue,
-  ToolCallTracker
-} from "./chunk-5ZOFBTOR.js";
+  buildMenuKeyboard,
+  buildSkillMessages,
+  handleClear,
+  handleHelp,
+  handleMenu
+} from "./chunk-AFKX424Q.js";
+import {
+  DoctorEngine
+} from "./chunk-QAQDGPB4.js";
 import {
   BaseRenderer,
   MessagingAdapter,
@@ -15,17 +20,7 @@ import {
   splitMessage,
   stripCodeFences,
   truncateContent
-} from "./chunk-V2M243KZ.js";
-import {
-  buildMenuKeyboard,
-  buildSkillMessages,
-  handleClear,
-  handleHelp,
-  handleMenu
-} from "./chunk-AFKX424Q.js";
-import {
-  DoctorEngine
-} from "./chunk-L7YNNBI5.js";
+} from "./chunk-TRXBJEZ5.js";
 import {
   CheckpointReader,
   DEFAULT_MAX_TOKENS
@@ -1510,7 +1505,7 @@ Downloading... ${bar} ${percent}%`, { parse_mode: "HTML" });
     const { getAgentCapabilities } = await import("./agent-dependencies-WS7Z2DFW.js");
     const caps = getAgentCapabilities(result.agentKey);
     if (caps.integration) {
-      const { installIntegration } = await import("./integrate-APK4OEQF.js");
+      const { installIntegration } = await import("./integrate-G6CVXTGT.js");
       const intResult = await installIntegration(result.agentKey, caps.integration);
       if (intResult.success) {
         try {
@@ -1580,7 +1575,7 @@ function buildProgressBar(percent) {
 // src/plugins/telegram/commands/integrate.ts
 import { InlineKeyboard as InlineKeyboard5 } from "grammy";
 async function handleIntegrate(ctx, _core) {
-  const { listIntegrations } = await import("./integrate-APK4OEQF.js");
+  const { listIntegrations } = await import("./integrate-G6CVXTGT.js");
   const agents = listIntegrations();
   const keyboard = new InlineKeyboard5();
   for (const agent of agents) {
@@ -1613,7 +1608,7 @@ function setupIntegrateCallbacks(bot, core) {
     } catch {
     }
     if (data === "i:back") {
-      const { listIntegrations } = await import("./integrate-APK4OEQF.js");
+      const { listIntegrations } = await import("./integrate-G6CVXTGT.js");
       const agents = listIntegrations();
       const keyboard2 = new InlineKeyboard5();
       for (const agent of agents) {
@@ -1633,7 +1628,7 @@ Select an agent to manage its integrations.`,
     const agentMatch = data.match(/^i:agent:(.+)$/);
     if (agentMatch) {
       const agentName2 = agentMatch[1];
-      const { getIntegration: getIntegration2 } = await import("./integrate-APK4OEQF.js");
+      const { getIntegration: getIntegration2 } = await import("./integrate-G6CVXTGT.js");
       const integration2 = getIntegration2(agentName2);
       if (!integration2) {
         await ctx.reply(`\u274C No integration available for '${escapeHtml(agentName2)}'.`, { parse_mode: "HTML" });
@@ -1660,7 +1655,7 @@ ${integration2.items.map((i) => `\u2022 <b>${escapeHtml(i.name)}</b> \u2014 ${es
     const action = actionMatch[1];
     const agentName = actionMatch[2];
     const itemId = actionMatch[3];
-    const { getIntegration } = await import("./integrate-APK4OEQF.js");
+    const { getIntegration } = await import("./integrate-G6CVXTGT.js");
     const integration = getIntegration(agentName);
     if (!integration) return;
     const item = integration.items.find((i) => i.id === itemId);
@@ -2637,6 +2632,424 @@ ${escapeHtml(request.description)}`,
   }
 };
 
+// src/data/product-guide.ts
+var PRODUCT_GUIDE = `
+# OpenACP \u2014 Product Guide
+
+OpenACP lets you chat with AI coding agents (like Claude Code) through messaging platforms (Telegram, Discord).
+You type messages in your chat platform, the agent reads/writes/runs code in your project folder, and results stream back in real time.
+
+---
+
+## Quick Start
+
+1. Start OpenACP: \`openacp\` (or \`openacp start\` for background daemon)
+2. Open your messaging platform (Telegram group or Discord server) \u2014 you'll see the Assistant topic/thread
+3. Tap/click \u{1F195} New Session or type /new
+4. Pick an agent and a project folder
+5. Chat in the session topic/thread \u2014 the agent works on your code
+
+---
+
+## Core Concepts
+
+### Sessions
+A session = one conversation with one AI agent working in one project folder.
+Each session gets its own topic (Telegram) or forum thread (Discord). Chat there to give instructions to the agent.
+
+### Agents
+An agent is an AI coding tool (e.g., Claude Code, Gemini, Cursor, Codex, etc.).
+OpenACP supports 28+ agents from the official ACP Registry (agentclientprotocol.com).
+You can install multiple agents and choose which one to use per session.
+The default agent is used when you don't specify one.
+
+### Agent Management
+- Browse agents: \`/agents\` in your chat platform or \`openacp agents\` in CLI
+- Install: tap the install button in /agents, or \`openacp agents install <name>\`
+- Uninstall: \`openacp agents uninstall <name>\`
+- Setup/login: \`openacp agents run <name> -- <args>\` (e.g., \`openacp agents run gemini -- auth login\`)
+- Details: \`openacp agents info <name>\` shows version, dependencies, and setup steps
+
+Some agents need additional setup before they can be used:
+- Claude: requires \`claude login\`
+- Gemini: requires \`openacp agents run gemini -- auth login\`
+- Codex: requires setting \`OPENAI_API_KEY\` environment variable
+- GitHub Copilot: requires \`openacp agents run copilot -- auth login\`
+
+Agents are installed in three ways depending on the agent:
+- **npx** \u2014 Node.js agents, downloaded automatically on first use
+- **uvx** \u2014 Python agents, downloaded automatically on first use
+- **binary** \u2014 Platform-specific binaries, downloaded to \`~/.openacp/agents/\`
+
+### Project Folder (Workspace)
+The directory where the agent reads, writes, and runs code.
+When creating a session, you choose which folder the agent works in.
+You can type a full path like \`~/code/my-project\` or just a name like \`my-project\` (it becomes \`<base-dir>/my-project\`).
+
+### System Topics
+- **Assistant** \u2014 Always-on helper that can answer questions, create sessions, check status, troubleshoot
+- **Notifications** \u2014 System alerts (permission requests, session errors, completions)
+
+---
+
+## Creating Sessions
+
+### From menu
+Tap \u{1F195} New Session \u2192 choose agent (if multiple) \u2192 choose project folder \u2192 confirm
+
+### From command
+- \`/new\` \u2014 Interactive flow (asks agent + folder)
+- \`/new claude ~/code/my-project\` \u2014 Create directly with specific agent and folder
+
+### From Assistant topic
+Just ask: "Create a session for my-project with claude" \u2014 the assistant handles it
+
+### Quick new chat
+\`/newchat\` in a session topic \u2014 creates new session with same agent and folder as current one
+
+---
+
+## Working with Sessions
+
+### Chat
+Type messages in the session topic. The agent responds with code changes, explanations, tool outputs.
+
+### What you see while the agent works
+- **\u{1F4AD} Thinking indicator** \u2014 Shows when the agent is reasoning, with elapsed time
+- **Text responses** \u2014 Streamed in real time, updated every few seconds
+- **Tool calls** \u2014 When the agent runs commands or edits files, you see tool name, input, status, and output
+- **\u{1F4CB} Plan card** \u2014 Visual task progress with completed/in-progress/pending items and progress bar
+- **"View File" / "View Diff" buttons** \u2014 Opens in browser with Monaco editor (requires tunnel)
+
+### Session lifecycle
+1. **Creating** \u2014 Topic created, agent spawning
+2. **Warming up** \u2014 Agent primes its cache (happens automatically, invisible to you)
+3. **Active** \u2014 Ready for your messages
+4. **Auto-naming** \u2014 After your first message, the session gets a descriptive name (agent summarizes in ~5 words). The topic title updates automatically.
+5. **Finished/Error** \u2014 Session completed or hit an error
+
+### Agent skills
+Some agents provide slash commands (e.g., /compact, /review). Available skills are pinned in the session topic.
+
+### Permission requests
+When the agent wants to run a command, it asks for permission.
+You see buttons: \u2705 Allow, \u274C Reject (and sometimes "Always Allow").
+A notification also appears in the Notifications topic with a link to the request.
+
+### Dangerous mode
+Auto-approves ALL permission requests \u2014 the agent runs any command without asking.
+- Enable: \`/enable_dangerous\` or tap the \u2620\uFE0F button in the session
+- Disable: \`/disable_dangerous\` or tap the \u{1F510} button
+- \u26A0\uFE0F Use with caution \u2014 the agent can execute anything
+
+### Session timeout
+Idle sessions are automatically cancelled after a configurable timeout (default: 60 minutes).
+Configure via \`security.sessionTimeoutMinutes\` in config.
+
+---
+
+## Session Transfer (Handoff)
+
+### Chat \u2192 Terminal
+1. Type \`/handoff\` in a session topic/thread
+2. You get a command like \`claude --resume <SESSION_ID>\`
+3. Copy and run it in your terminal \u2014 the session continues there with full conversation history
+
+### Terminal \u2192 Chat
+1. First time: run \`openacp integrate claude\` to install the handoff skill (one-time setup)
+2. In Claude Code, use the /openacp:handoff slash command
+3. The session appears as a new topic/thread and you can continue chatting there
+
+### How it works
+- The agent session ID is shared between platforms
+- Conversation history is preserved \u2014 pick up where you left off
+- The agent that supports resume (e.g., Claude with \`--resume\`) handles the actual transfer
+
+---
+
+## Managing Sessions
+
+### Status
+- \`/status\` \u2014 Shows active sessions count and details
+- Ask the Assistant: "What sessions are running?"
+
+### List all sessions
+- \`/sessions\` \u2014 Shows all sessions with status (active, finished, error)
+
+### Cancel
+- \`/cancel\` in a session topic \u2014 cancels that session
+- Ask the Assistant: "Cancel the stuck session"
+
+### Cleanup
+- From \`/sessions\` \u2192 tap cleanup buttons (finished, errors, all)
+- Ask the Assistant: "Clean up old sessions"
+
+---
+
+## Assistant Topic
+
+The Assistant is an always-on AI helper in its own topic. It can:
+- Answer questions about OpenACP
+- Create sessions for you
+- Check status and health
+- Cancel sessions
+- Clean up old sessions
+- Troubleshoot issues
+- Manage configuration
+
+Just chat naturally: "How do I create a session?", "What's the status?", "Something is stuck"
+
+### Clear history
+\`/clear\` in the Assistant topic \u2014 resets the conversation
+
+---
+
+## System Commands
+
+| Command | Where | What it does |
+|---------|-------|-------------|
+| \`/new [agent] [path]\` | Anywhere | Create new session |
+| \`/newchat\` | Session topic | New session, same agent + folder |
+| \`/cancel\` | Session topic | Cancel current session |
+| \`/status\` | Anywhere | Show status |
+| \`/sessions\` | Anywhere | List all sessions |
+| \`/agents\` | Anywhere | Browse & install agents from ACP Registry |
+| \`/install <name>\` | Anywhere | Install an agent |
+| \`/enable_dangerous\` | Session topic | Auto-approve all permissions |
+| \`/disable_dangerous\` | Session topic | Restore permission prompts |
+| \`/handoff\` | Session topic | Transfer session to terminal |
+| \`/clear\` | Assistant topic | Clear assistant history |
+| \`/menu\` | Anywhere | Show action menu |
+| \`/help\` | Anywhere | Show help |
+| \`/restart\` | Anywhere | Restart OpenACP |
+| \`/update\` | Anywhere | Update to latest version |
+| \`/integrate\` | Anywhere | Manage agent integrations |
+
+---
+
+## Menu Buttons
+
+| Button | Action |
+|--------|--------|
+| \u{1F195} New Session | Create new session (interactive) |
+| \u{1F4CB} Sessions | List all sessions with cleanup options |
+| \u{1F4CA} Status | Show active/total session count |
+| \u{1F916} Agents | List available agents |
+| \u{1F517} Integrate | Manage agent integrations |
+| \u2753 Help | Show help text |
+| \u{1F504} Restart | Restart OpenACP |
+| \u2B06\uFE0F Update | Check and install updates |
+
+---
+
+## CLI Commands
+
+### Server
+- \`openacp\` \u2014 Start (uses configured mode: foreground or daemon)
+- \`openacp start\` \u2014 Start as background daemon
+- \`openacp stop\` \u2014 Stop daemon
+- \`openacp status\` \u2014 Show daemon status
+- \`openacp logs\` \u2014 Tail daemon logs
+- \`openacp --foreground\` \u2014 Force foreground mode (useful for debugging or containers)
+
+### Auto-start (run on boot)
+- macOS: installs a LaunchAgent in \`~/Library/LaunchAgents/\`
+- Linux: installs a systemd user service in \`~/.config/systemd/user/\`
+- Enabled automatically when you start the daemon. Remove with \`openacp stop\`.
+
+### Configuration
+- \`openacp config\` \u2014 Interactive config editor
+- \`openacp reset\` \u2014 Delete all data and start fresh
+
+### Agent Management (CLI)
+- \`openacp agents\` \u2014 List all agents (installed + available from ACP Registry)
+- \`openacp agents install <name>\` \u2014 Install an agent
+- \`openacp agents uninstall <name>\` \u2014 Remove an agent
+- \`openacp agents info <name>\` \u2014 Show details, dependencies, and setup guide
+- \`openacp agents run <name> [-- args]\` \u2014 Run agent CLI directly (for login, config, etc.)
+- \`openacp agents refresh\` \u2014 Force-refresh registry cache
+
+### Plugins
+- \`openacp install <package>\` \u2014 Install adapter plugin
+- \`openacp uninstall <package>\` \u2014 Remove adapter plugin
+- \`openacp plugins\` \u2014 List installed plugins
+
+### Integration
+- \`openacp integrate <agent>\` \u2014 Install agent integration (e.g., Claude handoff skill)
+- \`openacp integrate <agent> --uninstall\` \u2014 Remove integration
+
+### API (requires running daemon)
+\`openacp api <command>\` \u2014 Interact with running daemon:
+
+| Command | Description |
+|---------|-------------|
+| \`status\` | List active sessions |
+| \`session <id>\` | Session details |
+| \`new <agent> <path>\` | Create session |
+| \`send <id> "text"\` | Send prompt |
+| \`cancel <id>\` | Cancel session |
+| \`dangerous <id> on/off\` | Toggle dangerous mode |
+| \`topics [--status x,y]\` | List topics |
+| \`delete-topic <id> [--force]\` | Delete topic |
+| \`cleanup [--status x,y]\` | Cleanup old topics |
+| \`agents\` | List agents |
+| \`health\` | System health |
+| \`config\` | Show config |
+| \`config set <key> <value>\` | Update config |
+| \`adapters\` | List adapters |
+| \`tunnel\` | Tunnel status |
+| \`notify "message"\` | Send notification |
+| \`version\` | Daemon version |
+| \`restart\` | Restart daemon |
+
+---
+
+## File Viewer (Tunnel)
+
+When tunnel is enabled, file edits and diffs get "View" buttons that open in your browser:
+- **Monaco Editor** \u2014 Full VS Code editor with syntax highlighting
+- **Diff viewer** \u2014 Side-by-side or inline comparison
+- **Line highlighting** \u2014 Click lines to highlight
+- Dark/light theme toggle
+
+### Setup
+Enable in config: set \`tunnel.enabled\` to \`true\`.
+Providers: Cloudflare (default, free), ngrok, bore, Tailscale Funnel.
+
+### Port Tunneling
+
+Expose any local port (dev servers, APIs, etc.) to the internet:
+
+**CLI commands** (agent can call these directly):
+- \`openacp tunnel add <port> --label <name>\` \u2014 Create tunnel to a local port
+- \`openacp tunnel list\` \u2014 List active tunnels
+- \`openacp tunnel stop <port>\` \u2014 Stop a tunnel
+- \`openacp tunnel stop-all\` \u2014 Stop all user tunnels
+
+**Telegram commands**:
+- \`/tunnel <port> [label]\` \u2014 Create tunnel
+- \`/tunnels\` \u2014 List active tunnels
+- \`/tunnel stop <port>\` \u2014 Stop tunnel
+
+Example: after starting a dev server on port 3000, run \`openacp tunnel add 3000 --label my-app\` to get a public URL.
+
+---
+
+## Configuration
+
+Config file: \`~/.openacp/config.json\`
+
+### Channels
+- **channels.telegram.botToken** \u2014 Your Telegram bot token
+- **channels.telegram.chatId** \u2014 Your Telegram supergroup ID
+- **channels.discord.botToken** \u2014 Your Discord bot token
+- **channels.discord.guildId** \u2014 Your Discord server (guild) ID
+
+### Agents
+- **defaultAgent** \u2014 Which agent to use by default
+- Agents are managed via \`/agents\` (Telegram) or \`openacp agents\` (CLI)
+- Installed agents are stored in \`~/.openacp/agents.json\`
+- Agent list is fetched from the ACP Registry CDN and cached locally (24h)
+
+### Workspace
+- **workspace.baseDir** \u2014 Base directory for project folders (default: \`~/openacp-workspace\`)
+
+### Security
+- **security.allowedUserIds** \u2014 Restrict who can use the bot (empty = everyone)
+- **security.maxConcurrentSessions** \u2014 Max parallel sessions (default: 5)
+- **security.sessionTimeoutMinutes** \u2014 Auto-cancel idle sessions (default: 60)
+
+### Tunnel / File Viewer
+- **tunnel.enabled** \u2014 Enable file viewer tunnel
+- **tunnel.provider** \u2014 Tunnel provider: cloudflare (default, free), ngrok, bore, tailscale
+- **tunnel.port** \u2014 Local port for tunnel server (default: 3100)
+- **tunnel.auth.enabled** \u2014 Enable authentication for tunnel URLs
+- **tunnel.auth.token** \u2014 Auth token for tunnel access
+- **tunnel.storeTtlMinutes** \u2014 How long viewer links stay cached (default: 60)
+
+### Logging
+- **logging.level** \u2014 Log level: silent, debug, info, warn, error, fatal (default: info)
+- **logging.logDir** \u2014 Log directory (default: \`~/.openacp/logs\`)
+- **logging.maxFileSize** \u2014 Max log file size before rotation
+- **logging.maxFiles** \u2014 Max number of rotated log files
+- **logging.sessionLogRetentionDays** \u2014 Auto-delete old session logs (default: 30)
+
+### Data Retention
+- **sessionStore.ttlDays** \u2014 How long session records persist (default: 30). Old records are cleaned up automatically.
+
+### Environment variables
+Override config with env vars:
+- \`OPENACP_TELEGRAM_BOT_TOKEN\`
+- \`OPENACP_TELEGRAM_CHAT_ID\`
+- \`OPENACP_DISCORD_BOT_TOKEN\`
+- \`OPENACP_DISCORD_GUILD_ID\`
+- \`OPENACP_DEFAULT_AGENT\`
+- \`OPENACP_RUN_MODE\` \u2014 foreground or daemon
+- \`OPENACP_API_PORT\` \u2014 API server port (default: 21420)
+- \`OPENACP_TUNNEL_ENABLED\`
+- \`OPENACP_TUNNEL_PORT\`
+- \`OPENACP_TUNNEL_PROVIDER\`
+- \`OPENACP_LOG_LEVEL\`
+- \`OPENACP_LOG_DIR\`
+- \`OPENACP_DEBUG\` \u2014 Sets log level to debug
+
+---
+
+## Troubleshooting
+
+### Session stuck / not responding
+- Check status: ask Assistant "Is anything stuck?"
+- Cancel and create new: \`/cancel\` then \`/new\`
+- Check system health: Assistant can run health check
+
+### Agent not found
+- Check available agents: \`/agents\` or \`openacp agents\`
+- Install missing agent: \`openacp agents install <name>\`
+- Some agents need login first: \`openacp agents info <name>\` to see setup steps
+- Run agent CLI for setup: \`openacp agents run <name> -- <args>\`
+
+### Permission request not showing
+- Check Notifications topic for the alert
+- Try \`/enable_dangerous\` to auto-approve (if you trust the agent)
+
+### Session disappeared after restart
+- Sessions persist across restarts
+- Send a message in the old topic \u2014 it auto-resumes
+- If topic was deleted, the session record may still exist in status
+
+### Bot not responding at all
+- Check daemon: \`openacp status\`
+- Check logs: \`openacp logs\`
+- Restart: \`openacp start\` or \`/restart\`
+
+### Messages going to wrong topic
+- Each session is bound to a specific topic/thread
+- If you see messages appearing in the Assistant topic instead of the session topic, try creating a new session
+
+### Viewing logs
+- Session-specific logs: \`~/.openacp/logs/sessions/\`
+- System logs: \`openacp logs\` to tail live
+- Set \`OPENACP_DEBUG=true\` for verbose output
+
+---
+
+## Data & Storage
+
+All data is stored in \`~/.openacp/\`:
+- \`config.json\` \u2014 Configuration
+- \`agents.json\` \u2014 Installed agents (managed by AgentCatalog)
+- \`registry-cache.json\` \u2014 Cached ACP Registry data (refreshes every 24h)
+- \`agents/\` \u2014 Downloaded binary agents
+- \`sessions/\` \u2014 Session records and state
+- \`topics/\` \u2014 Topic-to-session mappings
+- \`logs/\` \u2014 System and session logs
+- \`plugins/\` \u2014 Installed adapter plugins
+- \`openacp.pid\` \u2014 Daemon PID file
+
+Session records auto-cleanup: 30 days (configurable via \`sessionStore.ttlDays\`).
+Session logs auto-cleanup: 30 days (configurable via \`logging.sessionLogRetentionDays\`).
+`;
+
 // src/plugins/telegram/assistant.ts
 var log9 = createChildLogger({ module: "telegram-assistant" });
 async function spawnAssistant(core, adapter, assistantTopicId) {
@@ -2720,7 +3133,7 @@ function buildAssistantSystemPrompt(ctx) {
 - Ask which agent to use (if multiple are installed). Show installed: ${agentNames}
 - Ask which project directory to use as workspace. Suggest \`${config.workspace.baseDir}\` as the base, but explain the user can provide any path.
 - Confirm before creating: show agent name + full workspace path.
-- Create via: \`openacp api new <agent> <workspace>\`
+- Create via: \`openacp api new <agent> <workspace> --channel telegram\`
 
 ### Browse & Install Agents
 - Guide users to /agents command to see all available agents (installed + from ACP Registry)
@@ -2782,7 +3195,7 @@ function buildAssistantSystemPrompt(ctx) {
 # Session management
 openacp api status                       # List active sessions
 openacp api session <id>                 # Session detail
-openacp api new <agent> <workspace>      # Create new session
+openacp api new <agent> <workspace> --channel telegram  # Create new session
 openacp api send <id> "prompt text"      # Send prompt to session
 openacp api cancel <id>                  # Cancel session
 openacp api dangerous <id> on|off        # Toggle dangerous mode
@@ -3136,6 +3549,104 @@ var ActivityTracker = class {
   }
 };
 
+// src/core/adapter-primitives/primitives/send-queue.ts
+var SendQueue = class {
+  constructor(config) {
+    this.config = config;
+  }
+  items = [];
+  processing = false;
+  lastExec = 0;
+  lastCategoryExec = /* @__PURE__ */ new Map();
+  get pending() {
+    return this.items.length;
+  }
+  enqueue(fn, opts) {
+    const type = opts?.type ?? "other";
+    const key = opts?.key;
+    const category = opts?.category;
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    promise.catch(() => {
+    });
+    if (type === "text" && key) {
+      const idx = this.items.findIndex(
+        (item) => item.type === "text" && item.key === key
+      );
+      if (idx !== -1) {
+        this.items[idx].resolve(void 0);
+        this.items[idx] = { fn, type, key, category, resolve, reject, promise };
+        this.scheduleProcess();
+        return promise;
+      }
+    }
+    this.items.push({ fn, type, key, category, resolve, reject, promise });
+    this.scheduleProcess();
+    return promise;
+  }
+  onRateLimited() {
+    this.config.onRateLimited?.();
+    const remaining = [];
+    for (const item of this.items) {
+      if (item.type === "text") {
+        item.resolve(void 0);
+      } else {
+        remaining.push(item);
+      }
+    }
+    this.items = remaining;
+  }
+  clear() {
+    for (const item of this.items) {
+      item.resolve(void 0);
+    }
+    this.items = [];
+  }
+  scheduleProcess() {
+    if (this.processing) return;
+    if (this.items.length === 0) return;
+    const item = this.items[0];
+    const interval = this.getInterval(item.category);
+    const lastExec = item.category ? this.lastCategoryExec.get(item.category) ?? 0 : this.lastExec;
+    const elapsed = Date.now() - lastExec;
+    const delay = Math.max(0, interval - elapsed);
+    this.processing = true;
+    setTimeout(() => void this.processNext(), delay);
+  }
+  getInterval(category) {
+    if (category && this.config.categoryIntervals?.[category] != null) {
+      return this.config.categoryIntervals[category];
+    }
+    return this.config.minInterval;
+  }
+  async processNext() {
+    const item = this.items.shift();
+    if (!item) {
+      this.processing = false;
+      return;
+    }
+    try {
+      const result = await item.fn();
+      item.resolve(result);
+    } catch (err) {
+      this.config.onError?.(err instanceof Error ? err : new Error(String(err)));
+      item.reject(err);
+    } finally {
+      const now = Date.now();
+      this.lastExec = now;
+      if (item.category) {
+        this.lastCategoryExec.set(item.category, now);
+      }
+      this.processing = false;
+      this.scheduleProcess();
+    }
+  }
+};
+
 // src/plugins/telegram/action-detect.ts
 import { nanoid as nanoid2 } from "nanoid";
 import { InlineKeyboard as InlineKeyboard11 } from "grammy";
@@ -3293,6 +3804,37 @@ function setupActionCallbacks(bot, core, chatId, getAssistantSessionId) {
   });
 }
 
+// src/core/adapter-primitives/primitives/tool-call-tracker.ts
+var ToolCallTracker = class {
+  sessions = /* @__PURE__ */ new Map();
+  track(sessionId, meta, messageId) {
+    if (!this.sessions.has(sessionId)) {
+      this.sessions.set(sessionId, /* @__PURE__ */ new Map());
+    }
+    this.sessions.get(sessionId).set(meta.id, { ...meta, messageId });
+  }
+  update(sessionId, toolId, status, patch) {
+    const tool = this.sessions.get(sessionId)?.get(toolId);
+    if (!tool) return null;
+    tool.status = status;
+    if (patch?.viewerLinks) tool.viewerLinks = patch.viewerLinks;
+    if (patch?.viewerFilePath) tool.viewerFilePath = patch.viewerFilePath;
+    if (patch?.name) tool.name = patch.name;
+    if (patch?.kind) tool.kind = patch.kind;
+    return tool;
+  }
+  getActive(sessionId) {
+    const session = this.sessions.get(sessionId);
+    return session ? [...session.values()] : [];
+  }
+  clear(sessionId) {
+    this.sessions.delete(sessionId);
+  }
+  clearAll() {
+    this.sessions.clear();
+  }
+};
+
 // src/plugins/telegram/tool-call-tracker.ts
 var log11 = createChildLogger({ module: "tool-call-tracker" });
 var TelegramToolCallTracker = class {
@@ -4836,6 +5378,9 @@ Task completed.
 };
 
 export {
+  PRODUCT_GUIDE,
+  SendQueue,
+  ToolCallTracker,
   TelegramAdapter
 };
-//# sourceMappingURL=chunk-FDLQ5M6W.js.map
+//# sourceMappingURL=chunk-LP45RCA4.js.map