@wrongstack/mcp 0.1.2 → 0.1.3

package/dist/index.js

@@ -1,5 +1,436 @@
 import { spawn } from 'child_process';
 
+// src/client.ts
+
+// src/transport.ts
+var SSEReader = class {
+  buffer = "";
+  listeners = [];
+  onMessage(cb) {
+    this.listeners.push(cb);
+    return () => {
+      const idx = this.listeners.indexOf(cb);
+      if (idx >= 0) this.listeners.splice(idx, 1);
+    };
+  }
+  feed(chunk) {
+    this.buffer += chunk;
+    let idx = this.buffer.indexOf("\n");
+    while (idx !== -1) {
+      const line = this.buffer.slice(0, idx);
+      this.buffer = this.buffer.slice(idx + 1);
+      idx = this.buffer.indexOf("\n");
+      if (line.startsWith("event:")) ; else if (line.startsWith("data:")) {
+        const data = line.slice(5).trim();
+        if (data) {
+          try {
+            const parsed = JSON.parse(data);
+            this.dispatch(parsed);
+          } catch {
+          }
+        }
+      }
+    }
+  }
+  dispatch(msg) {
+    for (const cb of this.listeners) {
+      try {
+        cb(msg);
+      } catch {
+      }
+    }
+  }
+  reset() {
+    this.buffer = "";
+    this.listeners = [];
+  }
+};
+function isJsonRpcResult(v) {
+  return typeof v === "object" && v !== null && "jsonrpc" in v;
+}
+var SSETransport = class {
+  state = "idle";
+  url;
+  headers;
+  timeout;
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  tools = [];
+  abortController;
+  reader;
+  readerDone = false;
+  disconnectHandlers = [];
+  readLoopAbort;
+  toolsChangedListeners = /* @__PURE__ */ new Set();
+  constructor(opts) {
+    this.url = opts.url;
+    this.headers = { ...opts.headers };
+    this.timeout = opts.startupTimeoutMs ?? 1e4;
+  }
+  getState() {
+    return this.state;
+  }
+  listTools() {
+    return [...this.tools];
+  }
+  onDisconnect(cb) {
+    this.disconnectHandlers.push(cb);
+    return () => {
+      const idx = this.disconnectHandlers.indexOf(cb);
+      if (idx >= 0) this.disconnectHandlers.splice(idx, 1);
+    };
+  }
+  onToolsChanged(cb) {
+    this.toolsChangedListeners.add(cb);
+    return () => {
+      this.toolsChangedListeners.delete(cb);
+    };
+  }
+  /** Refresh tool list when server sends notifications/tools/list_changed. */
+  async handleToolsListChanged() {
+    try {
+      const res = await this.httpPost("tools/list", {});
+      if (!res.error) {
+        this.tools = res.result?.tools ?? [];
+        for (const cb of this.toolsChangedListeners) {
+          try {
+            cb([...this.tools]);
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  async connect() {
+    this.state = "connecting";
+    this.abortController = new AbortController();
+    const signal = this.abortController.signal;
+    const startupTimer = setTimeout(() => this.abortController?.abort(), this.timeout);
+    try {
+      const sseUrl = this.buildSSEUrl();
+      const response = await fetch(sseUrl, {
+        headers: this.headers,
+        signal
+      });
+      if (!response.ok) {
+        throw new Error(`SSE connect HTTP ${response.status}: ${response.statusText}`);
+      }
+      if (!response.body) {
+        throw new Error("SSE response has no body");
+      }
+      const textDecoder = new TextDecoder();
+      const sseReader = new SSEReader();
+      this.readLoopAbort = new AbortController();
+      sseReader.onMessage((msg) => {
+        if (msg.id !== void 0) {
+          const resolve = this.pending.get(msg.id);
+          if (resolve) {
+            this.pending.delete(msg.id);
+            resolve({ jsonrpc: "2.0", id: msg.id, result: msg.params });
+          }
+        }
+        if (msg.method && !msg.id) {
+          if (msg.method === "notifications/tools/list_changed") {
+            void this.handleToolsListChanged();
+          }
+        }
+      });
+      const reader = response.body.getReader();
+      this.reader = {
+        cancel: () => reader.cancel(),
+        releaseLock: () => reader.releaseLock()
+      };
+      this.readSSEBody(reader, textDecoder, sseReader);
+      const initRes = await this.httpPost("initialize", {
+        protocolVersion: "2024-11-05",
+        capabilities: { tools: {} },
+        clientInfo: { name: "wrongstack", version: "0.1.1" }
+      });
+      if (initRes.error) {
+        throw new Error(`initialize failed: ${initRes.error.message}`);
+      }
+      try {
+        await this.httpPost("notifications/initialized", {});
+      } catch {
+      }
+      const toolsRes = await this.httpPost("tools/list", {});
+      if (toolsRes.error) {
+        this.tools = [];
+      } else {
+        const result = toolsRes.result;
+        this.tools = result?.tools ?? [];
+      }
+      this.state = "connected";
+      clearTimeout(startupTimer);
+    } catch (err) {
+      clearTimeout(startupTimer);
+      this.state = "failed";
+      this.abortController.abort();
+      throw err;
+    }
+  }
+  async readSSEBody(reader, decoder, sseReader) {
+    try {
+      while (!this.readerDone) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        const chunk = decoder.decode(value, { stream: true });
+        sseReader.feed(chunk);
+      }
+    } catch {
+      if (this.state !== "disconnected" && this.state !== "failed") {
+        this.state = "disconnected";
+        for (const cb of this.disconnectHandlers) {
+          try {
+            cb();
+          } catch {
+          }
+        }
+      }
+    }
+  }
+  buildSSEUrl() {
+    try {
+      const url = new URL(this.url);
+      url.searchParams.set("session", String(Date.now()));
+      return url.toString();
+    } catch {
+      return this.url;
+    }
+  }
+  async httpPost(method, params) {
+    const id = this.nextId++;
+    const body = JSON.stringify({ jsonrpc: "2.0", id, method, params });
+    const res = await fetch(this.url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.headers
+      },
+      body,
+      signal: this.abortController?.signal
+    });
+    if (!res.ok) {
+      throw new Error(`HTTP ${res.status}: ${await res.text()}`);
+    }
+    const data = await res.json();
+    if (!isJsonRpcResult(data)) {
+      throw new Error("Invalid JSON-RPC response");
+    }
+    return data;
+  }
+  async callTool(name, input) {
+    if (this.state !== "connected") {
+      throw new Error(`SSE transport not connected (state=${this.state})`);
+    }
+    const res = await this.httpPost("tools/call", { name, arguments: input });
+    if (res.error) {
+      return { content: res.error.message, isError: true };
+    }
+    const result = res.result;
+    return {
+      content: result?.content ?? "",
+      isError: Boolean(result?.isError)
+    };
+  }
+  async close() {
+    if (this.state === "disconnected") return;
+    this.readerDone = true;
+    this.readLoopAbort?.abort();
+    try {
+      this.reader?.cancel();
+    } catch {
+    }
+    try {
+      this.reader?.releaseLock();
+    } catch {
+    }
+    this.abortController?.abort();
+    this.disconnectHandlers = [];
+    this.state = "disconnected";
+  }
+};
+var StreamableHTTPTransport = class {
+  state = "idle";
+  url;
+  headers;
+  timeout;
+  nextId = 1;
+  tools = [];
+  abortController;
+  sessionId;
+  disconnectHandlers = [];
+  toolsChangedListeners = /* @__PURE__ */ new Set();
+  constructor(opts) {
+    this.url = opts.url;
+    this.headers = { ...opts.headers };
+    this.timeout = opts.startupTimeoutMs ?? 1e4;
+  }
+  getState() {
+    return this.state;
+  }
+  listTools() {
+    return [...this.tools];
+  }
+  onDisconnect(cb) {
+    this.disconnectHandlers.push(cb);
+    return () => {
+      const idx = this.disconnectHandlers.indexOf(cb);
+      if (idx >= 0) this.disconnectHandlers.splice(idx, 1);
+    };
+  }
+  onToolsChanged(cb) {
+    this.toolsChangedListeners.add(cb);
+    return () => {
+      this.toolsChangedListeners.delete(cb);
+    };
+  }
+  async handleToolsListChanged() {
+    try {
+      const res = await this.postRaw("tools/list", {});
+      if (!res.error) {
+        this.tools = res.result?.tools ?? [];
+        for (const cb of this.toolsChangedListeners) {
+          try {
+            cb([...this.tools]);
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  async connect() {
+    this.state = "connecting";
+    this.abortController = new AbortController();
+    const signal = this.abortController.signal;
+    const startupTimer = setTimeout(() => this.abortController?.abort(), this.timeout);
+    try {
+      const initRes = await fetch(this.url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Accept": "application/json, text/event-stream",
+          ...this.headers
+        },
+        body: JSON.stringify({
+          jsonrpc: "2.0",
+          id: this.nextId++,
+          method: "initialize",
+          params: {
+            protocolVersion: "2024-11-05",
+            capabilities: { tools: {} },
+            clientInfo: { name: "wrongstack", version: "0.1.1" }
+          }
+        }),
+        signal
+      });
+      if (!initRes.ok) {
+        throw new Error(`initialize HTTP ${initRes.status}: ${initRes.statusText}`);
+      }
+      const contentType = initRes.headers.get("content-type") ?? "";
+      let data;
+      if (contentType.includes("application/json")) {
+        const parsed = await initRes.json();
+        if (isJsonRpcResult(parsed)) data = parsed;
+      } else {
+        const text = await initRes.text();
+        const lines = text.split("\n").filter((l) => l.trim());
+        for (const line of lines) {
+          try {
+            const parsed = JSON.parse(line);
+            if (isJsonRpcResult(parsed)) {
+              data = parsed;
+              break;
+            }
+          } catch {
+            continue;
+          }
+        }
+      }
+      if (!data) {
+        throw new Error("Could not parse initialize response");
+      }
+      if (data.error) {
+        throw new Error(`initialize failed: ${data.error.message}`);
+      }
+      this.sessionId = initRes.headers.get("x-mcp-session") ?? void 0;
+      await this.postRaw("notifications/initialized", {});
+      const toolsRes = await this.postRaw("tools/list", {});
+      if (toolsRes.error) {
+        this.tools = [];
+      } else {
+        const result = toolsRes.result;
+        this.tools = result?.tools ?? [];
+      }
+      this.state = "connected";
+      clearTimeout(startupTimer);
+    } catch (err) {
+      clearTimeout(startupTimer);
+      this.state = "failed";
+      this.abortController.abort();
+      throw err;
+    }
+  }
+  async postRaw(method, params) {
+    const id = this.nextId++;
+    const body = JSON.stringify({ jsonrpc: "2.0", id, method, params });
+    const url = this.sessionId ? `${this.url}${this.url.includes("?") ? "&" : "?"}session=${this.sessionId}` : this.url;
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Accept": "application/json, text/event-stream",
+        ...this.sessionId ? { "x-mcp-session": this.sessionId } : {},
+        ...this.headers
+      },
+      body,
+      signal: this.abortController?.signal
+    });
+    if (!res.ok) {
+      throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+    }
+    const text = await res.text();
+    const lines = text.split("\n").filter((l) => l.trim());
+    for (const line of lines) {
+      try {
+        const parsed = JSON.parse(line);
+        if (isJsonRpcResult(parsed)) return parsed;
+      } catch {
+        continue;
+      }
+    }
+    throw new Error("Could not parse response as JSON-RPC");
+  }
+  async callTool(name, input) {
+    if (this.state !== "connected") {
+      throw new Error(`streamable-http transport not connected (state=${this.state})`);
+    }
+    const res = await this.postRaw("tools/call", { name, arguments: input });
+    if (res.error) {
+      return { content: res.error.message, isError: true };
+    }
+    const result = res.result;
+    return {
+      content: result?.content ?? "",
+      isError: Boolean(result?.isError)
+    };
+  }
+  async close() {
+    if (this.state === "disconnected") return;
+    this.state = "disconnected";
+    this.abortController?.abort();
+    for (const cb of this.disconnectHandlers) {
+      try {
+        cb();
+      } catch {
+      }
+    }
+    this.disconnectHandlers = [];
+  }
+};
+
 // src/client.ts
 var MCPClient = class {
   constructor(opts) {
@@ -11,31 +442,64 @@ var MCPClient = class {
   nextId = 1;
   pending = /* @__PURE__ */ new Map();
   rxBuffer = "";
-  tools = [];
-  /**
-   * Guards against multiple concurrent drain-waits. When `stdin.write()`
-   * returns false the first waiter sets this flag; any subsequent callers
-   * skip the drain wait and emit a warning instead of racing.
-   */
+  _tools = [];
+  /** Cached tool list — survives reconnects so the registry can re-register without re-discovering. */
+  _toolsCache;
   _drainPending = false;
-  /** Set when a notify() call failed for reasons the caller should know about. */
   _lastNotifySkipped = false;
+  // HTTP transports
+  sseTransport;
+  httpTransport;
+  /** Notified when the stdio child process exits so the registry can attempt reconnect. */
+  exitListeners = /* @__PURE__ */ new Set();
+  /** Notified when the server announces a tools/list_changed notification. */
+  toolsChangedListeners = /* @__PURE__ */ new Set();
+  /** Notified when an HTTP transport (SSE or streamable-http) disconnects. */
+  disconnectListeners = /* @__PURE__ */ new Set();
   getState() {
     return this.state;
   }
   listTools() {
-    return [...this.tools];
+    return this._tools.length > 0 ? [...this._tools] : this._toolsCache ? [...this._toolsCache] : [];
   }
   /** Returns true if a prior notify() call was skipped due to backpressure. */
   hadNotifySkipped() {
     return this._lastNotifySkipped;
   }
+  /**
+   * Register a listener for child-process exit events.
+   * The registry uses this to trigger reconnection.
+   */
+  addExitListener(listener) {
+    this.exitListeners.add(listener);
+  }
+  removeExitListener(listener) {
+    this.exitListeners.delete(listener);
+  }
+  /**
+   * Register a listener for transport disconnect events (SSE / streamable-http).
+   * Used by the registry to trigger reconnection for HTTP-based servers.
+   */
+  addDisconnectListener(listener) {
+    this.disconnectListeners.add(listener);
+  }
+  removeDisconnectListener(listener) {
+    this.disconnectListeners.delete(listener);
+  }
   async connect() {
     this.state = "connecting";
-    if (this.opts.transport !== "stdio") {
+    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 {
       this.state = "failed";
-      throw new Error(`MCP transport "${this.opts.transport}" not supported in this build`);
+      throw new Error(`Unknown transport "${this.opts.transport}"`);
     }
+  }
+  async connectStdio() {
     if (!this.opts.command) {
       this.state = "failed";
       throw new Error('MCP stdio transport requires "command"');
@@ -48,8 +512,14 @@ var MCPClient = class {
     child.stdout?.on("data", (chunk) => this.onData(chunk.toString()));
     child.stderr?.on("data", () => {
     });
-    child.on("exit", () => {
+    child.on("exit", (code, signal) => {
       this.state = "disconnected";
+      for (const listener of this.exitListeners) {
+        try {
+          listener(this.opts.name, code, signal);
+        } catch {
+        }
+      }
     });
     child.on("error", () => {
       this.state = "failed";
@@ -78,17 +548,104 @@ var MCPClient = class {
     }
     const toolsRes = await this.request("tools/list", {});
     if (toolsRes.error) {
-      this.tools = [];
+      this._tools = [];
     } else {
       const result = toolsRes.result;
-      this.tools = result?.tools ?? [];
+      this._tools = result?.tools ?? [];
+    }
+    this._toolsCache = this._tools;
+    this.state = "connected";
+  }
+  async connectSSE() {
+    if (!this.opts.url) {
+      this.state = "failed";
+      throw new Error('MCP SSE transport requires "url"');
+    }
+    const httpOpts = {
+      name: this.opts.name,
+      url: this.opts.url,
+      headers: this.opts.headers,
+      startupTimeoutMs: this.opts.startupTimeoutMs
+    };
+    this.sseTransport = new SSETransport(httpOpts);
+    this.sseTransport.onDisconnect(() => {
+      this.state = "disconnected";
+      for (const cb of this.disconnectListeners) {
+        try {
+          cb();
+        } catch {
+        }
+      }
+    });
+    this.sseTransport.onToolsChanged((tools) => {
+      this._tools = tools;
+      for (const cb of this.toolsChangedListeners) {
+        try {
+          cb(this.opts.name, tools);
+        } catch {
+        }
+      }
+    });
+    try {
+      await this.sseTransport.connect();
+    } catch (err) {
+      this.state = "failed";
+      throw err;
+    }
+    this._tools = this.sseTransport.listTools();
+    this._toolsCache = this._tools;
+    this.state = "connected";
+  }
+  async connectStreamableHTTP() {
+    if (!this.opts.url) {
+      this.state = "failed";
+      throw new Error('MCP streamable-http transport requires "url"');
+    }
+    const httpOpts = {
+      name: this.opts.name,
+      url: this.opts.url,
+      headers: this.opts.headers,
+      startupTimeoutMs: this.opts.startupTimeoutMs
+    };
+    this.httpTransport = new StreamableHTTPTransport(httpOpts);
+    this.httpTransport.onDisconnect(() => {
+      this.state = "disconnected";
+      for (const cb of this.disconnectListeners) {
+        try {
+          cb();
+        } catch {
+        }
+      }
+    });
+    this.httpTransport.onToolsChanged((tools) => {
+      this._tools = tools;
+      for (const cb of this.toolsChangedListeners) {
+        try {
+          cb(this.opts.name, tools);
+        } catch {
+        }
+      }
+    });
+    try {
+      await this.httpTransport.connect();
+    } catch (err) {
+      this.state = "failed";
+      throw err;
     }
+    this._tools = this.httpTransport.listTools();
+    this._toolsCache = this._tools;
     this.state = "connected";
   }
   async callTool(name, input) {
     if (this.state !== "connected") {
       throw new Error(`MCP client "${this.opts.name}" not connected (state=${this.state})`);
     }
+    if (this.sseTransport) {
+      return this.sseTransport.callTool(name, input);
+    }
+    if (this.httpTransport) {
+      return this.httpTransport.callTool(name, input);
+    }
     const res = await this.request("tools/call", { name, arguments: input });
     if (res.error) {
       return { content: res.error.message, isError: true };
@@ -101,11 +658,19 @@ var MCPClient = class {
   }
   async close() {
     if (this.child) {
+      const child = this.child;
+      const exitPromise = child.exitCode === null && child.signalCode === null ? new Promise((resolve) => child.once("exit", () => resolve())) : Promise.resolve();
       try {
-        this.child.kill();
+        child.kill();
       } catch {
       }
+      await Promise.race([
+        exitPromise,
+        new Promise((resolve) => setTimeout(resolve, 1e3))
+      ]);
     }
+    this.sseTransport?.close();
+    this.httpTransport?.close();
     this.state = "disconnected";
   }
   request(method, params) {
@@ -177,12 +742,58 @@ var MCPClient = class {
       const resolve = this.pending.get(msg.id);
       this.pending.delete(msg.id);
       resolve?.(msg);
+      return;
+    }
+    if (typeof msg.method === "string" && msg.method === "notifications/tools/list_changed") {
+      void this.handleToolsListChanged();
+    }
+  }
+  /**
+   * L2-C: refresh the cached tool list when the server announces a
+   * `tools/list_changed`. Listeners (the registry) re-wrap and
+   * re-register. Failures are swallowed — a stale cache is preferable
+   * to a hard crash on a transient notification glitch.
+   */
+  async handleToolsListChanged() {
+    try {
+      const toolsRes = await this.request("tools/list", {});
+      const tools = (toolsRes.result?.tools ?? []).filter(
+        (t) => !!t && typeof t.name === "string"
+      );
+      this._tools = tools;
+      this._toolsCache = tools;
+      for (const listener of this.toolsChangedListeners) {
+        try {
+          listener(this.opts.name, [...tools]);
+        } catch {
+        }
+      }
+    } catch {
     }
   }
+  addToolsChangedListener(listener) {
+    this.toolsChangedListeners.add(listener);
+  }
+  removeToolsChangedListener(listener) {
+    this.toolsChangedListeners.delete(listener);
+  }
 };
 
 // src/wrap-tool.ts
 var MUTATING_RE = /create|update|delete|write|send|set|put|post|patch|remove|rename|move/i;
+function isMutatingTool(mcpTool) {
+  if (MUTATING_RE.test(mcpTool.name)) return true;
+  const schema = mcpTool.inputSchema;
+  if (schema && typeof schema === "object") {
+    const props = schema.properties;
+    if (props) {
+      for (const key of Object.keys(props)) {
+        if (MUTATING_RE.test(key)) return true;
+      }
+    }
+  }
+  return false;
+}
 function wrapMCPTool(serverName, mcpTool, client, permission = "confirm") {
   const qualifiedName = `mcp__${serverName}__${mcpTool.name}`;
   return {
@@ -190,7 +801,7 @@ function wrapMCPTool(serverName, mcpTool, client, permission = "confirm") {
     description: mcpTool.description ?? `${qualifiedName} (MCP tool)`,
     usageHint: `Tool provided by MCP server "${serverName}". ${mcpTool.description ?? ""}`,
     permission,
-    mutating: MUTATING_RE.test(mcpTool.name),
+    mutating: isMutatingTool(mcpTool),
     inputSchema: mcpTool.inputSchema ?? { type: "object", properties: {} },
     async execute(input, ctx, opts) {
       const res = await client.callTool(mcpTool.name, input);
@@ -223,7 +834,7 @@ function stringify(c) {
 }
 
 // src/registry.ts
-var MCPRegistry = class {
+var MCPRegistry = class _MCPRegistry {
   servers = /* @__PURE__ */ new Map();
   toolRegistry;
   events;
@@ -239,7 +850,9 @@ var MCPRegistry = class {
       cfg,
       state: "idle",
       toolNames: [],
-      attempts: 0
+      attempts: 0,
+      reconnectPending: false,
+      reconnectCycles: 0
     };
     this.servers.set(cfg.name, slot);
     await this.attemptConnect(slot);
@@ -247,7 +860,13 @@ var MCPRegistry = class {
   async stop(name) {
     const slot = this.servers.get(name);
     if (!slot) return;
-    if (slot.client) await slot.client.close();
+    slot.reconnectPending = false;
+    if (slot.client) {
+      slot.client.removeExitListener(this.onChildExit);
+      slot.client.removeDisconnectListener(() => this.onTransportDisconnect(slot.cfg.name));
+      slot.client.removeToolsChangedListener(this.onToolsChanged);
+      await slot.client.close();
+    }
     for (const t of slot.toolNames) this.toolRegistry.unregister(t);
     slot.toolNames = [];
     slot.state = "disconnected";
@@ -258,6 +877,7 @@ var MCPRegistry = class {
     if (!slot) throw new Error(`MCP server "${name}" not registered`);
     await this.stop(name);
     slot.attempts = 0;
+    slot.reconnectCycles = 0;
     await this.attemptConnect(slot);
   }
   list() {
@@ -272,6 +892,117 @@ var MCPRegistry = class {
       await this.stop(name);
     }
   }
+  /**
+   * Health check — returns 'ok' for connected servers, the current state otherwise.
+   * For HTTP-based transports this could also ping the server.
+   */
+  health() {
+    return Array.from(this.servers.values()).map((s) => ({
+      name: s.cfg.name,
+      alive: s.state === "connected"
+    }));
+  }
+  /**
+   * L2-C: handle `notifications/tools/list_changed` from the server.
+   * Unregister the previous wrapper set, then re-register the fresh
+   * tool list. The client has already refreshed its cache before
+   * dispatching — we just need to re-wrap and re-register.
+   */
+  onToolsChanged = (name, _tools) => {
+    const slot = this.servers.get(name);
+    if (!slot || !slot.client) return;
+    for (const t of slot.toolNames) {
+      try {
+        this.toolRegistry.unregister(t);
+      } catch {
+      }
+    }
+    slot.toolNames = [];
+    const allowed = slot.cfg.allowedTools;
+    const wrapped = slot.client.listTools().filter((t) => !allowed || allowed.includes(t.name)).map((t) => wrapMCPTool(slot.cfg.name, t, slot.client, slot.cfg.permission ?? "confirm"));
+    for (const tool of wrapped) {
+      try {
+        this.toolRegistry.register(tool, `mcp:${slot.cfg.name}`);
+        slot.toolNames.push(tool.name);
+      } catch (err) {
+        this.log.warn(`MCP tool "${tool.name}" not re-registered after list_changed`, err);
+      }
+    }
+    this.events.emit("mcp.server.connected", {
+      name: slot.cfg.name,
+      toolCount: slot.toolNames.length
+    });
+    this.log.info(
+      `MCP server "${slot.cfg.name}" tools refreshed (${slot.toolNames.length} active)`
+    );
+  };
+  onChildExit = (name, code, _signal) => {
+    const slot = this.servers.get(name);
+    if (!slot) return;
+    for (const t of slot.toolNames) {
+      try {
+        this.toolRegistry.unregister(t);
+      } catch {
+      }
+    }
+    slot.toolNames = [];
+    slot.state = "disconnected";
+    this.events.emit("mcp.server.disconnected", { name, reason: `exit:${code ?? "unknown"}` });
+    this.scheduleReconnect(slot);
+  };
+  /** Handles SSE / streamable-http disconnect — same recovery as stdio child exit. */
+  onTransportDisconnect = (name) => {
+    const slot = this.servers.get(name);
+    if (!slot) return;
+    for (const t of slot.toolNames) {
+      try {
+        this.toolRegistry.unregister(t);
+      } catch {
+      }
+    }
+    slot.toolNames = [];
+    slot.state = "disconnected";
+    this.events.emit("mcp.server.disconnected", { name, reason: "http-disconnect" });
+    this.scheduleReconnect(slot);
+  };
+  /**
+   * L2-B: maximum number of reconnect cycles before staying `failed`.
+   * One cycle = one full `attemptConnect` (which itself may try up to 3
+   * times). Caps total reconnect storm at ~5 cycles, then the slot
+   * needs an explicit `restart()` to re-engage.
+   */
+  static MAX_RECONNECT_CYCLES = 5;
+  /** Base delay between cycles, in ms. Real delay adds jitter. */
+  static BASE_RECONNECT_DELAY_MS = 1e3;
+  /** Hard ceiling on the inter-cycle delay so the user doesn't wait minutes. */
+  static MAX_RECONNECT_DELAY_MS = 3e4;
+  scheduleReconnect(slot) {
+    if (slot.reconnectPending) return;
+    if (slot.reconnectCycles >= _MCPRegistry.MAX_RECONNECT_CYCLES) {
+      slot.state = "failed";
+      this.log.error(
+        `MCP server "${slot.cfg.name}" giving up after ${slot.reconnectCycles} reconnect cycles. Use \`/mcp restart ${slot.cfg.name}\` to retry.`
+      );
+      this.events.emit("mcp.server.disconnected", {
+        name: slot.cfg.name,
+        reason: `reconnect-exhausted:${slot.reconnectCycles}`
+      });
+      return;
+    }
+    slot.reconnectPending = true;
+    const base = Math.min(
+      _MCPRegistry.BASE_RECONNECT_DELAY_MS * 2 ** slot.reconnectCycles,
+      _MCPRegistry.MAX_RECONNECT_DELAY_MS
+    );
+    const jitter = base * 0.2 * (Math.random() * 2 - 1);
+    const delay = Math.max(100, Math.round(base + jitter));
+    setTimeout(() => this.attemptReconnect(slot), delay);
+  }
+  async attemptReconnect(slot) {
+    slot.reconnectPending = false;
+    slot.reconnectCycles++;
+    await this.attemptConnect(slot);
+  }
   async attemptConnect(slot) {
     const MAX_ATTEMPTS = 3;
     let attempt = 0;
@@ -279,8 +1010,9 @@ var MCPRegistry = class {
       attempt++;
       slot.state = attempt === 1 ? "connecting" : "reconnecting";
       slot.attempts = attempt;
+      let client;
       try {
-        const client = new MCPClient({
+        client = new MCPClient({
           name: slot.cfg.name,
           transport: slot.cfg.transport,
           command: slot.cfg.command,
@@ -290,12 +1022,22 @@ var MCPRegistry = class {
           headers: slot.cfg.headers,
           startupTimeoutMs: slot.cfg.startupTimeoutMs
         });
+        if (slot.cfg.transport === "stdio") {
+          client.addExitListener(this.onChildExit);
+        } else {
+          client.addDisconnectListener(() => this.onTransportDisconnect(slot.cfg.name));
+        }
+        client.addToolsChangedListener(this.onToolsChanged);
         await client.connect();
         slot.client = client;
         const isReconnect = attempt > 1;
         slot.state = "connected";
+        slot.reconnectCycles = 0;
         const allowed = slot.cfg.allowedTools;
-        const wrapped = client.listTools().filter((t) => !allowed || allowed.includes(t.name)).map((t) => wrapMCPTool(slot.cfg.name, t, client, slot.cfg.permission ?? "confirm"));
+        const mc = client;
+        const candidateTools = mc.listTools();
+        const toWrap = candidateTools.length > 0 ? candidateTools : mc.listTools();
+        const wrapped = toWrap.filter((t) => !allowed || allowed.includes(t.name)).map((t) => wrapMCPTool(slot.cfg.name, t, mc, slot.cfg.permission ?? "confirm"));
         for (const tool of wrapped) {
           try {
             this.toolRegistry.register(tool, `mcp:${slot.cfg.name}`);
@@ -311,9 +1053,17 @@ var MCPRegistry = class {
         return;
       } catch (err) {
         this.log.warn(`MCP server "${slot.cfg.name}" connect attempt ${attempt} failed`, err);
+        if (client) {
+          client.removeExitListener(this.onChildExit);
+          client.removeDisconnectListener(() => this.onTransportDisconnect(slot.cfg.name));
+          client.removeToolsChangedListener(this.onToolsChanged);
+          await client.close().catch(() => {
+          });
+        }
         if (attempt >= MAX_ATTEMPTS) {
           this.log.error(`MCP server "${slot.cfg.name}" connect exhausted after ${MAX_ATTEMPTS} attempts`, err);
           slot.state = "failed";
+          slot.client = void 0;
           this.events.emit("mcp.server.disconnected", {
             name: slot.cfg.name,
             reason: err instanceof Error ? err.message : "unknown"
@@ -327,6 +1077,6 @@ var MCPRegistry = class {
   }
 };
 
-export { MCPClient, MCPRegistry, wrapMCPTool };
+export { MCPClient, MCPRegistry, SSEReader, SSETransport, StreamableHTTPTransport, wrapMCPTool };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map