@pwrdrvr/agent-acp 0.12.2 → 0.13.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Client } from '@zed-industries/agent-client-protocol';
+import { Client, McpServer } from '@agentclientprotocol/sdk';
 import { Logger, AgentBackend, NormalizedThreadEvent, Unsubscribe, AgentBackendToolCallHandler, AgentBackendApprovalHandler, AgentStartThreadOptions, AgentBackendStartThreadResult, AgentStartTurnOptions, NormalizedTokenUsage, NormalizedToolCall } from '@pwrdrvr/agent-core';
 import { JsonRpcId } from '@pwrdrvr/agent-transport';
 
@@ -24,8 +24,8 @@ interface AcpAgentConnection {
     setSessionMode(params: Record<string, unknown>): Promise<unknown>;
     setSessionModel(params: Record<string, unknown>): Promise<unknown>;
     authenticate(params: Record<string, unknown>): Promise<unknown>;
-    extMethod(method: string, params: Record<string, unknown>): Promise<Record<string, unknown>>;
-    extNotification(method: string, params: Record<string, unknown>): Promise<void>;
+    request(method: string, params: Record<string, unknown>): Promise<unknown>;
+    notify(method: string, params: Record<string, unknown>): Promise<void>;
 }
 /** Built connection + a teardown handle (kills the child / closes streams). */
 type AcpAgentConnectionHandle = {
@@ -178,8 +178,13 @@ type AcpRuntimeAgentInfo = {
     title?: string;
     version?: string;
 };
+type AcpRuntimeMcpCapabilities = {
+    http?: boolean;
+    sse?: boolean;
+};
 type AcpRuntimeAgentCapabilities = {
     loadSession?: boolean;
+    mcp?: AcpRuntimeMcpCapabilities;
     sessionHistoryReplay?: boolean;
     session?: {
         close?: boolean;
@@ -212,6 +217,10 @@ declare function normalizeAcpRuntimeCapabilities(params: {
     initialize?: AcpRuntimeCapabilities;
 }): AcpRuntimeCapabilities | undefined;
 declare function acpRuntimeSupportsSessionLoad(capabilities: AcpRuntimeCapabilities | undefined): boolean;
+/** Optional ACP MCP transports are supported only when explicitly advertised. */
+declare function acpRuntimeSupportsHttpMcp(capabilities: AcpRuntimeCapabilities | undefined): boolean;
+/** Optional ACP MCP transports are supported only when explicitly advertised. */
+declare function acpRuntimeSupportsSseMcp(capabilities: AcpRuntimeCapabilities | undefined): boolean;
 /** The configOption an agent uses to expose model choice (ACP `category:
  *  "model"`, falling back to a literal `model` id). Some agents (e.g. Kimi)
  *  advertise the active model HERE rather than via top-level
@@ -235,6 +244,43 @@ declare function mergeAcpRuntimeState(existing: AcpSessionRuntimeState | undefin
 /** Resolve the human-facing label for a mode id from the capabilities snapshot. */
 declare function modeLabelFor(capabilities: AcpRuntimeCapabilities | undefined, modeId: string): string | undefined;
 
+/** ACP key/value entry used by stdio environments and HTTP headers. */
+type AcpMcpKeyValue = {
+    name: string;
+    value: string;
+};
+/** Host-friendly collection accepted wherever ACP requires key/value entries. */
+type AcpMcpKeyValueCollection = Readonly<Record<string, string>> | readonly AcpMcpKeyValue[];
+/** Backward-compatible stdio MCP configuration. ACP stdio has no `type` field. */
+type AcpStdioMcpServerConfig = {
+    name: string;
+    command: string;
+    args?: readonly string[];
+    env?: AcpMcpKeyValueCollection;
+};
+/** Streamable HTTP MCP configuration from the ACP v1 schema. */
+type AcpHttpMcpServerConfig = {
+    name: string;
+    type: "http";
+    url: string;
+    headers: AcpMcpKeyValueCollection;
+};
+/** Legacy HTTP+SSE MCP configuration from the ACP v1 schema. */
+type AcpSseMcpServerConfig = {
+    name: string;
+    type: "sse";
+    url: string;
+    headers: AcpMcpKeyValueCollection;
+};
+/** Public MCP input accepted by agent-acp session lifecycle methods. */
+type AcpMcpServerConfig = AcpStdioMcpServerConfig | AcpHttpMcpServerConfig | AcpSseMcpServerConfig;
+/** Exact MCP server wire union from the pinned ACP protocol library. */
+type AcpMcpServerWireConfig = McpServer;
+/** Serialize a host-friendly config into the exact ACP v1 wire representation. */
+declare function normalizeAcpMcpServerConfig(server: AcpMcpServerConfig): AcpMcpServerWireConfig;
+/** Serialize a per-session list without retaining mutable caller collections. */
+declare function normalizeAcpMcpServerConfigs(servers: readonly AcpMcpServerConfig[]): AcpMcpServerWireConfig[];
+
 type AcpPromptContentBlock = {
     type: "text";
     text: string;
@@ -243,12 +289,6 @@ type AcpPromptContentBlock = {
     mimeType: string;
     data: string;
 };
-type AcpMcpServerConfig = {
-    name: string;
-    command: string;
-    args?: string[];
-    env?: Record<string, string>;
-};
 type AcpRuntimeOptionSource = "mode" | "model" | "configOption";
 type AcpAgentClientOptions = {
     /** The transport (real stdio or a fake). */
@@ -262,7 +302,7 @@ type AcpAgentClientOptions = {
     /** Default cwd for `session/new` when `startThread` omits one. */
     cwd?: string;
     /** MCP servers to attach at `session/new` / `session/load`. */
-    mcpServers?: AcpMcpServerConfig[];
+    mcpServers?: readonly AcpMcpServerConfig[];
     now?: () => number;
     logger?: Logger;
 };
@@ -274,7 +314,15 @@ type AcpAgentClientOptions = {
 type AcpStartThreadOptions = {
     /** Working directory for the agent session. */
     cwd?: string;
-    mcpServers?: AcpMcpServerConfig[];
+    mcpServers?: readonly AcpMcpServerConfig[];
+};
+/** ACP-native `session/load` options. The protocol session id is the id the
+ * agent persisted; `threadId` optionally preserves a separate host-facing id. */
+type AcpLoadThreadOptions = {
+    sessionId: string;
+    threadId?: string;
+    cwd?: string;
+    mcpServers?: readonly AcpMcpServerConfig[];
 };
 /** ACP-NATIVE turn/start options. Internal mapping target; the public `startTurn`
  *  takes neutral `AgentStartTurnOptions`. */
@@ -343,6 +391,10 @@ declare class AcpAgentClient implements AgentBackend {
      *  mapping cwd + dropping Codex-only fields. Exposed for hosts that need
      *  ACP-specific control (per-thread `mcpServers`). */
     startThreadNative(options?: AcpStartThreadOptions): Promise<AgentBackendStartThreadResult>;
+    /** 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`. */
+    loadThreadNative(options: AcpLoadThreadOptions): Promise<AgentBackendStartThreadResult>;
     /**
      * 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
@@ -362,7 +414,7 @@ declare class AcpAgentClient implements AgentBackend {
          *  surfaces with different tool sets (library vs sizzle): each surface
          *  passes its own servers, so its threads spawn its tools — overriding the
          *  client-level default. */
-        mcpServers?: AcpMcpServerConfig[];
+        mcpServers?: readonly AcpMcpServerConfig[];
     }): Promise<void>;
     /**
      * Mint a thread id WITHOUT spawning the agent or opening a session. The
@@ -383,6 +435,7 @@ declare class AcpAgentClient implements AgentBackend {
      *  `bindThreadId` is given (resume), in which case the new ACP session is
      *  bound to that existing host thread id. */
     private establishSession;
+    private openSession;
     /**
      * Public `AgentBackend.startTurn`: accepts NEUTRAL `AgentStartTurnOptions` and
      * maps them onto ACP prompt content blocks — a leading `text` block from
@@ -423,10 +476,6 @@ declare class AcpAgentClient implements AgentBackend {
     private handleNotification;
     private applySessionUpdate;
     private handleAcpRequest;
-    /** 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. */
-    private knownMcpServerNames;
     private handlePermissionRequest;
     private setRuntimeOption;
     private setRuntimeOptionOnTransport;
@@ -448,8 +497,13 @@ declare class AcpAgentClient implements AgentBackend {
     private notifyRuntimeCapabilities;
     private emitThreadSettings;
     private requireSession;
+    private assertMcpTransportSupport;
     /** Whether the agent advertises session/load support (for hosts that resume). */
     supportsSessionLoad(): boolean;
+    /** Whether the initialize result explicitly advertises streamable HTTP MCP. */
+    supportsHttpMcp(): boolean;
+    /** Whether the initialize result explicitly advertises legacy HTTP+SSE MCP. */
+    supportsSseMcp(): boolean;
 }
 /** Pick the value to set on a "thinking" config option for a neutral reasoning
  *  token: low-effort → the OFF-like value, high-effort → the ON-like value.
@@ -820,4 +874,4 @@ declare class AcpRegistryService {
 declare function evaluateAcpDistributionPolicy(distribution: AcpRegistryDistribution, allowlist: AcpAllowlistDecision): AcpDistributionPolicy;
 declare function normalizeRegistry(raw: unknown): AcpRegistryAgent[];
 
-export { ACP_REGISTRY_URL, AcpAgentAllowlist, type AcpAgentAllowlistRule, AcpAgentClient, type AcpAgentClientFactory, type AcpAgentClientOptions, AcpAgentClientPool, type AcpAgentClientPoolOptions, type AcpAgentConnection, type AcpAgentConnectionHandle, type AcpAgentInstanceSource, type AcpAgentQuirks, type AcpAgentStrategy, type AcpAllowlistDecision, type AcpApplyContext, type AcpBinaryPlatformDistribution, AcpConnection, type AcpConnectionOptions, type AcpDiscoveryProbe, type AcpDistributionKind, type AcpDistributionPolicy, type AcpJsonRpcTransport, type AcpMcpServerConfig, type AcpNormalizeResult, type AcpNormalizerOptions, AcpOneShotClient, type AcpOneShotClientOptions, type AcpOneShotRequest, type AcpOneShotResponse, type AcpPackageDistribution, type AcpPathExecutableLister, type AcpPromptContentBlock, type AcpRegistryAgent, type AcpRegistryAgentWithPolicy, type AcpRegistryAuthDescriptor, type AcpRegistryAuthMethod, type AcpRegistryDistribution, type AcpRegistryFetch, AcpRegistryService, type AcpRegistryServiceOptions, type AcpRegistrySnapshot, type AcpRuntimeAgentCapabilities, type AcpRuntimeAgentInfo, type AcpRuntimeCapabilities, type AcpRuntimeCapabilitiesHandler, type AcpRuntimeCapabilitiesSource, type AcpRuntimeConfigOption, type AcpRuntimeConfigOptionValue, type AcpRuntimeMode, type AcpRuntimeModel, type AcpRuntimeModels, type AcpRuntimeModes, type AcpRuntimeOptionSource, AcpSessionNormalizer, type AcpSessionRuntimeState, type AcpSpawnSpec, type AcpStartThreadOptions, type AcpStartTurnOptions, type AcpTitleHandler, type AcpVerificationStatus, BANNED_ACP_REGISTRY_IDS, BUILT_IN_ACP_STRATEGIES, DEFAULT_ACP_AGENT_ALLOWLIST, type DiscoveredAcpAgent, type DiscoveredAcpAgentGroup, type DiscoveredAcpAgentInstance, type LocalAcpAgentProbe, type LocalAcpDiscoveryOptions, type LocalAcpProbeResult, acpRuntimeSupportsSessionLoad, acpSessionRuntimeStateFromCapabilities, acpSessionRuntimeStateFromUpdate, asRecord, buildAcpBackendId, buildStrategyTable, defaultAcpAgentAllowlist, defaultQuirks, discoverLocalAcpAgentInstances, discoverLocalAcpAgents, evaluateAcpDistributionPolicy, geminiStrategy, grokStrategy, isBannedAcpRegistryId, kimiStrategy, mergeAcpRuntimeState, modeLabelFor, modelConfigOption, modelIdFromCapabilities, modelsFromCapabilities, normalizeAcpRuntimeCapabilities, normalizeRegistry, qwenStrategy, readAcpContentText, readBoolean, readContentText, readFirstLocationPath, readFirstString, readKind, readNonEmptyString, readNumber, readPromptText, readString, readToolCallId, readToolContentText, readToolOutput, readUpdateText, reasoningValueForThoughtLevel, strategyByBackendId, strategyById, toolCallFromUpdate, wellKnownAgentBinDirs };
+export { ACP_REGISTRY_URL, AcpAgentAllowlist, type AcpAgentAllowlistRule, AcpAgentClient, type AcpAgentClientFactory, type AcpAgentClientOptions, AcpAgentClientPool, type AcpAgentClientPoolOptions, type AcpAgentConnection, type AcpAgentConnectionHandle, type AcpAgentInstanceSource, type AcpAgentQuirks, type AcpAgentStrategy, type AcpAllowlistDecision, type AcpApplyContext, type AcpBinaryPlatformDistribution, AcpConnection, type AcpConnectionOptions, type AcpDiscoveryProbe, type AcpDistributionKind, type AcpDistributionPolicy, type AcpHttpMcpServerConfig, type AcpJsonRpcTransport, type AcpLoadThreadOptions, type AcpMcpKeyValue, type AcpMcpKeyValueCollection, type AcpMcpServerConfig, type AcpMcpServerWireConfig, type AcpNormalizeResult, type AcpNormalizerOptions, AcpOneShotClient, type AcpOneShotClientOptions, type AcpOneShotRequest, type AcpOneShotResponse, type AcpPackageDistribution, type AcpPathExecutableLister, type AcpPromptContentBlock, type AcpRegistryAgent, type AcpRegistryAgentWithPolicy, type AcpRegistryAuthDescriptor, type AcpRegistryAuthMethod, type AcpRegistryDistribution, type AcpRegistryFetch, AcpRegistryService, type AcpRegistryServiceOptions, type AcpRegistrySnapshot, type AcpRuntimeAgentCapabilities, type AcpRuntimeAgentInfo, type AcpRuntimeCapabilities, type AcpRuntimeCapabilitiesHandler, type AcpRuntimeCapabilitiesSource, type AcpRuntimeConfigOption, type AcpRuntimeConfigOptionValue, type AcpRuntimeMcpCapabilities, type AcpRuntimeMode, type AcpRuntimeModel, type AcpRuntimeModels, type AcpRuntimeModes, type AcpRuntimeOptionSource, AcpSessionNormalizer, type AcpSessionRuntimeState, type AcpSpawnSpec, type AcpSseMcpServerConfig, type AcpStartThreadOptions, type AcpStartTurnOptions, type AcpStdioMcpServerConfig, type AcpTitleHandler, type AcpVerificationStatus, BANNED_ACP_REGISTRY_IDS, BUILT_IN_ACP_STRATEGIES, DEFAULT_ACP_AGENT_ALLOWLIST, type DiscoveredAcpAgent, type DiscoveredAcpAgentGroup, type DiscoveredAcpAgentInstance, type LocalAcpAgentProbe, type LocalAcpDiscoveryOptions, type LocalAcpProbeResult, acpRuntimeSupportsHttpMcp, acpRuntimeSupportsSessionLoad, acpRuntimeSupportsSseMcp, acpSessionRuntimeStateFromCapabilities, acpSessionRuntimeStateFromUpdate, asRecord, buildAcpBackendId, buildStrategyTable, defaultAcpAgentAllowlist, defaultQuirks, discoverLocalAcpAgentInstances, discoverLocalAcpAgents, evaluateAcpDistributionPolicy, geminiStrategy, grokStrategy, isBannedAcpRegistryId, kimiStrategy, mergeAcpRuntimeState, modeLabelFor, modelConfigOption, modelIdFromCapabilities, modelsFromCapabilities, normalizeAcpMcpServerConfig, normalizeAcpMcpServerConfigs, normalizeAcpRuntimeCapabilities, normalizeRegistry, qwenStrategy, readAcpContentText, readBoolean, readContentText, readFirstLocationPath, readFirstString, readKind, readNonEmptyString, readNumber, readPromptText, readString, readToolCallId, readToolContentText, readToolOutput, readUpdateText, reasoningValueForThoughtLevel, strategyByBackendId, strategyById, toolCallFromUpdate, wellKnownAgentBinDirs };

package/dist/index.js

@@ -4,105 +4,8 @@ import { Readable, Writable } from "stream";
 import {
   ClientSideConnection,
   ndJsonStream
-} from "@zed-industries/agent-client-protocol";
+} 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;
-}
 var AcpConnection = class {
   constructor(options) {
     this.options = options;
@@ -172,12 +75,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 +117,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 +128,7 @@ var AcpConnection = class {
       await conn.cancel(params);
       return;
     }
-    await conn.extNotification(method, params);
+    await conn.notify(method, params);
   }
   async close() {
     try {
@@ -760,6 +659,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 +852,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 +893,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 +1083,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 +1140,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 +1156,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 +1225,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 +1246,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 +1525,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 +1545,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 +1680,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",
@@ -2795,7 +2837,9 @@ export {
   BANNED_ACP_REGISTRY_IDS,
   BUILT_IN_ACP_STRATEGIES,
   DEFAULT_ACP_AGENT_ALLOWLIST,
+  acpRuntimeSupportsHttpMcp,
   acpRuntimeSupportsSessionLoad,
+  acpRuntimeSupportsSseMcp,
   acpSessionRuntimeStateFromCapabilities,
   acpSessionRuntimeStateFromUpdate,
   asRecord,
@@ -2815,6 +2859,8 @@ export {
   modelConfigOption,
   modelIdFromCapabilities,
   modelsFromCapabilities,
+  normalizeAcpMcpServerConfig,
+  normalizeAcpMcpServerConfigs,
   normalizeAcpRuntimeCapabilities,
   normalizeRegistry,
   qwenStrategy,