@wrongstack/acp 1.0.19 → 1.0.26

package/dist/client.js

@@ -213,6 +213,7 @@ var ClientTransport = class {
     this.messageQueue.length = 0;
     this.queuedChars = 0;
     this.handlers.clear();
+    this.claimHandlers.clear();
     if (code !== 0 && code !== null) {
       writeErr(`[acp-child exited with code ${code}]
 `);
@@ -223,17 +224,28 @@ var ClientTransport = class {
       const resolve3 = this.resolveRead;
       this.resolveRead = null;
       resolve3(msg);
-    } else if (this.handlers.size === 0) {
-      if (this.messageQueue.length >= this.maxQueuedMessages || this.queuedChars + chars > this.maxQueuedChars) {
-        writeErr(
-          `[acp-child message queue exceeds ${this.maxQueuedMessages} entries or ${this.maxQueuedChars} characters]
+    } else {
+      let claimed = false;
+      for (const handler of this.claimHandlers) {
+        try {
+          if (handler(msg)) claimed = true;
+        } catch (err) {
+          writeErr(`[acp-child handler error] ${err}
+`);
+        }
+      }
+      if (!claimed && this.handlers.size === 0) {
+        if (this.messageQueue.length >= this.maxQueuedMessages || this.queuedChars + chars > this.maxQueuedChars) {
+          writeErr(
+            `[acp-child message queue exceeds ${this.maxQueuedMessages} entries or ${this.maxQueuedChars} characters]
 `
-        );
-        this.stop();
-        return;
+          );
+          this.stop();
+          return;
+        }
+        this.messageQueue.push({ message: msg, chars });
+        this.queuedChars += chars;
       }
-      this.messageQueue.push({ message: msg, chars });
-      this.queuedChars += chars;
     }
     for (const handler of this.handlers) {
       try {
@@ -242,36 +254,403 @@ var ClientTransport = class {
       }
     }
   }
-};
-function spawnInvocation(command, args, platform) {
-  if (platform !== "win32") return { command, args };
-  return buildWin32CmdShimInvocation(command, args);
+};
+function spawnInvocation(command, args, platform) {
+  if (platform !== "win32") return { command, args };
+  return buildWin32CmdShimInvocation(command, args);
+}
+function verbatimOptions(invocation) {
+  return invocation.windowsVerbatimArguments ? { windowsVerbatimArguments: invocation.windowsVerbatimArguments } : {};
+}
+
+// src/types/acp-v1.ts
+var ACP_PROTOCOL_VERSION = 1;
+
+// src/version.ts
+import { createRequire } from "node:module";
+var require2 = createRequire(import.meta.url);
+function readPackageVersion(load = () => require2("../package.json")) {
+  try {
+    const packageJson = load();
+    if (typeof packageJson.version === "string" && packageJson.version.length > 0) {
+      return packageJson.version;
+    }
+  } catch {
+  }
+  return "dev";
+}
+var ACP_PACKAGE_VERSION = readPackageVersion();
+
+// src/client/acp-late-session.ts
+var LATE_CANCEL_SEND_TIMEOUT_MS = 1e4;
+function cancelLateAcpSession(transport, createPromise) {
+  createPromise.then(async (lateId) => {
+    try {
+      await new Promise((resolve3, reject) => {
+        const timer = setTimeout(() => {
+          reject(new Error("late session/cancel send timed out"));
+        }, LATE_CANCEL_SEND_TIMEOUT_MS);
+        Promise.resolve(
+          transport.send({
+            jsonrpc: "2.0",
+            method: "session/cancel",
+            params: { sessionId: lateId }
+          })
+        ).then(
+          () => {
+            clearTimeout(timer);
+            resolve3();
+          },
+          (sendErr) => {
+            clearTimeout(timer);
+            reject(sendErr instanceof Error ? sendErr : new Error(String(sendErr)));
+          }
+        );
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.warn(
+        JSON.stringify({
+          level: "warn",
+          event: "acp_session.late_cancel_failed",
+          sessionId: lateId,
+          message
+        })
+      );
+    }
+  }).catch((reason) => {
+    const message = reason instanceof Error ? reason.message : String(reason);
+    console.warn(
+      JSON.stringify({
+        level: "warn",
+        event: "acp_session.late_cancel_failed",
+        reason: message
+      })
+    );
+  });
+}
+
+// src/client/acp-message-routing.ts
+function isBestEffortAckMethod(method) {
+  return method === "mcp/connect" || method === "mcp/message" || method === "mcp/disconnect" || method === "elicitation/create" || method === "elicitation/complete";
+}
+
+// src/client/acp-session-errors.ts
+var ACPSessionError = class extends Error {
+  kind;
+  cause;
+  constructor(kind, message, cause) {
+    super(message);
+    this.name = "ACPSessionError";
+    this.kind = kind;
+    this.cause = cause;
+  }
+};
+function isJsonRpcError(v) {
+  return typeof v === "object" && v !== null && typeof v.code === "number" && typeof v.message === "string";
+}
+function isAuthRequiredError(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  if (/auth(_|-)?required|authentication required/i.test(message)) return true;
+  const cause = err instanceof ACPSessionError ? err.cause : err && typeof err === "object" && "cause" in err ? err.cause : err;
+  if (!cause || typeof cause !== "object") return false;
+  const data = cause.data;
+  if (data === "auth_required" || data === "AUTH_REQUIRED") return true;
+  if (data && typeof data === "object") {
+    const d = data;
+    if (d.authRequired === true) return true;
+    if (d.code === "auth_required" || d.code === "AUTH_REQUIRED") return true;
+  }
+  return false;
+}
+
+// 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 && ctx.sessionId !== 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 && ctx.sessionId !== 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-auth.ts
+async function authenticate(host, methodId) {
+  if (host.state === "closed") {
+    throw new ACPSessionError("closed", "session is closed");
+  }
+  if (host.state !== "ready" && host.state !== "authenticated") {
+    throw new ACPSessionError(
+      "protocol_error",
+      `authenticate called in state=${host.state} (expected 'ready')`
+    );
+  }
+  if (host.state === "authenticated") return;
+  if (!host.authMethods.some((m) => m.id === methodId)) {
+    throw new ACPSessionError(
+      "auth_failed",
+      `auth method "${methodId}" not in advertised methods: ${host.authMethods.map((m) => m.id).join(", ")}`
+    );
+  }
+  if (host.authMethods.find((m) => m.id === methodId)?.type === "terminal") {
+    throw new ACPSessionError(
+      "auth_failed",
+      "Terminal authentication requires interactive login followed by reconnect; it cannot use authenticate"
+    );
+  }
+  const id = host.allocId();
+  const result = await host.sendRequest(id, "authenticate", { methodId });
+  if (isJsonRpcError(result)) {
+    throw new ACPSessionError("auth_failed", `authenticate failed: ${result.message}`, result);
+  }
+  host.state = "authenticated";
+}
+async function logout(host) {
+  if (host.state === "closed") {
+    throw new ACPSessionError("closed", "session is closed");
+  }
+  if (!host.agentCapabilities.auth?.logout) {
+    throw new ACPSessionError(
+      "unsupported_capability",
+      "agent does not support logout (auth.logout capability not advertised)"
+    );
+  }
+  const id = host.allocId();
+  const result = await host.sendRequest(id, "logout", {});
+  if (isJsonRpcError(result)) {
+    throw new ACPSessionError("logout_failed", `logout failed: ${result.message}`, result);
+  }
+  host.state = "ready";
 }
-function verbatimOptions(invocation) {
-  return invocation.windowsVerbatimArguments ? { windowsVerbatimArguments: invocation.windowsVerbatimArguments } : {};
-}
-
-// src/types/acp-v1.ts
-var ACP_PROTOCOL_VERSION = 1;
-
-// src/version.ts
-import { createRequire } from "node:module";
-var require2 = createRequire(import.meta.url);
-function readPackageVersion(load = () => require2("../package.json")) {
+async function createSessionWithAuth(host) {
   try {
-    const packageJson = load();
-    if (typeof packageJson.version === "string" && packageJson.version.length > 0) {
-      return packageJson.version;
+    return await executeCreateSession(host.opContext());
+  } catch (err) {
+    if (host.state === "authenticated" || !isAuthRequiredError(err)) {
+      throw err instanceof ACPSessionError ? err : new ACPSessionError(
+        "session_create_failed",
+        err instanceof Error ? err.message : String(err),
+        err
+      );
     }
-  } catch {
+    await host.ensureAuthenticated();
+    return executeCreateSession(host.opContext());
   }
-  return "dev";
 }
-var ACP_PACKAGE_VERSION = readPackageVersion();
-
-// src/client/acp-message-routing.ts
-function isBestEffortAckMethod(method) {
-  return method === "mcp/connect" || method === "mcp/message" || method === "mcp/disconnect" || method === "elicitation/create" || method === "elicitation/complete";
+async function ensureAuthenticated(host) {
+  if (host.state === "authenticated") return;
+  if (host.authMethods.length === 0) {
+    throw new ACPSessionError(
+      "auth_failed",
+      "This agent requires authentication before a session can start, but advertised no authMethods. Log into the CLI, then retry."
+    );
+  }
+  const inProcess = host.authMethods.find(
+    (m) => m.type === void 0 || m.type === "agent" || m.type === "oauth" || m.type === "http"
+  );
+  if (inProcess) {
+    await host.authenticate(inProcess.id);
+    return;
+  }
+  const terminal = host.authMethods.find((m) => m.type === "terminal");
+  const setupArgs = terminal?.args?.length ? terminal.args.join(" ") : void 0;
+  const setup = setupArgs !== void 0 ? `${host.opts.command}${host.opts.args?.length ? ` ${host.opts.args.join(" ")}` : ""} ${setupArgs}` : `${host.opts.command}${host.opts.args?.length ? ` ${host.opts.args.join(" ")}` : ""}`;
+  throw new ACPSessionError(
+    "auth_failed",
+    `This agent requires a terminal login before ACP can start. Run \`${setup}\` (or the CLI's /login), then retry.`
+  );
 }
 
 // src/client/file-server.ts
@@ -316,6 +695,13 @@ var FileServer = class {
   }
   /** Read a text file. Returns the content as a string. */
   async readTextFile(params) {
+    if (params.line != null && (!Number.isSafeInteger(params.line) || params.line < 1) || params.limit != null && (!Number.isSafeInteger(params.limit) || params.limit < 0)) {
+      throw new FsError(
+        "INVALID_PATH",
+        params.path,
+        "line must be a positive integer and limit a non-negative integer"
+      );
+    }
     const safe = await this.resolveInside(params.path);
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), this.timeoutMs);
@@ -334,7 +720,12 @@ var FileServer = class {
         encoding: "utf8",
         signal: controller.signal
       });
-      return { content };
+      if (params.line == null && params.limit == null) return { content };
+      const lines = content.match(/[^\n]*\n|[^\n]+$/g) ?? [];
+      const start = (params.line ?? 1) - 1;
+      return {
+        content: lines.slice(start, params.limit == null ? void 0 : start + params.limit).join("")
+      };
     } catch (err) {
       if (err instanceof FsError) throw err;
       if (controller.signal.aborted) {
@@ -439,7 +830,8 @@ var FileServer = class {
         throw mapFsError(err, resolvedPath);
       }
       const normReal = isWindows ? real.toLowerCase() : real;
-      if (normReal === normRealRoot || normReal.startsWith(normRealRoot + path.sep)) return;
+      const realRootWithSep = normRealRoot.endsWith(path.sep) ? normRealRoot : normRealRoot + path.sep;
+      if (normReal === normRealRoot || normReal.startsWith(realRootWithSep)) return;
       throw new FsError(
         "OUTSIDE_ROOT",
         resolvedPath,
@@ -488,9 +880,12 @@ async function handleAcpPermissionRequest(msg, permissionPolicy, sender, callbac
     );
     await sender.sendResult(id, { outcome });
   } catch (err) {
+    if (isAbortLikeError(err)) {
+      await sender.sendResult(id, { outcome: { outcome: "cancelled" } });
+      return;
+    }
     const message = err instanceof Error ? err.message : String(err);
-    const code = isAbortLikeError(err) ? -32800 : -32603;
-    await sender.sendErrorResponse(id, code, `permission policy failed: ${message}`);
+    await sender.sendErrorResponse(id, -32603, `permission policy failed: ${message}`);
   }
 }
 async function handleAcpFsRequest(msg, fileServer, permissionPolicy, sender, callbackOptions = {}) {
@@ -526,7 +921,9 @@ async function handleAcpFsRequest(msg, fileServer, permissionPolicy, sender, cal
     if (msg.method === "fs/read_text_file") {
       const result = await fileServer.readTextFile({
         sessionId: params.sessionId ?? "",
-        path: params.path
+        path: params.path,
+        line: params.line,
+        limit: params.limit
       });
       await sender.sendResult(id, result);
     } else {
@@ -626,338 +1023,107 @@ async function handleAcpTerminalRequest(msg, terminalServer, permissionPolicy, s
 }
 async function authorizeAcpCallback(permissionPolicy, partial, callbackOptions) {
   try {
-    const outcome = await runPermissionWithDeadline(
-      permissionPolicy,
-      {
-        toolCall: {
-          sessionUpdate: "tool_call_update",
-          toolCallId: partial.toolCallId,
-          title: partial.title,
-          kind: partial.kind,
-          status: "pending",
-          rawInput: partial.rawInput
-        },
-        options: [
-          { optionId: "allow", name: "Allow", kind: "allow_once" },
-          { optionId: "reject", name: "Reject", kind: "reject_once" }
-        ]
-      },
-      callbackOptions
-    );
-    return outcome.outcome === "selected" && outcome.optionId !== "reject" && outcome.optionId !== "reject_once" && outcome.optionId !== "reject_always" ? "allowed" : "denied";
-  } catch (err) {
-    return isAbortLikeError(err) ? "cancelled" : "denied";
-  }
-}
-async function runPermissionWithDeadline(permissionPolicy, call, callbackOptions) {
-  const timeoutMs = resolvePermissionDeadline(callbackOptions.permissionTimeoutMs);
-  const controller = new AbortController();
-  const abort = () => controller.abort();
-  const timer = timeoutMs === null ? null : setTimeout(abort, timeoutMs);
-  let removeAbort;
-  if (callbackOptions.signal) {
-    if (callbackOptions.signal.aborted) {
-      abort();
-    } else {
-      callbackOptions.signal.addEventListener("abort", abort, { once: true });
-      removeAbort = () => callbackOptions.signal?.removeEventListener("abort", abort);
-    }
-  }
-  try {
-    return await Promise.race([
-      permissionPolicy({
-        toolCall: call.toolCall,
-        options: call.options,
-        signal: controller.signal
-      }),
-      rejectOnAbort(controller.signal)
-    ]);
-  } finally {
-    if (timer !== null) clearTimeout(timer);
-    removeAbort?.();
-  }
-}
-function rejectOnAbort(signal) {
-  return new Promise((_, reject) => {
-    const rejectAbort = () => reject(new Error("permission request cancelled or timed out"));
-    if (signal.aborted) {
-      rejectAbort();
-      return;
-    }
-    signal.addEventListener("abort", rejectAbort, { once: true });
-  });
-}
-function isAbortLikeError(err) {
-  return err instanceof Error && /cancelled|canceled|timed out|aborted/i.test(err.message);
-}
-function resolvePermissionDeadline(value) {
-  if (value === Number.POSITIVE_INFINITY) return null;
-  if (value !== void 0 && Number.isFinite(value) && value > 0) return Math.trunc(value);
-  return DEFAULT_PERMISSION_TIMEOUT_MS;
-}
-
-// src/client/acp-session-content.ts
-function textContent(text) {
-  return { type: "text", text };
-}
-function imageContent(mimeType, data) {
-  return { type: "image", mimeType, data };
-}
-function audioContent(mimeType, data) {
-  return { type: "audio", mimeType, data };
-}
-function extractText(block) {
-  if (typeof block !== "object" || block === null) return "";
-  const b = block;
-  if (b.type === "text" && typeof b.text === "string") return b.text;
-  if (b.type === "resource" && b.resource && typeof b.resource === "object" && typeof b.resource.text === "string") {
-    return b.resource.text;
-  }
-  return "";
-}
-function isRecord(v) {
-  return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-function emptyRunResult(stopReason) {
-  return {
-    text: "",
-    stopReason,
-    hasText: false,
-    toolCalls: [],
-    diffs: [],
-    thoughts: ""
-  };
-}
-
-// src/client/acp-session-errors.ts
-var ACPSessionError = class extends Error {
-  kind;
-  cause;
-  constructor(kind, message, cause) {
-    super(message);
-    this.name = "ACPSessionError";
-    this.kind = kind;
-    this.cause = cause;
-  }
-};
-function isJsonRpcError(v) {
-  return typeof v === "object" && v !== null && typeof v.code === "number" && typeof v.message === "string";
-}
-function isAuthRequiredError(err) {
-  const message = err instanceof Error ? err.message : String(err);
-  if (/auth(_|-)?required|authentication required/i.test(message)) return true;
-  const cause = err instanceof ACPSessionError ? err.cause : err && typeof err === "object" && "cause" in err ? err.cause : err;
-  if (!cause || typeof cause !== "object") return false;
-  const data = cause.data;
-  if (data === "auth_required" || data === "AUTH_REQUIRED") return true;
-  if (data && typeof data === "object") {
-    const d = data;
-    if (d.authRequired === true) return true;
-    if (d.code === "auth_required" || d.code === "AUTH_REQUIRED") return true;
-  }
-  return false;
-}
-
-// 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 outcome = await runPermissionWithDeadline(
+      permissionPolicy,
+      {
+        toolCall: {
+          sessionUpdate: "tool_call_update",
+          toolCallId: partial.toolCallId,
+          title: partial.title,
+          kind: partial.kind,
+          status: "pending",
+          rawInput: partial.rawInput
+        },
+        options: [
+          { optionId: "allow", name: "Allow", kind: "allow_once" },
+          { optionId: "reject", name: "Reject", kind: "reject_once" }
+        ]
+      },
+      callbackOptions
     );
+    return outcome.outcome === "selected" && outcome.optionId !== "reject" && outcome.optionId !== "reject_once" && outcome.optionId !== "reject_always" ? "allowed" : "denied";
+  } catch (err) {
+    return isAbortLikeError(err) ? "cancelled" : "denied";
   }
-  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);
+}
+async function runPermissionWithDeadline(permissionPolicy, call, callbackOptions) {
+  const timeoutMs = resolvePermissionDeadline(callbackOptions.permissionTimeoutMs);
+  const controller = new AbortController();
+  const abort = () => controller.abort();
+  const timer = timeoutMs === null ? null : setTimeout(abort, timeoutMs);
+  let removeAbort;
+  if (callbackOptions.signal) {
+    if (callbackOptions.signal.aborted) {
+      abort();
+    } else {
+      callbackOptions.signal.addEventListener("abort", abort, { once: true });
+      removeAbort = () => callbackOptions.signal?.removeEventListener("abort", abort);
+    }
   }
-  if (ctx.sessionId === sessionId) {
-    ctx.setSessionId(null);
+  try {
+    return await Promise.race([
+      permissionPolicy({
+        toolCall: call.toolCall,
+        options: call.options,
+        signal: controller.signal
+      }),
+      rejectOnAbort(controller.signal)
+    ]);
+  } finally {
+    if (timer !== null) clearTimeout(timer);
+    removeAbort?.();
   }
 }
-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 } : {}
+function rejectOnAbort(signal) {
+  return new Promise((_, reject) => {
+    const rejectAbort = () => reject(new Error("permission request cancelled or timed out"));
+    if (signal.aborted) {
+      rejectAbort();
+      return;
+    }
+    signal.addEventListener("abort", rejectAbort, { once: true });
   });
-  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
-    );
-  }
+function isAbortLikeError(err) {
+  return err instanceof Error && /cancelled|canceled|timed out|aborted/i.test(err.message);
 }
