@wrongstack/acp 0.10.2 → 0.24.0

package/dist/index.js

@@ -1,22 +1,842 @@
-/**
- * @wrongstack/acp — ACP integration public surface.
- *
- * DIR-2: WrongStack as ACP Server
- *   import { WrongStackACPServer } from '@wrongstack/acp/agent';
- *
- * DIR-1: WrongStack as ACP Client
- *   import { makeACPSubagentRunner } from '@wrongstack/acp/client';
- */
-// Agent (server) side
-export { StdioTransport } from './agent/stdio-transport.js';
-export { ACPToolsRegistry } from './agent/tools-registry.js';
-export { ACPProtocolHandler } from './agent/protocol-handler.js';
-export { WrongStackACPServer } from './agent/wrongstack-acp-agent.js';
-// Client side (DIR-1: WrongStack spawns external ACP agents)
-export { ClientTransport } from './agent/stdio-transport.js';
-export { ToolTranslator } from './client/tool-translator.js';
-export { makeACPSubagentRunner, makeACPSubagentRunnerWithStop } from './integration/acp-subagent-runner.js';
-export { ACP_AGENT_COMMANDS } from './integration/acp-subagent-runner.js';
-// Types
-export * from './types/acp-messages.js';
+import { buildChildEnv } from '@wrongstack/core';
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+
+// src/agent/stdio-transport.ts
+var StdioTransport = class {
+  stdin = process.stdin;
+  stdout = process.stdout;
+  stderr = process.stderr;
+  buffer = "";
+  handlers = /* @__PURE__ */ new Set();
+  closed = false;
+  resolveRead = null;
+  messageQueue = [];
+  constructor() {
+    this.stdin.resume();
+    this.stdin.setEncoding("utf8");
+    this.stdin.on("data", (chunk) => this.onData(chunk));
+    this.stdin.on("end", () => this.handleClose());
+    this.stdin.on("error", (err) => this.failAll(err));
+  }
+  sendStartupMarker() {
+    this.stdout.write("[wstack-acp]\n", "utf8");
+  }
+  send(msg) {
+    if (this.closed) return Promise.resolve();
+    return new Promise((resolve) => {
+      const line = JSON.stringify(msg) + "\n";
+      this.stdout.write(line, "utf8", () => resolve());
+    });
+  }
+  sendRaw(chunk) {
+    this.stdout.write(chunk, "utf8");
+  }
+  read() {
+    if (this.messageQueue.length > 0) return Promise.resolve(this.messageQueue.shift());
+    if (this.closed) return Promise.resolve(null);
+    return new Promise((resolve) => {
+      this.resolveRead = resolve;
+    });
+  }
+  onMessage(handler) {
+    this.handlers.add(handler);
+    return () => this.handlers.delete(handler);
+  }
+  close() {
+    this.closed = true;
+    this.stdin.pause();
+    this.resolveRead?.(null);
+    this.resolveRead = null;
+  }
+  onData(chunk) {
+    this.buffer += chunk;
+    const lines = this.buffer.split("\n");
+    this.buffer = lines.pop() ?? "";
+    for (const raw of lines) {
+      if (!raw.trim()) continue;
+      try {
+        this.dispatch(JSON.parse(raw));
+      } catch (err) {
+        this.stderr.write(`[wstack-acp parse error] ${err}
+`, "utf8");
+      }
+    }
+  }
+  dispatch(msg) {
+    if (this.resolveRead) {
+      const resolve = this.resolveRead;
+      this.resolveRead = null;
+      resolve(msg);
+    } else {
+      this.messageQueue.push(msg);
+    }
+    for (const handler of this.handlers) {
+      try {
+        handler(msg);
+      } catch (err) {
+        this.stderr.write(`[wstack-acp handler error] ${err}
+`, "utf8");
+      }
+    }
+  }
+  handleClose() {
+    this.closed = true;
+    this.resolveRead?.(null);
+    this.resolveRead = null;
+  }
+  failAll(err) {
+    this.stderr.write(`[wstack-acp stdin error] ${err.message}
+`, "utf8");
+    this.close();
+  }
+};
+var ClientTransport = class {
+  child = null;
+  buffer = "";
+  handlers = /* @__PURE__ */ new Set();
+  closed = false;
+  resolveRead = null;
+  messageQueue = [];
+  opts;
+  constructor(options) {
+    this.opts = {
+      handshakeTimeoutMs: 3e4,
+      ...options
+    };
+  }
+  async start() {
+    if (this.child) return;
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(
+          new Error(`ACP child process failed to start within ${this.opts.handshakeTimeoutMs}ms`)
+        );
+      }, this.opts.handshakeTimeoutMs);
+      try {
+        this.child = spawn(this.opts.command, this.opts.args ?? [], {
+          env: { ...buildChildEnv(), ...this.opts.env },
+          cwd: this.opts.cwd,
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+      } catch (err) {
+        clearTimeout(timeout);
+        reject(err);
+        return;
+      }
+      const child = this.child;
+      child.stdout.setEncoding("utf8");
+      const waitForMarker = (chunk) => {
+        this.buffer += chunk;
+        const idx = this.buffer.indexOf("[wstack-acp]\n");
+        if (idx !== -1) {
+          this.buffer = this.buffer.slice(idx + "[wstack-acp]\n".length);
+          child.stdout.removeListener("data", waitForMarker);
+          child.stdout.on("data", (c) => this.onChildData(c));
+          child.stderr.on("data", (c) => this.onChildError(c));
+          child.on("close", (code) => this.onChildClose(code));
+          clearTimeout(timeout);
+          resolve();
+        }
+      };
+      child.stdout.on("data", waitForMarker);
+      child.stdout.on("error", (err) => {
+        clearTimeout(timeout);
+        reject(err);
+      });
+      child.on("error", (err) => {
+        clearTimeout(timeout);
+        reject(err);
+      });
+    });
+  }
+  send(msg) {
+    if (!this.child) return Promise.reject(new Error("ClientTransport not started"));
+    return new Promise((resolve, reject) => {
+      const line = JSON.stringify(msg) + "\n";
+      this.child.stdin.write(line, "utf8", (err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    });
+  }
+  read() {
+    if (this.messageQueue.length > 0) return Promise.resolve(this.messageQueue.shift());
+    if (this.closed) return Promise.resolve(null);
+    return new Promise((resolve) => {
+      this.resolveRead = resolve;
+    });
+  }
+  onMessage(handler) {
+    this.handlers.add(handler);
+    return () => this.handlers.delete(handler);
+  }
+  stop() {
+    if (!this.child) return;
+    this.closed = true;
+    try {
+      this.child.kill();
+    } catch {
+    }
+    this.child = null;
+  }
+  onChildData(chunk) {
+    this.buffer += chunk;
+    const lines = this.buffer.split("\n");
+    this.buffer = lines.pop() ?? "";
+    for (const raw of lines) {
+      if (!raw.trim()) continue;
+      try {
+        this.dispatch(JSON.parse(raw));
+      } catch {
+      }
+    }
+  }
+  onChildError(chunk) {
+    process.stderr.write(`[acp-child stderr] ${chunk}`, "utf8");
+  }
+  onChildClose(code) {
+    this.closed = true;
+    this.resolveRead?.(null);
+    this.resolveRead = null;
+    if (code !== 0 && code !== null) {
+      process.stderr.write(`[acp-child exited with code ${code}]
+`, "utf8");
+    }
+  }
+  dispatch(msg) {
+    if (this.resolveRead) {
+      const resolve = this.resolveRead;
+      this.resolveRead = null;
+      resolve(msg);
+    } else {
+      this.messageQueue.push(msg);
+    }
+    for (const handler of this.handlers) {
+      try {
+        handler(msg);
+      } catch {
+      }
+    }
+  }
+};
+
+// src/agent/tools-registry.ts
+var ACPToolsRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  owner;
+  constructor(owner = "wrongstack") {
+    this.owner = owner;
+  }
+  /**
+   * Register one or more tools.
+   * Throws on duplicate name unless force=true.
+   */
+  register(tools) {
+    for (const tool of tools) {
+      this.tools.set(tool.name, tool);
+    }
+  }
+  /**
+   * Replace the current tool set.
+   */
+  setTools(tools) {
+    this.tools.clear();
+    for (const tool of tools) this.tools.set(tool.name, tool);
+  }
+  get(name) {
+    return this.tools.get(name);
+  }
+  has(name) {
+    return this.tools.has(name);
+  }
+  list() {
+    return Array.from(this.tools.values());
+  }
+  /** Build the ACP tools/list payload from registered tools. */
+  buildToolList() {
+    return {
+      tools: Array.from(this.tools.values()).map(
+        (t) => toACPToolDefinition(t, this.owner)
+      )
+    };
+  }
+  /**
+   * Execute a tool by name and return ACP-formatted result.
+   * Returns null if the tool is not found.
+   */
+  async execute(name, args, ctx, signal) {
+    const tool = this.tools.get(name);
+    if (!tool) return null;
+    try {
+      const result = await tool.execute(args, ctx, {
+        signal
+      });
+      return toACPToolResult(result);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return { content: [{ type: "text", text: msg }], isError: true };
+    }
+  }
+};
+function toACPToolDefinition(tool, _owner) {
+  return {
+    name: tool.name,
+    description: tool.description,
+    inputSchema: toACPInputSchema(tool.inputSchema),
+    annotations: {
+      title: tool.name,
+      description: tool.usageHint ?? tool.description,
+      priority: toolToPriority(tool),
+      alwaysAccept: tool.permission === "auto"
+    }
+  };
+}
+function toACPInputSchema(src) {
+  if (!src || typeof src !== "object") {
+    return {};
+  }
+  const s = src;
+  if (s.properties && typeof s.properties === "object") {
+    const props = {};
+    for (const [k, v] of Object.entries(s.properties)) {
+      props[k] = toACPInputSchema(v);
+    }
+    return {
+      type: typeof s.type === "string" ? s.type : void 0,
+      properties: props,
+      required: Array.isArray(s.required) ? s.required : void 0,
+      items: s.items ? toACPInputSchema(s.items) : void 0,
+      enum: Array.isArray(s.enum) ? s.enum : void 0,
+      description: typeof s.description === "string" ? s.description : void 0,
+      default: s.default,
+      minimum: typeof s.minimum === "number" ? s.minimum : void 0,
+      maximum: typeof s.maximum === "number" ? s.maximum : void 0
+    };
+  }
+  return {
+    type: typeof s.type === "string" ? s.type : void 0,
+    items: s.items ? toACPInputSchema(s.items) : void 0,
+    enum: Array.isArray(s.enum) ? s.enum : void 0,
+    description: typeof s.description === "string" ? s.description : void 0,
+    default: s.default,
+    minimum: typeof s.minimum === "number" ? s.minimum : void 0,
+    maximum: typeof s.maximum === "number" ? s.maximum : void 0
+  };
+}
+function toACPToolResult(result) {
+  const blocks = [];
+  if (result === void 0 || result === null) {
+    return { content: [{ type: "text", text: "ok" }] };
+  }
+  if (typeof result === "string") {
+    blocks.push({ type: "text", text: result });
+  } else if (typeof result === "object") {
+    blocks.push({ type: "text", text: JSON.stringify(result, null, 2) });
+  } else {
+    blocks.push({ type: "text", text: String(result) });
+  }
+  return { content: blocks };
+}
+function toolToPriority(tool) {
+  if (tool.riskTier === "destructive") return "high";
+  if (tool.riskTier === "standard" || tool.permission === "confirm") return "medium";
+  return "low";
+}
+
+// src/agent/protocol-handler.ts
+var WRONGSTACK_VERSION = "0.1.0";
+var WRONGSTACK_CAPABILITIES = [
+  "code-generation",
+  "async-tools",
+  "streaming",
+  "progress"
+];
+var ACPProtocolHandler = class {
+  constructor(transport, registry, context) {
+    this.transport = transport;
+    this.registry = registry;
+    this.context = context;
+  }
+  transport;
+  registry;
+  context;
+  initialized = false;
+  signal = new AbortController();
+  pendingCalls = /* @__PURE__ */ new Map();
+  /** Wire an external abort signal from the ACP client */
+  wireAbortController(abortController) {
+    abortController.signal.addEventListener("abort", () => {
+      for (const id of this.pendingCalls.keys()) {
+        this.transport.send({ id, method: "cancel", result: { ok: true } }).catch(() => {
+        });
+      }
+    });
+  }
+  /** Process one inbound message. Returns true if this was a terminal message. */
+  async handleMessage(msg) {
+    if (msg.id !== void 0) {
+      return this.handleRequest(msg);
+    }
+    return this.handleNotification(msg);
+  }
+  async handleRequest(req) {
+    if (req.method !== "initialize" && !this.initialized) {
+      await this.sendError(req.id ?? null, -32e3, "Not initialized");
+      return false;
+    }
+    const id = req.id;
+    switch (req.method) {
+      case "initialize":
+        return this.handleInitialize(req, id);
+      case "ping":
+        await this.transport.send({ id, method: "ping", result: { pong: true } });
+        return false;
+      case "tools/call":
+        return this.handleToolCall(req, id);
+      case "tools/list":
+        return this.handleToolsList(id);
+      case "cancel":
+        return this.handleCancel(id);
+      case "session/list":
+        return this.handleSessionList(id);
+      case "sessionInfoUpdate":
+        await this.transport.send({ id, method: "sessionInfoUpdate", result: { ok: true } });
+        return false;
+      default:
+        await this.sendError(id, -32601, `Unknown method: ${req.method}`);
+        return false;
+    }
+  }
+  async handleNotification(n) {
+    if (n.method === "cancel") {
+      this.handleCancelNotification(n);
+    }
+    return false;
+  }
+  async handleInitialize(req, id) {
+    this.initialized = true;
+    const result = {
+      capabilities: WRONGSTACK_CAPABILITIES,
+      agentName: "WrongStack",
+      agentVersion: WRONGSTACK_VERSION,
+      protocolVersion: req.params?.protocolVersion ?? "2024-11",
+      ...this.registry.buildToolList()
+    };
+    await this.transport.send({ id, method: "initialize", result });
+    return false;
+  }
+  async handleToolsList(id) {
+    await this.transport.send({
+      id,
+      method: "tools/list",
+      result: this.registry.buildToolList()
+    });
+    return false;
+  }
+  async handleToolCall(req, id) {
+    const { name, arguments: args } = req.params;
+    const runPromise = (async () => {
+      if (!this.registry.has(name)) {
+        return {
+          content: [{ type: "text", text: `Tool not found: ${name}` }],
+          isError: true
+        };
+      }
+      const result = await this.registry.execute(
+        name,
+        args,
+        this.context,
+        this.signal.signal
+      );
+      return result ?? { content: [{ type: "text", text: "Tool returned null" }], isError: false };
+    })();
+    this.pendingCalls.set(id, runPromise);
+    try {
+      const toolResult = await runPromise;
+      this.pendingCalls.delete(id);
+      const response = { method: "tools/call", id, result: toolResult };
+      await this.transport.send(response);
+    } catch (err) {
+      this.pendingCalls.delete(id);
+      const msg = err instanceof Error ? err.message : String(err);
+      await this.transport.send({
+        id,
+        method: "tools/call",
+        result: { content: [{ type: "text", text: msg }], isError: true }
+      });
+    }
+    return false;
+  }
+  async handleCancel(id) {
+    this.pendingCalls.delete(id);
+    await this.transport.send({ id, method: "cancel", result: { ok: true } });
+    return false;
+  }
+  handleCancelNotification(_n) {
+  }
+  async handleSessionList(id) {
+    await this.transport.send({
+      id,
+      method: "session/list",
+      result: { sessions: [] }
+    });
+    return false;
+  }
+  async sendError(id, code, message) {
+    if (id === null) return;
+    await this.transport.send({ id, method: "", error: { code, message } });
+  }
+};
+var WrongStackACPServer = class {
+  transport;
+  registry;
+  handler;
+  running = false;
+  constructor(opts) {
+    this.transport = new StdioTransport();
+    this.registry = new ACPToolsRegistry(opts.owner);
+    this.registry.register(opts.tools);
+    this.handler = new ACPProtocolHandler(
+      this.transport,
+      this.registry,
+      /* TODO: load WrongStack Context */
+      {}
+    );
+  }
+  /**
+   * Start the server. Blocks until the client disconnects.
+   *
+   * 1. Send the startup marker `[wstack-acp]` so the client
+   *    knows which stdout line is the protocol boundary.
+   * 2. Loop: read messages, dispatch to handler, until EOF or error.
+   */
+  async start() {
+    this.transport.sendStartupMarker();
+    this.running = true;
+    this.transport.onMessage((msg) => {
+      void this.handler.handleMessage(msg);
+    });
+    while (this.running) {
+      const msg = await this.transport.read();
+      if (!msg) break;
+      const terminal = await this.handler.handleMessage(msg);
+      if (terminal) break;
+    }
+    this.transport.close();
+  }
+  /** Stop the server. */
+  stop() {
+    this.running = false;
+    this.transport.close();
+  }
+};
+async function main() {
+  const server = new WrongStackACPServer({ tools: [] });
+  await server.start();
+}
+var isEntrypoint = process.argv[1] !== void 0 && fileURLToPath(import.meta.url) === process.argv[1];
+if (isEntrypoint) {
+  main().catch((err) => {
+    process.stderr.write(`[wstack-acp fatal] ${err}
+`);
+    process.exit(1);
+  });
+}
+
+// src/client/tool-translator.ts
+var DEFAULT_OPTIONS = {
+  asyncTools: true,
+  pollIntervalMs: 500,
+  totalTimeoutMs: 12e4
+};
+function extractTextFromContent(blocks) {
+  const parts = [];
+  for (const b of blocks) {
+    if (b.type === "text") parts.push(b.text);
+    else if (b.type === "resource") parts.push(`[resource: ${b.resource.uri}]`);
+    else if (b.type === "image") parts.push(`[image: ${b.data.slice(0, 20)}...]`);
+    else if (b.type === "progress") {
+      if (b.messages?.length) parts.push(b.messages.join("\n"));
+    }
+  }
+  return parts.join("\n");
+}
+function parseToolResponse(taskId, subagentId, response) {
+  const blocks = response.result.content;
+  const text = extractTextFromContent(blocks);
+  const isError = response.result.isError || text.toLowerCase().includes("error") || text.toLowerCase().includes("failed");
+  return {
+    taskId,
+    subagentId,
+    status: isError ? "failed" : "success",
+    result: text,
+    iterations: 1,
+    toolCalls: 1,
+    durationMs: 0
+  };
+}
+var ToolTranslator = class {
+  opts;
+  pending = /* @__PURE__ */ new Map();
+  constructor(opts = {}) {
+    this.opts = { ...DEFAULT_OPTIONS, ...opts };
+  }
+  /**
+   * Start listening to a transport for tool responses and cancellations.
+   * Call this once after constructing the translator and before sending tasks.
+   */
+  attachToTransport(transport) {
+    transport.onMessage((msg) => {
+      if (msg.method === "tools/call" && msg.id !== void 0) {
+        const pending = this.pending.get(msg.id);
+        if (pending) {
+          clearTimeout(pending.timeout);
+          this.pending.delete(msg.id);
+          pending.resolve(msg);
+        }
+      }
+      if (msg.method === "cancel" && msg.id !== void 0) {
+        const pending = this.pending.get(msg.id);
+        if (pending) {
+          clearTimeout(pending.timeout);
+          this.pending.delete(msg.id);
+          pending.reject(new Error("Call cancelled by client"));
+        }
+      }
+    });
+  }
+  /**
+   * Send a tool call over the transport and wait for a response.
+   * If asyncTools is true, polls for progress and resolves when the final
+   * response arrives.
+   */
+  async callTool(transport, name, args, callId = crypto.randomUUID()) {
+    await transport.send({
+      method: "tools/call",
+      id: callId,
+      params: { name, arguments: args }
+    });
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pending.delete(callId);
+        reject(new Error(`Tool call ${name} timed out after ${this.opts.totalTimeoutMs}ms`));
+      }, this.opts.totalTimeoutMs);
+      this.pending.set(callId, { resolve, reject, timeout });
+    });
+  }
+  cancelAll() {
+    for (const [, p] of this.pending) {
+      clearTimeout(p.timeout);
+    }
+    this.pending.clear();
+  }
+};
+
+// src/integration/acp-subagent-runner.ts
+var ACP_AGENT_COMMANDS = {
+  cline: {
+    command: "npx",
+    args: ["-y", "@agentify/cline"],
+    role: "cline"
+  },
+  "gemini-cli": {
+    command: "gemini",
+    role: "gemini-cli"
+  },
+  copilot: {
+    command: "gh",
+    args: ["copilot", "agent"],
+    role: "copilot"
+  },
+  openhands: {
+    command: "openhands",
+    role: "openhands"
+  },
+  goose: {
+    command: "goose",
+    role: "goose"
+  }
+};
+async function makeACPSubagentRunner(options) {
+  const transport = new ClientTransport({
+    command: options.command,
+    args: options.args,
+    env: options.env,
+    cwd: options.cwd,
+    handshakeTimeoutMs: 3e4
+  });
+  const translator = new ToolTranslator(options.toolTranslatorOpts);
+  const activeAbort = new AbortController();
+  let sessionStarted = false;
+  const startSession = async () => {
+    if (sessionStarted) return;
+    await transport.start();
+    await transport.send({
+      method: "initialize",
+      id: "1",
+      params: {
+        capabilities: ["code-generation", "async-tools", "streaming", "progress"],
+        protocolVersion: "2024-11",
+        sessionId: options.role ?? "wrongstack-subagent"
+      }
+    });
+    const initResp = await transport.read();
+    if (!initResp || initResp.error) {
+      throw new Error(`ACP initialize failed: ${initResp?.error?.message ?? "no response"}`);
+    }
+    translator.attachToTransport({
+      onMessage: (h) => transport.onMessage(h),
+      send: (m) => transport.send(m)
+    });
+    sessionStarted = true;
+  };
+  const runner = async (task, ctx) => {
+    ctx.signal.addEventListener("abort", () => {
+      activeAbort.abort();
+      transport.stop();
+    });
+    await startSession();
+    const callId = crypto.randomUUID();
+    let toolResult = null;
+    const resultPromise = new Promise((resolve, reject) => {
+      const budgetMs = ctx.budget.limits.timeoutMs ?? 3e5;
+      const timeout = setTimeout(() => {
+        reject(new Error(`ACP task timed out for subagent ${ctx.subagentId} (${budgetMs}ms budget)`));
+      }, budgetMs);
+      transport.onMessage((msg) => {
+        if (msg.method === "tools/call" && msg.id !== void 0) {
+          clearTimeout(timeout);
+          resolve(msg);
+        }
+      });
+      ctx.signal.addEventListener("abort", () => {
+        clearTimeout(timeout);
+        reject(new Error("Task aborted by parent"));
+      });
+    });
+    try {
+      await transport.send({
+        method: "agent/run",
+        id: callId,
+        params: {
+          task: task.description,
+          sessionId: ctx.subagentId
+        }
+      });
+      toolResult = await resultPromise;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return {
+        result: `ACP subagent error: ${msg}`,
+        iterations: 0,
+        toolCalls: 0
+      };
+    }
+    if (!toolResult) {
+      return { result: "ACP subagent returned no result", iterations: 1, toolCalls: 1 };
+    }
+    const parsed = parseToolResponse(task.id, ctx.subagentId, toolResult);
+    return {
+      result: parsed.result ?? parsed.error,
+      iterations: parsed.iterations,
+      toolCalls: parsed.toolCalls
+    };
+  };
+  return runner;
+}
+async function makeACPSubagentRunnerWithStop(options) {
+  const transport = new ClientTransport({
+    command: options.command,
+    args: options.args,
+    env: options.env,
+    cwd: options.cwd,
+    handshakeTimeoutMs: 3e4
+  });
+  const translator = new ToolTranslator(options.toolTranslatorOpts);
+  const activeAbort = new AbortController();
+  let sessionStarted = false;
+  const startSession = async () => {
+    if (sessionStarted) return;
+    await transport.start();
+    await transport.send({
+      method: "initialize",
+      id: "1",
+      params: {
+        capabilities: ["code-generation", "async-tools", "streaming", "progress"],
+        protocolVersion: "2024-11",
+        sessionId: options.role ?? "wrongstack-subagent"
+      }
+    });
+    const initResp = await transport.read();
+    if (!initResp || initResp.error) {
+      throw new Error(`ACP initialize failed: ${initResp?.error?.message ?? "no response"}`);
+    }
+    translator.attachToTransport({
+      onMessage: (h) => transport.onMessage(h),
+      send: (m) => transport.send(m)
+    });
+    sessionStarted = true;
+  };
+  const stop = () => {
+    activeAbort.abort();
+    transport.stop();
+  };
+  const runner = async (task, ctx) => {
+    ctx.signal.addEventListener("abort", () => {
+      activeAbort.abort();
+      transport.stop();
+    });
+    await startSession();
+    const callId = crypto.randomUUID();
+    let toolResult = null;
+    const resultPromise = new Promise((resolve, reject) => {
+      const budgetMs = ctx.budget.limits.timeoutMs ?? 3e5;
+      const timeout = setTimeout(() => {
+        reject(new Error(`ACP task timed out for subagent ${ctx.subagentId} (${budgetMs}ms budget)`));
+      }, budgetMs);
+      transport.onMessage((msg) => {
+        if (msg.method === "tools/call" && msg.id !== void 0) {
+          clearTimeout(timeout);
+          resolve(msg);
+        }
+      });
+      ctx.signal.addEventListener("abort", () => {
+        clearTimeout(timeout);
+        reject(new Error("Task aborted by parent"));
+      });
+    });
+    try {
+      await transport.send({
+        method: "agent/run",
+        id: callId,
+        params: {
+          task: task.description,
+          sessionId: ctx.subagentId
+        }
+      });
+      toolResult = await resultPromise;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return {
+        result: `ACP subagent error: ${msg}`,
+        iterations: 0,
+        toolCalls: 0
+      };
+    }
+    if (!toolResult) {
+      return { result: "ACP subagent returned no result", iterations: 1, toolCalls: 1 };
+    }
+    const parsed = parseToolResponse(task.id, ctx.subagentId, toolResult);
+    return {
+      result: parsed.result ?? parsed.error,
+      iterations: parsed.iterations,
+      toolCalls: parsed.toolCalls
+    };
+  };
+  return { runner, stop };
+}
+
+export { ACPProtocolHandler, ACPToolsRegistry, ACP_AGENT_COMMANDS, ClientTransport, StdioTransport, ToolTranslator, WrongStackACPServer, makeACPSubagentRunner, makeACPSubagentRunnerWithStop };
+//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map