@pwrdrvr/agent-acp 0.12.3 → 0.13.1

package/dist/index.js

@@ -6,103 +6,10 @@ import {
   ndJsonStream
 } from "@agentclientprotocol/sdk";
 import { noopLogger } from "@pwrdrvr/agent-core";
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function sanitizeAcpNotificationLine(line) {
-  if (line.trim().length === 0) return line;
-  let message;
-  try {
-    message = JSON.parse(line);
-  } catch {
-    return line;
-  }
-  if (!isPlainObject(message) || message.method !== "session/update") return line;
-  const params = message.params;
-  if (!isPlainObject(params)) return line;
-  const update = params.update;
-  if (!isPlainObject(update)) return line;
-  if (update.sessionUpdate === "config_option_update") return "";
-  let changed = false;
-  for (const key of ["rawInput", "rawOutput"]) {
-    if (!(key in update)) continue;
-    const value = update[key];
-    if (value === void 0 || isPlainObject(value)) continue;
-    if (value === null) {
-      delete update[key];
-    } else {
-      update[key] = { value };
-    }
-    changed = true;
-  }
-  return changed ? JSON.stringify(message) : line;
-}
-function sanitizeInboundStream(source) {
-  const decoder = new TextDecoder();
-  const encoder = new TextEncoder();
-  let buffer = "";
-  return source.pipeThrough(
-    new TransformStream({
-      transform(chunk, controller) {
-        buffer += decoder.decode(chunk, { stream: true });
-        let nl = buffer.indexOf("\n");
-        while (nl !== -1) {
-          const line = buffer.slice(0, nl);
-          buffer = buffer.slice(nl + 1);
-          const sanitized = sanitizeAcpNotificationLine(line);
-          if (sanitized.length > 0) controller.enqueue(encoder.encode(sanitized + "\n"));
-          nl = buffer.indexOf("\n");
-        }
-      },
-      flush(controller) {
-        if (buffer.length > 0) {
-          const sanitized = sanitizeAcpNotificationLine(buffer);
-          if (sanitized.length > 0) controller.enqueue(encoder.encode(sanitized));
-          buffer = "";
-        }
-      }
-    })
-  );
-}
-function rewriteOutboundAcpLine(line) {
-  if (line.trim().length === 0) return line;
-  let message;
-  try {
-    message = JSON.parse(line);
-  } catch {
-    return line;
-  }
-  if (!isPlainObject(message) || message.method !== "_session/set_config_option") {
-    return line;
-  }
-  message.method = "session/set_config_option";
-  return JSON.stringify(message);
-}
-function rewriteOutboundStream(target) {
-  const decoder = new TextDecoder();
-  const encoder = new TextEncoder();
-  let buffer = "";
-  const transform = new TransformStream({
-    transform(chunk, controller) {
-      buffer += decoder.decode(chunk, { stream: true });
-      let nl = buffer.indexOf("\n");
-      while (nl !== -1) {
-        const line = buffer.slice(0, nl);
-        buffer = buffer.slice(nl + 1);
-        controller.enqueue(encoder.encode(rewriteOutboundAcpLine(line) + "\n"));
-        nl = buffer.indexOf("\n");
-      }
-    },
-    flush(controller) {
-      if (buffer.length > 0) {
-        controller.enqueue(encoder.encode(rewriteOutboundAcpLine(buffer)));
-        buffer = "";
-      }
-    }
-  });
-  void transform.readable.pipeTo(target).catch(() => void 0);
-  return transform.writable;
-}
+import {
+  createCommandInvocation,
+  prependCommandDirToPath
+} from "@pwrdrvr/agent-transport";
 var AcpConnection = class {
   constructor(options) {
     this.options = options;
@@ -161,9 +68,12 @@ var AcpConnection = class {
     const { command, args, env } = this.options;
     const logger = this.logger;
     return (client) => {
-      const child = spawn(command, args, {
+      const launchEnv = prependCommandDirToPath(command, env ?? process.env);
+      const invocation = createCommandInvocation({ command, args, env: launchEnv });
+      const child = spawn(invocation.command, invocation.args, {
         stdio: ["pipe", "pipe", "pipe"],
-        ...env !== void 0 ? { env } : {}
+        env: launchEnv,
+        windowsVerbatimArguments: invocation.windowsVerbatimArguments
       });
       child.on("error", (error) => {
         logger.error("acp agent process error", { command, message: error.message });
@@ -172,12 +82,8 @@ var AcpConnection = class {
         const line = chunk.toString("utf8").trimEnd();
         if (line.length > 0) logger.debug("acp agent stderr", { line });
       });
-      const toAgentStdin = rewriteOutboundStream(
-        Writable.toWeb(child.stdin)
-      );
-      const fromAgentStdout = sanitizeInboundStream(
-        Readable.toWeb(child.stdout)
-      );
+      const toAgentStdin = Writable.toWeb(child.stdin);
+      const fromAgentStdout = Readable.toWeb(child.stdout);
       const stream = ndJsonStream(toAgentStdin, fromAgentStdout);
       const connection = new ClientSideConnection(
         (_agent) => client,
@@ -218,7 +124,7 @@ var AcpConnection = class {
       case "authenticate":
         return await conn.authenticate(params);
       default:
-        return await conn.extMethod(method, params);
+        return await conn.request(method, params);
     }
   }
   async notify(method, params = {}) {
@@ -229,7 +135,7 @@ var AcpConnection = class {
       await conn.cancel(params);
       return;
     }
-    await conn.extNotification(method, params);
+    await conn.notify(method, params);
   }
   async close() {
     try {
@@ -760,6 +666,12 @@ function normalizeAcpRuntimeCapabilities(params) {
 function acpRuntimeSupportsSessionLoad(capabilities) {
   return capabilities?.agentCapabilities?.loadSession !== false;
 }
+function acpRuntimeSupportsHttpMcp(capabilities) {
+  return capabilities?.agentCapabilities?.mcp?.http === true;
+}
+function acpRuntimeSupportsSseMcp(capabilities) {
+  return capabilities?.agentCapabilities?.mcp?.sse === true;
+}
 function modelConfigOption(capabilities) {
   return capabilities?.configOptions?.find(
     (option) => option.category === "model" || option.id === "model"
@@ -947,10 +859,21 @@ function readAgentCapabilities(value, sessionCapabilitiesValue) {
   const close = readBoolean(asRecord(record?.session), "close");
   const cancel = readBoolean(asRecord(record?.session), "cancel");
   const sessionHistoryReplay = readBoolean(kimiMeta, "sessionHistoryReplay") ?? readBoolean(kimiMeta, "session_history_replay");
+  const mcpRecord = asRecord(
+    record?.mcpCapabilities ?? record?.mcp_capabilities ?? record?.mcp
+  );
+  const http = readBoolean(mcpRecord, "http");
+  const sse = readBoolean(mcpRecord, "sse");
   const capabilities = {
     raw: record ?? sessionCapabilities
   };
   if (loadSession !== void 0) capabilities.loadSession = loadSession;
+  if (http !== void 0 || sse !== void 0) {
+    capabilities.mcp = {
+      ...http !== void 0 ? { http } : {},
+      ...sse !== void 0 ? { sse } : {}
+    };
+  }
   if (sessionHistoryReplay !== void 0) {
     capabilities.sessionHistoryReplay = sessionHistoryReplay;
   }
@@ -977,6 +900,51 @@ function readAgentInfo(value) {
   return Object.keys(agentInfo).length > 0 ? agentInfo : void 0;
 }
 
+// src/mcp-server-config.ts
+function isKeyValueArray(collection) {
+  return Array.isArray(collection);
+}
+function normalizeKeyValues(collection) {
+  if (collection === void 0) return [];
+  if (isKeyValueArray(collection)) {
+    return collection.map(({ name, value }) => ({ name, value }));
+  }
+  return Object.entries(collection).map(([name, value]) => ({ name, value }));
+}
+function normalizeAcpMcpServerConfig(server) {
+  if ("type" in server) {
+    return {
+      name: server.name,
+      type: server.type,
+      url: server.url,
+      headers: normalizeKeyValues(server.headers)
+    };
+  }
+  return {
+    name: server.name,
+    command: server.command,
+    args: [...server.args ?? []],
+    env: normalizeKeyValues(server.env)
+  };
+}
+function normalizeAcpMcpServerConfigs(servers) {
+  return servers.map(normalizeAcpMcpServerConfig);
+}
+function redactAcpMcpCredentials(message, servers) {
+  const secrets = /* @__PURE__ */ new Set();
+  for (const server of servers) {
+    const values = "type" in server ? [server.url, ...normalizeKeyValues(server.headers).map(({ value }) => value)] : normalizeKeyValues(server.env).map(({ value }) => value);
+    for (const value of values) {
+      if (value.length > 0) secrets.add(value);
+    }
+  }
+  let redacted = message;
+  for (const secret of [...secrets].sort((a, b) => b.length - a.length)) {
+    redacted = redacted.split(secret).join("[REDACTED]");
+  }
+  return redacted;
+}
+
 // src/acp-client.ts
 var ACP_PROTOCOL_VERSION = 1;
 var ACP_PROMPT_REQUEST_TIMEOUT_MS = 60 * 6e4;
@@ -1122,6 +1090,18 @@ var AcpAgentClient = class {
       ...options.mcpServers !== void 0 ? { mcpServers: options.mcpServers } : {}
     });
   }
+  /** ACP-native `session/load`. The pinned ACP v1 library has no separate
+   *  `session/resume` method; loading is the protocol-defined history restore
+   *  path and receives the same per-thread MCP configuration as `session/new`. */
+  async loadThreadNative(options) {
+    return this.openSession({
+      lifecycle: "load",
+      protocolSessionId: options.sessionId,
+      ...options.threadId !== void 0 ? { bindThreadId: options.threadId } : {},
+      ...options.cwd !== void 0 ? { cwd: options.cwd } : {},
+      ...options.mcpServers !== void 0 ? { mcpServers: options.mcpServers } : {}
+    });
+  }
   /**
    * Re-establish a fresh ACP session for a PERSISTED thread id whose underlying
    * session is gone (e.g. resuming a chat after an app restart — the agent
@@ -1167,7 +1147,13 @@ var AcpAgentClient = class {
    *  `bindThreadId` is given (resume), in which case the new ACP session is
    *  bound to that existing host thread id. */
   async establishSession(options) {
+    return this.openSession({ lifecycle: "new", ...options });
+  }
+  async openSession(options) {
     await this.initialize();
+    if (options.lifecycle === "load" && !acpRuntimeSupportsSessionLoad(this.runtimeCapabilities)) {
+      throw new Error("ACP agent does not advertise session/load support");
+    }
     const cwd = options.cwd ?? this.defaultCwd ?? process.cwd();
     try {
       mkdirSync(cwd, { recursive: true });
@@ -1177,23 +1163,68 @@ var AcpAgentClient = class {
         message: cause instanceof Error ? cause.message : String(cause)
       });
     }
-    const mcpServers = (options.mcpServers ?? this.defaultMcpServers).map((server) => ({
-      name: server.name,
-      command: server.command,
-      args: server.args ?? [],
-      env: Object.entries(server.env ?? {}).map(([name, value]) => ({ name, value }))
-    }));
-    const result = await this.transport.request("session/new", {
-      cwd,
-      mcpServers
-    });
+    const configuredMcpServers = options.mcpServers ?? this.defaultMcpServers;
+    this.assertMcpTransportSupport(configuredMcpServers);
+    const mcpServers = normalizeAcpMcpServerConfigs(configuredMcpServers);
+    const method = options.lifecycle === "load" ? "session/load" : "session/new";
+    let session;
+    if (options.lifecycle === "load") {
+      const protocolSessionId2 = options.protocolSessionId;
+      if (!protocolSessionId2) {
+        throw new Error("ACP session/load did not provide a session id");
+      }
+      const threadId2 = options.bindThreadId ?? `acp:${this.strategy.id}:${isUuid(protocolSessionId2) ? protocolSessionId2 : randomUUID()}`;
+      if (this.sessions.has(threadId2)) {
+        throw new Error(`ACP thread is already open: ${threadId2}`);
+      }
+      const mappedThreadId = this.threadIdByProtocolId.get(protocolSessionId2);
+      if (mappedThreadId !== void 0) {
+        throw new Error(
+          `ACP session is already loaded for thread: ${mappedThreadId}`
+        );
+      }
+      session = {
+        threadId: threadId2,
+        protocolSessionId: protocolSessionId2,
+        normalizer: new AcpSessionNormalizer({ quirks: this.strategy.quirks }),
+        turnId: void 0,
+        runtimeState: void 0,
+        pendingTurn: void 0,
+        pendingInstructions: options.instructions,
+        mcpServerNames: configuredMcpServers.map((server) => server.name)
+      };
+      this.sessions.set(threadId2, session);
+      this.threadIdByProtocolId.set(protocolSessionId2, threadId2);
+    }
+    let result;
+    try {
+      result = await this.transport.request(method, {
+        cwd,
+        mcpServers,
+        ...options.lifecycle === "load" ? { sessionId: options.protocolSessionId } : {}
+      });
+    } catch (cause) {
+      const message = redactAcpMcpCredentials(
+        errorMessage(cause),
+        configuredMcpServers
+      );
+      if (session !== void 0) {
+        if (this.sessions.get(session.threadId) === session) {
+          this.sessions.delete(session.threadId);
+        }
+        if (this.threadIdByProtocolId.get(session.protocolSessionId) === session.threadId) {
+          this.threadIdByProtocolId.delete(session.protocolSessionId);
+        }
+      }
+      throw new Error(`ACP ${method} failed: ${message}`);
+    }
     const record = asRecord2(result);
-    const protocolSessionId = readString2(record, "sessionId") ?? readString2(record, "session_id");
+    const protocolSessionId = options.lifecycle === "load" ? options.protocolSessionId : readString2(record, "sessionId") ?? readString2(record, "session_id");
     if (!protocolSessionId) {
-      throw new Error("ACP session/new did not return a session id");
+      throw new Error(`ACP ${method} did not provide a session id`);
     }
-    const threadId = options.bindThreadId ?? `acp:${this.strategy.id}:${isUuid(protocolSessionId) ? protocolSessionId : randomUUID()}`;
-    const session = {
+    const threadId = session?.threadId ?? options.bindThreadId ?? `acp:${this.strategy.id}:${isUuid(protocolSessionId) ? protocolSessionId : randomUUID()}`;
+    session ??= {
       threadId,
       protocolSessionId,
       normalizer: new AcpSessionNormalizer({ quirks: this.strategy.quirks }),
@@ -1201,14 +1232,18 @@ var AcpAgentClient = class {
       runtimeState: void 0,
       pendingTurn: void 0,
       pendingInstructions: options.instructions,
-      // Remember the MCP servers attached to THIS session so its tools can be
-      // auto-approved even when the (pooled, shared) client has no client-level
-      // `mcpServers` default.
-      mcpServerNames: (options.mcpServers ?? this.defaultMcpServers).map((server) => server.name)
+      // Remember ONLY the MCP servers attached to THIS session so the host's
+      // approval policy never sees another pooled thread's tool set.
+      mcpServerNames: configuredMcpServers.map((server) => server.name)
     };
-    this.sessions.set(threadId, session);
-    this.threadIdByProtocolId.set(protocolSessionId, threadId);
-    const runtimeCapabilities = this.captureRuntimeCapabilities("session-new", result);
+    if (options.lifecycle === "new") {
+      this.sessions.set(threadId, session);
+      this.threadIdByProtocolId.set(protocolSessionId, threadId);
+    }
+    const runtimeCapabilities = this.captureRuntimeCapabilities(
+      options.lifecycle === "load" ? "session-load" : "session-new",
+      result
+    );
     if (runtimeCapabilities) {
       const runtimeState = acpSessionRuntimeStateFromCapabilities(
         runtimeCapabilities,
@@ -1218,10 +1253,11 @@ var AcpAgentClient = class {
       this.notifyRuntimeCapabilities({ threadId, runtimeCapabilities, runtimeState });
       this.emitThreadSettings(session, runtimeCapabilities, runtimeState);
     }
-    this.logger.debug("acp thread started", {
+    this.logger.debug("acp thread opened", {
       threadId,
       protocolSessionId,
-      resumed: options.bindThreadId !== void 0
+      lifecycle: options.lifecycle,
+      rebound: options.bindThreadId !== void 0
     });
     const out = { threadId };
     const model = modelIdFromCapabilities(runtimeCapabilities);
@@ -1496,16 +1532,6 @@ var AcpAgentClient = class {
     }
     throw new Error(`Unsupported ACP request: ${method}`);
   }
-  /** Every MCP server name this client knows about — the client-level default
-   *  plus the per-thread servers of every live session. Used to auto-approve a
-   *  configured MCP tool regardless of which session's permission request it is. */
-  knownMcpServerNames() {
-    const names = new Set(this.defaultMcpServers.map((server) => server.name));
-    for (const session of this.sessions.values()) {
-      for (const name of session.mcpServerNames) names.add(name);
-    }
-    return [...names];
-  }
   async handlePermissionRequest(params, id) {
     const protocolSessionId = readString2(params, "sessionId") ?? readString2(params, "session_id");
     const threadId = protocolSessionId ? this.threadIdByProtocolId.get(protocolSessionId) : void 0;
@@ -1526,7 +1552,7 @@ var AcpAgentClient = class {
     }
     const handlerParams = {
       ...params,
-      mcpServerNames: this.knownMcpServerNames()
+      mcpServerNames: threadId ? this.sessions.get(threadId)?.mcpServerNames ?? [] : []
     };
     if (threadId !== void 0) handlerParams.threadId = threadId;
     const decision = await handler("session/request_permission", handlerParams);
@@ -1661,10 +1687,33 @@ var AcpAgentClient = class {
     }
     return session;
   }
+  assertMcpTransportSupport(servers) {
+    for (const server of servers) {
+      if (!("type" in server)) continue;
+      if (server.type === "http" && !acpRuntimeSupportsHttpMcp(this.runtimeCapabilities)) {
+        throw new Error(
+          `ACP agent does not advertise HTTP MCP support for server "${server.name}"`
+        );
+      }
+      if (server.type === "sse" && !acpRuntimeSupportsSseMcp(this.runtimeCapabilities)) {
+        throw new Error(
+          `ACP agent does not advertise SSE MCP support for server "${server.name}"`
+        );
+      }
+    }
+  }
   /** Whether the agent advertises session/load support (for hosts that resume). */
   supportsSessionLoad() {
     return acpRuntimeSupportsSessionLoad(this.runtimeCapabilities);
   }
+  /** Whether the initialize result explicitly advertises streamable HTTP MCP. */
+  supportsHttpMcp() {
+    return acpRuntimeSupportsHttpMcp(this.runtimeCapabilities);
+  }
+  /** Whether the initialize result explicitly advertises legacy HTTP+SSE MCP. */
+  supportsSseMcp() {
+    return acpRuntimeSupportsSseMcp(this.runtimeCapabilities);
+  }
 };
 var LOW_EFFORT_TOKENS = /* @__PURE__ */ new Set([
   "off",
@@ -2260,7 +2309,10 @@ import { readdirSync, realpathSync, statSync } from "fs";
 import { homedir as homedir4 } from "os";
 import path4 from "path";
 import { promisify } from "util";
-import { prependCommandDirToPath } from "@pwrdrvr/agent-transport";
+import {
+  createCommandInvocation as createCommandInvocation2,
+  prependCommandDirToPath as prependCommandDirToPath2
+} from "@pwrdrvr/agent-transport";
 var execFile = promisify(execFileCallback);
 async function discoverLocalAcpAgentInstances(options = {}) {
   const strategies = options.strategies ?? BUILT_IN_ACP_STRATEGIES;
@@ -2361,35 +2413,60 @@ function candidateCommands(strategy, env, listExecutables, override) {
   return out;
 }
 function canonicalize(command) {
-  if (!path4.isAbsolute(command)) return command;
+  if (!path4.isAbsolute(command)) {
+    return process.platform === "win32" ? command.toLowerCase() : command;
+  }
   try {
-    return realpathSync(command);
+    const canonical = realpathSync(command);
+    return process.platform === "win32" ? canonical.toLowerCase() : canonical;
   } catch {
-    return command;
+    return process.platform === "win32" ? command.toLowerCase() : command;
   }
 }
 function defaultListExecutables(command, env) {
-  if (process.platform === "win32") return [];
-  if (command.includes(path4.sep)) return [];
+  if (command.includes("/") || command.includes("\\")) return [];
   const found = [];
   const seenDir = /* @__PURE__ */ new Set();
   for (const dir of discoveryDirs(env)) {
-    if (dir.length === 0 || seenDir.has(dir)) continue;
-    seenDir.add(dir);
-    const candidate = path4.join(dir, command);
-    try {
-      const stat = statSync(candidate);
-      if (stat.isFile() && (stat.mode & 73) !== 0) {
-        found.push(candidate);
+    const normalizedDir = normalizePathEntry(dir);
+    const dirKey = process.platform === "win32" ? normalizedDir.toLowerCase() : normalizedDir;
+    if (normalizedDir.length === 0 || seenDir.has(dirKey)) continue;
+    seenDir.add(dirKey);
+    for (const commandName of executableCommandNames(command, env)) {
+      const candidate = path4.join(normalizedDir, commandName);
+      try {
+        const stat = statSync(candidate);
+        if (stat.isFile() && (process.platform === "win32" || (stat.mode & 73) !== 0)) {
+          found.push(candidate);
+        }
+      } catch {
       }
-    } catch {
     }
   }
   return found;
 }
+function executableCommandNames(command, env) {
+  if (process.platform !== "win32") return [command];
+  const extensions = (readWindowsEnv(env, "PATHEXT")?.trim() || ".COM;.EXE;.BAT;.CMD").split(";").map((extension) => extension.trim()).filter(Boolean).map((extension) => extension.startsWith(".") ? extension : `.${extension}`);
+  const commandExtension = path4.win32.extname(command);
+  if (commandExtension.length > 0 && extensions.some((extension) => extension.toLowerCase() === commandExtension.toLowerCase())) {
+    return [command];
+  }
+  return extensions.map((extension) => `${command}${extension}`);
+}
+function readWindowsEnv(env, name) {
+  const key = Object.keys(env).find((candidate) => candidate.toLowerCase() === name.toLowerCase());
+  return key ? env[key] : void 0;
+}
+function normalizePathEntry(entry) {
+  const trimmed = entry.trim();
+  const quoted = trimmed.match(/^"(.*)"$/);
+  return quoted?.[1] ?? trimmed;
+}
 function discoveryDirs(env) {
-  const pathValue = env.PATH ?? env.Path ?? "";
-  return [...pathValue.split(path4.delimiter), ...wellKnownAgentBinDirs(homedir4())];
+  const pathValue = process.platform === "win32" ? readWindowsEnv(env, "PATH") ?? "" : env.PATH ?? "";
+  const pathDirs = pathValue.split(path4.delimiter);
+  return process.platform === "win32" ? pathDirs : [...pathDirs, ...wellKnownAgentBinDirs(homedir4())];
 }
 function wellKnownAgentBinDirs(home = homedir4()) {
   return [
@@ -2427,12 +2504,15 @@ function ensureArgs(args, ensure) {
 }
 function makeDefaultProbe(env) {
   return async (command, args) => {
-    return await execFile(command, args, {
+    const launchEnv = prependCommandDirToPath2(command, env);
+    const invocation = createCommandInvocation2({ command, args, env: launchEnv });
+    return await execFile(invocation.command, invocation.args, {
       timeout: 5e3,
       maxBuffer: 1024 * 1024,
       // Prepend the candidate's own dir so a node-script CLI (e.g. an nvm-
       // installed `qwen`) finds its sibling `node` during the probe.
-      env: prependCommandDirToPath(command, env)
+      env: launchEnv,
+      windowsVerbatimArguments: invocation.windowsVerbatimArguments
     });
   };
 }
@@ -2795,7 +2875,9 @@ export {
   BANNED_ACP_REGISTRY_IDS,
   BUILT_IN_ACP_STRATEGIES,
   DEFAULT_ACP_AGENT_ALLOWLIST,
+  acpRuntimeSupportsHttpMcp,
   acpRuntimeSupportsSessionLoad,
+  acpRuntimeSupportsSseMcp,
   acpSessionRuntimeStateFromCapabilities,
   acpSessionRuntimeStateFromUpdate,
   asRecord,
@@ -2815,6 +2897,8 @@ export {
   modelConfigOption,
   modelIdFromCapabilities,
   modelsFromCapabilities,
+  normalizeAcpMcpServerConfig,
+  normalizeAcpMcpServerConfigs,
   normalizeAcpRuntimeCapabilities,
   normalizeRegistry,
   qwenStrategy,