@wrongstack/mcp 0.319.0 → 0.320.1

package/dist/client.d.ts

@@ -63,6 +63,7 @@ export declare class MCPClient {
     private _toolsCache?;
     private _drainPending;
     private _lastNotifySkipped;
+    private closePromise?;
     private sseTransport?;
     private httpTransport?;
     /** Notified when the stdio child process exits so the registry can attempt reconnect. */
@@ -106,6 +107,7 @@ export declare class MCPClient {
     listPrompts(opts?: MCPPageOptions): Promise<MCPListPromptsResult>;
     getPrompt(name: string, args?: Record<string, string> | undefined, opts?: MCPRequestOptions): Promise<MCPGetPromptResult>;
     close(): Promise<void>;
+    private closeInner;
     private request;
     private requestCapability;
     private requireResourceSubscriptions;

package/dist/index.js

@@ -1335,6 +1335,7 @@ function createTimeoutSignal(parent, timeoutMs) {
     () => ctrl.abort(new Error(`MCP HTTP request timed out after ${timeoutMs}ms`)),
     timeoutMs
   );
+  timer.unref?.();
   return {
     signal: ctrl.signal,
     dispose: () => {
@@ -1775,7 +1776,8 @@ var SSETransport = class extends BaseHTTPTransport {
         sseReader.feed(chunk);
       }
     } catch {
-      if (this.state !== "disconnected" && this.state !== "failed") {
+    } finally {
+      if (!this.readerDone && this.state !== "disconnected" && this.state !== "failed") {
         this.state = "disconnected";
         this.notifyDisconnect();
       }
@@ -1809,9 +1811,13 @@ var SSETransport = class extends BaseHTTPTransport {
     try {
       const res = await this.fetchWithAuthorization(this.url, fetchOpts, timeoutSignal.signal);
       if (!res.ok) {
-        const body2 = await res.text();
-        const cap = MCP_CONSTANTS.REQUEST_LOG_CAP;
-        const snippet = body2.length > cap ? `${body2.slice(0, cap)}\u2026 [${body2.length} bytes total]` : body2;
+        let snippet;
+        try {
+          snippet = await readBodyCapped(res, MCP_CONSTANTS.REQUEST_LOG_CAP);
+        } catch (err) {
+          const received = err instanceof ToolError4 && typeof err.context?.["received"] === "number" ? err.context["received"] : void 0;
+          snippet = typeof received === "number" ? `\u2026 [${received}+ bytes total]` : "\u2026 [error body unreadable]";
+        }
         throw new ToolError4({
           message: `HTTP ${res.status}: ${snippet}`,
           code: "TOOL_EXECUTION_FAILED",
@@ -1819,6 +1825,10 @@ var SSETransport = class extends BaseHTTPTransport {
           context: { transport: "sse", url: this.url, status: res.status }
         });
       }
+      if (method.startsWith("notifications/")) {
+        await readBodyCapped(res).catch(() => void 0);
+        return { jsonrpc: "2.0", id };
+      }
       let data;
       try {
         data = JSON.parse(await readBodyCapped(res));
@@ -1897,6 +1907,10 @@ var SSETransport = class extends BaseHTTPTransport {
           }
         });
       }
+      if (method.startsWith("notifications/")) {
+        await readBodyCapped(res).catch(() => void 0);
+        return { jsonrpc: "2.0", id };
+      }
       let data;
       try {
         data = JSON.parse(await readBodyCapped(res));
@@ -2023,10 +2037,10 @@ var StreamableHTTPTransport = class extends BaseHTTPTransport {
       const contentType = initRes.headers.get("content-type") ?? "";
       let data;
       if (contentType.includes("application/json")) {
-        const parsed = await initRes.json();
+        const parsed = JSON.parse(await readBodyCapped(initRes));
         if (isJsonRpcResult(parsed)) data = parsed;
       } else {
-        data = extractJsonRpcResults(await initRes.text())[0];
+        data = extractJsonRpcResults(await readBodyCapped(initRes))[0];
       }
       if (!data) {
         throw new Error("Could not parse initialize response");
@@ -2079,7 +2093,7 @@ var StreamableHTTPTransport = class extends BaseHTTPTransport {
         throw new Error(`HTTP ${res.status}: ${res.statusText}`);
       }
       if (method.startsWith("notifications/")) {
-        await res.text().catch(() => void 0);
+        await readBodyCapped(res).catch(() => void 0);
         return { jsonrpc: "2.0", id };
       }
       const match = this.consumeResponseText(await readBodyCapped(res), id);
@@ -2126,7 +2140,7 @@ var StreamableHTTPTransport = class extends BaseHTTPTransport {
         throw new Error(`HTTP ${res.status}: ${res.statusText}`);
       }
       if (method.startsWith("notifications/")) {
-        await res.text().catch(() => void 0);
+        await readBodyCapped(res).catch(() => void 0);
         return { jsonrpc: "2.0", id };
       }
       const parsed = this.consumeResponseText(await readBodyCapped(res), id);
@@ -2207,6 +2221,7 @@ var MCPClient = class _MCPClient {
   _toolsCache;
   _drainPending = false;
   _lastNotifySkipped = false;
+  closePromise;
   // HTTP transports
   sseTransport;
   httpTransport;
@@ -2260,15 +2275,21 @@ var MCPClient = class _MCPClient {
   async connect() {
     this.state = "connecting";
     this._serverMetadata = void 0;
-    if (this.opts.transport === "stdio") {
-      await this.connectStdio();
-    } else if (this.opts.transport === "sse") {
-      await this.connectSSE();
-    } else if (this.opts.transport === "streamable-http") {
-      await this.connectStreamableHTTP();
-    } else {
+    try {
+      if (this.opts.transport === "stdio") {
+        await this.connectStdio();
+      } else if (this.opts.transport === "sse") {
+        await this.connectSSE();
+      } else if (this.opts.transport === "streamable-http") {
+        await this.connectStreamableHTTP();
+      } else {
+        throw new Error(`Unknown transport "${this.opts.transport}"`);
+      }
+    } catch (err) {
+      await this.close().catch(() => {
+      });
       this.state = "failed";
-      throw new Error(`Unknown transport "${this.opts.transport}"`);
+      throw err;
     }
   }
   async connectStdio() {
@@ -2303,6 +2324,13 @@ var MCPClient = class _MCPClient {
     })() : spawn2(this.opts.command, rawArgs, { env: spawnEnv, stdio, windowsHide: true });
     this.child = child;
     child.stdout?.on("data", (chunk) => this.onData(chunk.toString()));
+    child.stdout?.on("end", () => {
+      if (this.rxBuffer.trim()) {
+        const line = this.rxBuffer.trim();
+        this.rxBuffer = "";
+        this.onLine(line);
+      }
+    });
     child.stderr?.on("data", () => {
     });
     child.stdin?.on("error", (err) => {
@@ -2554,6 +2582,13 @@ var MCPClient = class _MCPClient {
     );
   }
   async close() {
+    if (this.closePromise) return this.closePromise;
+    this.closePromise = this.closeInner().finally(() => {
+      this.closePromise = void 0;
+    });
+    return this.closePromise;
+  }
+  async closeInner() {
     if (this.child) {
       const child = this.child;
       const exitPromise = new Promise((resolve) => {
@@ -2570,16 +2605,26 @@ var MCPClient = class _MCPClient {
       }
       const GRACEFUL_MS = 800;
       const FORCE_TIMEOUT_MS = 1200;
+      let gracefulTimer;
       const gracefulRace = await Promise.race([
         exitPromise.then(() => "exited"),
-        new Promise((resolve) => setTimeout(() => resolve("timeout"), GRACEFUL_MS))
+        new Promise((resolve) => {
+          gracefulTimer = setTimeout(() => resolve("timeout"), GRACEFUL_MS);
+          gracefulTimer.unref?.();
+        })
       ]);
+      if (gracefulTimer) clearTimeout(gracefulTimer);
       if (gracefulRace === "timeout") {
         forceKillTree(child);
+        let forceTimer;
         await Promise.race([
           exitPromise,
-          new Promise((resolve) => setTimeout(resolve, FORCE_TIMEOUT_MS))
+          new Promise((resolve) => {
+            forceTimer = setTimeout(resolve, FORCE_TIMEOUT_MS);
+            forceTimer.unref?.();
+          })
         ]);
+        if (forceTimer) clearTimeout(forceTimer);
       }
       child.stdout?.removeAllListeners();
       child.stderr?.removeAllListeners();
@@ -2709,49 +2754,53 @@ 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 = this.child?.stdin?.write(encoded);
+      const ok = stdin.write(encoded);
       if (!ok) {
-        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;
-        }
         this._drainPending = true;
         await new Promise((resolve, reject) => {
           const timeout = setTimeout(() => {
-            this.child?.stdin?.removeListener?.("drain", onDrain);
-            this.child?.stdin?.removeListener?.("error", onError);
+            stdin.removeListener?.("drain", onDrain);
+            stdin.removeListener?.("error", onError);
             this._drainPending = false;
             reject(new Error(`MCP notify("${method}") drain timeout`));
           }, 500);
           const onDrain = () => {
             clearTimeout(timeout);
-            this.child?.stdin?.removeListener?.("drain", onDrain);
-            this.child?.stdin?.removeListener?.("error", onError);
+            stdin.removeListener?.("drain", onDrain);
+            stdin.removeListener?.("error", onError);
             this._drainPending = false;
             resolve();
           };
           const onError = (err) => {
             clearTimeout(timeout);
-            this.child?.stdin?.removeListener?.("drain", onDrain);
-            this.child?.stdin?.removeListener?.("error", onError);
+            stdin.removeListener?.("drain", onDrain);
+            stdin.removeListener?.("error", onError);
             this._drainPending = false;
             reject(err);
           };
-          this.child?.stdin?.once("drain", onDrain);
-          this.child?.stdin?.once("error", onError);
+          stdin.once?.("drain", onDrain);
+          stdin.once?.("error", onError);
         });
       }
     } catch (err) {
@@ -2769,12 +2818,16 @@ var MCPClient = class _MCPClient {
       void this.close();
       return;
     }
+    let start = 0;
     let idx = this.rxBuffer.indexOf("\n");
     while (idx !== -1) {
-      const line = this.rxBuffer.slice(0, idx).trim();
-      this.rxBuffer = this.rxBuffer.slice(idx + 1);
+      const line = this.rxBuffer.slice(start, idx).trim();
+      start = idx + 1;
       if (line) this.onLine(line);
-      idx = this.rxBuffer.indexOf("\n");
+      idx = this.rxBuffer.indexOf("\n", start);
+    }
+    if (start > 0) {
+      this.rxBuffer = this.rxBuffer.slice(start);
     }
   }
   onLine(line) {
@@ -3040,11 +3093,7 @@ async function persist(configPath, full, servers) {
   full.mcpServers = servers;
   await writeConfig(configPath, full);
 }
-var UNSAFE_SERVER_NAMES = /* @__PURE__ */ new Set([
-  "__proto__",
-  "constructor",
-  "prototype"
-]);
+var UNSAFE_SERVER_NAMES = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
 function unsafeServerNameResult(name) {
   if (!UNSAFE_SERVER_NAMES.has(name)) return void 0;
   return { ok: false, message: `Invalid server name "${name}"` };
@@ -3615,7 +3664,8 @@ function wrapMCPTool(serverName, mcpTool, client, permission = "confirm", observ
         const signal = opts?.signal ?? ctx?.signal;
         const res = await live.callTool(mcpTool.name, input, signal ? { signal } : void 0);
         if (res.isError) {
-          throw new Error(stringify(res.content));
+          const errText = stringify(res.content);
+          throw new Error(errText || `MCP tool "${qualifiedName}" failed`);
         }
         ok = true;
         return stringify(res.content);
@@ -3664,6 +3714,7 @@ function applySlotTools(ctx, slot, tools, client) {
       },
       onFinish: ({ durationMs, ok }) => {
         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);
@@ -3787,7 +3838,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" || !ctx.servers.has(slot.cfg.name) || ctx.servers.get(slot.cfg.name) !== slot) {
         client.removeExitListener(ctx.onChildExit);
         if (boundDisconnect) client.removeDisconnectListener(boundDisconnect);
         client.removeToolsChangedListener(ctx.onToolsChanged);
@@ -3890,8 +3941,28 @@ function resetDisconnectedSlotTools(slot, toolRegistry) {
   slot.resourceTemplates = void 0;
   slot.prompts = void 0;
 }
-function markLazySlotDormant(slot, events, reason) {
-  slot.client = void 0;
+function markLazySlotDormant(slot, events, reason, options) {
+  slot.reconnectPending = false;
+  if (slot.reconnectTimer) {
+    clearTimeout(slot.reconnectTimer);
+    slot.reconnectTimer = void 0;
+  }
+  if (slot.client) {
+    if (options?.onChildExit) {
+      slot.client.removeExitListener?.(options.onChildExit);
+    }
+    if (slot.onDisconnect) {
+      slot.client.removeDisconnectListener?.(slot.onDisconnect);
+    }
+    if (options?.onToolsChanged) {
+      slot.client.removeToolsChangedListener?.(options.onToolsChanged);
+    }
+    options?.removeCatalogListeners?.(slot.client);
+    slot.client.close?.().catch(() => {
+    });
+    slot.client = void 0;
+  }
+  slot.onDisconnect = void 0;
   slot.state = "dormant";
   events.emit("mcp.server.disconnected", {
     name: slot.cfg.name,
@@ -3954,17 +4025,23 @@ function buildRegistryOperationalHealth(servers, disabledServers) {
 
 // src/registry-idle.ts
 async function sleepIdleSlot(ctx, slot) {
+  if (slot.operations.inFlightCalls > 0) return;
   slot.reconnectPending = false;
   if (slot.reconnectTimer) {
     clearTimeout(slot.reconnectTimer);
     slot.reconnectTimer = void 0;
   }
   if (slot.client) {
-    slot.client.removeExitListener(ctx.onChildExit);
-    if (slot.onDisconnect) slot.client.removeDisconnectListener(slot.onDisconnect);
-    slot.client.removeToolsChangedListener(ctx.onToolsChanged);
-    ctx.removeCatalogListeners(slot.client);
-    await slot.client.close();
+    const client = slot.client;
+    client.removeExitListener?.(ctx.onChildExit);
+    if (slot.onDisconnect) client.removeDisconnectListener?.(slot.onDisconnect);
+    client.removeToolsChangedListener?.(ctx.onToolsChanged);
+    ctx.removeCatalogListeners(client);
+    try {
+      await client.close?.();
+    } catch (err) {
+      ctx.log.warn(`MCP server "${slot.cfg.name}" error during idle sleep close`, err);
+    }
     slot.client = void 0;
   }
   slot.onDisconnect = void 0;
@@ -3978,7 +4055,7 @@ async function sweepIdleSlots(ctx) {
   if (ctx.idleTimeoutMs <= 0) return false;
   const now = Date.now();
   for (const slot of ctx.servers.values()) {
-    if (slot.lazy && slot.state === "connected" && slot.client && now - slot.lastUsed > ctx.idleTimeoutMs) {
+    if (slot.lazy && slot.state === "connected" && slot.client && slot.operations.inFlightCalls === 0 && now - slot.lastUsed > ctx.idleTimeoutMs) {
       await sleepIdleSlot(ctx, slot);
     }
   }
@@ -4066,6 +4143,7 @@ function scheduleRegistryReconnect({
     slot.reconnectTimer = void 0;
     void attemptReconnect(slot);
   }, delay);
+  slot.reconnectTimer.unref?.();
 }
 
 // src/registry.ts
@@ -4213,7 +4291,7 @@ var MCPRegistry = class _MCPRegistry {
     if (!slot) throw new Error(`MCP server "${name}" not registered`);
     slot.lastUsed = Date.now();
     if (slot.client && slot.state === "connected") return slot.client;
-    const waking = slot.state === "dormant";
+    const waking = slot.state === "dormant" && !slot.connecting;
     if (waking) {
       slot.operations.wakeCount++;
       this.recordOperation(slot, "wake", "lazy-demand");
@@ -4289,22 +4367,21 @@ var MCPRegistry = class _MCPRegistry {
     }
     slot.state = "disconnected";
     if (slot.client) {
-      slot.client.removeExitListener(this.onChildExit);
-      if (slot.onDisconnect) slot.client.removeDisconnectListener(slot.onDisconnect);
-      slot.client.removeToolsChangedListener(this.onToolsChanged);
-      this.removeCatalogListeners(slot.client);
-      await slot.client.close();
+      const client = slot.client;
+      client.removeExitListener?.(this.onChildExit);
+      if (slot.onDisconnect) client.removeDisconnectListener?.(slot.onDisconnect);
+      client.removeToolsChangedListener?.(this.onToolsChanged);
+      this.removeCatalogListeners(client);
+      try {
+        await client.close?.();
+      } catch (err) {
+        this.log.warn(`MCP server "${name}" error during stop close`, err);
+      }
       slot.client = void 0;
     }
     slot.onDisconnect = void 0;
     slot.connecting = void 0;
-    for (const t of slot.toolNames) this.toolRegistry.unregister(t);
-    slot.toolNames = [];
-    slot.lazyTools = [];
-    slot.serverMetadata = void 0;
-    slot.resources = void 0;
-    slot.resourceTemplates = void 0;
-    slot.prompts = void 0;
+    resetDisconnectedSlotTools(slot, this.toolRegistry);
     slot.registeredLazy = false;
     this.recordOperation(slot, "stop", "manual");
     this.events.emit("mcp.server.disconnected", { name, reason: "stop" });
@@ -4348,8 +4425,17 @@ var MCPRegistry = class _MCPRegistry {
   }
   getCatalog(name) {
     const slot = this.servers.get(name);
-    if (!slot) return void 0;
-    return registryCatalogSnapshot(slot);
+    if (slot) {
+      return registryCatalogSnapshot(slot);
+    }
+    const disabled = this.disabledServers.get(name);
+    if (disabled) {
+      return {
+        name: disabled.name,
+        state: "idle"
+      };
+    }
+    return void 0;
   }
   async listResources(name, opts = {}) {
     const slot = this.requireSlot(name);
@@ -4506,9 +4592,16 @@ var MCPRegistry = class _MCPRegistry {
       clearInterval(this.idleTimer);
       this.idleTimer = void 0;
     }
-    for (const name of Array.from(this.servers.keys())) {
-      await this.stop(name);
-    }
+    const names = Array.from(this.servers.keys());
+    await Promise.all(
+      names.map(async (name) => {
+        try {
+          await this.stop(name);
+        } catch (err) {
+          this.log.warn(`MCP server "${name}" failed to stop during stopAll`, err);
+        }
+      })
+    );
     this.disabledServers.clear();
   }
   /**
@@ -4570,15 +4663,19 @@ var MCPRegistry = class _MCPRegistry {
     client.addPromptsChangedListener(this.onPromptsChanged);
   }
   removeCatalogListeners(client) {
-    client.removeResourcesChangedListener(this.onResourcesChanged);
-    client.removePromptsChangedListener(this.onPromptsChanged);
+    client.removeResourcesChangedListener?.(this.onResourcesChanged);
+    client.removePromptsChangedListener?.(this.onPromptsChanged);
   }
   onChildExit = (name, code, _signal) => {
     const slot = this.servers.get(name);
     if (!slot) return;
     if (slot.lazy) {
       this.recordFailure(slot, "transport", "process-exit-lazy");
-      markLazySlotDormant(slot, this.events, `exit:${code ?? "unknown"}`);
+      markLazySlotDormant(slot, this.events, `exit:${code ?? "unknown"}`, {
+        onChildExit: this.onChildExit,
+        onToolsChanged: this.onToolsChanged,
+        removeCatalogListeners: (c) => this.removeCatalogListeners(c)
+      });
       return;
     }
     resetDisconnectedSlotTools(slot, this.toolRegistry);
@@ -4593,7 +4690,11 @@ var MCPRegistry = class _MCPRegistry {
     if (!slot) return;
     if (slot.lazy) {
       this.recordFailure(slot, "transport", "http-disconnect-lazy");
-      markLazySlotDormant(slot, this.events, "http-disconnect");
+      markLazySlotDormant(slot, this.events, "http-disconnect", {
+        onChildExit: this.onChildExit,
+        onToolsChanged: this.onToolsChanged,
+        removeCatalogListeners: (c) => this.removeCatalogListeners(c)
+      });
       return;
     }
     resetDisconnectedSlotTools(slot, this.toolRegistry);
@@ -4956,11 +5057,14 @@ function serveStdio(server, opts = {}) {
       onEnd();
       return;
     }
-    let idx = buffer.indexOf("\n");
+    let start = 0;
+    let idx = buffer.indexOf("\n", start);
     while (idx !== -1) {
-      const line = buffer.slice(0, idx);
-      buffer = buffer.slice(idx + 1);
-      idx = buffer.indexOf("\n");
+      let end = idx;
+      if (end > start && buffer.charCodeAt(end - 1) === 13) end--;
+      const line = buffer.slice(start, end);
+      start = idx + 1;
+      idx = buffer.indexOf("\n", start);
       if (!line.trim()) continue;
       const handler = server.handleMessage(line).then((res) => {
         if (res !== null) writeLine(res);
@@ -4978,6 +5082,7 @@ function serveStdio(server, opts = {}) {
       });
       inFlightHandlers.add(handler);
     }
+    if (start > 0) buffer = buffer.slice(start);
   };
   let resolveDone;
   const done = new Promise((resolve) => {
@@ -4989,6 +5094,25 @@ function serveStdio(server, opts = {}) {
     if (closed) return;
     closed = true;
     stdin.off("data", onData);
+    if (!bufferTooLarge && buffer.trim()) {
+      const line = buffer.trim();
+      buffer = "";
+      const handler = server.handleMessage(line).then((res) => {
+        if (res !== null) writeLine(res);
+      }).catch((err) => {
+        console.error(
+          JSON.stringify({
+            level: "error",
+            event: "mcp_server.handle_message_failed",
+            message: toErrorMessage2(err),
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          })
+        );
+      }).finally(() => {
+        inFlightHandlers.delete(handler);
+      });
+      inFlightHandlers.add(handler);
+    }
     resolveDone();
   };
   stdin.on("data", onData);
@@ -5073,18 +5197,24 @@ async function handleHttpRequest(server, req, res, token, log, boundHost) {
     return send(415, JSON.stringify({ error: "content-type must be application/json" }));
   }
   let body = "";
+  let aborted = false;
   req.on("data", (chunk) => {
+    if (aborted) return;
     body += chunk.toString("utf8");
     if (body.length > HTTP_BODY_CAP) {
+      aborted = true;
       send(413, JSON.stringify({ error: "payload too large" }));
       req.destroy();
     }
   });
   req.on("end", () => {
+    if (aborted) return;
     void server.handleMessage(body).then((out) => {
+      if (aborted) return;
       if (out === null) return send(202, "");
       return send(200, out);
     }).catch((err) => {
+      if (aborted) return;
       log?.warn?.(`MCP http handler error: ${toErrorMessage2(err)}`);
       send(500, JSON.stringify({ error: "internal error" }));
     });

package/dist/registry-disconnect.d.ts

@@ -2,5 +2,12 @@ import type { EventBus } from '@wrongstack/core/kernel';
 import type { ToolRegistry } from '@wrongstack/core/registry';
 import type { ServerSlot } from './registry-slots.js';
 export declare function resetDisconnectedSlotTools(slot: ServerSlot, toolRegistry: ToolRegistry): void;
-export declare function markLazySlotDormant(slot: ServerSlot, events: EventBus, reason: string): void;
+export interface MarkLazySlotDormantOptions {
+    onChildExit?: (name: string, code: number | null, signal: string | null) => void;
+    onToolsChanged?: (name: string, tools: {
+        name: string;
+    }[]) => void;
+    removeCatalogListeners?: (client: import('./client.js').MCPClient) => void;
+}
+export declare function markLazySlotDormant(slot: ServerSlot, events: EventBus, reason: string, options?: MarkLazySlotDormantOptions): void;
 //# sourceMappingURL=registry-disconnect.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrongstack/mcp",
-  "version": "0.319.0",
+  "version": "0.320.1",
   "license": "MIT",
   "description": "WrongStack Model Context Protocol client and registry: stdio, SSE, and streamable HTTP transports.",
   "repository": {
@@ -26,7 +26,7 @@
     "!dist/**/*.map"
   ],
   "dependencies": {
-    "@wrongstack/core": "0.319.0"
+    "@wrongstack/core": "0.320.1"
   },
   "devDependencies": {
     "@types/node": "^26.2.0",