@openacp/cli 0.2.4 → 0.2.11

package/dist/chunk-I6KXISAR.js

@@ -0,0 +1,1481 @@
+import {
+  log
+} from "./chunk-KADEDKIM.js";
+
+// src/core/streams.ts
+function nodeToWebWritable(nodeStream) {
+  return new WritableStream({
+    write(chunk) {
+      return new Promise((resolve, reject) => {
+        nodeStream.write(Buffer.from(chunk), (err) => {
+          if (err) reject(err);
+          else resolve();
+        });
+      });
+    }
+  });
+}
+function nodeToWebReadable(nodeStream) {
+  return new ReadableStream({
+    start(controller) {
+      nodeStream.on("data", (chunk) => {
+        controller.enqueue(new Uint8Array(chunk));
+      });
+      nodeStream.on("end", () => controller.close());
+      nodeStream.on("error", (err) => controller.error(err));
+    }
+  });
+}
+
+// src/core/stderr-capture.ts
+var StderrCapture = class {
+  constructor(maxLines = 50) {
+    this.maxLines = maxLines;
+  }
+  lines = [];
+  append(chunk) {
+    this.lines.push(...chunk.split("\n").filter(Boolean));
+    if (this.lines.length > this.maxLines) {
+      this.lines = this.lines.slice(-this.maxLines);
+    }
+  }
+  getLastLines() {
+    return this.lines.join("\n");
+  }
+};
+
+// src/core/agent-instance.ts
+import { spawn, execSync } from "child_process";
+import fs from "fs";
+import path from "path";
+import { randomUUID } from "crypto";
+import { ClientSideConnection, ndJsonStream } from "@agentclientprotocol/sdk";
+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] };
+      }
+    }
+  }
+  try {
+    const fullPath = execSync(`which ${cmd}`, { encoding: "utf-8" }).trim();
+    if (fullPath) {
+      const content = fs.readFileSync(fullPath, "utf-8");
+      if (content.startsWith("#!/usr/bin/env node")) {
+        return { command: process.execPath, args: [fullPath] };
+      }
+    }
+  } catch {
+  }
+  return { command: cmd, args: [] };
+}
+var AgentInstance = class _AgentInstance {
+  connection;
+  child;
+  stderrCapture;
+  terminals = /* @__PURE__ */ new Map();
+  sessionId;
+  agentName;
+  // Callbacks — set by core when wiring events
+  onSessionUpdate = () => {
+  };
+  onPermissionRequest = async () => "";
+  constructor(agentName) {
+    this.agentName = agentName;
+  }
+  static async spawn(agentDef, workingDirectory) {
+    const instance = new _AgentInstance(agentDef.name);
+    const resolved = resolveAgentCommand(agentDef.command);
+    log.debug(`Spawning agent "${agentDef.name}" \u2192 ${resolved.command} ${resolved.args.join(" ")}`);
+    instance.child = spawn(resolved.command, [...resolved.args, ...agentDef.args], {
+      stdio: ["pipe", "pipe", "pipe"],
+      cwd: workingDirectory,
+      env: { ...process.env, ...agentDef.env }
+    });
+    await new Promise((resolve, reject) => {
+      instance.child.on("error", (err) => {
+        reject(new Error(`Failed to spawn agent "${agentDef.name}": ${err.message}. Is "${agentDef.command}" installed?`));
+      });
+      instance.child.on("spawn", () => resolve());
+    });
+    instance.stderrCapture = new StderrCapture(50);
+    instance.child.stderr.on("data", (chunk) => {
+      instance.stderrCapture.append(chunk.toString());
+    });
+    const toAgent = nodeToWebWritable(instance.child.stdin);
+    const fromAgent = nodeToWebReadable(instance.child.stdout);
+    const stream = ndJsonStream(toAgent, fromAgent);
+    instance.connection = new ClientSideConnection(
+      (_agent) => instance.createClient(_agent),
+      stream
+    );
+    await instance.connection.initialize({
+      protocolVersion: 1,
+      clientCapabilities: {
+        fs: { readTextFile: true, writeTextFile: true },
+        terminal: true
+      }
+    });
+    const response = await instance.connection.newSession({
+      cwd: workingDirectory,
+      mcpServers: []
+    });
+    instance.sessionId = response.sessionId;
+    instance.child.on("exit", (code, signal) => {
+      if (code !== 0 && code !== null) {
+        const stderr = instance.stderrCapture.getLastLines();
+        instance.onSessionUpdate({
+          type: "error",
+          message: `Agent crashed (exit code ${code})
+${stderr}`
+        });
+      }
+    });
+    instance.connection.closed.then(() => {
+      log.debug("ACP connection closed for", instance.agentName);
+    });
+    log.info(`Agent "${agentDef.name}" spawned with session ${response.sessionId}`);
+    return instance;
+  }
+  // createClient — implemented in Task 6b
+  createClient(_agent) {
+    const self = this;
+    const MAX_OUTPUT_BYTES = 1024 * 1024;
+    return {
+      // ── Session updates ──────────────────────────────────────────────────
+      async sessionUpdate(params) {
+        const update = params.update;
+        let event = null;
+        switch (update.sessionUpdate) {
+          case "agent_message_chunk":
+            if (update.content.type === "text") {
+              event = { type: "text", content: update.content.text };
+            }
+            break;
+          case "agent_thought_chunk":
+            if (update.content.type === "text") {
+              event = { type: "thought", content: update.content.text };
+            }
+            break;
+          case "tool_call":
+            event = {
+              type: "tool_call",
+              id: update.toolCallId,
+              name: update.title,
+              kind: update.kind ?? void 0,
+              status: update.status ?? "pending",
+              content: update.content ?? void 0
+            };
+            break;
+          case "tool_call_update":
+            event = {
+              type: "tool_update",
+              id: update.toolCallId,
+              status: update.status ?? "pending",
+              content: update.content ?? void 0
+            };
+            break;
+          case "plan":
+            event = { type: "plan", entries: update.entries };
+            break;
+          case "usage_update":
+            event = {
+              type: "usage",
+              tokensUsed: update.used,
+              contextSize: update.size,
+              cost: update.cost ?? void 0
+            };
+            break;
+          case "available_commands_update":
+            event = { type: "commands_update", commands: update.availableCommands };
+            break;
+          default:
+            return;
+        }
+        if (event !== null) {
+          self.onSessionUpdate(event);
+        }
+      },
+      // ── Permission requests ──────────────────────────────────────────────
+      async requestPermission(params) {
+        const permissionRequest = {
+          id: params.toolCall.toolCallId,
+          description: params.toolCall.title ?? params.toolCall.toolCallId,
+          options: params.options.map((opt) => ({
+            id: opt.optionId,
+            label: opt.name,
+            isAllow: opt.kind === "allow_once" || opt.kind === "allow_always"
+          }))
+        };
+        const selectedOptionId = await self.onPermissionRequest(permissionRequest);
+        return {
+          outcome: { outcome: "selected", optionId: selectedOptionId }
+        };
+      },
+      // ── File operations ──────────────────────────────────────────────────
+      async readTextFile(params) {
+        const content = await fs.promises.readFile(params.path, "utf-8");
+        return { content };
+      },
+      async writeTextFile(params) {
+        await fs.promises.mkdir(path.dirname(params.path), { recursive: true });
+        await fs.promises.writeFile(params.path, params.content, "utf-8");
+        return {};
+      },
+      // ── Terminal operations ──────────────────────────────────────────────
+      async createTerminal(params) {
+        const terminalId = randomUUID();
+        const args = params.args ?? [];
+        const env = {};
+        for (const ev of params.env ?? []) {
+          env[ev.name] = ev.value;
+        }
+        const childProcess = spawn(params.command, args, {
+          cwd: params.cwd ?? void 0,
+          env: { ...process.env, ...env },
+          shell: false
+        });
+        const state = {
+          process: childProcess,
+          output: "",
+          exitStatus: null
+        };
+        self.terminals.set(terminalId, state);
+        const outputByteLimit = params.outputByteLimit ?? MAX_OUTPUT_BYTES;
+        const appendOutput = (chunk) => {
+          state.output += chunk;
+          const bytes = Buffer.byteLength(state.output, "utf-8");
+          if (bytes > outputByteLimit) {
+            const excess = bytes - outputByteLimit;
+            state.output = state.output.slice(excess);
+          }
+        };
+        childProcess.stdout?.on("data", (chunk) => appendOutput(chunk.toString()));
+        childProcess.stderr?.on("data", (chunk) => appendOutput(chunk.toString()));
+        childProcess.on("exit", (code, signal) => {
+          state.exitStatus = { exitCode: code, signal };
+        });
+        return { terminalId };
+      },
+      async terminalOutput(params) {
+        const state = self.terminals.get(params.terminalId);
+        if (!state) {
+          throw new Error(`Terminal not found: ${params.terminalId}`);
+        }
+        return {
+          output: state.output,
+          truncated: false,
+          exitStatus: state.exitStatus ? { exitCode: state.exitStatus.exitCode, signal: state.exitStatus.signal } : void 0
+        };
+      },
+      async waitForTerminalExit(params) {
+        const state = self.terminals.get(params.terminalId);
+        if (!state) {
+          throw new Error(`Terminal not found: ${params.terminalId}`);
+        }
+        if (state.exitStatus !== null) {
+          return { exitCode: state.exitStatus.exitCode, signal: state.exitStatus.signal };
+        }
+        return new Promise((resolve) => {
+          state.process.on("exit", (code, signal) => {
+            resolve({ exitCode: code, signal });
+          });
+        });
+      },
+      async killTerminal(params) {
+        const state = self.terminals.get(params.terminalId);
+        if (!state) {
+          throw new Error(`Terminal not found: ${params.terminalId}`);
+        }
+        state.process.kill("SIGTERM");
+        return {};
+      },
+      async releaseTerminal(params) {
+        const state = self.terminals.get(params.terminalId);
+        if (!state) {
+          return;
+        }
+        state.process.kill("SIGKILL");
+        self.terminals.delete(params.terminalId);
+      }
+    };
+  }
+  async prompt(text) {
+    return this.connection.prompt({
+      sessionId: this.sessionId,
+      prompt: [{ type: "text", text }]
+    });
+  }
+  async cancel() {
+    await this.connection.cancel({ sessionId: this.sessionId });
+  }
+  async destroy() {
+    for (const [, t] of this.terminals) {
+      t.process.kill("SIGKILL");
+    }
+    this.terminals.clear();
+    this.child.kill("SIGTERM");
+    setTimeout(() => {
+      if (!this.child.killed) this.child.kill("SIGKILL");
+    }, 1e4);
+  }
+};
+
+// src/core/agent-manager.ts
+var AgentManager = class {
+  constructor(config) {
+    this.config = config;
+  }
+  getAvailableAgents() {
+    return Object.entries(this.config.agents).map(([name, cfg]) => ({
+      name,
+      command: cfg.command,
+      args: cfg.args,
+      workingDirectory: cfg.workingDirectory,
+      env: cfg.env
+    }));
+  }
+  getAgent(name) {
+    const cfg = this.config.agents[name];
+    if (!cfg) return void 0;
+    return { name, ...cfg };
+  }
+  async spawn(agentName, workingDirectory) {
+    const agentDef = this.getAgent(agentName);
+    if (!agentDef) throw new Error(`Agent "${agentName}" not found in config`);
+    return AgentInstance.spawn(agentDef, workingDirectory);
+  }
+};
+
+// src/core/session.ts
+import { nanoid } from "nanoid";
+var Session = class {
+  id;
+  channelId;
+  threadId = "";
+  agentName;
+  workingDirectory;
+  agentInstance;
+  status = "initializing";
+  name;
+  promptQueue = [];
+  promptRunning = false;
+  createdAt = /* @__PURE__ */ new Date();
+  adapter;
+  // Set by wireSessionEvents for renaming
+  pendingPermission;
+  constructor(opts) {
+    this.id = opts.id || nanoid(12);
+    this.channelId = opts.channelId;
+    this.agentName = opts.agentName;
+    this.workingDirectory = opts.workingDirectory;
+    this.agentInstance = opts.agentInstance;
+  }
+  async enqueuePrompt(text) {
+    if (this.promptRunning) {
+      this.promptQueue.push(text);
+      log.debug(`Prompt queued for session ${this.id} (${this.promptQueue.length} in queue)`);
+      return;
+    }
+    await this.runPrompt(text);
+  }
+  async runPrompt(text) {
+    this.promptRunning = true;
+    this.status = "active";
+    try {
+      await this.agentInstance.prompt(text);
+      if (!this.name) {
+        await this.autoName();
+      }
+    } catch (err) {
+      this.status = "error";
+      log.error(`Prompt failed for session ${this.id}:`, err);
+    } finally {
+      this.promptRunning = false;
+      if (this.promptQueue.length > 0) {
+        const next = this.promptQueue.shift();
+        await this.runPrompt(next);
+      }
+    }
+  }
+  // NOTE: This injects a summary prompt into the agent's conversation history.
+  // Known Phase 1 limitation — the agent sees this prompt in its context.
+  async autoName() {
+    let title = "";
+    const prevHandler = this.agentInstance.onSessionUpdate;
+    this.agentInstance.onSessionUpdate = (event) => {
+      if (event.type === "text") title += event.content;
+    };
+    try {
+      await this.agentInstance.prompt(
+        "Summarize this conversation in max 5 words for a topic title. Reply ONLY with the title, nothing else."
+      );
+      this.name = title.trim().slice(0, 50);
+      if (this.adapter && this.name) {
+        await this.adapter.renameSessionThread(this.id, this.name);
+      }
+    } catch {
+      this.name = `Session ${this.id.slice(0, 6)}`;
+    } finally {
+      this.agentInstance.onSessionUpdate = prevHandler;
+    }
+  }
+  async cancel() {
+    this.status = "cancelled";
+    await this.agentInstance.cancel();
+  }
+  async destroy() {
+    await this.agentInstance.destroy();
+  }
+};
+
+// src/core/session-manager.ts
+var SessionManager = class {
+  sessions = /* @__PURE__ */ new Map();
+  async createSession(channelId, agentName, workingDirectory, agentManager) {
+    const agentInstance = await agentManager.spawn(agentName, workingDirectory);
+    const session = new Session({ channelId, agentName, workingDirectory, agentInstance });
+    this.sessions.set(session.id, session);
+    return session;
+  }
+  getSession(sessionId) {
+    return this.sessions.get(sessionId);
+  }
+  getSessionByThread(channelId, threadId) {
+    for (const session of this.sessions.values()) {
+      if (session.channelId === channelId && session.threadId === threadId) {
+        return session;
+      }
+    }
+    return void 0;
+  }
+  async cancelSession(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (session) await session.cancel();
+  }
+  listSessions(channelId) {
+    const all = Array.from(this.sessions.values());
+    if (channelId) return all.filter((s) => s.channelId === channelId);
+    return all;
+  }
+  async destroyAll() {
+    for (const session of this.sessions.values()) {
+      await session.destroy();
+    }
+    this.sessions.clear();
+  }
+};
+
+// src/core/notification.ts
+var NotificationManager = class {
+  constructor(adapters) {
+    this.adapters = adapters;
+  }
+  async notify(channelId, notification) {
+    const adapter = this.adapters.get(channelId);
+    if (adapter) {
+      await adapter.sendNotification(notification);
+    }
+  }
+  async notifyAll(notification) {
+    for (const adapter of this.adapters.values()) {
+      await adapter.sendNotification(notification);
+    }
+  }
+};
+
+// src/core/core.ts
+var OpenACPCore = class {
+  configManager;
+  agentManager;
+  sessionManager;
+  notificationManager;
+  adapters = /* @__PURE__ */ new Map();
+  constructor(configManager) {
+    this.configManager = configManager;
+    const config = configManager.get();
+    this.agentManager = new AgentManager(config);
+    this.sessionManager = new SessionManager();
+    this.notificationManager = new NotificationManager(this.adapters);
+  }
+  registerAdapter(name, adapter) {
+    this.adapters.set(name, adapter);
+  }
+  async start() {
+    for (const adapter of this.adapters.values()) {
+      await adapter.start();
+    }
+  }
+  async stop() {
+    try {
+      await this.notificationManager.notifyAll({
+        sessionId: "system",
+        type: "error",
+        summary: "OpenACP is shutting down"
+      });
+    } catch {
+    }
+    await this.sessionManager.destroyAll();
+    for (const adapter of this.adapters.values()) {
+      await adapter.stop();
+    }
+  }
+  // --- Message Routing ---
+  async handleMessage(message) {
+    const config = this.configManager.get();
+    if (config.security.allowedUserIds.length > 0) {
+      if (!config.security.allowedUserIds.includes(message.userId)) return;
+    }
+    const activeSessions = this.sessionManager.listSessions().filter((s) => s.status === "active" || s.status === "initializing");
+    if (activeSessions.length >= config.security.maxConcurrentSessions) {
+      const adapter = this.adapters.get(message.channelId);
+      if (adapter) {
+        await adapter.sendMessage("system", {
+          type: "error",
+          text: `Max concurrent sessions (${config.security.maxConcurrentSessions}) reached. Cancel a session first.`
+        });
+      }
+      return;
+    }
+    const session = this.sessionManager.getSessionByThread(message.channelId, message.threadId);
+    if (!session) return;
+    await session.enqueuePrompt(message.text);
+  }
+  async handleNewSession(channelId, agentName, workspacePath) {
+    const config = this.configManager.get();
+    const resolvedAgent = agentName || config.defaultAgent;
+    const resolvedWorkspace = this.configManager.resolveWorkspace(
+      workspacePath || config.agents[resolvedAgent]?.workingDirectory
+    );
+    const session = await this.sessionManager.createSession(
+      channelId,
+      resolvedAgent,
+      resolvedWorkspace,
+      this.agentManager
+    );
+    const adapter = this.adapters.get(channelId);
+    if (adapter) {
+      this.wireSessionEvents(session, adapter);
+    }
+    return session;
+  }
+  async handleNewChat(channelId, currentThreadId) {
+    const currentSession = this.sessionManager.getSessionByThread(channelId, currentThreadId);
+    if (!currentSession) return null;
+    return this.handleNewSession(
+      channelId,
+      currentSession.agentName,
+      currentSession.workingDirectory
+    );
+  }
+  // --- Event Wiring ---
+  toOutgoingMessage(event) {
+    switch (event.type) {
+      case "text":
+        return { type: "text", text: event.content };
+      case "thought":
+        return { type: "thought", text: event.content };
+      case "tool_call":
+        return { type: "tool_call", text: event.name, metadata: { id: event.id, kind: event.kind, status: event.status, content: event.content, locations: event.locations } };
+      case "tool_update":
+        return { type: "tool_update", text: "", metadata: { id: event.id, status: event.status, content: event.content } };
+      case "plan":
+        return { type: "plan", text: "", metadata: { entries: event.entries } };
+      case "usage":
+        return { type: "usage", text: "", metadata: { tokensUsed: event.tokensUsed, contextSize: event.contextSize, cost: event.cost } };
+      case "commands_update":
+        log.debug("Commands update:", event.commands);
+        return { type: "text", text: "" };
+      // no-op for now
+      default:
+        return { type: "text", text: "" };
+    }
+  }
+  // Public — adapters call this for assistant session wiring
+  wireSessionEvents(session, adapter) {
+    session.adapter = adapter;
+    session.agentInstance.onSessionUpdate = (event) => {
+      switch (event.type) {
+        case "text":
+        case "thought":
+        case "tool_call":
+        case "tool_update":
+        case "plan":
+        case "usage":
+          adapter.sendMessage(session.id, this.toOutgoingMessage(event));
+          break;
+        case "session_end":
+          session.status = "finished";
+          adapter.sendMessage(session.id, { type: "session_end", text: `Done (${event.reason})` });
+          this.notificationManager.notify(session.channelId, {
+            sessionId: session.id,
+            sessionName: session.name,
+            type: "completed",
+            summary: `Session "${session.name || session.id}" completed`
+          });
+          break;
+        case "error":
+          adapter.sendMessage(session.id, { type: "error", text: event.message });
+          this.notificationManager.notify(session.channelId, {
+            sessionId: session.id,
+            sessionName: session.name,
+            type: "error",
+            summary: event.message
+          });
+          break;
+        case "commands_update":
+          log.debug("Commands available:", event.commands);
+          break;
+      }
+    };
+    session.agentInstance.onPermissionRequest = async (request) => {
+      const promise = new Promise((resolve) => {
+        session.pendingPermission = { requestId: request.id, resolve };
+      });
+      await adapter.sendPermissionRequest(session.id, request);
+      return promise;
+    };
+  }
+};
+
+// src/core/channel.ts
+var ChannelAdapter = class {
+  constructor(core, config) {
+    this.core = core;
+    this.config = config;
+  }
+};
+
+// src/adapters/telegram/adapter.ts
+import { Bot } from "grammy";
+
+// src/adapters/telegram/formatting.ts
+function escapeHtml(text) {
+  if (!text) return "";
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function markdownToTelegramHtml(md) {
+  const codeBlocks = [];
+  const inlineCodes = [];
+  let text = md.replace(/```(\w*)\n?([\s\S]*?)```/g, (_match, lang, code) => {
+    const index = codeBlocks.length;
+    const escapedCode = escapeHtml(code);
+    const langAttr = lang ? ` class="language-${escapeHtml(lang)}"` : "";
+    codeBlocks.push(`<pre><code${langAttr}>${escapedCode}</code></pre>`);
+    return `\0CODE_BLOCK_${index}\0`;
+  });
+  text = text.replace(/`([^`]+)`/g, (_match, code) => {
+    const index = inlineCodes.length;
+    inlineCodes.push(`<code>${escapeHtml(code)}</code>`);
+    return `\0INLINE_CODE_${index}\0`;
+  });
+  text = escapeHtml(text);
+  text = text.replace(/\*\*(.+?)\*\*/g, "<b>$1</b>");
+  text = text.replace(/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g, "<i>$1</i>");
+  text = text.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>');
+  text = text.replace(/\x00CODE_BLOCK_(\d+)\x00/g, (_match, idx) => {
+    return codeBlocks[parseInt(idx, 10)];
+  });
+  text = text.replace(/\x00INLINE_CODE_(\d+)\x00/g, (_match, idx) => {
+    return inlineCodes[parseInt(idx, 10)];
+  });
+  return text;
+}
+var STATUS_ICON = {
+  pending: "\u23F3",
+  in_progress: "\u{1F504}",
+  completed: "\u2705",
+  failed: "\u274C"
+};
+var KIND_ICON = {
+  read: "\u{1F4D6}",
+  edit: "\u270F\uFE0F",
+  delete: "\u{1F5D1}\uFE0F",
+  execute: "\u25B6\uFE0F",
+  search: "\u{1F50D}",
+  fetch: "\u{1F310}",
+  think: "\u{1F9E0}",
+  move: "\u{1F4E6}",
+  other: "\u{1F6E0}\uFE0F"
+};
+function extractContentText(content) {
+  if (!content) return "";
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((c) => extractContentText(c)).filter(Boolean).join("\n");
+  }
+  if (typeof content === "object" && content !== null) {
+    const c = content;
+    if (c.type === "text" && typeof c.text === "string") return c.text;
+    if (typeof c.text === "string") return c.text;
+    if (typeof c.content === "string") return c.content;
+    if (c.input) return extractContentText(c.input);
+    if (c.output) return extractContentText(c.output);
+    const keys = Object.keys(c).filter((k) => k !== "type");
+    if (keys.length === 0) return "";
+    return JSON.stringify(c, null, 2);
+  }
+  return String(content);
+}
+function truncateContent(text, maxLen = 3800) {
+  if (text.length <= maxLen) return text;
+  return text.slice(0, maxLen) + "\n\u2026 (truncated)";
+}
+function formatToolCall(tool) {
+  const si = STATUS_ICON[tool.status || ""] || "\u{1F527}";
+  const ki = KIND_ICON[tool.kind || ""] || "\u{1F6E0}\uFE0F";
+  let text = `${si} ${ki} <b>${escapeHtml(tool.name || "Tool")}</b>`;
+  const details = extractContentText(tool.content);
+  if (details) {
+    text += `
+<pre>${escapeHtml(truncateContent(details))}</pre>`;
+  }
+  return text;
+}
+function formatToolUpdate(update) {
+  const si = STATUS_ICON[update.status] || "\u{1F527}";
+  const ki = KIND_ICON[update.kind || ""] || "\u{1F6E0}\uFE0F";
+  const name = update.name || "Tool";
+  let text = `${si} ${ki} <b>${escapeHtml(name)}</b>`;
+  const details = extractContentText(update.content);
+  if (details) {
+    text += `
+<pre>${escapeHtml(truncateContent(details))}</pre>`;
+  }
+  return text;
+}
+function formatPlan(plan) {
+  const statusIcon = { pending: "\u2B1C", in_progress: "\u{1F504}", completed: "\u2705" };
+  const lines = plan.entries.map(
+    (e, i) => `${statusIcon[e.status] || "\u2B1C"} ${i + 1}. ${escapeHtml(e.content)}`
+  );
+  return `<b>Plan:</b>
+${lines.join("\n")}`;
+}
+function formatUsage(usage) {
+  const parts = [];
+  if (usage.tokensUsed != null) parts.push(`Tokens: ${usage.tokensUsed.toLocaleString()}`);
+  if (usage.contextSize != null) parts.push(`Context: ${usage.contextSize.toLocaleString()}`);
+  if (usage.cost) parts.push(`Cost: $${usage.cost.amount.toFixed(4)}`);
+  return `\u{1F4CA} ${parts.join(" | ")}`;
+}
+function splitMessage(text, maxLength = 4096) {
+  if (text.length <= maxLength) return [text];
+  const chunks = [];
+  let remaining = text;
+  while (remaining.length > 0) {
+    if (remaining.length <= maxLength) {
+      chunks.push(remaining);
+      break;
+    }
+    let splitAt = remaining.lastIndexOf("\n\n", maxLength);
+    if (splitAt === -1 || splitAt < maxLength * 0.5) {
+      splitAt = remaining.lastIndexOf("\n", maxLength);
+    }
+    if (splitAt === -1 || splitAt < maxLength * 0.5) {
+      splitAt = maxLength;
+    }
+    chunks.push(remaining.slice(0, splitAt));
+    remaining = remaining.slice(splitAt).trimStart();
+  }
+  return chunks;
+}
+
+// src/adapters/telegram/streaming.ts
+var MessageDraft = class {
+  // 1 second throttle
+  constructor(bot, chatId, threadId) {
+    this.bot = bot;
+    this.chatId = chatId;
+    this.threadId = threadId;
+  }
+  messageId;
+  buffer = "";
+  lastFlush = 0;
+  flushTimer;
+  flushPromise = Promise.resolve();
+  // serialize flushes
+  minInterval = 1e3;
+  append(text) {
+    this.buffer += text;
+    this.scheduleFlush();
+  }
+  scheduleFlush() {
+    const now = Date.now();
+    const elapsed = now - this.lastFlush;
+    if (elapsed >= this.minInterval) {
+      this.flushPromise = this.flushPromise.then(() => this.flush()).catch(() => {
+      });
+    } else if (!this.flushTimer) {
+      this.flushTimer = setTimeout(() => {
+        this.flushTimer = void 0;
+        this.flushPromise = this.flushPromise.then(() => this.flush()).catch(() => {
+        });
+      }, this.minInterval - elapsed);
+    }
+  }
+  async flush() {
+    if (!this.buffer) return;
+    this.lastFlush = Date.now();
+    const html = markdownToTelegramHtml(this.buffer);
+    const truncated = html.length > 4096 ? html.slice(0, 4090) + "\n..." : html;
+    if (!truncated) return;
+    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
+        });
+        this.messageId = msg.message_id;
+      } else {
+        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
+          });
+          this.messageId = msg.message_id;
+        }
+      } catch {
+      }
+    }
+  }
+  async finalize() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = void 0;
+    }
+    await this.flushPromise;
+    if (!this.buffer) return this.messageId;
+    const html = markdownToTelegramHtml(this.buffer);
+    const chunks = splitMessage(html);
+    try {
+      for (let i = 0; i < chunks.length; i++) {
+        const chunk = chunks[i];
+        if (i === 0 && this.messageId) {
+          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
+          });
+          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
+        });
+      } catch {
+      }
+    }
+    return this.messageId;
+  }
+  getMessageId() {
+    return this.messageId;
+  }
+};
+
+// src/adapters/telegram/topics.ts
+async function ensureTopics(bot, chatId, config, saveConfig) {
+  let notificationTopicId = config.notificationTopicId;
+  let assistantTopicId = config.assistantTopicId;
+  if (notificationTopicId === null) {
+    const topic = await bot.api.createForumTopic(chatId, "\u{1F4CB} Notifications");
+    notificationTopicId = topic.message_thread_id;
+    await saveConfig({ notificationTopicId });
+  }
+  if (assistantTopicId === null) {
+    const topic = await bot.api.createForumTopic(chatId, "\u{1F916} Assistant");
+    assistantTopicId = topic.message_thread_id;
+    await saveConfig({ assistantTopicId });
+  }
+  return { notificationTopicId, assistantTopicId };
+}
+async function createSessionTopic(bot, chatId, name) {
+  const topic = await bot.api.createForumTopic(chatId, name);
+  return topic.message_thread_id;
+}
+async function renameSessionTopic(bot, chatId, threadId, name) {
+  try {
+    await bot.api.editForumTopic(chatId, threadId, { name });
+  } catch {
+  }
+}
+function buildDeepLink(chatId, messageId) {
+  const cleanId = String(chatId).replace("-100", "");
+  return `https://t.me/c/${cleanId}/${messageId}`;
+}
+
+// src/adapters/telegram/commands.ts
+import { InlineKeyboard } from "grammy";
+function setupCommands(bot, core, chatId) {
+  bot.command("new", (ctx) => handleNew(ctx, core, chatId));
+  bot.command("new_chat", (ctx) => handleNewChat(ctx, core, chatId));
+  bot.command("cancel", (ctx) => handleCancel(ctx, core));
+  bot.command("status", (ctx) => handleStatus(ctx, core));
+  bot.command("agents", (ctx) => handleAgents(ctx, core));
+  bot.command("help", (ctx) => handleHelp(ctx));
+  bot.command("menu", (ctx) => handleMenu(ctx));
+}
+function buildMenuKeyboard() {
+  return new InlineKeyboard().text("\u{1F195} New Session", "m:new").text("\u{1F4AC} New Chat", "m:new_chat").row().text("\u26D4 Cancel", "m:cancel").text("\u{1F4CA} Status", "m:status").row().text("\u{1F916} Agents", "m:agents").text("\u2753 Help", "m:help");
+}
+async function handleMenu(ctx) {
+  await ctx.reply(`<b>OpenACP Menu</b>
+Choose an action:`, {
+    parse_mode: "HTML",
+    reply_markup: buildMenuKeyboard()
+  });
+}
+async function handleNew(ctx, core, chatId) {
+  const rawMatch = ctx.match;
+  const matchStr = typeof rawMatch === "string" ? rawMatch : "";
+  const args = matchStr.split(" ").filter(Boolean);
+  const agentName = args[0];
+  const workspace = args[1];
+  let threadId;
+  try {
+    const topicName = `\u{1F504} New Session`;
+    threadId = await createSessionTopic(botFromCtx(ctx), chatId, topicName);
+    const session = await core.handleNewSession(
+      "telegram",
+      agentName,
+      workspace
+    );
+    session.threadId = String(threadId);
+    const finalName = `\u{1F504} ${session.agentName} \u2014 New Session`;
+    try {
+      await ctx.api.editForumTopic(chatId, threadId, { name: finalName });
+    } catch {
+    }
+    await ctx.api.sendMessage(
+      chatId,
+      `\u2705 Session started
+<b>Agent:</b> ${escapeHtml(session.agentName)}
+<b>Workspace:</b> <code>${escapeHtml(session.workingDirectory)}</code>`,
+      {
+        message_thread_id: threadId,
+        parse_mode: "HTML"
+      }
+    );
+  } catch (err) {
+    if (threadId) {
+      try {
+        await ctx.api.deleteForumTopic(chatId, threadId);
+      } catch {
+      }
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    await ctx.reply(`\u274C ${escapeHtml(message)}`, { parse_mode: "HTML" });
+  }
+}
+async function handleNewChat(ctx, core, chatId) {
+  const threadId = ctx.message?.message_thread_id;
+  if (!threadId) {
+    await ctx.reply(
+      "Use /new_chat inside a session topic to inherit its config.",
+      { parse_mode: "HTML" }
+    );
+    return;
+  }
+  try {
+    const session = await core.handleNewChat("telegram", String(threadId));
+    if (!session) {
+      await ctx.reply("No active session in this topic.", {
+        parse_mode: "HTML"
+      });
+      return;
+    }
+    const topicName = `\u{1F504} ${session.agentName} \u2014 New Chat`;
+    const newThreadId = await createSessionTopic(
+      botFromCtx(ctx),
+      chatId,
+      topicName
+    );
+    session.threadId = String(newThreadId);
+    await ctx.api.sendMessage(
+      chatId,
+      `\u2705 New chat (same agent &amp; workspace)
+<b>Agent:</b> ${escapeHtml(session.agentName)}
+<b>Workspace:</b> <code>${escapeHtml(session.workingDirectory)}</code>`,
+      {
+        message_thread_id: newThreadId,
+        parse_mode: "HTML"
+      }
+    );
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    await ctx.reply(`\u274C ${escapeHtml(message)}`, { parse_mode: "HTML" });
+  }
+}
+async function handleCancel(ctx, core) {
+  const threadId = ctx.message?.message_thread_id;
+  if (!threadId) return;
+  const session = core.sessionManager.getSessionByThread(
+    "telegram",
+    String(threadId)
+  );
+  if (session) {
+    await session.cancel();
+    await ctx.reply("\u26D4 Session cancelled.", { parse_mode: "HTML" });
+  }
+}
+async function handleStatus(ctx, core) {
+  const threadId = ctx.message?.message_thread_id;
+  if (threadId) {
+    const session = core.sessionManager.getSessionByThread(
+      "telegram",
+      String(threadId)
+    );
+    if (session) {
+      await ctx.reply(
+        `<b>Session:</b> ${escapeHtml(session.name || session.id)}
+<b>Agent:</b> ${escapeHtml(session.agentName)}
+<b>Status:</b> ${escapeHtml(session.status)}
+<b>Workspace:</b> <code>${escapeHtml(session.workingDirectory)}</code>
+<b>Queue:</b> ${session.promptQueue.length} pending`,
+        { parse_mode: "HTML" }
+      );
+    } else {
+      await ctx.reply("No active session in this topic.", {
+        parse_mode: "HTML"
+      });
+    }
+  } else {
+    const sessions = core.sessionManager.listSessions("telegram");
+    const active = sessions.filter(
+      (s) => s.status === "active" || s.status === "initializing"
+    );
+    await ctx.reply(
+      `<b>OpenACP Status</b>
+Active sessions: ${active.length}
+Total sessions: ${sessions.length}`,
+      { parse_mode: "HTML" }
+    );
+  }
+}
+async function handleAgents(ctx, core) {
+  const agents = core.agentManager.getAvailableAgents();
+  const defaultAgent = core.configManager.get().defaultAgent;
+  const lines = agents.map(
+    (a) => `\u2022 <b>${escapeHtml(a.name)}</b>${a.name === defaultAgent ? " (default)" : ""}
+  <code>${escapeHtml(a.command)} ${a.args.map((arg) => escapeHtml(arg)).join(" ")}</code>`
+  );
+  const text = lines.length > 0 ? `<b>Available Agents:</b>
+
+${lines.join("\n")}` : `<b>Available Agents:</b>
+
+No agents configured.`;
+  await ctx.reply(text, { parse_mode: "HTML" });
+}
+async function handleHelp(ctx) {
+  await ctx.reply(
+    `<b>OpenACP Commands:</b>
+
+/new [agent] [workspace] \u2014 Create new session
+/new_chat \u2014 New chat, same agent &amp; workspace
+/cancel \u2014 Cancel current session
+/status \u2014 Show session/system status
+/agents \u2014 List available agents
+/menu \u2014 Show interactive menu
+/help \u2014 Show this help
+
+Or just chat in the \u{1F916} Assistant topic for help!`,
+    { parse_mode: "HTML" }
+  );
+}
+function botFromCtx(ctx) {
+  return { api: ctx.api };
+}
+
+// src/adapters/telegram/permissions.ts
+import { InlineKeyboard as InlineKeyboard2 } from "grammy";
+import { nanoid as nanoid2 } from "nanoid";
+var PermissionHandler = class {
+  constructor(bot, chatId, getSession, sendNotification) {
+    this.bot = bot;
+    this.chatId = chatId;
+    this.getSession = getSession;
+    this.sendNotification = sendNotification;
+  }
+  pending = /* @__PURE__ */ new Map();
+  async sendPermissionRequest(session, request) {
+    const threadId = Number(session.threadId);
+    const callbackKey = nanoid2(8);
+    this.pending.set(callbackKey, { sessionId: session.id, requestId: request.id });
+    const keyboard = new InlineKeyboard2();
+    for (const option of request.options) {
+      const emoji = option.isAllow ? "\u2705" : "\u274C";
+      keyboard.text(`${emoji} ${option.label}`, `p:${callbackKey}:${option.id}`);
+    }
+    const msg = await this.bot.api.sendMessage(
+      this.chatId,
+      `\u{1F510} <b>Permission request:</b>
+
+${escapeHtml(request.description)}`,
+      {
+        message_thread_id: threadId,
+        parse_mode: "HTML",
+        reply_markup: keyboard,
+        disable_notification: false
+      }
+    );
+    const deepLink = buildDeepLink(this.chatId, msg.message_id);
+    await this.sendNotification({
+      sessionId: session.id,
+      sessionName: session.name,
+      type: "permission",
+      summary: request.description,
+      deepLink
+    });
+  }
+  setupCallbackHandler() {
+    this.bot.on("callback_query:data", async (ctx) => {
+      const data = ctx.callbackQuery.data;
+      if (!data.startsWith("p:")) return;
+      const parts = data.split(":");
+      if (parts.length < 3) return;
+      const [, callbackKey, optionId] = parts;
+      const pending = this.pending.get(callbackKey);
+      if (!pending) {
+        try {
+          await ctx.answerCallbackQuery({ text: "\u274C Expired" });
+        } catch {
+        }
+        return;
+      }
+      const session = this.getSession(pending.sessionId);
+      if (session?.pendingPermission?.requestId === pending.requestId) {
+        session.pendingPermission.resolve(optionId);
+        session.pendingPermission = void 0;
+      }
+      this.pending.delete(callbackKey);
+      try {
+        await ctx.answerCallbackQuery({ text: "\u2705 Responded" });
+      } catch {
+      }
+      try {
+        await ctx.editMessageReplyMarkup({ reply_markup: void 0 });
+      } catch {
+      }
+    });
+  }
+};
+
+// src/adapters/telegram/assistant.ts
+async function spawnAssistant(core, adapter, assistantTopicId) {
+  const config = core.configManager.get();
+  const session = await core.sessionManager.createSession(
+    "telegram",
+    config.defaultAgent,
+    core.configManager.resolveWorkspace(),
+    core.agentManager
+  );
+  session.threadId = String(assistantTopicId);
+  const systemPrompt = buildAssistantSystemPrompt(config);
+  await session.enqueuePrompt(systemPrompt);
+  core.wireSessionEvents(session, adapter);
+  return session;
+}
+function buildAssistantSystemPrompt(config) {
+  const agentNames = Object.keys(config.agents).join(", ");
+  return `You are the OpenACP Assistant. Help users manage their AI coding sessions.
+
+Available agents: ${agentNames}
+Default agent: ${config.defaultAgent}
+Workspace base: ${config.workspace.baseDir}
+
+When a user wants to create a session, guide them through:
+1. Which agent to use
+2. Which workspace/project
+3. Confirm and create
+
+Commands reference:
+- /new [agent] [workspace] \u2014 Create new session
+- /new_chat \u2014 New chat with same agent & workspace
+- /cancel \u2014 Cancel current session
+- /status \u2014 Show status
+- /agents \u2014 List agents
+- /help \u2014 Show help
+
+Be concise and helpful. When the user confirms session creation, tell them you'll create it now.`;
+}
+async function handleAssistantMessage(session, text) {
+  if (!session) return;
+  await session.enqueuePrompt(text);
+}
+function redirectToAssistant(chatId, assistantTopicId) {
+  const cleanId = String(chatId).replace("-100", "");
+  const link = `https://t.me/c/${cleanId}/${assistantTopicId}`;
+  return `\u{1F4AC} Please use the <a href="${link}">\u{1F916} Assistant</a> topic to chat with OpenACP.`;
+}
+
+// src/adapters/telegram/adapter.ts
+var TelegramAdapter = class extends ChannelAdapter {
+  bot;
+  telegramConfig;
+  sessionDrafts = /* @__PURE__ */ new Map();
+  toolCallMessages = /* @__PURE__ */ new Map();
+  // sessionId → (toolCallId → state)
+  permissionHandler;
+  assistantSession = null;
+  notificationTopicId;
+  assistantTopicId;
+  constructor(core, config) {
+    super(core, config);
+    this.telegramConfig = config;
+  }
+  async start() {
+    this.bot = new Bot(this.telegramConfig.botToken);
+    this.bot.catch((err) => {
+      log.error("Bot error:", err.message || err);
+    });
+    this.bot.api.config.use((prev, method, payload, signal) => {
+      if (method === "getUpdates") {
+        payload.allowed_updates = payload.allowed_updates ?? ["message", "callback_query"];
+      }
+      return prev(method, payload, signal);
+    });
+    this.bot.use((ctx, next) => {
+      const chatId = ctx.chat?.id ?? ctx.callbackQuery?.message?.chat?.id;
+      if (chatId !== this.telegramConfig.chatId) return;
+      return next();
+    });
+    const topics = await ensureTopics(
+      this.bot,
+      this.telegramConfig.chatId,
+      this.telegramConfig,
+      async (updates) => {
+        await this.core.configManager.save({
+          channels: { telegram: updates }
+        });
+      }
+    );
+    this.notificationTopicId = topics.notificationTopicId;
+    this.assistantTopicId = topics.assistantTopicId;
+    this.permissionHandler = new PermissionHandler(
+      this.bot,
+      this.telegramConfig.chatId,
+      (sessionId) => this.core.sessionManager.getSession(sessionId),
+      (notification) => this.sendNotification(notification)
+    );
+    this.permissionHandler.setupCallbackHandler();
+    setupCommands(this.bot, this.core, this.telegramConfig.chatId);
+    this.setupRoutes();
+    this.bot.start({
+      allowed_updates: ["message", "callback_query"],
+      onStart: () => log.info("Telegram bot started")
+    });
+    try {
+      this.assistantSession = await spawnAssistant(
+        this.core,
+        this,
+        this.assistantTopicId
+      );
+    } catch (err) {
+      log.error("Failed to spawn assistant:", err);
+    }
+  }
+  async stop() {
+    if (this.assistantSession) {
+      await this.assistantSession.destroy();
+    }
+    await this.bot.stop();
+  }
+  setupRoutes() {
+    this.bot.on("message:text", async (ctx) => {
+      const threadId = ctx.message.message_thread_id;
+      if (!threadId) {
+        const html = redirectToAssistant(this.telegramConfig.chatId, this.assistantTopicId);
+        await ctx.reply(html, { parse_mode: "HTML" });
+        return;
+      }
+      if (threadId === this.notificationTopicId) return;
+      if (threadId === this.assistantTopicId) {
+        handleAssistantMessage(this.assistantSession, ctx.message.text).catch((err) => log.error("Assistant error:", err));
+        return;
+      }
+      ;
+      this.core.handleMessage({
+        channelId: "telegram",
+        threadId: String(threadId),
+        userId: String(ctx.from.id),
+        text: ctx.message.text
+      }).catch((err) => log.error("handleMessage error:", err));
+    });
+  }
+  // --- ChannelAdapter implementations ---
+  async sendMessage(sessionId, content) {
+    const session = this.core.sessionManager.getSession(sessionId);
+    if (!session) return;
+    const threadId = Number(session.threadId);
+    switch (content.type) {
+      case "thought": {
+        break;
+      }
+      case "text": {
+        let draft = this.sessionDrafts.get(sessionId);
+        if (!draft) {
+          draft = new MessageDraft(this.bot, this.telegramConfig.chatId, threadId);
+          this.sessionDrafts.set(sessionId, draft);
+        }
+        draft.append(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 }
+        );
+        if (!this.toolCallMessages.has(sessionId)) {
+          this.toolCallMessages.set(sessionId, /* @__PURE__ */ new Map());
+        }
+        this.toolCallMessages.get(sessionId).set(meta.id, { msgId: msg.message_id, name: meta.name, kind: meta.kind });
+        break;
+      }
+      case "tool_update": {
+        const meta = content.metadata;
+        const toolState = this.toolCallMessages.get(sessionId)?.get(meta.id);
+        if (toolState) {
+          const merged = { ...meta, name: meta.name || toolState.name, kind: meta.kind || toolState.kind };
+          try {
+            await this.bot.api.editMessageText(
+              this.telegramConfig.chatId,
+              toolState.msgId,
+              formatToolUpdate(merged),
+              { parse_mode: "HTML" }
+            );
+          } catch {
+          }
+        }
+        break;
+      }
+      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 }
+        );
+        break;
+      }
+      case "usage": {
+        await this.bot.api.sendMessage(
+          this.telegramConfig.chatId,
+          formatUsage(content.metadata),
+          { message_thread_id: threadId, parse_mode: "HTML", disable_notification: true }
+        );
+        break;
+      }
+      case "session_end": {
+        await this.finalizeDraft(sessionId);
+        this.sessionDrafts.delete(sessionId);
+        this.toolCallMessages.delete(sessionId);
+        await 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 }
+        );
+        break;
+      }
+    }
+  }
+  async sendPermissionRequest(sessionId, request) {
+    const session = this.core.sessionManager.getSession(sessionId);
+    if (!session) return;
+    await this.permissionHandler.sendPermissionRequest(session, request);
+  }
+  async sendNotification(notification) {
+    if (!this.notificationTopicId) return;
+    const emoji = {
+      completed: "\u2705",
+      error: "\u274C",
+      permission: "\u{1F510}",
+      input_required: "\u{1F4AC}"
+    };
+    let text = `${emoji[notification.type] || "\u2139\uFE0F"} <b>${escapeHtml(notification.sessionName || notification.sessionId)}</b>
+`;
+    text += escapeHtml(notification.summary);
+    if (notification.deepLink) {
+      text += `
+
+<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
+    });
+  }
+  async createSessionThread(sessionId, name) {
+    return String(await createSessionTopic(this.bot, this.telegramConfig.chatId, name));
+  }
+  async renameSessionThread(sessionId, newName) {
+    const session = this.core.sessionManager.getSession(sessionId);
+    if (!session) return;
+    await renameSessionTopic(this.bot, this.telegramConfig.chatId, Number(session.threadId), newName);
+  }
+  async finalizeDraft(sessionId) {
+    const draft = this.sessionDrafts.get(sessionId);
+    if (draft) {
+      await draft.finalize();
+      this.sessionDrafts.delete(sessionId);
+    }
+  }
+};
+
+export {
+  nodeToWebWritable,
+  nodeToWebReadable,
+  StderrCapture,
+  AgentInstance,
+  AgentManager,
+  Session,
+  SessionManager,
+  NotificationManager,
+  OpenACPCore,
+  ChannelAdapter,
+  TelegramAdapter
+};
+//# sourceMappingURL=chunk-I6KXISAR.js.map