@wrongstack/mcp 1.0.29 → 1.0.32

package/dist/index.js

@@ -6,7 +6,7 @@ import * as dns from "node:dns/promises";
 import * as http from "node:http";
 import * as https from "node:https";
 import * as net from "node:net";
-import { isPrivateIPv4, isPrivateIPv6 } from "@wrongstack/core/utils";
+import { isPrivateIPv4, isPrivateIPv6, toErrorMessage } from "@wrongstack/core/utils";
 var MCPOAuthHttpError = class extends Error {
   constructor(message, status) {
     super(message);
@@ -216,10 +216,10 @@ function requiredString(value, field) {
   return value;
 }
 function optionalString(value, field) {
-  return value === void 0 ? void 0 : requiredString(value, field);
+  return value === void 0 || value === null || value === "" ? void 0 : requiredString(value, field);
 }
 function optionalBoolean(value, field) {
-  if (value === void 0) return void 0;
+  if (value === void 0 || value === null) return void 0;
   if (typeof value !== "boolean") {
     throw new Error(`MCP authorization field "${field}" must be a boolean`);
   }
@@ -232,7 +232,7 @@ function boundedStringArray(value, field, maxItems) {
   return [...new Set(value.map((entry) => requiredString(entry, field)))];
 }
 function optionalStringArray(value, field, maxItems) {
-  return value === void 0 ? [] : boundedStringArray(value, field, maxItems);
+  return value === void 0 || value === null ? [] : boundedStringArray(value, field, maxItems);
 }
 function secureOAuthUrl(value, label2) {
   let url;
@@ -263,7 +263,7 @@ async function discoverFirst(candidates, fetchJson, signal, parse, label2) {
       return { url: candidate, value: parse(value) };
     } catch (error) {
       signal?.throwIfAborted();
-      failures.push(`${candidate}: ${error instanceof Error ? error.message : String(error)}`);
+      failures.push(`${candidate}: ${toErrorMessage(error)}`);
     }
   }
   throw new Error(`MCP ${label2} discovery failed (${failures.join("; ")})`);
@@ -634,7 +634,7 @@ function parseTokenResponse(value, resource) {
   }
   const expiresIn = response["expires_in"];
   let expiresAt;
-  if (expiresIn !== void 0) {
+  if (expiresIn !== void 0 && expiresIn !== null) {
     if (typeof expiresIn !== "number" || !Number.isFinite(expiresIn) || expiresIn <= 0 || expiresIn > 31536e3) {
       throw new Error("MCP OAuth expires_in must be between 1 second and 1 year");
     }
@@ -1154,9 +1154,7 @@ function boundedServerName(value) {
 }
 
 // src/client.ts
-import { spawn as spawn2 } from "node:child_process";
-import { StringDecoder } from "node:string_decoder";
-import { buildChildEnv as buildChildEnv2, buildWin32CmdShimInvocation, toErrorMessage } from "@wrongstack/core/utils";
+import { StringDecoder as StringDecoder2 } from "node:string_decoder";
 
 // src/client-protocol-helpers.ts
 var MAX_PROTOCOL_INPUT_CHARS = 8192;
@@ -1479,7 +1477,7 @@ function resolveHttpBearerHeaders(options, env = process.env) {
   if (!/^[A-Za-z_][A-Za-z0-9_]{0,127}$/.test(envName)) {
     throw new Error(`MCP bearerTokenEnv "${envName}" is not a valid environment variable name`);
   }
-  const token = env[envName];
+  const token = Object.hasOwn(env, envName) ? env[envName] : void 0;
   if (!token) throw new Error(`MCP "${options.name}" requires environment variable ${envName}`);
   if (token.length > 16384 || /[\r\n]/.test(token)) {
     throw new Error(`MCP "${options.name}" bearer token is oversized or contains newlines`);
@@ -1528,7 +1526,9 @@ var SSE_READER_MAX_BUFFER = 256 * 1024;
 var SSE_READER_MAX_DATA_LINES = 1024;
 var SSEReader = class {
   buffer = "";
+  skipLeadingLF = false;
   dataLines = [];
+  dataLength = 0;
   eventName = "";
   endpointListeners = [];
   /**
@@ -1553,15 +1553,21 @@ var SSEReader = class {
   }
   feed(chunk) {
     const carried = this.buffer.length;
+    if (this.skipLeadingLF && chunk.length > 0) {
+      this.skipLeadingLF = false;
+      if (chunk.startsWith("\n")) chunk = chunk.slice(1);
+    }
     this.buffer += chunk;
     let start = 0;
-    let idx = this.buffer.indexOf("\n", start);
-    while (idx !== -1) {
-      let end = idx;
-      if (end > start && this.buffer.charCodeAt(end - 1) === 13) end--;
-      this.processLine(this.buffer.slice(start, end));
+    for (let idx = 0; idx < this.buffer.length; idx++) {
+      const code = this.buffer.charCodeAt(idx);
+      if (code !== 10 && code !== 13) continue;
+      this.processLine(this.buffer.slice(start, idx));
+      if (code === 13) {
+        if (this.buffer.charCodeAt(idx + 1) === 10) idx++;
+        else if (idx + 1 === this.buffer.length) this.skipLeadingLF = true;
+      }
       start = idx + 1;
-      idx = this.buffer.indexOf("\n", start);
     }
     if (start > 0) this.buffer = this.buffer.slice(start);
     if (this.buffer.length <= SSE_READER_MAX_BUFFER) return;
@@ -1585,6 +1591,13 @@ var SSEReader = class {
     });
   }
   processLine(line) {
+    if (line.length > SSE_READER_MAX_BUFFER) {
+      throw new ToolError({
+        message: `SSE: completed line exceeds ${SSE_READER_MAX_BUFFER} characters`,
+        code: "TOOL_EXECUTION_FAILED",
+        toolName: "mcp_transport_sse_reader"
+      });
+    }
     if (line === "") {
       this.flush();
       return;
@@ -1597,6 +1610,14 @@ var SSEReader = class {
     if (field === "event") {
       this.eventName = value;
     } else if (field === "data") {
+      const nextLength = this.dataLength + value.length + (this.dataLines.length > 0 ? 1 : 0);
+      if (nextLength > SSE_READER_MAX_BUFFER) {
+        throw new ToolError({
+          message: `SSE: event data exceeds ${SSE_READER_MAX_BUFFER} characters`,
+          code: "TOOL_EXECUTION_FAILED",
+          toolName: "mcp_transport_sse_reader"
+        });
+      }
       if (this.dataLines.length >= SSE_READER_MAX_DATA_LINES) {
         throw new ToolError({
           message: `SSE: exceeded ${SSE_READER_MAX_DATA_LINES} data lines per event \u2014 upstream is not sending blank-line delimiters`,
@@ -1609,12 +1630,14 @@ var SSEReader = class {
           }
         });
       }
+      this.dataLength = nextLength;
       this.dataLines.push(value);
     }
   }
   flush() {
     const eventName = this.eventName;
     this.eventName = "";
+    this.dataLength = 0;
     if (this.dataLines.length === 0) {
       return;
     }
@@ -1646,8 +1669,10 @@ var SSEReader = class {
   }
   reset() {
     this.buffer = "";
+    this.skipLeadingLF = false;
     this.dataLines = [];
     this.eventName = "";
+    this.dataLength = 0;
     this.listeners = [];
     this.endpointListeners = [];
   }
@@ -1896,9 +1921,14 @@ function checkValue(field, raw) {
 function validateElicitationContent(fields, content) {
   const out = {};
   for (const field of fields) {
-    const raw = content[field.name];
+    const raw = Object.hasOwn(content, field.name) ? content[field.name] : void 0;
     if (Array.isArray(raw) && raw.length === 0 && field.kind === "multi-enum" && field.minItems === 0) {
-      out[field.name] = [];
+      Object.defineProperty(out, field.name, {
+        value: [],
+        enumerable: true,
+        writable: true,
+        configurable: true
+      });
       continue;
     }
     if (raw === void 0 || raw === null || Array.isArray(raw) && raw.length === 0) {
@@ -1907,7 +1937,12 @@ function validateElicitationContent(fields, content) {
     }
     const checked = checkValue(field, raw);
     if (!checked.ok) return checked;
-    out[field.name] = checked.value;
+    Object.defineProperty(out, field.name, {
+      value: checked.value,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
   }
   return { ok: true, value: out };
 }
@@ -1965,7 +2000,7 @@ var ServerRequestResponder = class {
       return { jsonrpc: "2.0", id, result: { action: "cancel" } };
     } finally {
       clearTimeout(deadline);
-      this.pending.delete(id);
+      if (this.pending.get(id) === controller) this.pending.delete(id);
     }
   }
   /**
@@ -2011,7 +2046,17 @@ async function readBodyCapped(res, maxBytes = MAX_MCP_HTTP_BODY_BYTES) {
   const safeCap = typeof maxBytes === "number" && Number.isFinite(maxBytes) && maxBytes >= 0 ? maxBytes : MAX_MCP_HTTP_BODY_BYTES;
   const body = res.body;
   if (!body || typeof body.getReader !== "function") {
-    return await res.text();
+    const text = await res.text();
+    const received = Buffer.byteLength(text, "utf8");
+    if (received > safeCap) {
+      throw new ToolError2({
+        message: `MCP response body exceeded ${safeCap} bytes \u2014 refusing to buffer`,
+        code: "TOOL_EXECUTION_FAILED",
+        toolName: "mcp_transport",
+        context: { maxBytes: safeCap, received }
+      });
+    }
+    return text;
   }
   const reader = body.getReader();
   const chunks = [];
@@ -2568,7 +2613,7 @@ function extractJsonRpcEnvelopes(text) {
     } catch {
     }
   };
-  for (const raw of text.split("\n")) {
+  for (const raw of text.split(/\r\n|\r|\n/)) {
     const line = raw.replace(/\r$/, "");
     if (line === "") {
       flush();
@@ -2773,6 +2818,8 @@ var SSETransport = class extends BaseHTTPTransport {
   _nextId = 1;
   readerDone = false;
   closed = false;
+  toolCatalogVersion = 0;
+  toolCatalogRevision = 0;
   readLoopAbort;
   reader;
   /** POST target announced by the server's `endpoint` event. */
@@ -2791,10 +2838,12 @@ var SSETransport = class extends BaseHTTPTransport {
   }
   /** Refresh tool list when server sends notifications/tools/list_changed. */
   async handleToolsListChanged() {
+    const version = ++this.toolCatalogVersion;
     try {
       const tools = await listAllTools((params) => this.httpPost("tools/list", params));
-      if (!tools) return;
+      if (!tools || version !== this.toolCatalogVersion) return;
       this.tools.splice(0, this.tools.length, ...tools);
+      this.toolCatalogRevision++;
       for (const cb of this.toolsChangedListeners) {
         try {
           cb([...this.tools]);
@@ -2805,14 +2854,21 @@ var SSETransport = class extends BaseHTTPTransport {
     }
   }
   async connect() {
+    this.toolCatalogVersion++;
     this.readerDone = false;
     this.closed = false;
     this.endpointUrl = void 0;
     this.state = "connecting";
     this.serverMetadata = void 0;
-    this.abortController = new AbortController();
-    const signal = this.abortController.signal;
-    const startupTimer = setTimeout(() => this.abortController?.abort(), this.timeout);
+    const controller = new AbortController();
+    this.abortController = controller;
+    const signal = controller.signal;
+    const assertCurrent = () => {
+      if (this.abortController !== controller || signal.aborted || this.closed) {
+        throw makeAbortError("connect");
+      }
+    };
+    const startupTimer = setTimeout(() => controller.abort(), this.timeout);
     try {
       const sseUrl = this.buildSSEUrl();
       const fetchOpts = {
@@ -2821,6 +2877,12 @@ var SSETransport = class extends BaseHTTPTransport {
       };
       this.applyTlsAgent(fetchOpts);
       const response = await this.fetchWithAuthorization(sseUrl, fetchOpts, signal);
+      try {
+        assertCurrent();
+      } catch (error) {
+        await response.body?.cancel().catch(() => void 0);
+        throw error;
+      }
       if (!response.ok) {
         throw new ToolError4({
           message: `SSE connect HTTP ${response.status}: ${response.statusText}`,
@@ -2839,15 +2901,18 @@ var SSETransport = class extends BaseHTTPTransport {
       }
       const textDecoder = new TextDecoder();
       const sseReader = new SSEReader();
-      this.readLoopAbort = new AbortController();
+      const readLoopAbort = new AbortController();
+      this.readLoopAbort = readLoopAbort;
       const streamReady = new Promise((resolve) => {
         this.streamSignal = resolve;
       });
       sseReader.onEndpoint((endpoint) => {
+        if (this.abortController !== controller || signal.aborted || this.closed) return;
         this.acceptEndpoint(endpoint);
         this.streamSignal?.();
       });
       sseReader.onMessage((msg) => {
+        if (this.abortController !== controller || signal.aborted || this.closed) return;
         this.streamSignal?.();
         const id = msg.id;
         if (msg.method && (typeof id === "number" || typeof id === "string")) {
@@ -2886,8 +2951,9 @@ var SSETransport = class extends BaseHTTPTransport {
         cancel: () => reader.cancel(),
         releaseLock: () => reader.releaseLock()
       };
-      void this.readSSEBody(reader, textDecoder, sseReader);
+      void this.readSSEBody(reader, textDecoder, sseReader, controller, readLoopAbort.signal);
       await this.waitForStream(streamReady, signal);
+      assertCurrent();
       const initRes = await this.httpPost("initialize", {
         protocolVersion: MCP_CONSTANTS.PROTOCOL_VERSION,
         // Client capabilities: elicitation when the host can ask its user.
@@ -2895,6 +2961,7 @@ var SSETransport = class extends BaseHTTPTransport {
         capabilities: this.serverRequests.capabilities(),
         clientInfo: MCP_CONSTANTS.CLIENT_INFO
       });
+      assertCurrent();
       if (initRes.error) {
         throw new ToolError4({
           message: `initialize failed: ${initRes.error.message}`,
@@ -2909,17 +2976,24 @@ var SSETransport = class extends BaseHTTPTransport {
         await this.httpPost("notifications/initialized", {});
       } catch {
       }
+      assertCurrent();
+      const revision = this.toolCatalogRevision;
       const tools = await listAllTools((params) => this.httpPost("tools/list", params));
-      this.tools.splice(0, this.tools.length, ...tools ?? []);
+      assertCurrent();
+      if (revision === this.toolCatalogRevision) {
+        this.tools.splice(0, this.tools.length, ...tools ?? []);
+      }
       this.state = "connected";
       clearTimeout(startupTimer);
     } catch (err) {
       clearTimeout(startupTimer);
-      this.state = "failed";
-      this.abortController.abort();
+      if (this.abortController === controller && !this.closed) {
+        this.state = "failed";
+      }
+      controller.abort();
       throw err;
     } finally {
-      this.streamSignal = void 0;
+      if (this.abortController === controller) this.streamSignal = void 0;
     }
   }
   /** Resolve once the stream announced its endpoint, emitted anything, ended, or the cap passed. */
@@ -2957,9 +3031,9 @@ var SSETransport = class extends BaseHTTPTransport {
     } catch {
     }
   }
-  async readSSEBody(reader, decoder, sseReader) {
+  async readSSEBody(reader, decoder, sseReader, controller, signal) {
     try {
-      while (!this.readerDone) {
+      while (!this.readerDone && !signal?.aborted && (!controller || this.abortController === controller) && !this.closed) {
         const { done, value } = await reader.read();
         if (done) break;
         const chunk = decoder.decode(value, { stream: true });
@@ -2967,11 +3041,13 @@ var SSETransport = class extends BaseHTTPTransport {
       }
     } catch {
     } finally {
-      this.streamSignal?.();
-      this.rejectStreamPending("SSE stream closed");
-      if (!this.readerDone && this.state !== "disconnected" && this.state !== "failed") {
-        this.state = "disconnected";
-        this.notifyDisconnect();
+      if (!controller || this.abortController === controller) {
+        this.streamSignal?.();
+        this.rejectStreamPending("SSE stream closed");
+        if (!this.readerDone && !signal?.aborted && !this.closed && this.state !== "disconnected" && this.state !== "failed") {
+          this.state = "disconnected";
+          this.notifyDisconnect();
+        }
       }
     }
   }
@@ -3117,6 +3193,7 @@ var SSETransport = class extends BaseHTTPTransport {
     return { jsonrpc: "2.0", id: result.id, result: result.result, error: result.error };
   }
   async close() {
+    this.toolCatalogVersion++;
     this.releasePinnedDispatcher();
     const alreadyClosed = this.closed;
     this.closed = true;
@@ -3157,6 +3234,8 @@ function invalidResponse(method, url, err) {
 var StreamableHTTPTransport = class _StreamableHTTPTransport extends BaseHTTPTransport {
   _nextId = 1;
   closed = false;
+  toolCatalogVersion = 0;
+  toolCatalogRevision = 0;
   sessionId;
   constructor(opts) {
     super(opts, "StreamableHTTP");
@@ -3252,10 +3331,12 @@ var StreamableHTTPTransport = class _StreamableHTTPTransport extends BaseHTTPTra
     }
   }
   async refreshTools() {
+    const version = ++this.toolCatalogVersion;
     try {
       const tools = await listAllTools((params) => this.postRaw("tools/list", params));
-      if (!tools) return;
+      if (!tools || version !== this.toolCatalogVersion) return;
       this.tools.splice(0, this.tools.length, ...tools);
+      this.toolCatalogRevision++;
       for (const listener of this.toolsChangedListeners) {
         try {
           listener([...tools]);
@@ -3266,12 +3347,19 @@ var StreamableHTTPTransport = class _StreamableHTTPTransport extends BaseHTTPTra
     }
   }
   async connect() {
+    this.toolCatalogVersion++;
     this.closed = false;
     this.state = "connecting";
     this.serverMetadata = void 0;
-    this.abortController = new AbortController();
-    const signal = this.abortController.signal;
-    const startupTimer = setTimeout(() => this.abortController?.abort(), this.timeout);
+    const controller = new AbortController();
+    this.abortController = controller;
+    const signal = controller.signal;
+    const assertCurrent = () => {
+      if (this.abortController !== controller || signal.aborted || this.closed) {
+        throw makeAbortError("connect");
+      }
+    };
+    const startupTimer = setTimeout(() => controller.abort(), this.timeout);
     try {
       const initializeId = this.genId();
       const initFetchOpts = {
@@ -3297,6 +3385,7 @@ var StreamableHTTPTransport = class _StreamableHTTPTransport extends BaseHTTPTra
       };
       this.applyTlsAgent(initFetchOpts);
       const initRes = await this.fetchWithAuthorization(this.url, initFetchOpts, signal);
+      assertCurrent();
       if (!initRes.ok) {
         throw new Error(`initialize HTTP ${initRes.status}: ${initRes.statusText}`);
       }
@@ -3308,6 +3397,7 @@ var StreamableHTTPTransport = class _StreamableHTTPTransport extends BaseHTTPTra
       } else {
         data = extractJsonRpcResults(await readBodyCapped(initRes))[0];
       }
+      assertCurrent();
       if (!data) {
         throw new Error("Could not parse initialize response");
       }
@@ -3319,14 +3409,21 @@ var StreamableHTTPTransport = class _StreamableHTTPTransport extends BaseHTTPTra
       this.protocolVersion = this.serverMetadata.protocolVersion;
       this.sessionId = initRes.headers.get("mcp-session-id") ?? void 0;
       await this.postRaw("notifications/initialized", {});
+      assertCurrent();
+      const revision = this.toolCatalogRevision;
       const tools = await listAllTools((params) => this.postRaw("tools/list", params));
-      this.tools.splice(0, this.tools.length, ...tools ?? []);
+      assertCurrent();
+      if (revision === this.toolCatalogRevision) {
+        this.tools.splice(0, this.tools.length, ...tools ?? []);
+      }
       this.state = "connected";
       clearTimeout(startupTimer);
     } catch (err) {
       clearTimeout(startupTimer);
-      this.state = "failed";
-      this.abortController.abort();
+      if (this.abortController === controller && !this.closed) {
+        this.state = "failed";
+      }
+      controller.abort();
       throw err;
     }
   }
@@ -3443,6 +3540,7 @@ var StreamableHTTPTransport = class _StreamableHTTPTransport extends BaseHTTPTra
     return toToolCallResult(res);
   }
   async close() {
+    this.toolCatalogVersion++;
     this.releasePinnedDispatcher();
     const alreadyClosed = this.closed;
     this.closed = true;
@@ -3467,9 +3565,17 @@ var StreamableHTTPTransport = class _StreamableHTTPTransport extends BaseHTTPTra
   }
 };
 function completeEventsEnd(text) {
-  const lf = text.lastIndexOf("\n\n");
-  const crlf = text.lastIndexOf("\r\n\r\n");
-  return Math.max(lf === -1 ? 0 : lf + 2, crlf === -1 ? 0 : crlf + 4);
+  let start = 0;
+  let end = 0;
+  for (let idx = 0; idx < text.length; idx++) {
+    const code = text.charCodeAt(idx);
+    if (code !== 10 && code !== 13) continue;
+    const empty = idx === start;
+    if (code === 13 && text.charCodeAt(idx + 1) === 10) idx++;
+    start = idx + 1;
+    if (empty) end = start;
+  }
+  return end;
 }
 
 // src/client-http-connection.ts
@@ -3580,8 +3686,248 @@ async function connectStreamableHTTP(host) {
   host.state = "connected";
 }
 
+// src/client-stdio.ts
+import { spawn as spawn2 } from "node:child_process";
+import { StringDecoder } from "node:string_decoder";
+import { buildChildEnv as buildChildEnv2, buildWin32CmdShimInvocation, toErrorMessage as toErrorMessage2 } from "@wrongstack/core/utils";
+async function connectStdio(host) {
+  if (!host.opts.command) {
+    host.state = "failed";
+    throw new Error('MCP stdio transport requires "command"');
+  }
+  host.rxBuffer = "";
+  host.rxBufferBytes = 0;
+  host.rxDecoder = new StringDecoder("utf8");
+  const extraEnv = { ...host.opts.env };
+  if (host.opts.passthroughEnv) {
+    for (const name of host.opts.passthroughEnv) {
+      const val = process.env[name];
+      if (val !== void 0) {
+        extraEnv[name] = val;
+      }
+    }
+  }
+  const isWin = process.platform === "win32";
+  const rawArgs = host.opts.args ?? [];
+  const spawnEnv = buildChildEnv2({ extra: extraEnv });
+  const stdio = ["pipe", "pipe", "pipe"];
+  const child = isWin ? (() => {
+    const shim = buildWin32CmdShimInvocation(host.opts.command, rawArgs);
+    return spawn2(shim.command, shim.args, {
+      env: spawnEnv,
+      stdio,
+      ...host.opts.cwd ? { cwd: host.opts.cwd } : {},
+      windowsVerbatimArguments: shim.windowsVerbatimArguments,
+      // Without this every MCP server spawned from a console-less host
+      // (WebUI server, scheduled runs) opens a visible console window.
+      windowsHide: true
+    });
+  })() : spawn2(host.opts.command, rawArgs, {
+    env: spawnEnv,
+    stdio,
+    windowsHide: true,
+    ...host.opts.cwd ? { cwd: host.opts.cwd } : {}
+  });
+  host.child = child;
+  child.stdout?.on("data", (chunk) => host.onData(host.rxDecoder.write(chunk)));
+  child.stdout?.on("end", () => {
+    const tail = host.rxDecoder.end();
+    if (tail) host.onData(tail);
+    if (host.rxBuffer.trim()) {
+      const line = host.rxBuffer.trim();
+      host.rxBuffer = "";
+      host.onLine(line);
+    }
+  });
+  child.stderr?.on("data", () => {
+  });
+  child.stdin?.on("error", (err) => {
+    host.failPending(`MCP "${host.opts.name}" stdin error: ${toErrorMessage2(err)}`);
+  });
+  child.on("exit", (code, signal) => {
+    host.state = "disconnected";
+    host.failPending(
+      `MCP "${host.opts.name}" child exited (code=${code ?? "null"} signal=${signal ?? "null"})`
+    );
+    for (const listener of host.exitListeners) {
+      try {
+        listener(host.opts.name, code, signal);
+      } catch {
+      }
+    }
+  });
+  child.on("error", (err) => {
+    host.state = "failed";
+    host.failPending(`MCP "${host.opts.name}" child error: ${toErrorMessage2(err)}`);
+  });
+  const initialize = await host.request(
+    "initialize",
+    {
+      protocolVersion: MCP_CONSTANTS.PROTOCOL_VERSION,
+      // Client capabilities: elicitation when the host can ask its user.
+      // `tools` is a SERVER capability and never belonged here.
+      capabilities: host.serverRequests.capabilities(),
+      clientInfo: MCP_CONSTANTS.CLIENT_INFO
+    },
+    typeof host.opts.startupTimeoutMs === "number" && Number.isFinite(host.opts.startupTimeoutMs) && host.opts.startupTimeoutMs > 0 ? host.opts.startupTimeoutMs : 1e4
+  );
+  if (initialize.error) {
+    host.state = "failed";
+    throw new Error(`MCP initialize failed: ${initialize.error.message}`);
+  }
+  try {
+    host._serverMetadata = parseServerMetadata(initialize.result);
+  } catch (err) {
+    host.state = "failed";
+    throw new Error(`MCP initialize returned malformed server metadata: ${toErrorMessage2(err)}`);
+  }
+  try {
+    await host.notify("notifications/initialized", {});
+  } catch (err) {
+    console.warn(
+      '[MCP] notify("notifications/initialized") failed for "' + host.opts.name + '": ' + toErrorMessage2(err)
+    );
+  }
+  const revision = host.toolCatalogRevision;
+  const tools = await listAllTools((params) => host.request("tools/list", params)) ?? [];
+  if (revision === host.toolCatalogRevision) host._tools = tools;
+  host._toolsCache = host._tools;
+  host.state = "connected";
+}
+async function notifyStdio(host, method, params) {
+  if (host._drainPending) {
+    host._lastNotifySkipped = true;
+    console.warn(
+      JSON.stringify({
+        level: "warn",
+        event: "mcp.notify_skipped_backpressure",
+        server: host.opts.name,
+        method,
+        message: "stdin buffer backpressure (already waiting for drain)",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    );
+    return;
+  }
+  const stdin = host.child?.stdin;
+  if (!stdin || stdin.destroyed === true || stdin.writable === false) {
+    return;
+  }
+  const req = { jsonrpc: "2.0", method, params };
+  const encoded = JSON.stringify(req) + "\n";
+  try {
+    const ok = stdin.write(encoded);
+    if (!ok) {
+      host._drainPending = true;
+      await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          stdin.removeListener?.("drain", onDrain);
+          stdin.removeListener?.("error", onError);
+          host._drainPending = false;
+          reject(new Error(`MCP notify("${method}") drain timeout`));
+        }, 500);
+        const onDrain = () => {
+          clearTimeout(timeout);
+          stdin.removeListener?.("drain", onDrain);
+          stdin.removeListener?.("error", onError);
+          host._drainPending = false;
+          resolve();
+        };
+        const onError = (err) => {
+          clearTimeout(timeout);
+          stdin.removeListener?.("drain", onDrain);
+          stdin.removeListener?.("error", onError);
+          host._drainPending = false;
+          reject(err);
+        };
+        stdin.once?.("drain", onDrain);
+        stdin.once?.("error", onError);
+      });
+    }
+  } catch (err) {
+    throw new Error(`[MCP] notify("${method}") failed: ${toErrorMessage2(err)}`);
+  }
+}
+
+// src/client-stdio-protocol.ts
+var MAX_RX_BUFFER_BYTES = 16 * 1024 * 1024;
+function receiveStdioData(host, s) {
+  host.rxBufferBytes += Buffer.byteLength(s, "utf8");
+  if (host.rxBufferBytes > MAX_RX_BUFFER_BYTES) {
+    const truncated = host.rxBufferBytes;
+    host.rxParts = [];
+    host.rxBufferBytes = 0;
+    host.failPending(
+      `MCP "${host.opts.name}" rx buffer overflow (${truncated} bytes without a newline) \u2014 closing connection`
+    );
+    void host.close();
+    return;
+  }
+  let start = 0;
+  let idx = s.indexOf("\n");
+  if (idx === -1) {
+    host.rxParts.push(s);
+    return;
+  }
+  while (idx !== -1) {
+    const head = host.rxParts.length > 0 ? host.rxParts.join("") : "";
+    host.rxParts = [];
+    const line = (head + s.slice(start, idx)).trim();
+    start = idx + 1;
+    if (line) host.onLine(line);
+    idx = s.indexOf("\n", start);
+  }
+  const tail = s.slice(start);
+  host.rxBufferBytes = Buffer.byteLength(tail, "utf8");
+  if (tail) host.rxParts.push(tail);
+}
+function receiveStdioLine(host, line) {
+  let msg;
+  try {
+    msg = JSON.parse(line);
+  } catch {
+    return;
+  }
+  if (typeof msg !== "object" || msg === null) return;
+  const envelope = msg;
+  if (envelope["jsonrpc"] !== "2.0") return;
+  if (typeof envelope["method"] === "string") {
+    const id = envelope["id"];
+    if (typeof id === "number" || typeof id === "string") {
+      void host.handleServerRequest({
+        jsonrpc: "2.0",
+        id,
+        method: envelope["method"],
+        params: envelope["params"]
+      });
+      return;
+    }
+    if (Object.hasOwn(envelope, "id")) return;
+    if (envelope["method"] === "notifications/cancelled") {
+      host.serverRequests.cancel(envelope["params"]);
+    } else if (envelope["method"] === "notifications/tools/list_changed") {
+      void host.handleToolsListChanged();
+    } else if (envelope["method"] === "notifications/resources/list_changed") {
+      host.emitCapabilityChanged("resources");
+    } else if (envelope["method"] === "notifications/prompts/list_changed") {
+      host.emitCapabilityChanged("prompts");
+    } else if (envelope["method"] === "notifications/resources/updated") {
+      const uri = resourceUpdatedUri(envelope["params"]);
+      if (uri) host.emitResourceUpdated(uri);
+    }
+    return;
+  }
+  if (!isJsonRpcResult(msg)) return;
+  const response = msg;
+  if (host.pending.has(response.id)) {
+    const entry = host.pending.get(response.id);
+    host.pending.delete(response.id);
+    entry?.resolve(response);
+  }
+}
+
 // src/client.ts
-var MCPClient = class _MCPClient {
+var MCPClient = class {
   constructor(opts) {
     this.opts = opts;
     this.serverRequests = new ServerRequestResponder(opts.elicitation);
@@ -3591,15 +3937,6 @@ var MCPClient = class _MCPClient {
     this.requestCapability.bind(this),
     this.requireResourceSubscriptions.bind(this)
   );
-  /**
-   * Maximum bytes the rx buffer may accumulate before the connection is
-   * forcefully closed. A well-behaved JSON-RPC server emits newline-delimited
-   * messages that are individually much smaller than this; a server that never
-   * sends a newline would grow the buffer without limit and OOM the process.
-   * 16 MiB is generous for any legitimate single message while bounding the
-   * worst-case memory to a predictable cap.
-   */
-  static MAX_RX_BUFFER_BYTES = 16 * 1024 * 1024;
   state = "idle";
   child;
   nextId = 1;
@@ -3630,7 +3967,7 @@ var MCPClient = class _MCPClient {
    * JSON-RPC payload. StringDecoder withholds the partial sequence until the
    * chunk that completes it (same remedy as `readFileHead` in core utils).
    */
-  rxDecoder = new StringDecoder("utf8");
+  rxDecoder = new StringDecoder2("utf8");
   _tools = [];
   /** Server-declared handshake metadata. Populated for stdio in the first protocol slice. */
   _serverMetadata;
@@ -3640,6 +3977,8 @@ var MCPClient = class _MCPClient {
   _lastNotifySkipped = false;
   closePromise;
   connectPromise;
+  toolCatalogVersion = 0;
+  toolCatalogRevision = 0;
   // HTTP transports
   sseTransport;
   httpTransport;
@@ -3702,6 +4041,7 @@ var MCPClient = class _MCPClient {
     return this.connectPromise;
   }
   async connectInner() {
+    this.toolCatalogVersion++;
     this.state = "connecting";
     this._serverMetadata = void 0;
     try {
@@ -3722,106 +4062,7 @@ var MCPClient = class _MCPClient {
     }
   }
   async connectStdio() {
-    if (!this.opts.command) {
-      this.state = "failed";
-      throw new Error('MCP stdio transport requires "command"');
-    }
-    this.rxBuffer = "";
-    this.rxBufferBytes = 0;
-    this.rxDecoder = new StringDecoder("utf8");
-    const extraEnv = { ...this.opts.env };
-    if (this.opts.passthroughEnv) {
-      for (const name of this.opts.passthroughEnv) {
-        const val = process.env[name];
-        if (val !== void 0) {
-          extraEnv[name] = val;
-        }
-      }
-    }
-    const isWin = process.platform === "win32";
-    const rawArgs = this.opts.args ?? [];
-    const spawnEnv = buildChildEnv2({ extra: extraEnv });
-    const stdio = ["pipe", "pipe", "pipe"];
-    const child = isWin ? (() => {
-      const shim = buildWin32CmdShimInvocation(this.opts.command, rawArgs);
-      return spawn2(shim.command, shim.args, {
-        env: spawnEnv,
-        stdio,
-        ...this.opts.cwd ? { cwd: this.opts.cwd } : {},
-        windowsVerbatimArguments: shim.windowsVerbatimArguments,
-        // Without this every MCP server spawned from a console-less host
-        // (WebUI server, scheduled runs) opens a visible console window.
-        windowsHide: true
-      });
-    })() : spawn2(this.opts.command, rawArgs, {
-      env: spawnEnv,
-      stdio,
-      windowsHide: true,
-      ...this.opts.cwd ? { cwd: this.opts.cwd } : {}
-    });
-    this.child = child;
-    child.stdout?.on("data", (chunk) => this.onData(this.rxDecoder.write(chunk)));
-    child.stdout?.on("end", () => {
-      const tail = this.rxDecoder.end();
-      if (tail) this.onData(tail);
-      if (this.rxBuffer.trim()) {
-        const line = this.rxBuffer.trim();
-        this.rxBuffer = "";
-        this.onLine(line);
-      }
-    });
-    child.stderr?.on("data", () => {
-    });
-    child.stdin?.on("error", (err) => {
-      this.failPending(`MCP "${this.opts.name}" stdin error: ${toErrorMessage(err)}`);
-    });
-    child.on("exit", (code, signal) => {
-      this.state = "disconnected";
-      this.failPending(
-        `MCP "${this.opts.name}" child exited (code=${code ?? "null"} signal=${signal ?? "null"})`
-      );
-      for (const listener of this.exitListeners) {
-        try {
-          listener(this.opts.name, code, signal);
-        } catch {
-        }
-      }
-    });
-    child.on("error", (err) => {
-      this.state = "failed";
-      this.failPending(`MCP "${this.opts.name}" child error: ${toErrorMessage(err)}`);
-    });
-    const initialize = await this.request(
-      "initialize",
-      {
-        protocolVersion: MCP_CONSTANTS.PROTOCOL_VERSION,
-        // Client capabilities: elicitation when the host can ask its user.
-        // `tools` is a SERVER capability and never belonged here.
-        capabilities: this.serverRequests.capabilities(),
-        clientInfo: MCP_CONSTANTS.CLIENT_INFO
-      },
-      typeof this.opts.startupTimeoutMs === "number" && Number.isFinite(this.opts.startupTimeoutMs) && this.opts.startupTimeoutMs > 0 ? this.opts.startupTimeoutMs : 1e4
-    );
-    if (initialize.error) {
-      this.state = "failed";
-      throw new Error(`MCP initialize failed: ${initialize.error.message}`);
-    }
-    try {
-      this._serverMetadata = parseServerMetadata(initialize.result);
-    } catch (err) {
-      this.state = "failed";
-      throw new Error(`MCP initialize returned malformed server metadata: ${toErrorMessage(err)}`);
-    }
-    try {
-      await this.notify("notifications/initialized", {});
-    } catch (err) {
-      console.warn(
-        '[MCP] notify("notifications/initialized") failed for "' + this.opts.name + '": ' + toErrorMessage(err)
-      );
-    }
-    this._tools = await listAllTools((params) => this.request("tools/list", params)) ?? [];
-    this._toolsCache = this._tools;
-    this.state = "connected";
+    return connectStdio(this.clientStdioHost());
   }
   async connectSSE() {
     return connectSSE(this.clientHttpConnectionHost());
@@ -3878,6 +4119,7 @@ var MCPClient = class _MCPClient {
     return this.closePromise;
   }
   async closeInner() {
+    this.toolCatalogVersion++;
     if (this.child) {
       const child = this.child;
       const exitPromise = new Promise((resolve) => {
@@ -4055,132 +4297,13 @@ var MCPClient = class _MCPClient {
     this.pending.clear();
   }
   async notify(method, params) {
-    if (this._drainPending) {
-      this._lastNotifySkipped = true;
-      console.warn(
-        JSON.stringify({
-          level: "warn",
-          event: "mcp.notify_skipped_backpressure",
-          server: this.opts.name,
-          method,
-          message: "stdin buffer backpressure (already waiting for drain)",
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        })
-      );
-      return;
-    }
-    const stdin = this.child?.stdin;
-    if (!stdin || stdin.destroyed === true || stdin.writable === false) {
-      return;
-    }
-    const req = { jsonrpc: "2.0", method, params };
-    const encoded = JSON.stringify(req) + "\n";
-    try {
-      const ok = stdin.write(encoded);
-      if (!ok) {
-        this._drainPending = true;
-        await new Promise((resolve, reject) => {
-          const timeout = setTimeout(() => {
-            stdin.removeListener?.("drain", onDrain);
-            stdin.removeListener?.("error", onError);
-            this._drainPending = false;
-            reject(new Error(`MCP notify("${method}") drain timeout`));
-          }, 500);
-          const onDrain = () => {
-            clearTimeout(timeout);
-            stdin.removeListener?.("drain", onDrain);
-            stdin.removeListener?.("error", onError);
-            this._drainPending = false;
-            resolve();
-          };
-          const onError = (err) => {
-            clearTimeout(timeout);
-            stdin.removeListener?.("drain", onDrain);
-            stdin.removeListener?.("error", onError);
-            this._drainPending = false;
-            reject(err);
-          };
-          stdin.once?.("drain", onDrain);
-          stdin.once?.("error", onError);
-        });
-      }
-    } catch (err) {
-      throw new Error(`[MCP] notify("${method}") failed: ${toErrorMessage(err)}`);
-    }
+    return notifyStdio(this.clientStdioHost(), method, params);
   }
   onData(s) {
-    this.rxBufferBytes += Buffer.byteLength(s, "utf8");
-    if (this.rxBufferBytes > _MCPClient.MAX_RX_BUFFER_BYTES) {
-      const truncated = this.rxBufferBytes;
-      this.rxParts = [];
-      this.rxBufferBytes = 0;
-      this.failPending(
-        `MCP "${this.opts.name}" rx buffer overflow (${truncated} bytes without a newline) \u2014 closing connection`
-      );
-      void this.close();
-      return;
-    }
-    let start = 0;
-    let idx = s.indexOf("\n");
-    if (idx === -1) {
-      this.rxParts.push(s);
-      return;
-    }
-    while (idx !== -1) {
-      const head = this.rxParts.length > 0 ? this.rxParts.join("") : "";
-      this.rxParts = [];
-      const line = (head + s.slice(start, idx)).trim();
-      start = idx + 1;
-      if (line) this.onLine(line);
-      idx = s.indexOf("\n", start);
-    }
-    const tail = s.slice(start);
-    this.rxBufferBytes = Buffer.byteLength(tail, "utf8");
-    if (tail) this.rxParts.push(tail);
+    receiveStdioData(this.clientStdioProtocolHost(), s);
   }
   onLine(line) {
-    let msg;
-    try {
-      msg = JSON.parse(line);
-    } catch {
-      return;
-    }
-    if (typeof msg !== "object" || msg === null) return;
-    const envelope = msg;
-    if (envelope["jsonrpc"] !== "2.0") return;
-    if (typeof envelope["method"] === "string") {
-      const id = envelope["id"];
-      if (typeof id === "number" || typeof id === "string") {
-        void this.handleServerRequest({
-          jsonrpc: "2.0",
-          id,
-          method: envelope["method"],
-          params: envelope["params"]
-        });
-        return;
-      }
-      if (Object.hasOwn(envelope, "id")) return;
-      if (envelope["method"] === "notifications/cancelled") {
-        this.serverRequests.cancel(envelope["params"]);
-      } else if (envelope["method"] === "notifications/tools/list_changed") {
-        void this.handleToolsListChanged();
-      } else if (envelope["method"] === "notifications/resources/list_changed") {
-        this.emitCapabilityChanged("resources");
-      } else if (envelope["method"] === "notifications/prompts/list_changed") {
-        this.emitCapabilityChanged("prompts");
-      } else if (envelope["method"] === "notifications/resources/updated") {
-        const uri = resourceUpdatedUri(envelope["params"]);
-        if (uri) this.emitResourceUpdated(uri);
-      }
-      return;
-    }
-    if (!isJsonRpcResult(msg)) return;
-    const response = msg;
-    if (this.pending.has(response.id)) {
-      const entry = this.pending.get(response.id);
-      this.pending.delete(response.id);
-      entry?.resolve(response);
-    }
+    receiveStdioLine(this.clientStdioProtocolHost(), line);
   }
   async handleServerRequest(request3) {
     const response = await this.serverRequests.answer(request3);
@@ -4197,11 +4320,13 @@ var MCPClient = class _MCPClient {
    * to a hard crash on a transient notification glitch.
    */
   async handleToolsListChanged() {
+    const version = ++this.toolCatalogVersion;
     try {
       const tools = await listAllTools((params) => this.request("tools/list", params));
-      if (!tools) return;
+      if (!tools || version !== this.toolCatalogVersion) return;
       this._tools = tools;
       this._toolsCache = tools;
+      this.toolCatalogRevision++;
       for (const listener of this.toolsChangedListeners) {
         try {
           listener(this.opts.name, [...tools]);
@@ -4255,9 +4380,7 @@ var MCPClient = class _MCPClient {
   clientHttpConnectionHost() {
     const self = this;
     return {
-      get opts() {
-        return self.opts;
-      },
+      opts: this.opts,
       get state() {
         return self.state;
       },
@@ -4301,6 +4424,109 @@ var MCPClient = class _MCPClient {
       serverRequests: this.serverRequests
     };
   }
+  clientStdioHost() {
+    const self = this;
+    return {
+      opts: this.opts,
+      get state() {
+        return self.state;
+      },
+      set state(value) {
+        self.state = value;
+      },
+      get rxBuffer() {
+        return self.rxBuffer;
+      },
+      set rxBuffer(value) {
+        self.rxBuffer = value;
+      },
+      get rxBufferBytes() {
+        return self.rxBufferBytes;
+      },
+      set rxBufferBytes(value) {
+        self.rxBufferBytes = value;
+      },
+      get rxDecoder() {
+        return self.rxDecoder;
+      },
+      set rxDecoder(value) {
+        self.rxDecoder = value;
+      },
+      get child() {
+        return self.child;
+      },
+      set child(value) {
+        self.child = value;
+      },
+      onData: (...args) => this.onData(...args),
+      onLine: (...args) => this.onLine(...args),
+      failPending: (...args) => this.failPending(...args),
+      exitListeners: this.exitListeners,
+      request: (...args) => this.request(...args),
+      serverRequests: this.serverRequests,
+      get _serverMetadata() {
+        return self._serverMetadata;
+      },
+      set _serverMetadata(value) {
+        self._serverMetadata = value;
+      },
+      notify: (...args) => this.notify(...args),
+      get toolCatalogRevision() {
+        return self.toolCatalogRevision;
+      },
+      get _tools() {
+        return self._tools;
+      },
+      set _tools(value) {
+        self._tools = value;
+      },
+      get _toolsCache() {
+        return self._toolsCache;
+      },
+      set _toolsCache(value) {
+        self._toolsCache = value;
+      },
+      get _drainPending() {
+        return self._drainPending;
+      },
+      set _drainPending(value) {
+        self._drainPending = value;
+      },
+      get _lastNotifySkipped() {
+        return self._lastNotifySkipped;
+      },
+      set _lastNotifySkipped(value) {
+        self._lastNotifySkipped = value;
+      }
+    };
+  }
+  clientStdioProtocolHost() {
+    const self = this;
+    return {
+      get rxBufferBytes() {
+        return self.rxBufferBytes;
+      },
+      set rxBufferBytes(value) {
+        self.rxBufferBytes = value;
+      },
+      get rxParts() {
+        return self.rxParts;
+      },
+      set rxParts(value) {
+        self.rxParts = value;
+      },
+      failPending: (...args) => this.failPending(...args),
+      opts: this.opts,
+      close: (...args) => this.close(...args),
+      onLine: (...args) => this.onLine(...args),
+      handleServerRequest: (...args) => this.handleServerRequest(...args),
+      serverRequests: this.serverRequests,
+      handleToolsListChanged: (...args) => this.handleToolsListChanged(...args),
+      emitCapabilityChanged: (...args) => this.emitCapabilityChanged(...args),
+      emitResourceUpdated: (...args) => this.emitResourceUpdated(...args),
+      pending: this.pending
+    };
+  }
 };
 
 // src/config-env.ts
@@ -4321,7 +4547,7 @@ function mcpEnvPlaceholders(cfg) {
 function expandMcpEnvPlaceholders(cfg, env = process.env) {
   const missing = /* @__PURE__ */ new Set();
   const expand = (value) => value.replace(PLACEHOLDER, (_match, name, fallback) => {
-    const resolved = env[name];
+    const resolved = Object.hasOwn(env, name) ? env[name] : void 0;
     if (resolved !== void 0 && resolved !== "") return resolved;
     if (fallback !== void 0) return fallback;
     missing.add(name);
@@ -4680,7 +4906,12 @@ async function elicitViaUserInput(request3, fallback, options = {}) {
     }
     const content = {};
     form.fields.forEach((field, i) => {
-      content[field.name] = answerValue(field, byId.get(questionId(i)));
+      Object.defineProperty(content, field.name, {
+        value: answerValue(field, byId.get(questionId(i))),
+        enumerable: true,
+        writable: true,
+        configurable: true
+      });
     });
     const checked = validateElicitationContent(form.fields, content);
     if (checked.ok) return { action: "accept", content: checked.value };
@@ -5031,6 +5262,12 @@ function forgetRegistryState(registry, name) {
 import { createHash as createHash2, randomBytes as randomBytes4 } from "node:crypto";
 import * as fs2 from "node:fs/promises";
 import * as path from "node:path";
+function isRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isCachedTool(value) {
+  return isRecord2(value) && typeof value["name"] === "string" && value["name"].trim().length > 0 && (value["description"] === void 0 || typeof value["description"] === "string") && isRecord2(value["inputSchema"]) && (value["outputSchema"] === void 0 || isRecord2(value["outputSchema"]));
+}
 function manifestConfigHash(cfg) {
   const basis = JSON.stringify({
     transport: cfg.transport,
@@ -5066,7 +5303,8 @@ async function readCapabilityManifest(cacheDir, name, configHash) {
   try {
     const raw = await fs2.readFile(manifestFile(cacheDir, name), "utf8");
     const parsed = JSON.parse(raw);
-    if (parsed.configHash !== configHash || !Array.isArray(parsed.tools)) return null;
+    if (parsed.configHash !== configHash || !Array.isArray(parsed.tools) || !parsed.tools.every(isCachedTool))
+      return null;
     return {
       tools: parsed.tools,
       serverMetadata: parsed.serverMetadata === void 0 ? void 0 : parseServerMetadata(parsed.serverMetadata),
@@ -5283,6 +5521,13 @@ async function completeRegistryAuthorization(manager, cfg, name, callbackUrl, si
 // src/registry-catalog.ts
 var MAX_CATALOG_PAGES = 100;
 var MAX_CATALOG_ITEMS = 1e4;
+function advanceCatalogVersion(slot, kind) {
+  slot.catalogVersions ??= {};
+  const versions = slot.catalogVersions;
+  const version = (versions[kind] ?? 0) + 1;
+  versions[kind] = version;
+  return version;
+}
 async function collectCatalogPages(load, select) {
   const items = [];
   const seenCursors = /* @__PURE__ */ new Set();
@@ -5315,10 +5560,105 @@ function registryCatalogSnapshot(slot) {
   };
 }
 
+// src/registry-catalog-operations.ts
+function getCatalog(name) {
+  const slot = this.servers.get(name);
+  if (slot) {
+    return registryCatalogSnapshot(slot);
+  }
+  const disabled = this.disabledServers.get(name);
+  if (disabled) {
+    return {
+      name: disabled.name,
+      state: "idle"
+    };
+  }
+  return void 0;
+}
+async function listResources(name, opts = {}) {
+  const slot = this.requireSlot(name);
+  if (!opts.refresh && slot.resources) return cloneCatalogRecords(slot.resources);
+  const version = advanceCatalogVersion(slot, "resources");
+  return this.withConnectedClient(name, async (client, assertCurrent) => {
+    if (!client.getServerMetadata()?.capabilities.resources) return [];
+    const resources = await collectCatalogPages(
+      (cursor) => client.listResources(cursor ? { cursor } : {}),
+      (page) => page.resources
+    );
+    assertCurrent();
+    if (slot.catalogVersions?.resources === version) {
+      slot.resources = resources;
+      await this.persistCapabilityManifest(slot);
+    }
+    return cloneCatalogRecords(resources);
+  });
+}
+async function listResourceTemplates(name, opts = {}) {
+  const slot = this.requireSlot(name);
+  if (!opts.refresh && slot.resourceTemplates) return cloneCatalogRecords(slot.resourceTemplates);
+  const version = advanceCatalogVersion(slot, "resourceTemplates");
+  return this.withConnectedClient(name, async (client, assertCurrent) => {
+    if (!client.getServerMetadata()?.capabilities.resources) return [];
+    const templates = await collectCatalogPages(
+      (cursor) => client.listResourceTemplates(cursor ? { cursor } : {}),
+      (page) => page.resourceTemplates
+    );
+    assertCurrent();
+    if (slot.catalogVersions?.resourceTemplates === version) {
+      slot.resourceTemplates = templates;
+      await this.persistCapabilityManifest(slot);
+    }
+    return cloneCatalogRecords(templates);
+  });
+}
+async function readResource(name, uri) {
+  return this.withConnectedClient(name, (client) => client.readResource(uri));
+}
+async function selectResourceForInsertion(name, uri, policy) {
+  return prepareResourceInsertion(name, uri, await this.readResource(name, uri), policy);
+}
+async function subscribeResource(name, uri) {
+  await this.withConnectedClient(name, (client) => client.subscribeResource(uri));
+}
+async function unsubscribeResource(name, uri) {
+  await this.withConnectedClient(name, (client) => client.unsubscribeResource(uri));
+}
+async function listPrompts(name, opts = {}) {
+  const slot = this.requireSlot(name);
+  if (!opts.refresh && slot.prompts) return cloneCatalogRecords(slot.prompts);
+  const version = advanceCatalogVersion(slot, "prompts");
+  return this.withConnectedClient(name, async (client, assertCurrent) => {
+    if (!client.getServerMetadata()?.capabilities.prompts) return [];
+    const prompts = await collectCatalogPages(
+      (cursor) => client.listPrompts(cursor ? { cursor } : {}),
+      (page) => page.prompts
+    );
+    assertCurrent();
+    if (slot.catalogVersions?.prompts === version) {
+      slot.prompts = prompts;
+      await this.persistCapabilityManifest(slot);
+    }
+    return cloneCatalogRecords(prompts);
+  });
+}
+async function getPrompt(serverName, promptName, args) {
+  return this.withConnectedClient(serverName, (client) => client.getPrompt(promptName, args));
+}
+async function selectPromptForInsertion(serverName, promptName, args, policy) {
+  return preparePromptInsertion(
+    serverName,
+    promptName,
+    args,
+    await this.getPrompt(serverName, promptName, args),
+    policy
+  );
+}
+
 // src/registry-connect-loop.ts
 import { expectDefined } from "@wrongstack/core/utils";
 
 // src/wrap-tool.ts
+import { createSandboxMcpGate } from "@wrongstack/core/sandbox";
 import { ToolCapabilities } from "@wrongstack/core/security";
 import { mcpQualifiedToolName } from "@wrongstack/core/utils";
 
@@ -5385,9 +5725,10 @@ function isMutatingTool(mcpTool) {
   }
   return false;
 }
-function wrapMCPTool(serverName, mcpTool, client, permission = "confirm", observer) {
+function wrapMCPTool(serverName, mcpTool, client, permission = "confirm", sandboxTrust = false, observer) {
+  const sandboxGate = createSandboxMcpGate({ trusted: sandboxTrust });
   const qualifiedName = mcpQualifiedToolName(serverName, mcpTool.name);
-  return {
+  const tool = {
     name: qualifiedName,
     description: mcpTool.description ?? `${qualifiedName} (MCP tool)`,
     usageHint: `Tool provided by MCP server "${serverName}". ${mcpTool.description ?? ""}`,
@@ -5426,6 +5767,7 @@ function wrapMCPTool(serverName, mcpTool, client, permission = "confirm", observ
       }
     }
   };
+  return sandboxGate(tool);
 }
 function describeUrlOutcomes(serverName, toolName, outcomes) {
   const lines = outcomes.map(({ elicitation, action }) => {
@@ -5490,36 +5832,48 @@ function applySlotTools(ctx, slot, tools, client) {
   const allowed = slot.cfg.allowedTools;
   const filtered = tools.filter((t) => !allowed || allowed.includes(t.name));
   const signature = JSON.stringify(
-    filtered.map((t) => [t.name, t.description ?? null, t.inputSchema ?? null])
+    filtered.map((t) => [
+      t.name,
+      t.description ?? null,
+      t.inputSchema ?? null,
+      t.outputSchema ?? null
+    ])
   );
   const lazyWrappersCurrent = slot.lazy && slot.toolSignature === signature && slot.lazyTools.length === filtered.length && (slot.registeredLazy || ctx.lazyMode);
   if (lazyWrappersCurrent) return;
   const clientArg = slot.lazy ? () => ctx.ensureConnected(slot.cfg.name) : expectDefined(client);
   const wrapped = filtered.map(
-    (t) => wrapMCPTool(slot.cfg.name, t, clientArg, slot.cfg.permission ?? "confirm", {
-      onStart: (caller) => {
-        if (caller) slot.activeCallers = [...slot.activeCallers ?? [], caller];
-        slot.operations.inFlightCalls++;
-        slot.operations.peakInFlightCalls = Math.max(
-          slot.operations.peakInFlightCalls,
-          slot.operations.inFlightCalls
-        );
-        ctx.recordOperation(slot, "call", "started", void 0, void 0, false);
-      },
-      onFinish: ({ durationMs, ok }, caller) => {
-        const at = caller ? slot.activeCallers?.lastIndexOf(caller) ?? -1 : -1;
-        if (at >= 0) slot.activeCallers?.splice(at, 1);
-        slot.operations.inFlightCalls = Math.max(0, slot.operations.inFlightCalls - 1);
-        slot.lastUsed = Date.now();
-        pushBounded(slot.operations.callSamples, durationMs, MCP_OPERATION_LIMITS.LATENCY_SAMPLES);
-        if (ok) {
-          ctx.recordSuccess(slot);
-          ctx.recordOperation(slot, "call", "ok", void 0, durationMs, false);
-        } else {
-          ctx.recordFailure(slot, "tool", "tool-call-failed", durationMs);
+    (t) => wrapMCPTool(
+      slot.cfg.name,
+      t,
+      clientArg,
+      slot.cfg.permission ?? "confirm",
+      slot.cfg.sandboxTrust === true,
+      {
+        onStart: (caller) => {
+          if (caller) slot.activeCallers = [...slot.activeCallers ?? [], caller];
+          slot.operations.inFlightCalls++;
+          slot.operations.peakInFlightCalls = Math.max(
+            slot.operations.peakInFlightCalls,
+            slot.operations.inFlightCalls
+          );
+          ctx.recordOperation(slot, "call", "started", void 0, void 0, false);
+        },
+        onFinish: ({ durationMs, ok }, caller) => {
+          const at = caller ? slot.activeCallers?.lastIndexOf(caller) ?? -1 : -1;
+          if (at >= 0) slot.activeCallers?.splice(at, 1);
+          slot.operations.inFlightCalls = Math.max(0, slot.operations.inFlightCalls - 1);
+          slot.lastUsed = Date.now();
+          pushBounded(slot.operations.callSamples, durationMs, MCP_OPERATION_LIMITS.LATENCY_SAMPLES);
+          if (ok) {
+            ctx.recordSuccess(slot);
+            ctx.recordOperation(slot, "call", "ok", void 0, durationMs, false);
+          } else {
+            ctx.recordFailure(slot, "tool", "tool-call-failed", durationMs);
+          }
         }
       }
-    })
+    )
   );
   slot.lazyTools = wrapped;
   slot.toolSignature = signature;
@@ -5544,51 +5898,62 @@ function applySlotTools(ctx, slot, tools, client) {
 }
 async function discoverSlotCapabilities(ctx, slot, client) {
   const startedAt = Date.now();
-  slot.serverMetadata = client.getServerMetadata();
-  const capabilities = slot.serverMetadata?.capabilities;
+  const versions = { ...slot.catalogVersions };
+  const serverMetadata = client.getServerMetadata();
+  const capabilities = serverMetadata?.capabilities;
+  let resources;
+  let resourceTemplates;
+  let prompts;
   if (capabilities?.resources) {
     try {
-      slot.resources = await collectCatalogPages(
+      resources = await collectCatalogPages(
         (cursor) => client.listResources(cursor ? { cursor } : {}),
         (page) => page.resources
       );
     } catch (err) {
-      slot.resources = void 0;
+      if (!ownsConnectedSlot(ctx, slot, client)) return;
       ctx.recordFailure(slot, "protocol", "resource-discovery-failed");
       ctx.log.warn(`MCP server "${slot.cfg.name}" resource discovery failed`, err);
     }
+    if (!ownsConnectedSlot(ctx, slot, client)) return;
     try {
-      slot.resourceTemplates = await collectCatalogPages(
+      resourceTemplates = await collectCatalogPages(
         (cursor) => client.listResourceTemplates(cursor ? { cursor } : {}),
         (page) => page.resourceTemplates
       );
     } catch (err) {
-      slot.resourceTemplates = void 0;
+      if (!ownsConnectedSlot(ctx, slot, client)) return;
       ctx.recordFailure(slot, "protocol", "resource-template-discovery-failed");
       ctx.log.warn(`MCP server "${slot.cfg.name}" resource template discovery failed`, err);
     }
-  } else {
-    slot.resources = void 0;
-    slot.resourceTemplates = void 0;
   }
+  if (!ownsConnectedSlot(ctx, slot, client)) return;
   if (capabilities?.prompts) {
     try {
-      slot.prompts = await collectCatalogPages(
+      prompts = await collectCatalogPages(
         (cursor) => client.listPrompts(cursor ? { cursor } : {}),
         (page) => page.prompts
       );
     } catch (err) {
-      slot.prompts = void 0;
+      if (!ownsConnectedSlot(ctx, slot, client)) return;
       ctx.recordFailure(slot, "protocol", "prompt-discovery-failed");
       ctx.log.warn(`MCP server "${slot.cfg.name}" prompt discovery failed`, err);
     }
-  } else {
-    slot.prompts = void 0;
   }
+  if (!ownsConnectedSlot(ctx, slot, client)) return;
+  slot.serverMetadata = serverMetadata;
+  if (slot.catalogVersions?.resources === versions.resources) slot.resources = resources;
+  if (slot.catalogVersions?.resourceTemplates === versions.resourceTemplates) {
+    slot.resourceTemplates = resourceTemplates;
+  }
+  if (slot.catalogVersions?.prompts === versions.prompts) slot.prompts = prompts;
   const durationMs = Date.now() - startedAt;
   pushBounded(slot.operations.discoverySamples, durationMs, MCP_OPERATION_LIMITS.LATENCY_SAMPLES);
   ctx.recordOperation(slot, "discover", "complete", void 0, durationMs, false);
 }
+function ownsConnectedSlot(ctx, slot, client) {
+  return ctx.servers.get(slot.cfg.name) === slot && slot.client === client && slot.state === "connected";
+}
 async function persistSlotCapabilityManifest(cacheDir, slot) {
   if (!slot.lazy || !cacheDir) return;
   const previous = slot.manifestWrite ?? Promise.resolve();
@@ -5609,9 +5974,11 @@ async function persistSlotCapabilityManifest(cacheDir, slot) {
 }
 async function attemptConnectSlot(ctx, slot) {
   const MAX_ATTEMPTS2 = MCP_CONSTANTS.RECONNECT.MAX_ATTEMPTS;
+  const generation = slot.startupGeneration;
+  const isCurrent = () => ctx.servers.get(slot.cfg.name) === slot && slot.startupGeneration === generation;
   let attempt = 0;
   while (attempt < MAX_ATTEMPTS2) {
-    if (ctx.servers.get(slot.cfg.name) !== slot) {
+    if (!isCurrent()) {
       return;
     }
     attempt++;
@@ -5645,7 +6012,7 @@ async function attemptConnectSlot(ctx, slot) {
       client.addToolsChangedListener(ctx.onToolsChanged);
       ctx.addCatalogListeners(client);
       await client.connect();
-      if (slot.state === "disconnected" || !ctx.servers.has(slot.cfg.name) || ctx.servers.get(slot.cfg.name) !== slot) {
+      if (slot.state === "disconnected" || !isCurrent()) {
         client.removeExitListener(ctx.onChildExit);
         if (boundDisconnect) client.removeDisconnectListener(boundDisconnect);
         client.removeToolsChangedListener(ctx.onToolsChanged);
@@ -5673,8 +6040,10 @@ async function attemptConnectSlot(ctx, slot) {
       const discovered = mc.listTools();
       slot.discoveredTools = discovered;
       await discoverSlotCapabilities(ctx, slot, mc);
+      if (!ownsConnectedSlot(ctx, slot, mc)) return;
       await persistSlotCapabilityManifest(ctx.cacheDir, slot);
-      applySlotTools(ctx, slot, discovered, mc);
+      if (!ownsConnectedSlot(ctx, slot, mc)) return;
+      applySlotTools(ctx, slot, mc.listTools(), mc);
       const durationMs = Date.now() - startedAt;
       pushBounded(
         slot.operations.connectionSamples,
@@ -5697,8 +6066,6 @@ async function attemptConnectSlot(ctx, slot) {
       });
       return;
     } catch (err) {
-      ctx.recordFailure(slot, "transport", "connect-attempt-failed", Date.now() - startedAt);
-      ctx.log.warn(`MCP server "${slot.cfg.name}" connect attempt ${attempt} failed`, err);
       if (client) {
         client.removeExitListener(ctx.onChildExit);
         if (boundDisconnect) client.removeDisconnectListener(boundDisconnect);
@@ -5707,6 +6074,9 @@ async function attemptConnectSlot(ctx, slot) {
         await client.close().catch(() => {
         });
       }
+      if (!isCurrent() || slot.state === "disconnected") return;
+      ctx.recordFailure(slot, "transport", "connect-attempt-failed", Date.now() - startedAt);
+      ctx.log.warn(`MCP server "${slot.cfg.name}" connect attempt ${attempt} failed`, err);
       if (attempt >= MAX_ATTEMPTS2) {
         ctx.log.error(
           `MCP server "${slot.cfg.name}" connect exhausted after ${MAX_ATTEMPTS2} attempts`,
@@ -5728,7 +6098,7 @@ async function attemptConnectSlot(ctx, slot) {
       }
       const delay = 500 * 2 ** attempt;
       await new Promise((r) => setTimeout(r, delay));
-      if (slot.state === "disconnected" || ctx.servers.get(slot.cfg.name) !== slot) {
+      if (slot.state === "disconnected" || !isCurrent()) {
         return;
       }
     }
@@ -5860,7 +6230,7 @@ async function sleepIdleSlot(ctx, slot) {
       ctx.log.warn(`MCP server "${slot.cfg.name}" error during idle sleep close`, err);
     }
   }
-  if (slot.client || slot.state !== "dormant") return;
+  if (ctx.servers.get(slot.cfg.name) !== slot || slot.client || slot.state !== "dormant") return;
   slot.onDisconnect = void 0;
   slot.operations.sleepCount++;
   ctx.recordOperation(slot, "sleep", "idle-timeout");
@@ -6092,7 +6462,9 @@ var MCPRegistry = class _MCPRegistry {
   async startLazy(slot) {
     const cacheDir = expectDefined2(this.cacheDir);
     const hash = manifestConfigHash(slot.cfg);
+    const generation = slot.startupGeneration;
     const cached = await readCapabilityManifest(cacheDir, slot.cfg.name, hash);
+    if (this.servers.get(slot.cfg.name) !== slot || slot.startupGeneration !== generation) return;
     if (cached) {
       slot.serverMetadata = cached.serverMetadata;
       slot.resources = cached.resources;
@@ -6111,15 +6483,15 @@ var MCPRegistry = class _MCPRegistry {
   singleFlightConnect(slot) {
     if (slot.client && slot.state === "connected") return Promise.resolve(slot.client);
     if (slot.connecting) return slot.connecting;
-    const promise = (async () => {
-      try {
-        await this.attemptConnect(slot);
-        return slot.client;
-      } finally {
-        slot.connecting = void 0;
-      }
-    })();
+    const generation = slot.startupGeneration;
+    const promise = this.attemptConnect(slot).then(
+      () => slot.startupGeneration === generation ? slot.client : void 0
+    );
     slot.connecting = promise;
+    const clearFlight = () => {
+      if (slot.connecting === promise) slot.connecting = void 0;
+    };
+    void promise.then(clearFlight, clearFlight);
     return promise;
   }
   /**
@@ -6217,6 +6589,7 @@ var MCPRegistry = class _MCPRegistry {
   async stop(name) {
     const slot = this.servers.get(name);
     if (!slot) return;
+    slot.startupGeneration = (slot.startupGeneration ?? 0) + 1;
     slot.reconnectPending = false;
     if (slot.reconnectTimer) {
       clearTimeout(slot.reconnectTimer);
@@ -6268,7 +6641,7 @@ var MCPRegistry = class _MCPRegistry {
     }
     if (slot.state === "dormant") return;
     if (slot.operations.inFlightCalls > 0) {
-      throw new Error(`MCP server "${name}" has tool calls in flight \u2014 try again when they finish`);
+      throw new Error(`MCP server "${name}" has requests in flight \u2014 try again when they finish`);
     }
     await sleepIdleSlot(this.idleContext(), slot);
   }
@@ -6323,76 +6696,73 @@ var MCPRegistry = class _MCPRegistry {
     return buildRegistryOperationalHealth(this.servers.values(), this.disabledServers.values());
   }
   getCatalog(name) {
-    const slot = this.servers.get(name);
-    if (slot) {
-      return registryCatalogSnapshot(slot);
-    }
-    const disabled = this.disabledServers.get(name);
-    if (disabled) {
-      return {
-        name: disabled.name,
-        state: "idle"
-      };
-    }
-    return void 0;
+    return getCatalog.call(this.registryCatalogOperationsHost(), name);
   }
   async listResources(name, opts = {}) {
-    const slot = this.requireSlot(name);
-    if (!opts.refresh && slot.resources) return cloneCatalogRecords(slot.resources);
-    const client = await this.ensureConnected(name);
-    if (!client.getServerMetadata()?.capabilities.resources) return [];
-    slot.resources = await collectCatalogPages(
-      (cursor) => client.listResources(cursor ? { cursor } : {}),
-      (page) => page.resources
-    );
-    await this.persistCapabilityManifest(slot);
-    return cloneCatalogRecords(slot.resources);
+    return listResources.call(this.registryCatalogOperationsHost(), name, opts);
   }
   async listResourceTemplates(name, opts = {}) {
-    const slot = this.requireSlot(name);
-    if (!opts.refresh && slot.resourceTemplates) return cloneCatalogRecords(slot.resourceTemplates);
-    const client = await this.ensureConnected(name);
-    if (!client.getServerMetadata()?.capabilities.resources) return [];
-    slot.resourceTemplates = await collectCatalogPages(
-      (cursor) => client.listResourceTemplates(cursor ? { cursor } : {}),
-      (page) => page.resourceTemplates
-    );
-    await this.persistCapabilityManifest(slot);
-    return cloneCatalogRecords(slot.resourceTemplates);
+    return listResourceTemplates.call(this.registryCatalogOperationsHost(), name, opts);
   }
   async readResource(name, uri) {
-    return (await this.ensureConnected(name)).readResource(uri);
+    return readResource.call(this.registryCatalogOperationsHost(), name, uri);
   }
   async selectResourceForInsertion(name, uri, policy) {
-    return prepareResourceInsertion(name, uri, await this.readResource(name, uri), policy);
+    return selectResourceForInsertion.call(
+      this.registryCatalogOperationsHost(),
+      name,
+      uri,
+      policy
+    );
   }
   async subscribeResource(name, uri) {
-    await (await this.ensureConnected(name)).subscribeResource(uri);
+    return subscribeResource.call(this.registryCatalogOperationsHost(), name, uri);
   }
   async unsubscribeResource(name, uri) {
-    await (await this.ensureConnected(name)).unsubscribeResource(uri);
+    return unsubscribeResource.call(this.registryCatalogOperationsHost(), name, uri);
   }
   async listPrompts(name, opts = {}) {
-    const slot = this.requireSlot(name);
-    if (!opts.refresh && slot.prompts) return cloneCatalogRecords(slot.prompts);
-    const client = await this.ensureConnected(name);
-    if (!client.getServerMetadata()?.capabilities.prompts) return [];
-    slot.prompts = await collectCatalogPages(
-      (cursor) => client.listPrompts(cursor ? { cursor } : {}),
-      (page) => page.prompts
-    );
-    await this.persistCapabilityManifest(slot);
-    return cloneCatalogRecords(slot.prompts);
+    return listPrompts.call(this.registryCatalogOperationsHost(), name, opts);
   }
   async getPrompt(serverName, promptName, args) {
-    return (await this.ensureConnected(serverName)).getPrompt(promptName, args);
+    return getPrompt.call(
+      this.registryCatalogOperationsHost(),
+      serverName,
+      promptName,
+      args
+    );
+  }
+  /** Keep all remote requests awake and reject results from superseded clients. */
+  async withConnectedClient(name, run) {
+    const slot = this.requireSlot(name);
+    const generation = slot.startupGeneration;
+    slot.operations.inFlightCalls++;
+    slot.operations.peakInFlightCalls = Math.max(
+      slot.operations.peakInFlightCalls,
+      slot.operations.inFlightCalls
+    );
+    try {
+      const client = await this.ensureConnected(name);
+      const assertCurrent = () => {
+        if (this.servers.get(name) !== slot || slot.startupGeneration !== generation || slot.client !== client || slot.state !== "connected") {
+          throw new Error(`MCP server "${name}" connection changed during request`);
+        }
+      };
+      assertCurrent();
+      const result = await run(client, assertCurrent);
+      assertCurrent();
+      return result;
+    } finally {
+      slot.operations.inFlightCalls = Math.max(0, slot.operations.inFlightCalls - 1);
+      if (slot.startupGeneration === generation) slot.lastUsed = Date.now();
+    }
   }
   async selectPromptForInsertion(serverName, promptName, args, policy) {
-    return preparePromptInsertion(
+    return selectPromptForInsertion.call(
+      this.registryCatalogOperationsHost(),
       serverName,
       promptName,
       args,
-      await this.getPrompt(serverName, promptName, args),
       policy
     );
   }
@@ -6535,6 +6905,8 @@ var MCPRegistry = class _MCPRegistry {
   onResourcesChanged = (name) => {
     const slot = this.servers.get(name);
     if (!slot) return;
+    advanceCatalogVersion(slot, "resources");
+    advanceCatalogVersion(slot, "resourceTemplates");
     slot.resources = void 0;
     slot.resourceTemplates = void 0;
     void this.persistCapabilityManifest(slot);
@@ -6547,6 +6919,7 @@ var MCPRegistry = class _MCPRegistry {
   onPromptsChanged = (name) => {
     const slot = this.servers.get(name);
     if (!slot) return;
+    advanceCatalogVersion(slot, "prompts");
     slot.prompts = void 0;
     void this.persistCapabilityManifest(slot);
     this.log.info(`MCP server "${name}" prompt catalog invalidated`);
@@ -6640,12 +7013,20 @@ var MCPRegistry = class _MCPRegistry {
   async attemptConnect(slot) {
     return attemptConnectSlot(this.connectContext(), slot);
   }
+  registryCatalogOperationsHost() {
+    void this.servers;
+    void this.disabledServers;
+    void this.requireSlot;
+    void this.withConnectedClient;
+    void this.persistCapabilityManifest;
+    void this.readResource;
+    void this.getPrompt;
+    return this;
+  }
 };
 
-// src/server.ts
-import { timingSafeEqual as timingSafeEqual2 } from "node:crypto";
-import { createServer as createServer2 } from "node:http";
-import { expectDefined as expectDefined3, toErrorMessage as toErrorMessage2, validateAgainstSchema as validateAgainstSchema2 } from "@wrongstack/core/utils";
+// src/server-dispatch.ts
+import { expectDefined as expectDefined3, toErrorMessage as toErrorMessage3, validateAgainstSchema as validateAgainstSchema2 } from "@wrongstack/core/utils";
 var PARSE_ERROR = -32700;
 var INVALID_REQUEST = -32600;
 var METHOD_NOT_FOUND = -32601;
@@ -6711,7 +7092,7 @@ var MCPServer = class {
       }
       return JSON.stringify({ jsonrpc: "2.0", id: msg.id, result });
     } catch (err) {
-      const message = toErrorMessage2(err);
+      const message = toErrorMessage3(err);
       this.logger?.warn?.(`MCP server: method "${msg.method}" threw: ${message}`);
       const code = err instanceof InvalidToolArgumentsError ? INVALID_PARAMS : INTERNAL_ERROR;
       return this.encodeError(requestId, code, message);
@@ -6932,6 +7313,14 @@ function stringifyItem(c) {
     return String(c);
   }
 }
+
+// src/server-http.ts
+import { timingSafeEqual as timingSafeEqual2 } from "node:crypto";
+import { createServer as createServer2 } from "node:http";
+import { toErrorMessage as toErrorMessage5 } from "@wrongstack/core/utils";
+
+// src/server-stdio.ts
+import { toErrorMessage as toErrorMessage4 } from "@wrongstack/core/utils";
 function serveStdio(server, opts = {}) {
   const stdin = opts.stdin ?? process.stdin;
   const stdout = opts.stdout ?? process.stdout;
@@ -6949,7 +7338,7 @@ function serveStdio(server, opts = {}) {
 `, () => resolve());
       })
     ).catch((err) => {
-      const msg = toErrorMessage2(err);
+      const msg = toErrorMessage4(err);
       console.error(
         JSON.stringify({
           level: "error",
@@ -7001,7 +7390,7 @@ function serveStdio(server, opts = {}) {
           JSON.stringify({
             level: "error",
             event: "mcp_server.handle_message_failed",
-            message: toErrorMessage2(err),
+            message: toErrorMessage4(err),
             timestamp: (/* @__PURE__ */ new Date()).toISOString()
           })
         );
@@ -7036,7 +7425,7 @@ function serveStdio(server, opts = {}) {
           JSON.stringify({
             level: "error",
             event: "mcp_server.handle_message_failed",
-            message: toErrorMessage2(err),
+            message: toErrorMessage4(err),
             timestamp: (/* @__PURE__ */ new Date()).toISOString()
           })
         );
@@ -7061,6 +7450,8 @@ function serveStdio(server, opts = {}) {
   };
 }
 var HTTP_BODY_CAP = 4 * 1024 * 1024;
+
+// src/server-http.ts
 function isLoopbackHost(host) {
   return host === "127.0.0.1" || host === "::1" || host === "localhost";
 }
@@ -7097,7 +7488,7 @@ function serveHttp(server, opts = {}) {
   });
 }
 async function handleHttpRequest(server, req, res, token, log, boundHost) {
-  const send = (status, body2, type = "application/json") => {
+  const send = (status, body, type = "application/json") => {
     res.writeHead(status, {
       "content-type": type,
       // This endpoint executes tools. Nothing about it should be embedded,
@@ -7108,7 +7499,7 @@ async function handleHttpRequest(server, req, res, token, log, boundHost) {
       // No CORS headers are ever emitted: a cross-origin reader must not be
       // able to see a response even if it manages to send the request.
     });
-    res.end(body2);
+    res.end(body);
   };
   if (!originIsAcceptable(req, boundHost)) {
     return send(403, JSON.stringify({ error: "cross-origin forbidden" }));
@@ -7128,13 +7519,13 @@ async function handleHttpRequest(server, req, res, token, log, boundHost) {
   if (!isJsonContentType(req.headers["content-type"])) {
     return send(415, JSON.stringify({ error: "content-type must be application/json" }));
   }
-  let body = "";
+  const chunks = [];
   let bodyBytes = 0;
   let aborted = false;
   req.on("data", (chunk) => {
     if (aborted) return;
     bodyBytes += chunk.byteLength;
-    body += chunk.toString("utf8");
+    chunks.push(chunk);
     if (bodyBytes > HTTP_BODY_CAP) {
       aborted = true;
       send(413, JSON.stringify({ error: "payload too large" }));
@@ -7143,11 +7534,12 @@ async function handleHttpRequest(server, req, res, token, log, boundHost) {
   });
   req.on("end", () => {
     if (aborted) return;
+    const body = Buffer.concat(chunks, bodyBytes).toString("utf8");
     void server.handleMessage(body).then((out) => {
       if (out === null) return send(202, "");
       return send(200, out);
     }).catch((err) => {
-      log?.warn?.(`MCP http handler error: ${toErrorMessage2(err)}`);
+      log?.warn?.(`MCP http handler error: ${toErrorMessage5(err)}`);
       send(500, JSON.stringify({ error: "internal error" }));
     });
   });
@@ -7451,7 +7843,7 @@ function emptyFile() {
   return { version: TOKEN_STORE_VERSION, updatedAt: (/* @__PURE__ */ new Date(0)).toISOString(), entries: [] };
 }
 function validateStoreFile(value) {
-  if (!isRecord2(value) || value["version"] !== TOKEN_STORE_VERSION || !Array.isArray(value["entries"])) {
+  if (!isRecord3(value) || value["version"] !== TOKEN_STORE_VERSION || !Array.isArray(value["entries"])) {
     throw new Error("MCP token store has an unsupported or malformed structure");
   }
   if (value["entries"].length > MAX_ENTRIES)
@@ -7463,7 +7855,7 @@ function validateStoreFile(value) {
   };
 }
 function validateEncryptedEntry(value) {
-  if (!isRecord2(value)) throw new Error("MCP token store entry must be an object");
+  if (!isRecord3(value)) throw new Error("MCP token store entry must be an object");
   const resource = canonicalMcpResource(boundedString(value["resource"], "resource", 4096));
   const authorizationServer = validateMcpAuthorizationServerMetadata(value["authorizationServer"]);
   const scopes = stringArray(value["scopes"], "scopes", 128);
@@ -7508,7 +7900,7 @@ function normalizeStoredAuthorization(value) {
     updatedAt: boundedString(value.updatedAt, "updatedAt", 128)
   };
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function boundedString(value, field, maxLength) {