@wrongstack/acp 0.306.3 → 0.307.0

package/dist/index.js

@@ -1,7 +1,5 @@
 // src/agent/protocol-handler.ts
 import { randomUUID } from "node:crypto";
-import * as fsp from "node:fs/promises";
-import * as path from "node:path";
 
 // src/types/acp-v1.ts
 var ACP_PROTOCOL_VERSION = 1;
@@ -32,7 +30,9 @@ function toWire(msg) {
 }
 var WRONGSTACK_VERSION = ACP_PACKAGE_VERSION;
 
-// src/agent/protocol-handler.ts
+// src/agent/protocol-session-ops.ts
+import * as fsp from "node:fs/promises";
+import * as path from "node:path";
 var WRONGSTACK_AUTH_METHODS = [
   {
     id: "wrongstack-auth",
@@ -51,6 +51,384 @@ var DEFAULT_MODES = [
     description: "Default agent mode for code-generation tasks."
   }
 ];
+async function resolveSessionCwd(requested) {
+  if (!path.isAbsolute(requested)) return null;
+  const resolved = path.resolve(requested);
+  try {
+    const stat3 = await fsp.stat(resolved);
+    return stat3.isDirectory() ? resolved : null;
+  } catch {
+    return null;
+  }
+}
+function errorToJsonRpc(err) {
+  if (err && typeof err === "object") {
+    const e = err;
+    if (typeof e.code === "number" && typeof e.message === "string") {
+      const result = {
+        code: e.code,
+        message: e.message
+      };
+      if (e.data !== void 0) result.data = e.data;
+      return result;
+    }
+  }
+  const message = err instanceof Error ? err.message : String(err);
+  return { code: -32603, message };
+}
+function createRunTurnApi(sessionId, clientCapabilities, request) {
+  return {
+    clientCapabilities,
+    requestPermission: async (req) => {
+      const res = await request("session/request_permission", {
+        sessionId,
+        toolCall: req.toolCall,
+        options: req.options
+      });
+      const outcome = res?.outcome;
+      return outcome ?? { outcome: "cancelled" };
+    },
+    readTextFile: async (params) => {
+      const res = await request("fs/read_text_file", { sessionId, ...params });
+      return String(res?.content ?? "");
+    },
+    writeTextFile: async (params) => {
+      await request("fs/write_text_file", { sessionId, ...params });
+    },
+    runTerminal: async ({ command, args, cwd }) => {
+      const created = await request("terminal/create", {
+        sessionId,
+        command,
+        ...args ? { args } : {},
+        ...cwd ? { cwd } : {}
+      });
+      const terminalId = created?.terminalId;
+      if (!terminalId) return { output: "", exitCode: null };
+      try {
+        const exit = await request("terminal/wait_for_exit", {
+          sessionId,
+          terminalId
+        });
+        const out = await request("terminal/output", { sessionId, terminalId });
+        return {
+          output: String(out?.output ?? ""),
+          exitCode: typeof exit?.exitCode === "number" ? exit.exitCode : null
+        };
+      } finally {
+        try {
+          await request("terminal/release", { sessionId, terminalId });
+        } catch {
+        }
+      }
+    }
+  };
+}
+function buildInitializeResult(agentName, modes, configOptions) {
+  return {
+    protocolVersion: ACP_PROTOCOL_VERSION,
+    agentCapabilities: {
+      loadSession: true,
+      promptCapabilities: {
+        image: true,
+        audio: false,
+        embeddedContext: true
+      },
+      mcpCapabilities: {
+        http: false,
+        sse: false
+      },
+      sessionCapabilities: {
+        close: {},
+        list: {},
+        delete: {},
+        resume: {},
+        fork: {}
+      },
+      auth: {
+        logout: {}
+      }
+    },
+    agentInfo: {
+      name: agentName,
+      title: "WrongStack",
+      version: WRONGSTACK_VERSION
+    },
+    authMethods: WRONGSTACK_AUTH_METHODS,
+    modes,
+    configOptions
+  };
+}
+
+// src/agent/protocol-session-management.ts
+async function handleSessionNewOp(ctx, id, params) {
+  if (ctx.sessions.size >= ctx.maxSessions) {
+    await ctx.sendError(id, -32e3, `active session limit reached (${ctx.maxSessions})`);
+    return false;
+  }
+  const p = params ?? {};
+  let cwd = ctx.defaultCwd;
+  if (typeof p.cwd === "string") {
+    const resolved = await resolveSessionCwd(p.cwd);
+    if (resolved === null) {
+      await ctx.sendError(id, -32602, `cwd must be an absolute path to an existing directory`);
+      return false;
+    }
+    cwd = resolved;
+  }
+  const sessionId = `sess_${ctx.allocId()}`;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const state = {
+    id: sessionId,
+    cwd,
+    abort: new AbortController(),
+    modeId: DEFAULT_MODE_ID,
+    createdAt: now,
+    updatedAt: now
+  };
+  ctx.sessions.set(sessionId, state);
+  ctx.onSessionNew(state);
+  await ctx.persist(state);
+  await ctx.sendNotification({
+    sessionId,
+    update: {
+      sessionUpdate: "current_mode_update",
+      modeId: ctx.modes[0]?.id ?? DEFAULT_MODE_ID
+    }
+  });
+  if (ctx.configOptions.length > 0) {
+    await ctx.sendNotification({
+      sessionId,
+      update: {
+        sessionUpdate: "config_option_update",
+        configOptions: [...ctx.configOptions]
+      }
+    });
+  }
+  await ctx.sendResult(id, {
+    sessionId,
+    modes: ctx.modes,
+    configOptions: ctx.configOptions
+  });
+  return false;
+}
+async function handleSessionLoadOp(ctx, id, params) {
+  const p = params ?? {};
+  const sessionId = typeof p.sessionId === "string" ? p.sessionId : null;
+  const loadCwd = typeof p.cwd === "string" ? p.cwd : void 0;
+  const existing = sessionId ? ctx.sessions.get(sessionId) : void 0;
+  if (!existing && sessionId && ctx.store) {
+    const persisted = await ctx.store.load(sessionId);
+    if (persisted) {
+      if (ctx.sessions.size >= ctx.maxSessions) {
+        await ctx.sendError(id, -32e3, `active session limit reached (${ctx.maxSessions})`);
+        return false;
+      }
+      if (loadCwd !== void 0 && await resolveSessionCwd(loadCwd) === null) {
+        await ctx.sendError(id, -32602, `cwd must be an absolute path to an existing directory`);
+        return false;
+      }
+      const candidateCwd = persisted.cwd ?? loadCwd ?? ctx.defaultCwd;
+      const restoredCwd = await resolveSessionCwd(candidateCwd) ?? ctx.defaultCwd;
+      const restored = {
+        id: sessionId,
+        cwd: restoredCwd,
+        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 } : {}
+      };
+      ctx.sessions.set(sessionId, restored);
+      ctx.seedFor?.(sessionId, persisted.history ?? []);
+      for (const update of persisted.history ?? []) {
+        await ctx.sendNotification({ sessionId, update });
+      }
+      await ctx.sendNotification({
+        sessionId,
+        update: { sessionUpdate: "current_mode_update", modeId: restored.modeId }
+      });
+      await ctx.sendResult(id, {
+        initialMode: { currentModeId: restored.modeId, availableModes: ctx.modes }
+      });
+      return false;
+    }
+  }
+  if (existing) {
+    existing.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const replay = ctx.replayFor?.(sessionId);
+    if (replay) {
+      for (const update of replay) {
+        await ctx.sendNotification({ sessionId, update });
+      }
+    }
+    await ctx.sendNotification({
+      sessionId,
+      update: {
+        sessionUpdate: "session_info_update",
+        updatedAt: existing.updatedAt
+      }
+    });
+    await ctx.sendNotification({
+      sessionId,
+      update: {
+        sessionUpdate: "current_mode_update",
+        modeId: existing.modeId
+      }
+    });
+    await ctx.sendResult(id, {
+      initialMode: {
+        currentModeId: existing.modeId,
+        availableModes: ctx.modes
+      }
+    });
+    return false;
+  }
+  await ctx.sendError(id, -32e3, `session not found: ${sessionId}`);
+  return false;
+}
+async function handleSessionForkOp(ctx, id, params) {
+  const p = params ?? {};
+  const sourceId = typeof p.sessionId === "string" ? p.sessionId : null;
+  const source = sourceId ? ctx.sessions.get(sourceId) : void 0;
+  if (!sourceId || !source) {
+    await ctx.sendError(id, -32e3, `session not found: ${sourceId}`);
+    return false;
+  }
+  if (ctx.sessions.size >= ctx.maxSessions) {
+    await ctx.sendError(id, -32e3, `active session limit reached (${ctx.maxSessions})`);
+    return false;
+  }
+  let forkCwd = source.cwd;
+  if (typeof p.cwd === "string") {
+    const resolved = await resolveSessionCwd(p.cwd);
+    if (resolved === null) {
+      await ctx.sendError(id, -32602, `cwd must be an absolute path to an existing directory`);
+      return false;
+    }
+    forkCwd = resolved;
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const sessionId = `sess_${ctx.allocId()}`;
+  const forked = {
+    id: sessionId,
+    cwd: forkCwd,
+    abort: new AbortController(),
+    modeId: source.modeId,
+    createdAt: now,
+    updatedAt: now,
+    ...source.title !== void 0 ? { title: source.title } : {}
+  };
+  const history = (ctx.replayFor?.(sourceId) ?? []).map((update) => ({
+    sessionUpdate: update.sessionUpdate,
+    content: structuredClone(update.content)
+  }));
+  ctx.sessions.set(sessionId, forked);
+  ctx.seedFor?.(sessionId, history);
+  ctx.onSessionNew(forked);
+  await ctx.persist(forked, history);
+  await ctx.sendNotification({
+    sessionId,
+    update: { sessionUpdate: "current_mode_update", modeId: forked.modeId }
+  });
+  await ctx.sendResult(id, {
+    sessionId,
+    modes: ctx.modes,
+    configOptions: ctx.configOptions
+  });
+  return false;
+}
+async function handleSessionPromptOp(ctx, id, params) {
+  const p = params ?? {};
+  const sessionId = typeof p.sessionId === "string" ? p.sessionId : null;
+  if (!sessionId || !ctx.sessions.has(sessionId)) {
+    await ctx.sendError(id, -32e3, "unknown or missing sessionId");
+    return false;
+  }
+  if (!Array.isArray(p.prompt)) {
+    await ctx.sendError(id, -32602, "prompt must be an array of content blocks");
+    return false;
+  }
+  const session = ctx.sessions.get(sessionId);
+  if (session.abort.signal.aborted) {
+    session.abort = new AbortController();
+  }
+  const turnSignal = new AbortController();
+  const onCancel = () => turnSignal.abort();
+  session.abort.signal.addEventListener("abort", onCancel, { once: true });
+  const api = createRunTurnApi(
+    sessionId,
+    ctx.clientCapabilities ?? {},
+    (method, req) => ctx.request(method, req)
+  );
+  let result;
+  const pendingNotifications = [];
+  const emit = (update) => {
+    const notifPromise = ctx.sendNotification({ sessionId, update });
+    pendingNotifications.push(notifPromise.catch(() => {
+    }));
+  };
+  try {
+    result = await ctx.runTurn(
+      { sessionId, prompt: p.prompt, signal: turnSignal.signal },
+      emit,
+      api
+    );
+  } catch (err) {
+    session.abort.signal.removeEventListener("abort", onCancel);
+    const { code, message, data } = errorToJsonRpc(err);
+    await ctx.sendError(id, code, message, data);
+    return false;
+  }
+  await Promise.all(pendingNotifications);
+  session.abort.signal.removeEventListener("abort", onCancel);
+  session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await ctx.persist(session);
+  await ctx.sendResult(id, { stopReason: result.stopReason });
+  return false;
+}
+async function handleSetModeOp(ctx, id, params) {
+  const p = params ?? {};
+  const sessionId = typeof p.sessionId === "string" ? p.sessionId : null;
+  const modeId = typeof p.modeId === "string" ? p.modeId : null;
+  const session = sessionId ? ctx.sessions.get(sessionId) : void 0;
+  if (!session || !modeId || !ctx.modes.some((m) => m.id === modeId)) {
+    await ctx.sendError(id, -32602, "invalid sessionId or modeId");
+    return false;
+  }
+  session.modeId = modeId;
+  session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await ctx.sendNotification({
+    sessionId,
+    update: { sessionUpdate: "current_mode_update", modeId }
+  });
+  await ctx.sendResult(id, {});
+  return false;
+}
+async function handleSetConfigOptionOp(ctx, id, params) {
+  const p = params ?? {};
+  const sessionId = typeof p.sessionId === "string" ? p.sessionId : null;
+  const optionId = typeof p.configId === "string" ? p.configId : null;
+  const value = typeof p.value === "string" ? p.value : null;
+  const session = sessionId ? ctx.sessions.get(sessionId) : void 0;
+  const option = optionId ? ctx.configOptions.find((o) => o.id === optionId) : void 0;
+  if (!session || !option || value === null || !option.options.some((o) => o.value === value)) {
+    await ctx.sendError(id, -32602, "invalid sessionId, configId, or value");
+    return false;
+  }
+  option.currentValue = value;
+  session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await ctx.sendNotification({
+    sessionId,
+    update: {
+      sessionUpdate: "config_option_update",
+      configOptions: [...ctx.configOptions]
+    }
+  });
+  await ctx.sendResult(id, { configOptions: [...ctx.configOptions] });
+  return false;
+}
+
+// src/agent/protocol-handler.ts
 var ACPProtocolHandler = class {
   transport;
   defaultCwd;
@@ -159,6 +537,27 @@ var ACPProtocolHandler = class {
     } catch {
     }
   }
+  sessionContext() {
+    return {
+      sessions: this.sessions,
+      maxSessions: this.maxSessions,
+      defaultCwd: this.defaultCwd,
+      modes: this.modes,
+      configOptions: this.configOptions,
+      store: this.store,
+      replayFor: this.replayFor,
+      seedFor: this.seedFor,
+      onSessionNew: this.onSessionNew,
+      allocId: () => this.allocId(),
+      persist: (state, history) => this.persist(state, history),
+      sendNotification: (params) => this.sendNotification(params),
+      sendError: (id, code, message, data) => this.sendError(id, code, message, data),
+      sendResult: (id, result) => this.sendResult(id, result),
+      request: (method, params, timeoutMs) => this.request(method, params, timeoutMs),
+      runTurn: this.runTurn,
+      clientCapabilities: this.clientCapabilities
+    };
+  }
   // ────────────────────────────────────────────────────────────────────
   // Requests
   // ────────────────────────────────────────────────────────────────────
@@ -176,9 +575,9 @@ var ACPProtocolHandler = class {
         case "logout":
           return await this.handleLogout(id, params);
         case "session/new":
-          return await this.handleSessionNew(id, params);
+          return await handleSessionNewOp(this.sessionContext(), id, params);
         case "session/load":
-          return await this.handleSessionLoad(id, params);
+          return await handleSessionLoadOp(this.sessionContext(), id, params);
         case "session/resume":
           return await this.handleSessionResume(id, params);
         case "session/close":
@@ -186,15 +585,15 @@ var ACPProtocolHandler = class {
         case "session/delete":
           return await this.handleSessionDelete(id, params);
         case "session/prompt":
-          return await this.handleSessionPrompt(id, params);
+          return await handleSessionPromptOp(this.sessionContext(), id, params);
         case "session/set_mode":
-          return await this.handleSetMode(id, params);
+          return await handleSetModeOp(this.sessionContext(), id, params);
         case "session/set_config_option":
-          return await this.handleSetConfigOption(id, params);
+          return await handleSetConfigOptionOp(this.sessionContext(), id, params);
         case "session/list":
           return await this.handleSessionList(id);
         case "session/fork":
-          return await this.handleSessionFork(id, params);
+          return await handleSessionForkOp(this.sessionContext(), id, params);
         case "providers/list":
           return await this.handleProvidersList(id, params);
         case "providers/set":
@@ -219,232 +618,32 @@ var ACPProtocolHandler = class {
       this.clientCapabilities = p.clientCapabilities;
     }
     this.initialized = true;
-    await this.transport.send(
-      toWire({
-        jsonrpc: "2.0",
-        id,
-        result: {
-          protocolVersion: ACP_PROTOCOL_VERSION,
-          agentCapabilities: {
-            loadSession: true,
-            promptCapabilities: {
-              // 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: {},
-              fork: {}
-            },
-            auth: {
-              logout: {}
-            }
-          },
-          agentInfo: {
-            name: this.agentName,
-            title: "WrongStack",
-            version: WRONGSTACK_VERSION
-          },
-          authMethods: WRONGSTACK_AUTH_METHODS,
-          modes: this.modes,
-          configOptions: this.configOptions
-        }
-      })
+    await this.sendResult(
+      id,
+      buildInitializeResult(this.agentName, this.modes, this.configOptions)
     );
     return false;
   }
   async handleAuthenticate(id, _params) {
-    await this.transport.send(
-      toWire({
-        jsonrpc: "2.0",
-        id,
-        result: { outcome: "unauthenticated" }
-      })
-    );
+    await this.sendResult(id, { outcome: "unauthenticated" });
     return false;
   }
   async handleLogout(id, _params) {
-    await this.transport.send(
-      toWire({
-        jsonrpc: "2.0",
-        id,
-        result: {}
-      })
-    );
+    await this.sendResult(id, {});
     return false;
   }
-  async handleSessionNew(id, params) {
-    if (this.sessions.size >= this.maxSessions) {
-      await this.sendError(id, -32e3, `active session limit reached (${this.maxSessions})`);
-      return false;
-    }
-    const p = params ?? {};
-    let cwd = this.defaultCwd;
-    if (typeof p.cwd === "string") {
-      const resolved = await this.resolveSessionCwd(p.cwd);
-      if (resolved === null) {
-        await this.sendError(id, -32602, `cwd must be an absolute path to an existing directory`);
-        return false;
-      }
-      cwd = resolved;
-    }
-    const sessionId = `sess_${this.allocId()}`;
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const state = {
-      id: sessionId,
-      cwd,
-      abort: new AbortController(),
-      modeId: DEFAULT_MODE_ID,
-      createdAt: now,
-      updatedAt: now
-    };
-    this.sessions.set(sessionId, state);
-    this.onSessionNew(state);
-    await this.persist(state);
-    await this.sendNotification({
-      sessionId,
-      update: {
-        sessionUpdate: "current_mode_update",
-        modeId: this.modes[0]?.id ?? DEFAULT_MODE_ID
-      }
-    });
-    if (this.configOptions.length > 0) {
-      await this.sendNotification({
-        sessionId,
-        update: {
-          sessionUpdate: "config_option_update",
-          configOptions: [...this.configOptions]
-        }
-      });
-    }
-    await this.transport.send(
-      toWire({
-        jsonrpc: "2.0",
-        id,
-        result: {
-          sessionId,
-          modes: this.modes,
-          configOptions: this.configOptions
-        }
-      })
-    );
-    return false;
-  }
-  async handleSessionLoad(id, params) {
+  async handleSessionResume(id, params) {
     const p = params ?? {};
     const sessionId = typeof p.sessionId === "string" ? p.sessionId : null;
-    const loadCwd = typeof p.cwd === "string" ? p.cwd : void 0;
     const existing = sessionId ? this.sessions.get(sessionId) : void 0;
-    if (!existing && sessionId && this.store) {
-      const persisted = await this.store.load(sessionId);
-      if (persisted) {
-        if (this.sessions.size >= this.maxSessions) {
-          await this.sendError(id, -32e3, `active session limit reached (${this.maxSessions})`);
-          return false;
-        }
-        if (loadCwd !== void 0 && await this.resolveSessionCwd(loadCwd) === null) {
-          await this.sendError(id, -32602, `cwd must be an absolute path to an existing directory`);
-          return false;
-        }
-        const candidateCwd = persisted.cwd ?? loadCwd ?? this.defaultCwd;
-        const restoredCwd = await this.resolveSessionCwd(candidateCwd) ?? this.defaultCwd;
-        const restored = {
-          id: sessionId,
-          cwd: restoredCwd,
-          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 = this.replayFor?.(sessionId);
-      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.sendResult(id, {
+        initialMode: {
+          currentModeId: existing.modeId,
+          availableModes: this.modes
         }
       });
-      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}`);
@@ -461,13 +660,7 @@ var ACPProtocolHandler = class {
     session.abort.abort();
     this.sessions.delete(sessionId);
     this.disposeSession(sessionId);
-    await this.transport.send(
-      toWire({
-        jsonrpc: "2.0",
-        id,
-        result: {}
-      })
-    );
+    await this.sendResult(id, {});
     return false;
   }
   async handleSessionDelete(id, params) {
@@ -478,252 +671,37 @@ var ACPProtocolHandler = class {
       return false;
     }
     if (!this.sessions.has(sessionId)) {
-      await this.transport.send(
-        toWire({ jsonrpc: "2.0", id, result: { configOptions: [...this.configOptions] } })
-      );
+      await this.sendResult(id, { configOptions: [...this.configOptions] });
       return false;
     }
     const session = this.sessions.get(sessionId);
     session.abort.abort();
     this.sessions.delete(sessionId);
     this.disposeSession(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;
-    const source = sourceId ? this.sessions.get(sourceId) : void 0;
-    if (!sourceId || !source) {
-      await this.sendError(id, -32e3, `session not found: ${sourceId}`);
-      return false;
-    }
-    if (this.sessions.size >= this.maxSessions) {
-      await this.sendError(id, -32e3, `active session limit reached (${this.maxSessions})`);
-      return false;
-    }
-    let forkCwd = source.cwd;
-    if (typeof p.cwd === "string") {
-      const resolved = await this.resolveSessionCwd(p.cwd);
-      if (resolved === null) {
-        await this.sendError(id, -32602, `cwd must be an absolute path to an existing directory`);
-        return false;
-      }
-      forkCwd = resolved;
-    }
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const sessionId = `sess_${this.allocId()}`;
-    const forked = {
-      id: sessionId,
-      cwd: forkCwd,
-      abort: new AbortController(),
-      modeId: source.modeId,
-      createdAt: now,
-      updatedAt: now,
-      ...source.title !== void 0 ? { title: source.title } : {}
-    };
-    const history = (this.replayFor?.(sourceId) ?? []).map((update) => ({
-      sessionUpdate: update.sessionUpdate,
-      content: structuredClone(update.content)
-    }));
-    this.sessions.set(sessionId, forked);
-    this.seedFor?.(sessionId, history);
-    this.onSessionNew(forked);
-    await this.persist(forked, history);
-    await this.sendNotification({
-      sessionId,
-      update: { sessionUpdate: "current_mode_update", modeId: forked.modeId }
-    });
-    await this.transport.send(
-      toWire({
-        jsonrpc: "2.0",
-        id,
-        result: {
-          sessionId,
-          modes: this.modes,
-          configOptions: this.configOptions
-        }
-      })
-    );
+    await this.sendResult(id, {});
     return false;
   }
   async handleProvidersList(id, _params) {
-    await this.transport.send(
-      toWire({
-        jsonrpc: "2.0",
-        id,
-        result: {
-          providers: [],
-          currentProviderId: null
-        }
-      })
-    );
+    await this.sendResult(id, {
+      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 ?? {};
-    const sessionId = typeof p.sessionId === "string" ? p.sessionId : null;
-    if (!sessionId || !this.sessions.has(sessionId)) {
-      await this.sendError(id, -32e3, "unknown or missing sessionId");
-      return false;
-    }
-    if (!Array.isArray(p.prompt)) {
-      await this.sendError(id, -32602, "prompt must be an array of content blocks");
-      return false;
-    }
-    const session = this.sessions.get(sessionId);
-    if (session.abort.signal.aborted) {
-      session.abort = new AbortController();
-    }
-    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;
-    const pendingNotifications = [];
-    const emit = (update) => {
-      const p2 = this.sendNotification({ sessionId, update });
-      pendingNotifications.push(p2.catch(() => {
-      }));
-    };
-    try {
-      result = await this.runTurn(
-        { sessionId, prompt: p.prompt, signal: turnSignal.signal },
-        emit,
-        api
-      );
-    } catch (err) {
-      session.abort.signal.removeEventListener("abort", onCancel);
-      const { code, message, data } = errorToJsonRpc(err);
-      await this.sendError(id, code, message, data);
-      return false;
-    }
-    await Promise.all(pendingNotifications);
-    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,
-        result: { stopReason: result.stopReason }
-      })
+      -32e3,
+      "provider configuration not available through ACP; use wstack auth"
     );
     return false;
   }
-  async handleSetMode(id, params) {
-    const p = params ?? {};
-    const sessionId = typeof p.sessionId === "string" ? p.sessionId : null;
-    const modeId = typeof p.modeId === "string" ? p.modeId : null;
-    const session = sessionId ? this.sessions.get(sessionId) : void 0;
-    if (!session || !modeId || !this.modes.some((m) => m.id === modeId)) {
-      await this.sendError(id, -32602, "invalid sessionId or modeId");
-      return false;
-    }
-    session.modeId = modeId;
-    session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    await this.sendNotification({
-      sessionId,
-      update: { sessionUpdate: "current_mode_update", modeId }
-    });
-    await this.transport.send(toWire({ jsonrpc: "2.0", id, result: {} }));
+  async handleProvidersDisable(id, _params) {
+    await this.sendResult(id, {});
     return false;
   }
-  async handleSetConfigOption(id, params) {
-    const p = params ?? {};
-    const sessionId = typeof p.sessionId === "string" ? p.sessionId : 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, configId, or value");
-      return false;
-    }
-    option.currentValue = value;
-    session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    await this.sendNotification({
-      sessionId,
-      update: {
-        sessionUpdate: "config_option_update",
-        configOptions: [...this.configOptions]
-      }
-    });
-    await this.transport.send(
-      toWire({ jsonrpc: "2.0", id, result: { configOptions: [...this.configOptions] } })
-    );
+  async handleMcpMessage(id, _params) {
+    await this.sendError(id, -32e3, "MCP message routing not available through ACP");
     return false;
   }
   async handleSessionList(id) {
@@ -736,13 +714,7 @@ var ACPProtocolHandler = class {
       if (s.title !== void 0) out.title = s.title;
       return out;
     });
-    await this.transport.send(
-      toWire({
-        jsonrpc: "2.0",
-        id,
-        result: { sessions }
-      })
-    );
+    await this.sendResult(id, { sessions });
     return false;
   }
   // ────────────────────────────────────────────────────────────────────
@@ -775,7 +747,9 @@ 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 sendResult(id, result) {
+    await this.transport.send(toWire({ jsonrpc: "2.0", id, result }));
+  }
   async persist(state, history = void 0) {
     if (!this.store) return;
     try {
@@ -788,71 +762,10 @@ var ACPProtocolHandler = class {
     if (data !== void 0) error.data = data;
     await this.transport.send(toWire({ jsonrpc: "2.0", id, error }));
   }
-  /**
-   * Allocate a session id (WS-015).
-   *
-   * This was `this.nextId++`, so ids were `sess_1`, `sess_2`, … — and the
-   * handler has no per-connection ownership: any caller that names a session
-   * id can `session/load`, `session/prompt`, `session/cancel` or
-   * `session/delete` it. Over stdio that is academic (one client per process),
-   * but the agent also serves over HTTP, where a guessable id is the whole
-   * authorization story for any local process or page that reaches the port.
-   *
-   * Random ids do not create ownership — they remove the trivial enumeration
-   * that made its absence exploitable. Real per-connection ownership is the
-   * larger fix and is noted in the WS-015 test file.
-   *
-   * The counter is retained: it keeps ids ordered for debugging and guarantees
-   * uniqueness within a process even in the (impossible) event of a UUID
-   * collision. The random half is what makes the id unguessable.
-   */
-  /**
-   * Resolve a client-supplied `cwd` for a session, or `null` when it is not
-   * usable (WS-015).
-   *
-   * `session/new`, `session/load` and `session/fork` all took `params.cwd`
-   * with a single `typeof === 'string'` check and nothing else. That value is
-   * the working directory the agent then reads, writes and executes in.
-   *
-   * SCOPE, deliberately stated: this does NOT confine the session to a root.
-   * In ACP the client IS the editor and legitimately names its own workspace —
-   * Zed and JetBrains pass the project root — so a fixed boundary here would
-   * break the integration this package exists for. What it enforces is that
-   * the directory is absolute and actually exists as a directory: a relative
-   * or missing `cwd` is a bug or an attack under either reading, and silently
-   * running the agent somewhere other than where the client asked is worse
-   * than refusing. Confinement, if wanted, belongs in an operator-set option
-   * on top of this, not in place of it.
-   */
-  async resolveSessionCwd(requested) {
-    if (!path.isAbsolute(requested)) return null;
-    const resolved = path.resolve(requested);
-    try {
-      const stat3 = await fsp.stat(resolved);
-      return stat3.isDirectory() ? resolved : null;
-    } catch {
-      return null;
-    }
-  }
   allocId() {
     return `${this.nextId++}_${randomUUID().replaceAll("-", "")}`;
   }
 };
-function errorToJsonRpc(err) {
-  if (err && typeof err === "object") {
-    const e = err;
-    if (typeof e.code === "number" && typeof e.message === "string") {
-      const result = {
-        code: e.code,
-        message: e.message
-      };
-      if (e.data !== void 0) result.data = e.data;
-      return result;
-    }
-  }
-  const message = err instanceof Error ? err.message : String(err);
-  return { code: -32603, message };
-}
 
 // src/agent/stdio-transport.ts
 import { expectDefined, writeErr } from "@wrongstack/core/utils";
@@ -2757,6 +2670,220 @@ function isBestEffortAckMethod(method) {
   return method === "mcp/connect" || method === "mcp/message" || method === "mcp/disconnect" || method === "elicitation/create" || method === "elicitation/complete";
 }
 
+// src/client/acp-session-ops.ts
+function filterMcpServers(agentCapabilities, servers) {
+  if (!servers || servers.length === 0) return [];
+  const mcpCaps = agentCapabilities.mcpCapabilities ?? {};
+  return servers.filter((s) => {
+    if ("type" in s && s.type === "http") return mcpCaps.http === true;
+    if ("type" in s && s.type === "sse") return mcpCaps.sse === true;
+    return true;
+  });
+}
+async function executeLoadSession(ctx, sessionId, mcpServers, cwd) {
+  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
+  if (!ctx.agentCapabilities.loadSession) {
+    throw new ACPSessionError(
+      "unsupported_capability",
+      "agent does not support session/load (loadSession capability not advertised)"
+    );
+  }
+  if (ctx.sessionId) {
+    await ctx.closeSession();
+  }
+  ctx.resetScratch();
+  const servers = filterMcpServers(ctx.agentCapabilities, mcpServers ?? ctx.opts.mcpServers);
+  const id = ctx.allocId();
+  const result = await ctx.sendRequest(id, "session/load", {
+    sessionId,
+    cwd: cwd ?? ctx.opts.cwd ?? ctx.opts.projectRoot,
+    mcpServers: servers
+  });
+  if (isJsonRpcError(result)) {
+    throw new ACPSessionError("prompt_failed", `session/load failed: ${result.message}`, result);
+  }
+  ctx.setSessionId(sessionId);
+}
+async function executeResumeSession(ctx, sessionId, mcpServers, cwd) {
+  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
+  if (!ctx.agentCapabilities.sessionCapabilities?.resume) {
+    throw new ACPSessionError(
+      "unsupported_capability",
+      "agent does not support session/resume (sessionCapabilities.resume not advertised)"
+    );
+  }
+  if (ctx.sessionId) {
+    await ctx.closeSession();
+  }
+  const servers = filterMcpServers(ctx.agentCapabilities, mcpServers ?? ctx.opts.mcpServers);
+  const id = ctx.allocId();
+  const result = await ctx.sendRequest(id, "session/resume", {
+    sessionId,
+    cwd: cwd ?? ctx.opts.cwd ?? ctx.opts.projectRoot,
+    mcpServers: servers
+  });
+  if (isJsonRpcError(result)) {
+    throw new ACPSessionError(
+      "prompt_failed",
+      `session/resume failed: ${result.message}`,
+      result
+    );
+  }
+  ctx.setSessionId(sessionId);
+}
+async function executeListSessions(ctx, cursor, cwd) {
+  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
+  if (!ctx.agentCapabilities.sessionCapabilities?.list) {
+    throw new ACPSessionError(
+      "unsupported_capability",
+      "agent does not support session/list (sessionCapabilities.list not advertised)"
+    );
+  }
+  const id = ctx.allocId();
+  const params = {};
+  if (cursor !== void 0) params.cursor = cursor;
+  if (cwd !== void 0) params.cwd = cwd;
+  const result = await ctx.sendRequest(id, "session/list", params);
+  if (isJsonRpcError(result)) {
+    throw new ACPSessionError("prompt_failed", `session/list failed: ${result.message}`, result);
+  }
+  const r = result;
+  return {
+    sessions: r.sessions ?? [],
+    nextCursor: r.nextCursor
+  };
+}
+async function executeDeleteSession(ctx, sessionId) {
+  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
+  if (!ctx.agentCapabilities.sessionCapabilities?.delete) {
+    throw new ACPSessionError(
+      "unsupported_capability",
+      "agent does not support session/delete (sessionCapabilities.delete not advertised)"
+    );
+  }
+  const id = ctx.allocId();
+  const result = await ctx.sendRequest(id, "session/delete", { sessionId });
+  if (isJsonRpcError(result)) {
+    throw new ACPSessionError(
+      "prompt_failed",
+      `session/delete failed: ${result.message}`,
+      result
+    );
+  }
+  if (ctx.sessionId === sessionId) {
+    ctx.setSessionId(null);
+  }
+}
+async function executeForkSession(ctx, sourceSessionId, cwd, mcpServers) {
+  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
+  const servers = filterMcpServers(ctx.agentCapabilities, mcpServers ?? ctx.opts.mcpServers);
+  const id = ctx.allocId();
+  const result = await ctx.sendRequest(id, "session/fork", {
+    sessionId: sourceSessionId,
+    cwd: cwd ?? ctx.opts.cwd ?? ctx.opts.projectRoot,
+    ...servers.length > 0 ? { mcpServers: servers } : {}
+  });
+  if (isJsonRpcError(result)) {
+    throw new ACPSessionError("prompt_failed", `session/fork failed: ${result.message}`, result);
+  }
+  const newId = result.sessionId;
+  if (typeof newId !== "string" || !newId) {
+    throw new ACPSessionError("protocol_error", "session/fork returned no sessionId", result);
+  }
+  return newId;
+}
+async function executeSetMode(ctx, sessionId, modeId) {
+  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
+  const id = ctx.allocId();
+  const result = await ctx.sendRequest(id, "session/set_mode", { sessionId, modeId });
+  if (isJsonRpcError(result)) {
+    throw new ACPSessionError(
+      "prompt_failed",
+      `session/set_mode failed: ${result.message}`,
+      result
+    );
+  }
+}
+async function executeSetConfigOption(ctx, sessionId, configId, value) {
+  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
+  const id = ctx.allocId();
+  const result = await ctx.sendRequest(id, "session/set_config_option", {
+    sessionId,
+    configId,
+    value
+  });
+  if (isJsonRpcError(result)) {
+    throw new ACPSessionError(
+      "prompt_failed",
+      `session/set_config_option failed: ${result.message}`,
+      result
+    );
+  }
+}
+async function executeListProviders(ctx) {
+  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
+  const id = ctx.allocId();
+  const result = await ctx.sendRequest(id, "providers/list", {});
+  if (isJsonRpcError(result)) {
+    throw new ACPSessionError(
+      "prompt_failed",
+      `providers/list failed: ${result.message}`,
+      result
+    );
+  }
+  const r = result;
+  return { providers: r.providers ?? [], currentProviderId: r.currentProviderId ?? null };
+}
+async function executeSetProvider(ctx, providerId, config) {
+  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
+  const id = ctx.allocId();
+  const result = await ctx.sendRequest(id, "providers/set", { providerId, ...config ?? {} });
+  if (isJsonRpcError(result)) {
+    throw new ACPSessionError("prompt_failed", `providers/set failed: ${result.message}`, result);
+  }
+}
+async function executeDisableProvider(ctx) {
+  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
+  const id = ctx.allocId();
+  const result = await ctx.sendRequest(id, "providers/disable", {});
+  if (isJsonRpcError(result)) {
+    throw new ACPSessionError(
+      "prompt_failed",
+      `providers/disable failed: ${result.message}`,
+      result
+    );
+  }
+}
+async function executeMcpMessage(ctx, connectionId, message) {
+  if (ctx.closed) throw new ACPSessionError("closed", "session is closed");
+  const id = ctx.allocId();
+  const result = await ctx.sendRequest(id, "mcp/message", { connectionId, message });
+  if (isJsonRpcError(result)) {
+    throw new ACPSessionError("prompt_failed", `mcp/message failed: ${result.message}`, result);
+  }
+  return result;
+}
+async function executeCreateSession(ctx) {
+  const servers = filterMcpServers(ctx.agentCapabilities, ctx.opts.mcpServers);
+  const id = ctx.allocId();
+  const result = await ctx.sendRequest(id, "session/new", {
+    cwd: ctx.opts.cwd ?? ctx.opts.projectRoot,
+    mcpServers: servers
+  });
+  if (isJsonRpcError(result)) {
+    throw new ACPSessionError(
+      "session_create_failed",
+      `session/new failed: ${result.message}`,
+      result
+    );
+  }
+  const sessionId = result.sessionId;
+  if (typeof sessionId !== "string" || sessionId.length === 0) {
+    throw new ACPSessionError("protocol_error", "session/new returned no sessionId", result);
+  }
+  return sessionId;
+}
+
 // src/client/acp-session.ts
 var ACPSession = class _ACPSession {
   transport;
@@ -2945,9 +3072,6 @@ var ACPSession = class _ACPSession {
   /**
    * Authenticate with the agent using one of the advertised auth methods.
    * Call this AFTER start() and BEFORE any session/new call.
-   *
-   * Throws ACPSessionError('auth_failed') if the agent rejects the
-   * authentication or if the methodId is not in the advertised list.
    */
   async authenticate(methodId) {
     if (this.state === "closed") {
@@ -2994,268 +3118,59 @@ var ACPSession = class _ACPSession {
     this.state = "ready";
   }
   // ──────────────────────────────────────────────────────────────────────
-  // Session management
+  // Session management delegation
   // ──────────────────────────────────────────────────────────────────────
-  /**
-   * Load an existing session. The agent replays the conversation history
-   * via session/update notifications before responding.
-   *
-   * Only works if the agent advertises `loadSession` capability.
-   *
-   * @param sessionId - The session to load
-   * @param mcpServers - Optional MCP servers (defaults to options.mcpServers)
-   * @param cwd - Optional working directory (defaults to options.cwd or projectRoot)
-   */
+  opContext() {
+    return {
+      closed: this.closed,
+      sessionId: this.sessionId,
+      agentCapabilities: this.agentCapabilities,
+      opts: this.opts,
+      allocId: () => this.allocId(),
+      sendRequest: (id, method, params, timeoutMs) => this.sendRequest(id, method, params, timeoutMs),
+      setSessionId: (id) => {
+        this.sessionId = id;
+      },
+      resetScratch: () => this.resetScratch(),
+      closeSession: () => this.closeSession()
+    };
+  }
   async loadSession(sessionId, mcpServers, cwd) {
-    if (this.closed) {
-      throw new ACPSessionError("closed", "session is closed");
-    }
-    if (!this.agentCapabilities.loadSession) {
-      throw new ACPSessionError(
-        "unsupported_capability",
-        "agent does not support session/load (loadSession capability not advertised)"
-      );
-    }
-    if (this.sessionId) {
-      await this.closeSession();
-    }
-    this.resetScratch();
-    const servers = this.filterMcpServers(mcpServers ?? this.opts.mcpServers);
-    const id = this.allocId();
-    const result = await this.sendRequest(id, "session/load", {
-      sessionId,
-      cwd: cwd ?? this.opts.cwd ?? this.opts.projectRoot,
-      mcpServers: servers
-    });
-    if (isJsonRpcError(result)) {
-      throw new ACPSessionError("prompt_failed", `session/load failed: ${result.message}`, result);
-    }
-    this.sessionId = sessionId;
+    return executeLoadSession(this.opContext(), sessionId, mcpServers, cwd);
   }
-  /**
-   * Resume an existing session without replaying history.
-   *
-   * Only works if the agent advertises `sessionCapabilities.resume`.
-   *
-   * @param sessionId - The session to resume
-   * @param mcpServers - Optional MCP servers (defaults to options.mcpServers)
-   * @param cwd - Optional working directory (defaults to options.cwd or projectRoot)
-   */
   async resumeSession(sessionId, mcpServers, cwd) {
-    if (this.closed) {
-      throw new ACPSessionError("closed", "session is closed");
-    }
-    if (!this.agentCapabilities.sessionCapabilities?.resume) {
-      throw new ACPSessionError(
-        "unsupported_capability",
-        "agent does not support session/resume (sessionCapabilities.resume not advertised)"
-      );
-    }
-    if (this.sessionId) {
-      await this.closeSession();
-    }
-    const servers = this.filterMcpServers(mcpServers ?? this.opts.mcpServers);
-    const id = this.allocId();
-    const result = await this.sendRequest(id, "session/resume", {
-      sessionId,
-      cwd: cwd ?? this.opts.cwd ?? this.opts.projectRoot,
-      mcpServers: servers
-    });
-    if (isJsonRpcError(result)) {
-      throw new ACPSessionError(
-        "prompt_failed",
-        `session/resume failed: ${result.message}`,
-        result
-      );
-    }
-    this.sessionId = sessionId;
+    return executeResumeSession(this.opContext(), sessionId, mcpServers, cwd);
   }
-  /**
-   * List existing sessions known to the agent.
-   *
-   * Only works if the agent advertises `sessionCapabilities.list`.
-   */
   async listSessions(cursor, cwd) {
-    if (this.closed) {
-      throw new ACPSessionError("closed", "session is closed");
-    }
-    if (!this.agentCapabilities.sessionCapabilities?.list) {
-      throw new ACPSessionError(
-        "unsupported_capability",
-        "agent does not support session/list (sessionCapabilities.list not advertised)"
-      );
-    }
-    const id = this.allocId();
-    const params = {};
-    if (cursor !== void 0) params.cursor = cursor;
-    if (cwd !== void 0) params.cwd = cwd;
-    const result = await this.sendRequest(id, "session/list", params);
-    if (isJsonRpcError(result)) {
-      throw new ACPSessionError("prompt_failed", `session/list failed: ${result.message}`, result);
-    }
-    const r = result;
-    return {
-      sessions: r.sessions ?? [],
-      nextCursor: r.nextCursor
-    };
+    return executeListSessions(this.opContext(), cursor, cwd);
   }
-  /**
-   * Delete a session from the agent's session list.
-   *
-   * Only works if the agent advertises `sessionCapabilities.delete`.
-   */
   async deleteSession(sessionId) {
-    if (this.closed) {
-      throw new ACPSessionError("closed", "session is closed");
-    }
-    if (!this.agentCapabilities.sessionCapabilities?.delete) {
-      throw new ACPSessionError(
-        "unsupported_capability",
-        "agent does not support session/delete (sessionCapabilities.delete not advertised)"
-      );
-    }
-    const id = this.allocId();
-    const result = await this.sendRequest(id, "session/delete", { sessionId });
-    if (isJsonRpcError(result)) {
-      throw new ACPSessionError(
-        "prompt_failed",
-        `session/delete failed: ${result.message}`,
-        result
-      );
-    }
-    if (this.sessionId === sessionId) {
-      this.sessionId = null;
-    }
+    return executeDeleteSession(this.opContext(), sessionId);
   }
-  /**
-   * Fork a session — create a new session from an existing one.
-   */
   async forkSession(sourceSessionId, cwd, mcpServers) {
-    if (this.closed) throw new ACPSessionError("closed", "session is closed");
-    const servers = this.filterMcpServers(mcpServers ?? this.opts.mcpServers);
-    const id = this.allocId();
-    const result = await this.sendRequest(id, "session/fork", {
-      sessionId: sourceSessionId,
-      cwd: cwd ?? this.opts.cwd ?? this.opts.projectRoot,
-      ...servers.length > 0 ? { mcpServers: servers } : {}
-    });
-    if (isJsonRpcError(result)) {
-      throw new ACPSessionError("prompt_failed", `session/fork failed: ${result.message}`, result);
-    }
-    const newId = result.sessionId;
-    if (typeof newId !== "string" || !newId) {
-      throw new ACPSessionError("protocol_error", "session/fork returned no sessionId", result);
-    }
-    return newId;
+    return executeForkSession(this.opContext(), sourceSessionId, cwd, mcpServers);
   }
-  /**
-   * Set the active mode for a session.
-   */
   async setMode(sessionId, modeId) {
-    if (this.closed) throw new ACPSessionError("closed", "session is closed");
-    const id = this.allocId();
-    const result = await this.sendRequest(id, "session/set_mode", { sessionId, modeId });
-    if (isJsonRpcError(result)) {
-      throw new ACPSessionError(
-        "prompt_failed",
-        `session/set_mode failed: ${result.message}`,
-        result
-      );
-    }
+    return executeSetMode(this.opContext(), sessionId, modeId);
   }
-  /**
-   * Set a configuration option for a session.
-   */
   async setConfigOption(sessionId, configId, value) {
-    if (this.closed) throw new ACPSessionError("closed", "session is closed");
-    const id = this.allocId();
-    const result = await this.sendRequest(id, "session/set_config_option", {
-      sessionId,
-      configId,
-      value
-    });
-    if (isJsonRpcError(result)) {
-      throw new ACPSessionError(
-        "prompt_failed",
-        `session/set_config_option failed: ${result.message}`,
-        result
-      );
-    }
+    return executeSetConfigOption(this.opContext(), sessionId, configId, value);
   }
-  /**
-   * List available providers and the current provider.
-   */
   async listProviders() {
-    if (this.closed) throw new ACPSessionError("closed", "session is closed");
-    const id = this.allocId();
-    const result = await this.sendRequest(id, "providers/list", {});
-    if (isJsonRpcError(result)) {
-      throw new ACPSessionError(
-        "prompt_failed",
-        `providers/list failed: ${result.message}`,
-        result
-      );
-    }
-    const r = result;
-    return { providers: r.providers ?? [], currentProviderId: r.currentProviderId ?? null };
+    return executeListProviders(this.opContext());
   }
-  /**
-   * Send an MCP message to the agent for routing.
-   */
   async mcpMessage(connectionId, message) {
-    if (this.closed) throw new ACPSessionError("closed", "session is closed");
-    const id = this.allocId();
-    const result = await this.sendRequest(id, "mcp/message", { connectionId, message });
-    if (isJsonRpcError(result)) {
-      throw new ACPSessionError("prompt_failed", `mcp/message failed: ${result.message}`, result);
-    }
-    return result;
+    return executeMcpMessage(this.opContext(), connectionId, message);
   }
-  /**
-   * Set the active provider for the agent.
-   */
   async setProvider(providerId, config) {
-    if (this.closed) throw new ACPSessionError("closed", "session is closed");
-    const id = this.allocId();
-    const result = await this.sendRequest(id, "providers/set", { providerId, ...config ?? {} });
-    if (isJsonRpcError(result)) {
-      throw new ACPSessionError("prompt_failed", `providers/set failed: ${result.message}`, result);
-    }
+    return executeSetProvider(this.opContext(), providerId, config);
   }
-  /**
-   * Disable the current provider.
-   */
   async disableProvider() {
-    if (this.closed) throw new ACPSessionError("closed", "session is closed");
-    const id = this.allocId();
-    const result = await this.sendRequest(id, "providers/disable", {});
-    if (isJsonRpcError(result)) {
-      throw new ACPSessionError(
-        "prompt_failed",
-        `providers/disable failed: ${result.message}`,
-        result
-      );
-    }
+    return executeDisableProvider(this.opContext());
   }
   // ──────────────────────────────────────────────────────────────────────
   // Prompt
   // ──────────────────────────────────────────────────────────────────────
-  /**
-   * Run one prompt turn. Creates a session if needed, sends the
-   * prompt, streams session/update notifications, and resolves with
-   * the agent's response.
-   *
-   * @param blocks - Content blocks to send. Use `textContent()` for plain
-   *   text, or include ImageContent/AudioContent if the agent's
-   *   `promptCapabilities` allow it.
-   * @param signal - AbortSignal for cancellation.
-   *
-   * Cancellation: if `signal` aborts mid-prompt, we send
-   * `session/cancel` (a notification per spec) and keep accepting
-   * updates until the agent returns with `stopReason: 'cancelled'`.
-   * The result is the same shape as a normal turn, with
-   * `stopReason === 'cancelled'`.
-   */
   async prompt(blocks, signal, onProgress) {
     if (this.closed) {
       throw new ACPSessionError("closed", "session is closed");
@@ -3267,7 +3182,7 @@ var ACPSession = class _ACPSession {
       return emptyRunResult("cancelled");
     }
     if (!this.sessionId) {
-      await this.createSession();
+      this.sessionId = await executeCreateSession(this.opContext());
     }
     this.resetScratch();
     this.progressHandler = onProgress ?? null;
@@ -3329,33 +3244,6 @@ var ACPSession = class _ACPSession {
       thoughts: this.scratch.thoughts
     };
   }
-  async createSession() {
-    const servers = this.filterMcpServers(this.opts.mcpServers);
-    const id = this.allocId();
-    const result = await this.sendRequest(id, "session/new", {
-      cwd: this.opts.cwd ?? this.opts.projectRoot,
-      mcpServers: servers
-    });
-    if (isJsonRpcError(result)) {
-      throw new ACPSessionError(
-        "session_create_failed",
-        `session/new failed: ${result.message}`,
-        result
-      );
-    }
-    const sessionId = result.sessionId;
-    if (typeof sessionId !== "string" || sessionId.length === 0) {
-      throw new ACPSessionError("protocol_error", "session/new returned no sessionId", result);
-    }
-    this.sessionId = sessionId;
-  }
-  /**
-   * Close the current session gracefully (if the agent supports it).
-   *
-   * Sends `session/close` JSON-RPC request, then clears the local
-   * session id. Best-effort — errors are swallowed so the caller can
-   * always proceed to transport teardown.
-   */
   async closeSession() {
     if (!this.sessionId) return;
     const sid = this.sessionId;
@@ -3371,7 +3259,6 @@ var ACPSession = class _ACPSession {
   // ──────────────────────────────────────────────────────────────────────
   // Lifecycle — close
   // ──────────────────────────────────────────────────────────────────────
-  /** Tear down the session and kill the child process. */
   async close() {
     if (this.closed) return;
     this.closed = true;
@@ -3398,24 +3285,6 @@ var ACPSession = class _ACPSession {
     } catch {
     }
   }
-  // ──────────────────────────────────────────────────────────────────────
-  // Helpers
-  // ──────────────────────────────────────────────────────────────────────
-  /**
-   * Filter MCP servers according to agent capabilities.
-   * - Stdio servers are always included.
-   * - HTTP servers are only included if agent supports mcpCapabilities.http.
-   * - SSE servers are only included if agent supports mcpCapabilities.sse.
-   */
-  filterMcpServers(servers) {
-    if (!servers || servers.length === 0) return [];
-    const mcpCaps = this.agentCapabilities.mcpCapabilities ?? {};
-    return servers.filter((s) => {
-      if ("type" in s && s.type === "http") return mcpCaps.http === true;
-      if ("type" in s && s.type === "sse") return mcpCaps.sse === true;
-      return true;
-    });
-  }
   // ────────────────────────────────────────────────────────────────────
   // Wire layer
   // ────────────────────────────────────────────────────────────────────
@@ -3446,21 +3315,9 @@ var ACPSession = class _ACPSession {
       });
     });
   }
-  /**
-   * Send a JSON-RPC 2.0 success response to an agent-initiated request.
-   *
-   * Per JSON-RPC 2.0 (and the official ACP SDK's message router) a Response
-   * object MUST carry `jsonrpc: "2.0"` and MUST NOT carry a `method` field —
-   * the SDK classifies any object with a `method` key as a Request and drops
-   * it as a response, so an agent's `fs/*`, `terminal/*`, or
-   * `session/request_permission` callback would hang forever. The legacy
-   * `ACPMessage` type predates v1 (requires `method`, lacks `jsonrpc`), so we
-   * build the correct wire object and cast at the boundary.
-   */
   sendResult(id, result) {
     return this.transport.send({ jsonrpc: "2.0", id, result });
   }
-  /** Send a JSON-RPC 2.0 error response (no `method` field, per spec). */
   sendErrorResponse(id, code, message) {
     return this.transport.send({
       jsonrpc: "2.0",
@@ -3556,9 +3413,7 @@ var ACPSession = class _ACPSession {
     } catch {
     }
   }
-  /** Live progress handler installed for the duration of a `prompt()` turn. */
   progressHandler = null;
-  // Per-prompt scratch state
   scratch = createSessionScratch();
   resetScratch() {
     this.scratch = createSessionScratch();