-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
-    );
-  }
+function resolvePermissionDeadline(value) {
+  if (value === Number.POSITIVE_INFINITY) return null;
+  if (value !== void 0 && Number.isFinite(value) && value > 0) return Math.trunc(value);
+  return DEFAULT_PERMISSION_TIMEOUT_MS;
 }
-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 };
+
+// src/client/acp-session-content.ts
+function textContent(text) {
+  return { type: "text", text };
 }
-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);
-  }
+function imageContent(mimeType, data) {
+  return { type: "image", mimeType, data };
 }
-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
-    );
-  }
+function audioContent(mimeType, data) {
+  return { type: "audio", mimeType, data };
 }
-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);
+function extractText(block) {
+  if (typeof block !== "object" || block === null) return "";
+  const b = block;
+  if (b.type === "text" && typeof b.text === "string") return b.text;
+  if (b.type === "resource" && b.resource && typeof b.resource === "object" && typeof b.resource.text === "string") {
+    return b.resource.text;
   }
-  return result;
+  return "";
 }
-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;
+function isRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function emptyRunResult(stopReason) {
+  return {
+    text: "",
+    stopReason,
+    hasText: false,
+    toolCalls: [],
+    diffs: [],
+    thoughts: ""
+  };
 }
 
 // src/client/acp-session-updates.ts
