@wrongstack/acp 0.273.1 → 0.275.0

package/dist/agent.js

@@ -1,5 +1,8 @@
 import { writeErr, expectDefined } from '@wrongstack/core';
+import * as fsp from 'fs/promises';
+import * as path from 'path';
 import { fileURLToPath } from 'url';
+import { createServer } from 'http';
 
 // src/agent/stdio-transport.ts
 var StdioTransport = class {
@@ -212,7 +215,16 @@ var ACP_PROTOCOL_VERSION = 1;
 function toWire(msg) {
   return msg;
 }
-var WRONGSTACK_VERSION = "0.263.0";
+var WRONGSTACK_VERSION = "0.274.1";
+var WRONGSTACK_AUTH_METHODS = [
+  {
+    id: "wrongstack-auth",
+    name: "Run wstack auth",
+    description: "Configure a WrongStack model provider in an interactive terminal.",
+    type: "terminal",
+    args: ["auth"]
+  }
+];
 var DEFAULT_MODE_ID = "code";
 var DEFAULT_MODES = [
   {
@@ -229,9 +241,17 @@ var ACPProtocolHandler = class {
   modes;
   configOptions;
   agentName;
+  replayFor;
+  seedFor;
+  store;
   initialized = false;
+  clientCapabilities = {};
   sessions = /* @__PURE__ */ new Map();
   nextId = 1;
+  // Outbound request correlation (server → client requests, e.g.
+  // session/request_permission). Keyed by our own `srv_N` ids.
+  pendingOut = /* @__PURE__ */ new Map();
+  nextOutId = 1;
   constructor(opts) {
     this.transport = opts.transport;
     this.defaultCwd = opts.defaultCwd;
@@ -241,6 +261,43 @@ var ACPProtocolHandler = class {
     this.modes = opts.modes ?? DEFAULT_MODES;
     this.configOptions = opts.configOptions ?? [];
     this.agentName = opts.agentName ?? "wrongstack";
+    this.replayFor = opts.replayFor;
+    this.seedFor = opts.seedFor;
+    this.store = opts.store;
+    if (typeof this.transport.onMessage === "function") {
+      this.transport.onMessage((m) => this.maybeResolvePending(m));
+    }
+  }
+  /**
+   * Send a request to the client and await its response. Used for
+   * server-initiated calls like `session/request_permission`. Rejects on
+   * timeout or transport error so the caller can pick a safe fallback.
+   */
+  request(method, params, timeoutMs = 6e4) {
+    const id = `srv_${this.nextOutId++}`;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingOut.delete(id);
+        reject(new Error(`${method} timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+      this.pendingOut.set(id, { resolve, reject, timer });
+      this.transport.send(toWire({ jsonrpc: "2.0", id, method, params })).catch((e) => {
+        clearTimeout(timer);
+        this.pendingOut.delete(id);
+        reject(e instanceof Error ? e : new Error(String(e)));
+      });
+    });
+  }
+  maybeResolvePending(m) {
+    const id = m.id;
+    if (typeof id !== "string") return;
+    const pending = this.pendingOut.get(id);
+    if (!pending) return;
+    this.pendingOut.delete(id);
+    clearTimeout(pending.timer);
+    const err = m.error;
+    if (err) pending.reject(new Error(err.message ?? "client request failed"));
+    else pending.resolve(m.result);
   }
   /**
    * Process one inbound message. Returns true if this was a terminal
@@ -267,6 +324,11 @@ var ACPProtocolHandler = class {
       session.abort.abort();
     }
     this.sessions.clear();
+    for (const [, p] of this.pendingOut) {
+      clearTimeout(p.timer);
+      p.reject(new Error("protocol handler closed"));
+    }
+    this.pendingOut.clear();
   }
   // ────────────────────────────────────────────────────────────────────
   // Requests
@@ -282,10 +344,18 @@ var ACPProtocolHandler = class {
           return await this.handleInitialize(id, params);
         case "authenticate":
           return await this.handleAuthenticate(id, params);
+        case "logout":
+          return await this.handleLogout(id, params);
         case "session/new":
           return await this.handleSessionNew(id, params);
         case "session/load":
           return await this.handleSessionLoad(id, params);
+        case "session/resume":
+          return await this.handleSessionResume(id, params);
+        case "session/close":
+          return await this.handleSessionClose(id, params);
+        case "session/delete":
+          return await this.handleSessionDelete(id, params);
         case "session/prompt":
           return await this.handleSessionPrompt(id, params);
         case "session/set_mode":
@@ -294,6 +364,16 @@ var ACPProtocolHandler = class {
           return await this.handleSetConfigOption(id, params);
         case "session/list":
           return await this.handleSessionList(id);
+        case "session/fork":
+          return await this.handleSessionFork(id, params);
+        case "providers/list":
+          return await this.handleProvidersList(id, params);
+        case "providers/set":
+          return await this.handleProvidersSet(id, params);
+        case "providers/disable":
+          return await this.handleProvidersDisable(id, params);
+        case "mcp/message":
+          return await this.handleMcpMessage(id, params);
         default:
           await this.sendError(id, -32601, `Unknown method: ${method}`);
           return false;
@@ -306,14 +386,8 @@ var ACPProtocolHandler = class {
   }
   async handleInitialize(id, params) {
     const p = params ?? {};
-    const requested = typeof p.protocolVersion === "number" ? p.protocolVersion : 1;
-    if (requested !== ACP_PROTOCOL_VERSION) {
-      await this.sendError(
-        id,
-        -32e3,
-        `server speaks protocolVersion=${ACP_PROTOCOL_VERSION}, client requested ${requested}`
-      );
-      return false;
+    if (p.clientCapabilities && typeof p.clientCapabilities === "object") {
+      this.clientCapabilities = p.clientCapabilities;
     }
     this.initialized = true;
     await this.transport.send(toWire({
@@ -324,9 +398,25 @@ var ACPProtocolHandler = class {
         agentCapabilities: {
           loadSession: true,
           promptCapabilities: {
-            image: false,
+            // We route ACP image blocks into the core agent's multimodal
+            // input (server-agent-turn.promptToAgentInput); whether the
+            // model can see them is the configured provider's concern.
+            image: true,
             audio: false,
             embeddedContext: true
+          },
+          mcpCapabilities: {
+            http: false,
+            sse: false
+          },
+          sessionCapabilities: {
+            close: {},
+            list: {},
+            delete: {},
+            resume: {}
+          },
+          auth: {
+            logout: {}
           }
         },
         agentInfo: {
@@ -334,10 +424,7 @@ var ACPProtocolHandler = class {
           title: "WrongStack",
           version: WRONGSTACK_VERSION
         },
-        // Static options advertised at handshake. They are also
-        // re-sent on every `current_mode_update` / `config_option_update`
-        // notification so late-joining clients see them.
-        authMethods: [],
+        authMethods: WRONGSTACK_AUTH_METHODS,
         modes: this.modes,
         configOptions: this.configOptions
       }
@@ -352,6 +439,14 @@ var ACPProtocolHandler = class {
     }));
     return false;
   }
+  async handleLogout(id, _params) {
+    await this.transport.send(toWire({
+      jsonrpc: "2.0",
+      id,
+      result: {}
+    }));
+    return false;
+  }
   async handleSessionNew(id, params) {
     const p = params ?? {};
     const cwd = typeof p.cwd === "string" ? p.cwd : this.defaultCwd;
@@ -367,6 +462,7 @@ var ACPProtocolHandler = class {
     };
     this.sessions.set(sessionId, state);
     this.onSessionNew(state);
+    await this.persist(state);
     await this.sendNotification({
       sessionId,
       update: {
@@ -395,7 +491,173 @@ var ACPProtocolHandler = class {
     return false;
   }
   async handleSessionLoad(id, params) {
-    return this.handleSessionNew(id, params);
+    const p = params ?? {};
+    const sessionId = typeof p.sessionId === "string" ? p.sessionId : null;
+    const loadCwd = typeof p.cwd === "string" ? p.cwd : void 0;
+    let existing = sessionId ? this.sessions.get(sessionId) : void 0;
+    if (!existing && sessionId && this.store) {
+      const persisted = await this.store.load(sessionId);
+      if (persisted) {
+        const restored = {
+          id: sessionId,
+          cwd: persisted.cwd ?? loadCwd ?? this.defaultCwd,
+          abort: new AbortController(),
+          modeId: persisted.modeId ?? DEFAULT_MODE_ID,
+          createdAt: persisted.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          ...persisted.title !== void 0 ? { title: persisted.title } : {}
+        };
+        this.sessions.set(sessionId, restored);
+        this.seedFor?.(sessionId, persisted.history ?? []);
+        for (const update of persisted.history ?? []) {
+          await this.sendNotification({ sessionId, update });
+        }
+        await this.sendNotification({
+          sessionId,
+          update: { sessionUpdate: "current_mode_update", modeId: restored.modeId }
+        });
+        await this.transport.send(toWire({
+          jsonrpc: "2.0",
+          id,
+          result: {
+            initialMode: { currentModeId: restored.modeId, availableModes: this.modes }
+          }
+        }));
+        return false;
+      }
+    }
+    if (existing) {
+      existing.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const replay = sessionId ? this.replayFor?.(sessionId) : void 0;
+      if (replay) {
+        for (const update of replay) {
+          await this.sendNotification({ sessionId, update });
+        }
+      }
+      await this.sendNotification({
+        sessionId,
+        update: {
+          sessionUpdate: "session_info_update",
+          updatedAt: existing.updatedAt
+        }
+      });
+      await this.sendNotification({
+        sessionId,
+        update: {
+          sessionUpdate: "current_mode_update",
+          modeId: existing.modeId
+        }
+      });
+      await this.transport.send(toWire({
+        jsonrpc: "2.0",
+        id,
+        result: {
+          initialMode: {
+            currentModeId: existing.modeId,
+            availableModes: this.modes
+          }
+        }
+      }));
+      return false;
+    }
+    await this.sendError(id, -32e3, `session not found: ${sessionId}`);
+    return false;
+  }
+  async handleSessionResume(id, params) {
+    const p = params ?? {};
+    const sessionId = typeof p.sessionId === "string" ? p.sessionId : null;
+    const existing = sessionId ? this.sessions.get(sessionId) : void 0;
+    if (existing) {
+      existing.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      await this.transport.send(toWire({
+        jsonrpc: "2.0",
+        id,
+        result: {
+          initialMode: {
+            currentModeId: existing.modeId,
+            availableModes: this.modes
+          }
+        }
+      }));
+      return false;
+    }
+    await this.sendError(id, -32e3, `session not found: ${sessionId}`);
+    return false;
+  }
+  async handleSessionClose(id, params) {
+    const p = params ?? {};
+    const sessionId = typeof p.sessionId === "string" ? p.sessionId : null;
+    const session = sessionId ? this.sessions.get(sessionId) : void 0;
+    if (!session) {
+      await this.sendError(id, -32e3, `session not found: ${sessionId}`);
+      return false;
+    }
+    session.abort.abort();
+    if (sessionId) this.sessions.delete(sessionId);
+    await this.transport.send(toWire({
+      jsonrpc: "2.0",
+      id,
+      result: {}
+    }));
+    return false;
+  }
+  async handleSessionDelete(id, params) {
+    const p = params ?? {};
+    const sessionId = typeof p.sessionId === "string" ? p.sessionId : null;
+    if (!sessionId) {
+      await this.sendError(id, -32e3, `session not found: ${sessionId}`);
+      return false;
+    }
+    if (!this.sessions.has(sessionId)) {
+      await this.transport.send(toWire({ jsonrpc: "2.0", id, result: { configOptions: [...this.configOptions] } }));
+      return false;
+    }
+    const session = this.sessions.get(sessionId);
+    session.abort.abort();
+    this.sessions.delete(sessionId);
+    await this.transport.send(toWire({
+      jsonrpc: "2.0",
+      id,
+      result: {}
+    }));
+    return false;
+  }
+  async handleSessionFork(id, params) {
+    const p = params ?? {};
+    const sourceId = typeof p.sessionId === "string" ? p.sessionId : null;
+    if (!sourceId || !this.sessions.has(sourceId)) {
+      await this.sendError(id, -32e3, `session not found: ${sourceId}`);
+      return false;
+    }
+    const forkParams = params;
+    return this.handleSessionNew(id, { ...forkParams, cwd: p.cwd ?? this.defaultCwd });
+  }
+  async handleProvidersList(id, _params) {
+    await this.transport.send(toWire({
+      jsonrpc: "2.0",
+      id,
+      result: {
+        providers: [],
+        currentProviderId: null
+      }
+    }));
+    return false;
+  }
+  async handleProvidersSet(id, _params) {
+    await this.sendError(id, -32e3, "provider configuration not available through ACP; use wstack auth");
+    return false;
+  }
+  async handleProvidersDisable(id, _params) {
+    await this.transport.send(toWire({
+      jsonrpc: "2.0",
+      id,
+      result: {}
+    }));
+    return false;
+  }
+  async handleMcpMessage(id, _params) {
+    await this.sendError(id, -32e3, "MCP message routing not available through ACP");
+    return false;
   }
   async handleSessionPrompt(id, params) {
     const p = params ?? {};
@@ -415,11 +677,54 @@ var ACPProtocolHandler = class {
     const turnSignal = new AbortController();
     const onCancel = () => turnSignal.abort();
     session.abort.signal.addEventListener("abort", onCancel, { once: true });
+    const api = {
+      clientCapabilities: this.clientCapabilities,
+      requestPermission: async (req) => {
+        const res = await this.request("session/request_permission", {
+          sessionId,
+          toolCall: req.toolCall,
+          options: req.options
+        });
+        const outcome = res?.outcome;
+        return outcome ?? { outcome: "cancelled" };
+      },
+      readTextFile: async (params2) => {
+        const res = await this.request("fs/read_text_file", { sessionId, ...params2 });
+        return String(res?.content ?? "");
+      },
+      writeTextFile: async (params2) => {
+        await this.request("fs/write_text_file", { sessionId, ...params2 });
+      },
+      runTerminal: async ({ command, args, cwd }) => {
+        const created = await this.request("terminal/create", {
+          sessionId,
+          command,
+          ...args ? { args } : {},
+          ...cwd ? { cwd } : {}
+        });
+        const terminalId = created?.terminalId;
+        if (!terminalId) return { output: "", exitCode: null };
+        try {
+          const exit = await this.request("terminal/wait_for_exit", { sessionId, terminalId });
+          const out = await this.request("terminal/output", { sessionId, terminalId });
+          return {
+            output: String(out?.output ?? ""),
+            exitCode: typeof exit?.exitCode === "number" ? exit.exitCode : null
+          };
+        } finally {
+          try {
+            await this.request("terminal/release", { sessionId, terminalId });
+          } catch {
+          }
+        }
+      }
+    };
     let result;
     try {
       result = await this.runTurn(
         { sessionId, prompt: p.prompt, signal: turnSignal.signal },
-        (update) => this.sendNotification({ sessionId, update })
+        (update) => this.sendNotification({ sessionId, update }),
+        api
       );
     } catch (err) {
       session.abort.signal.removeEventListener("abort", onCancel);
@@ -429,6 +734,7 @@ var ACPProtocolHandler = class {
     }
     session.abort.signal.removeEventListener("abort", onCancel);
     session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await this.persist(session);
     await this.transport.send(toWire({
       jsonrpc: "2.0",
       id,
@@ -457,12 +763,12 @@ var ACPProtocolHandler = class {
   async handleSetConfigOption(id, params) {
     const p = params ?? {};
     const sessionId = typeof p.sessionId === "string" ? p.sessionId : null;
-    const optionId = typeof p.configOptionId === "string" ? p.configOptionId : null;
+    const optionId = typeof p.configId === "string" ? p.configId : null;
     const value = typeof p.value === "string" ? p.value : null;
     const session = sessionId ? this.sessions.get(sessionId) : void 0;
     const option = optionId ? this.configOptions.find((o) => o.id === optionId) : void 0;
     if (!session || !option || value === null || !option.options.some((o) => o.value === value)) {
-      await this.sendError(id, -32602, "invalid sessionId, configOptionId, or value");
+      await this.sendError(id, -32602, "invalid sessionId, configId, or value");
       return false;
     }
     option.currentValue = value;
@@ -474,7 +780,7 @@ var ACPProtocolHandler = class {
         configOptions: [...this.configOptions]
       }
     });
-    await this.transport.send(toWire({ jsonrpc: "2.0", id, result: {} }));
+    await this.transport.send(toWire({ jsonrpc: "2.0", id, result: { configOptions: [...this.configOptions] } }));
     return false;
   }
   async handleSessionList(id) {
@@ -508,6 +814,9 @@ var ACPProtocolHandler = class {
         }
         return false;
       }
+      case "$/cancel_request": {
+        return false;
+      }
       case "exit":
         this.close();
         return true;
@@ -521,6 +830,14 @@ var ACPProtocolHandler = class {
   async sendNotification(params) {
     await this.transport.send(toWire({ jsonrpc: "2.0", method: "session/update", params }));
   }
+  /** Best-effort durable persistence of a session + its recorded history. */
+  async persist(state) {
+    if (!this.store) return;
+    try {
+      await this.store.save(state, this.replayFor?.(state.id));
+    } catch {
+    }
+  }
   async sendError(id, code, message, data) {
     const error = { code, message };
     if (data !== void 0) error.data = data;
@@ -545,29 +862,240 @@ function errorToJsonRpc(err) {
   const message = err instanceof Error ? err.message : String(err);
   return { code: -32603, message };
 }
+var ACPSessionStore = class {
+  dir;
+  /**
+   * Memoized result of the first successful `init()`. Saved sessions
+   * are the hot path — calling `mkdir(..., {recursive:true})` on every
+   * turn adds an avoidable syscall to the per-prompt persistence flow.
+   * Cleared automatically if the directory disappears between calls.
+   */
+  initialized = false;
+  constructor(opts = {}) {
+    this.dir = opts.dir ?? path.join(process.cwd(), ".acp-sessions");
+  }
+  /** Ensure the store directory exists. Memoized — only mkdirs once. */
+  async init() {
+    if (this.initialized) return;
+    await fsp.mkdir(this.dir, { recursive: true });
+    this.initialized = true;
+  }
+  /**
+   * Persist a session state (and optionally its conversation history) to
+   * disk. Returns the session id. `history` enables cross-restart
+   * `session/load` replay.
+   */
+  async save(state, history) {
+    await this.init();
+    await fsp.writeFile(
+      path.join(this.dir, `${state.id}.json`),
+      JSON.stringify({
+        id: state.id,
+        cwd: state.cwd,
+        modeId: state.modeId,
+        createdAt: state.createdAt,
+        updatedAt: state.updatedAt,
+        title: state.title,
+        ...history && history.length > 0 ? { history } : {}
+      }),
+      "utf8"
+    );
+    await this.updateIndex(state.id, state.updatedAt);
+    return state.id;
+  }
+  /** Load a persisted session (metadata + history) from disk, or null. */
+  async load(sessionId) {
+    try {
+      const data = await fsp.readFile(path.join(this.dir, `${sessionId}.json`), "utf8");
+      return JSON.parse(data);
+    } catch {
+      return null;
+    }
+  }
+  /** List all persisted sessions. */
+  async list() {
+    const indexEntries = await this.readIndex();
+    if (indexEntries !== null) {
+      return indexEntries.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+    }
+    const files = [];
+    try {
+      const entries = await fsp.readdir(this.dir);
+      for (const entry of entries) {
+        if (entry.endsWith(".json") && entry !== "index.json") {
+          files.push(entry);
+        }
+      }
+    } catch {
+      return [];
+    }
+    const sessions = [];
+    for (const file of files) {
+      try {
+        const data = await fsp.readFile(path.join(this.dir, file), "utf8");
+        const parsed = JSON.parse(data);
+        if (parsed.id) {
+          sessions.push({ id: parsed.id, updatedAt: parsed.updatedAt ?? "" });
+        }
+      } catch {
+      }
+    }
+    sessions.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+    void this.writeIndex(sessions).catch(() => void 0);
+    return sessions;
+  }
+  /** Sidecar path that stores `{id, updatedAt}` for every saved session. */
+  indexPath() {
+    return path.join(this.dir, "index.json");
+  }
+  /** Read the sidecar index. Returns `null` when missing or unreadable. */
+  async readIndex() {
+    try {
+      const data = await fsp.readFile(this.indexPath(), "utf8");
+      const parsed = JSON.parse(data);
+      if (!Array.isArray(parsed)) return null;
+      const out = [];
+      for (const e of parsed) {
+        if (e && typeof e.id === "string" && typeof e.updatedAt === "string") {
+          out.push({
+            id: e.id,
+            updatedAt: e.updatedAt
+          });
+        }
+      }
+      return out;
+    } catch {
+      return null;
+    }
+  }
+  /** Atomically replace the sidecar index with the supplied entries. */
+  async writeIndex(entries) {
+    const target = this.indexPath();
+    const tmp = `${target}.${process.pid}.${Date.now()}.tmp`;
+    await fsp.writeFile(tmp, JSON.stringify(entries), "utf8");
+    await fsp.rename(tmp, target);
+  }
+  /** Update one entry in the index, adding it if missing. Best-effort. */
+  async updateIndex(id, updatedAt) {
+    let entries = await this.readIndex();
+    if (entries === null) {
+      await this.list();
+      return;
+    }
+    const i = entries.findIndex((e) => e.id === id);
+    if (i >= 0) entries[i] = { id, updatedAt };
+    else entries.push({ id, updatedAt });
+    try {
+      await this.writeIndex(entries);
+    } catch {
+    }
+  }
+  /** Delete a session file. */
+  async delete(sessionId) {
+    try {
+      await fsp.unlink(path.join(this.dir, `${sessionId}.json`));
+    } catch {
+    }
+    const entries = await this.readIndex();
+    if (entries === null) return;
+    const next = entries.filter((e) => e.id !== sessionId);
+    if (next.length !== entries.length) {
+      try {
+        await this.writeIndex(next);
+      } catch {
+      }
+    }
+  }
+  /** Get the store directory path. */
+  getDirectory() {
+    return this.dir;
+  }
+};
+
+// src/agent/ws-bridge-transport.ts
+var WsBridgeTransport = class {
+  /** @param sink Called with each outbound message to write to the socket. */
+  constructor(sink) {
+    this.sink = sink;
+  }
+  sink;
+  handlers = /* @__PURE__ */ new Set();
+  closed = false;
+  send(msg) {
+    if (this.closed) return Promise.resolve();
+    try {
+      this.sink(msg);
+    } catch {
+    }
+    return Promise.resolve();
+  }
+  sendRaw() {
+  }
+  read() {
+    return Promise.resolve(null);
+  }
+  onMessage(handler) {
+    this.handlers.add(handler);
+    return () => this.handlers.delete(handler);
+  }
+  close() {
+    this.closed = true;
+    this.handlers.clear();
+  }
+  /**
+   * Feed one inbound message from the socket. Fires the registered
+   * `onMessage` handlers (which route JSON-RPC responses to pending
+   * outbound requests inside the handler). Inbound *requests* are processed
+   * by the caller via `handler.handleMessage(msg)` — call both per message.
+   */
+  receive(msg) {
+    if (this.closed) return;
+    for (const handler of [...this.handlers]) {
+      try {
+        handler(msg);
+      } catch {
+      }
+    }
+  }
+};
 var WrongStackACPServer = class {
   transport;
   handler;
+  options;
+  /** HTTP server when transport mode is HTTP. */
+  httpServer = null;
   running = false;
   constructor(opts = {}) {
+    this.options = opts;
     this.transport = new StdioTransport();
     const runTurn = opts.runTurn ?? defaultEchoRunTurn;
     this.handler = new ACPProtocolHandler({
       transport: this.transport,
       defaultCwd: opts.defaultCwd ?? process.cwd(),
       runTurn,
-      agentName: opts.agentName
+      agentName: opts.agentName,
+      ...opts.replayFor ? { replayFor: opts.replayFor } : {},
+      ...opts.seedFor ? { seedFor: opts.seedFor } : {},
+      ...opts.store ? { store: opts.store } : {}
     });
   }
   /**
-   * Start the server. Blocks until the client disconnects.
-   *
-   * 1. Print the legacy `[wstack-acp]\n` marker so the client knows the
-   *    process is the ACP server (the old `StdioTransport` handshake).
-   * 2. Loop: read messages, dispatch to the handler, until EOF / error.
+   * Start the server. Mode depends on `options.transport`:
+   * - 'stdio' (default): reads JSON-RPC from stdin, writes to stdout.
+   * - number: listens as HTTP on the given port.
    */
   async start() {
-    this.transport.sendStartupMarker();
+    const transportMode = this.options.transport;
+    if (typeof transportMode === "number") {
+      await this.startHttp(transportMode);
+    } else {
+      await this.startStdio();
+    }
+  }
+  async startStdio() {
+    if (this.options.legacyStartupMarker) {
+      this.transport.sendStartupMarker();
+    }
     this.running = true;
     while (this.running) {
       const msg = await this.transport.read();
@@ -577,10 +1105,80 @@ var WrongStackACPServer = class {
     }
     this.transport.close();
   }
+  async startHttp(port) {
+    const host = this.options.host ?? "127.0.0.1";
+    const handler = this.handler;
+    this.httpServer = createServer(async (req, res) => {
+      const selfOrigin = `http://${host}:${port}`;
+      const reqOrigin = Array.isArray(req.headers.origin) ? req.headers.origin[0] : req.headers.origin;
+      if (reqOrigin && reqOrigin !== selfOrigin) {
+        res.writeHead(403);
+        res.end(JSON.stringify({ error: "cross-origin request forbidden" }));
+        return;
+      }
+      if (reqOrigin) res.setHeader("Access-Control-Allow-Origin", reqOrigin);
+      res.setHeader("Access-Control-Allow-Methods", "POST, OPTIONS");
+      res.setHeader("Access-Control-Allow-Headers", "Content-Type, Mcp-Session-Id");
+      if (req.method === "OPTIONS") {
+        res.writeHead(204);
+        res.end();
+        return;
+      }
+      if (req.method !== "POST") {
+        res.writeHead(405);
+        res.end(JSON.stringify({ error: "method not allowed" }));
+        return;
+      }
+      let body = "";
+      for await (const chunk of req) {
+        body += chunk;
+      }
+      let msg;
+      try {
+        msg = JSON.parse(body);
+      } catch {
+        res.writeHead(400);
+        res.end(JSON.stringify({ error: { code: -32700, message: "Parse error" } }));
+        return;
+      }
+      const notifications = [];
+      let response = null;
+      const originalSend = this.transport.send.bind(this.transport);
+      this.transport.send = async (m) => {
+        if (m.id !== void 0 && (m.result !== void 0 || m.error !== void 0)) {
+          response = m;
+        } else if (m.method === "session/update") {
+          notifications.push(m.params);
+        } else {
+          notifications.push(m);
+        }
+      };
+      try {
+        await handler.handleMessage(msg);
+      } finally {
+        this.transport.send = originalSend;
+      }
+      res.writeHead(200, { "Content-Type": "application/json" });
+      const responseBody = response !== null ? { ...response, notifications } : { notifications };
+      res.end(JSON.stringify(responseBody));
+    });
+    return new Promise((resolve) => {
+      this.httpServer.listen(port, host, () => {
+        writeErr(`[wstack-acp] HTTP server listening on http://${host}:${port}
+`);
+        this.running = true;
+        resolve();
+      });
+    });
+  }
   /** Stop the server. */
   stop() {
     this.running = false;
     this.transport.close();
+    if (this.httpServer) {
+      this.httpServer.close();
+      this.httpServer = null;
+    }
   }
 };
 var defaultEchoRunTurn = async (_input, _emit) => {
@@ -603,20 +1201,63 @@ if (isEntrypoint) {
 function makeACPServerAgentTurn(opts) {
   const agents = /* @__PURE__ */ new Map();
   const timeouts = /* @__PURE__ */ new Map();
+  const history = /* @__PURE__ */ new Map();
+  const pendingSeed = /* @__PURE__ */ new Set();
   const timeoutMs = opts.timeoutMs ?? 5 * 6e4;
-  return async (input, emit) => {
+  const turn = async (input, emit, api) => {
     let agent = agents.get(input.sessionId);
     if (!agent) {
-      agent = await opts.agentFor(input.sessionId, process.cwd());
+      agent = await opts.agentFor(input.sessionId, process.cwd(), api);
       agents.set(input.sessionId, agent);
+      if (pendingSeed.has(input.sessionId)) {
+        pendingSeed.delete(input.sessionId);
+        seedAgentContext(agent, history.get(input.sessionId) ?? []);
+      }
+    }
+    const turnAbort = new AbortController();
+    const abortForTimeout = () => turnAbort.abort();
+    const onParentAbort = () => turnAbort.abort();
+    if (input.signal.aborted) {
+      turnAbort.abort();
+    } else {
+      input.signal.addEventListener("abort", onParentAbort, { once: true });
     }
     const timer = setTimeout(() => {
       timeouts.delete(input.sessionId);
+      abortForTimeout();
     }, timeoutMs);
     timeouts.set(input.sessionId, timer);
+    const unsub = [];
+    const bus = agent.events;
+    if (bus?.on) {
+      unsub.push(
+        bus.on("tool.started", (e) => {
+          emit({
+            sessionUpdate: "tool_call",
+            toolCallId: e.id,
+            title: toolTitle(e.name, e.input),
+            kind: toolNameToKind(e.name),
+            status: "in_progress",
+            ...isRecord(e.input) ? { rawInput: e.input } : {}
+          });
+        }),
+        bus.on("tool.executed", (e) => {
+          emit({
+            sessionUpdate: "tool_call_update",
+            toolCallId: e.id ?? e.name,
+            status: e.ok ? "completed" : "failed",
+            ...e.output !== void 0 ? {
+              content: [
+                { type: "content", content: { type: "text", text: e.output } }
+              ]
+            } : {}
+          });
+        })
+      );
+    }
     try {
-      const userMessage = promptToText(input.prompt);
-      const result = await agent.run(userMessage, { signal: input.signal });
+      const userInput = promptToAgentInput(input.prompt);
+      const result = await agent.run(userInput, { signal: turnAbort.signal });
       const text = extractText(result);
       if (text) {
         emit({
@@ -624,16 +1265,114 @@ function makeACPServerAgentTurn(opts) {
           content: { type: "text", text }
         });
       }
+      const userText = promptToText(input.prompt);
+      const hist = history.get(input.sessionId) ?? [];
+      if (userText) {
+        hist.push({ sessionUpdate: "user_message_chunk", content: { type: "text", text: userText } });
+      }
+      if (text) {
+        hist.push({ sessionUpdate: "agent_message_chunk", content: { type: "text", text } });
+      }
+      if (hist.length > 0) history.set(input.sessionId, hist);
+      const plan = extractPlan(result);
+      if (plan.length > 0) {
+        emit({
+          sessionUpdate: "plan",
+          entries: plan
+        });
+      }
+      const usage = extractUsage(result);
+      if (usage) {
+        emit({
+          sessionUpdate: "usage_update",
+          used: usage.used,
+          size: usage.size,
+          ...usage.cost ? { cost: usage.cost } : {}
+        });
+      }
       const result_out = {
-        stopReason: pickStopReason(result, input.signal)
+        // `turnAbort.signal` covers both client cancellation and the
+        // wall-clock timeout, so either maps to stopReason 'cancelled'.
+        stopReason: pickStopReason(result, turnAbort.signal)
       };
       if (text) result_out.text = text;
+      const runTurnPlan = extractPlan(result);
+      if (runTurnPlan.length > 0) result_out.plan = runTurnPlan;
+      if (usage) result_out.usage = usage;
       return result_out;
     } finally {
       clearTimeout(timer);
       timeouts.delete(input.sessionId);
+      input.signal.removeEventListener("abort", onParentAbort);
+      for (const u of unsub) u();
     }
   };
+  const replay = (sessionId) => history.get(sessionId) ?? [];
+  const seed = (sessionId, incoming) => {
+    if (incoming.length === 0) return;
+    history.set(sessionId, [...incoming]);
+    pendingSeed.add(sessionId);
+  };
+  return Object.assign(turn, { replay, seed });
+}
+function seedAgentContext(agent, history) {
+  const state = agent.ctx?.state;
+  if (!state?.appendMessage) return;
+  for (const u of history) {
+    const text = u.content?.text;
+    if (typeof text !== "string" || text.length === 0) continue;
+    const role = u.sessionUpdate === "user_message_chunk" ? "user" : "assistant";
+    state.appendMessage({ role, content: text });
+  }
+}
+function toolNameToKind(name) {
+  const n = name.toLowerCase();
+  if (n.includes("read") || n.includes("cat")) return "read";
+  if (n.includes("write") || n.includes("edit") || n.includes("apply") || n.includes("patch")) return "edit";
+  if (n.includes("delete") || n.includes("rm")) return "delete";
+  if (n.includes("move") || n.includes("rename") || n.includes("mv")) return "move";
+  if (n.includes("grep") || n.includes("glob") || n.includes("search") || n.includes("find")) return "search";
+  if (n.includes("bash") || n.includes("shell") || n.includes("exec") || n.includes("run") || n.includes("terminal")) return "execute";
+  if (n.includes("fetch") || n.includes("http") || n.includes("web") || n.includes("url")) return "fetch";
+  if (n.includes("think") || n.includes("plan")) return "think";
+  return "other";
+}
+function toolTitle(name, input) {
+  if (isRecord(input)) {
+    const path2 = input.path ?? input.file ?? input.filePath ?? input.pattern ?? input.command;
+    if (typeof path2 === "string" && path2.length > 0) {
+      return `${name}: ${path2.length > 80 ? `${path2.slice(0, 77)}\u2026` : path2}`;
+    }
+  }
+  return name;
+}
+function isRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function promptToAgentInput(blocks) {
+  const hasImage = blocks.some((b) => b.type === "image");
+  if (!hasImage) {
+    return promptToText(blocks);
+  }
+  const out = [];
+  for (const b of blocks) {
+    if (b.type === "text") {
+      out.push({ type: "text", text: b.text });
+    } else if (b.type === "image") {
+      out.push({
+        type: "image",
+        source: { type: "base64", media_type: b.mimeType, data: b.data }
+      });
+    } else if (b.type === "audio") {
+      out.push({ type: "text", text: `[audio: ${b.mimeType}]` });
+    } else if (b.type === "resource") {
+      const text = "text" in b.resource && typeof b.resource.text === "string" ? b.resource.text : `[embedded resource: ${b.resource.uri}]`;
+      out.push({ type: "text", text });
+    } else if (b.type === "resource_link") {
+      out.push({ type: "text", text: `[resource link: ${b.uri}]` });
+    }
+  }
+  return out;
 }
 function promptToText(blocks) {
   const parts = [];
@@ -680,7 +1419,32 @@ function pickStopReason(result, signal) {
   }
   return "end_turn";
 }
+function extractPlan(result) {
+  if (typeof result !== "object" || result === null) return [];
+  const r = result;
+  if (Array.isArray(r.plan)) {
+    return r.plan.filter(
+      (e) => typeof e === "object" && e !== null && typeof e.content === "string"
+    );
+  }
+  return [];
+}
+function extractUsage(result) {
+  if (typeof result !== "object" || result === null) return null;
+  const r = result;
+  if (typeof r.usage === "object" && r.usage !== null) {
+    const u = r.usage;
+    if (typeof u.used === "number" && typeof u.size === "number") {
+      return {
+        used: u.used,
+        size: u.size,
+        ...typeof u.cost === "object" && u.cost !== null ? { cost: u.cost } : {}
+      };
+    }
+  }
+  return null;
+}
 
-export { ACPProtocolHandler, ACPToolsRegistry, StdioTransport, WrongStackACPServer, makeACPServerAgentTurn };
+export { ACPProtocolHandler, ACPSessionStore, ACPToolsRegistry, StdioTransport, WrongStackACPServer, WsBridgeTransport, makeACPServerAgentTurn };
 //# sourceMappingURL=agent.js.map
 //# sourceMappingURL=agent.js.map