@@ -978,6 +1144,7 @@ function handleAcpSessionUpdate(msg, scratch, emitProgress) {
       }
       return;
     }
+    case "agent_thought_chunk":
     case "thought_chunk": {
       const text = extractText(u.content);
       if (text) {
@@ -1643,7 +1810,6 @@ function finitePositiveLimit(value, fallback) {
 }
 
 // src/client/acp-session.ts
-var LATE_CANCEL_SEND_TIMEOUT_MS = 1e4;
 var ACPSession = class _ACPSession {
   transport;
   fileServer;
@@ -1813,7 +1979,7 @@ var ACPSession = class _ACPSession {
       throw new ACPSessionError("protocol_error", "initialize returned no protocolVersion");
     }
     const r = result;
-    if (r.protocolVersion > ACP_PROTOCOL_VERSION) {
+    if (r.protocolVersion !== ACP_PROTOCOL_VERSION) {
       throw new ACPSessionError(
         "unsupported_capability",
         `agent requires protocolVersion=${r.protocolVersion}, client supports up to ${ACP_PROTOCOL_VERSION}`
@@ -1833,49 +1999,14 @@ var ACPSession = class _ACPSession {
    * Call this AFTER start() and BEFORE any session/new call.
    */
   async authenticate(methodId) {
-    if (this.state === "closed") {
-      throw new ACPSessionError("closed", "session is closed");
-    }
-    if (this.state !== "ready" && this.state !== "authenticated") {
-      throw new ACPSessionError(
-        "protocol_error",
-        `authenticate called in state=${this.state} (expected 'ready')`
-      );
-    }
-    if (this.state === "authenticated") return;
-    if (!this.authMethods.some((m) => m.id === methodId)) {
-      throw new ACPSessionError(
-        "auth_failed",
-        `auth method "${methodId}" not in advertised methods: ${this.authMethods.map((m) => m.id).join(", ")}`
-      );
-    }
-    const id = this.allocId();
-    const result = await this.sendRequest(id, "authenticate", { methodId });
-    if (isJsonRpcError(result)) {
-      throw new ACPSessionError("auth_failed", `authenticate failed: ${result.message}`, result);
-    }
-    this.state = "authenticated";
+    return authenticate(this.acpSessionAuthHost(), methodId);
   }
   /**
    * Log out from the current authenticated session.
    * Only callable if the agent advertises `auth.logout` capability.
    */
   async logout() {
-    if (this.state === "closed") {
-      throw new ACPSessionError("closed", "session is closed");
-    }
-    if (!this.agentCapabilities.auth?.logout) {
-      throw new ACPSessionError(
-        "unsupported_capability",
-        "agent does not support logout (auth.logout capability not advertised)"
-      );
-    }
-    const id = this.allocId();
-    const result = await this.sendRequest(id, "logout", {});
-    if (isJsonRpcError(result)) {
-      throw new ACPSessionError("logout_failed", `logout failed: ${result.message}`, result);
-    }
-    this.state = "ready";
+    return logout(this.acpSessionAuthHost());
   }
   // ──────────────────────────────────────────────────────────────────────
   // Session management delegation
@@ -1944,6 +2075,16 @@ var ACPSession = class _ACPSession {
     if (signal.aborted) {
       return emptyRunResult("cancelled");
     }
+    const caps = this.agentCapabilities.promptCapabilities;
+    for (const block of blocks) {
+      const supported = block.type === "image" ? caps?.image : block.type === "audio" ? caps?.audio : block.type === "resource" ? caps?.embeddedContext : true;
+      if (supported !== true) {
+        throw new ACPSessionError(
+          "unsupported_capability",
+          `agent does not support ${block.type} prompt content`
+        );
+      }
+    }
     let cancelled = false;
     this.promptCallbackAbort = new AbortController();
     const onAbort = () => {
@@ -2078,50 +2219,7 @@ var ACPSession = class _ACPSession {
    * being silently swallowed.
    */
   cancelLateSession(createPromise) {
-    createPromise.then(async (lateId) => {
-      try {
-        await new Promise((resolve3, reject) => {
-          const timer = setTimeout(() => {
-            reject(new Error("late session/cancel send timed out"));
-          }, LATE_CANCEL_SEND_TIMEOUT_MS);
-          Promise.resolve(
-            this.transport.send({
-              jsonrpc: "2.0",
-              method: "session/cancel",
-              params: { sessionId: lateId }
-            })
-          ).then(
-            () => {
-              clearTimeout(timer);
-              resolve3();
-            },
-            (sendErr) => {
-              clearTimeout(timer);
-              reject(sendErr instanceof Error ? sendErr : new Error(String(sendErr)));
-            }
-          );
-        });
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        console.warn(
-          JSON.stringify({
-            level: "warn",
-            event: "acp_session.late_cancel_failed",
-            sessionId: lateId,
-            message
-          })
-        );
-      }
-    }).catch((reason) => {
-      const message = reason instanceof Error ? reason.message : String(reason);
-      console.warn(
-        JSON.stringify({
-          level: "warn",
-          event: "acp_session.late_cancel_failed",
-          reason: message
-        })
-      );
-    });
+    cancelLateAcpSession(this.transport, createPromise);
   }
   async closeSession() {
     if (!this.sessionId) return;
@@ -2168,7 +2266,13 @@ var ACPSession = class _ACPSession {
   // Wire layer
   // ────────────────────────────────────────────────────────────────────
   allocId() {
-    return this.nextId++;
+    let candidate = Number.isSafeInteger(this.nextId) && this.nextId >= 1 ? this.nextId : 1;
+    for (let probe = 0; probe <= this.pending.size; probe++) {
+      this.nextId = candidate >= Number.MAX_SAFE_INTEGER ? 1 : candidate + 1;
+      if (!this.pending.has(candidate)) return candidate;
+      candidate = this.nextId;
+    }
+    throw new ACPSessionError("protocol_error", "no JSON-RPC request id is available");
   }
   async sendRequest(id, method, params, timeoutMs) {
     return new Promise((resolve3, reject) => {
@@ -2200,19 +2304,7 @@ var ACPSession = class _ACPSession {
    * `authMethods`; we do not pop OAuth on every spawn.
    */
   async createSessionWithAuth() {
-    try {
-      return await executeCreateSession(this.opContext());
-    } catch (err) {
-      if (this.state === "authenticated" || !isAuthRequiredError(err)) {
-        throw err instanceof ACPSessionError ? err : new ACPSessionError(
-          "session_create_failed",
-          err instanceof Error ? err.message : String(err),
-          err
-        );
-      }
-      await this.ensureAuthenticated();
-      return executeCreateSession(this.opContext());
-    }
+    return createSessionWithAuth(this.acpSessionAuthHost());
   }
   /**
    * Pick a non-terminal auth method and run `authenticate`. Terminal-only
@@ -2220,27 +2312,7 @@ var ACPSession = class _ACPSession {
    * we refuse rather than hang a TUI inside the JSON-RPC child.
    */
   async ensureAuthenticated() {
-    if (this.state === "authenticated") return;
-    if (this.authMethods.length === 0) {
-      throw new ACPSessionError(
-        "auth_failed",
-        "This agent requires authentication before a session can start, but advertised no authMethods. Log into the CLI, then retry."
-      );
-    }
-    const inProcess = this.authMethods.find(
-      (m) => m.type === void 0 || m.type === "agent" || m.type === "oauth" || m.type === "http"
-    );
-    if (inProcess) {
-      await this.authenticate(inProcess.id);
-      return;
-    }
-    const terminal = this.authMethods.find((m) => m.type === "terminal");
-    const setupArgs = terminal?.args?.length ? terminal.args.join(" ") : void 0;
-    const setup = setupArgs !== void 0 ? `${this.opts.command} ${setupArgs}` : `${this.opts.command}${this.opts.args?.length ? ` ${this.opts.args.join(" ")}` : ""}`;
-    throw new ACPSessionError(
-      "auth_failed",
-      `This agent requires a terminal login before ACP can start. Run \`${setup}\` (or the CLI's /login), then retry.`
-    );
+    return ensureAuthenticated(this.acpSessionAuthHost());
   }
   sendResult(id, result) {
     return this.transport.send({ jsonrpc: "2.0", id, result });
@@ -2318,7 +2390,7 @@ var ACPSession = class _ACPSession {
     }
     if (isBestEffortAckMethod(msg.method)) {
       if (msg.id !== void 0) {
-        this.sendResult(msg.id, {}).catch(() => {
+        this.sendErrorResponse(msg.id, -32601, `Unsupported method: ${msg.method}`).catch(() => {
         });
       }
       return;
@@ -2327,6 +2399,13 @@ var ACPSession = class _ACPSession {
       return;
     }
     if (msg.method) {
+      if (msg.id !== void 0) {
+        void this.sendErrorResponse(msg.id, -32601, `Unsupported method: ${msg.method}`).catch(
+          () => {
+          }
+        );
+        return;
+      }
       console.warn(
         JSON.stringify({
           level: "warn",
@@ -2349,6 +2428,29 @@ var ACPSession = class _ACPSession {
   resetScratch() {
     this.scratch = createSessionScratch();
   }
+  acpSessionAuthHost() {
+    const self = this;
+    return {
+      get state() {
+        return self.state;
+      },
+      set state(value) {
+        self.state = value;
+      },
+      get authMethods() {
+        return self.authMethods;
+      },
+      allocId: (...args) => this.allocId(...args),
+      sendRequest: (...args) => this.sendRequest(...args),
+      get agentCapabilities() {
+        return self.agentCapabilities;
+      },
+      opContext: (...args) => this.opContext(...args),
+      ensureAuthenticated: (...args) => this.ensureAuthenticated(...args),
+      authenticate: (...args) => this.authenticate(...args),
+      opts: this.opts
+    };
+  }
 };
 
 // src/integration/acp-subagent-runner.ts