@wrongstack/mcp 0.306.4 → 0.307.0

package/dist/index.js

@@ -3469,7 +3469,7 @@ function percentile(sorted, ratio) {
 }
 
 // src/registry.ts
-import { expectDefined } from "@wrongstack/core/utils";
+import { expectDefined as expectDefined2 } from "@wrongstack/core/utils";
 
 // src/registry-catalog.ts
 var MAX_CATALOG_PAGES = 100;
@@ -3695,6 +3695,9 @@ function scheduleRegistryReconnect({
   }, delay);
 }
 
+// src/registry-connect-loop.ts
+import { expectDefined } from "@wrongstack/core/utils";
+
 // src/wrap-tool.ts
 import { ToolCapabilities } from "@wrongstack/core/security";
 import { mcpQualifiedToolName } from "@wrongstack/core/utils";
@@ -3761,6 +3764,274 @@ function stringify(c) {
   return String(c ?? "");
 }
 
+// src/registry-connect-loop.ts
+function applySlotTools(ctx, slot, tools, client) {
+  if (slot.lazy && slot.registeredLazy && !ctx.lazyMode) return;
+  const allowed = slot.cfg.allowedTools;
+  const filtered = tools.filter((t) => !allowed || allowed.includes(t.name));
+  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: () => {
+        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 }) => {
+        slot.operations.inFlightCalls = Math.max(0, slot.operations.inFlightCalls - 1);
+        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);
+        }
+      }
+    })
+  );
+  if (ctx.lazyMode) {
+    slot.lazyTools = wrapped;
+    return;
+  }
+  for (const tool of wrapped) {
+    try {
+      ctx.toolRegistry.register(tool, `mcp:${slot.cfg.name}`);
+      slot.toolNames.push(tool.name);
+    } catch (err) {
+      ctx.log.warn(`MCP tool "${tool.name}" not registered`, err);
+    }
+  }
+  if (slot.lazy && wrapped.length > 0) slot.registeredLazy = true;
+}
+async function discoverSlotCapabilities(ctx, slot, client) {
+  const startedAt = Date.now();
+  slot.serverMetadata = client.getServerMetadata();
+  const capabilities = slot.serverMetadata?.capabilities;
+  if (capabilities?.resources) {
+    try {
+      slot.resources = await collectCatalogPages(
+        (cursor) => client.listResources(cursor ? { cursor } : {}),
+        (page) => page.resources
+      );
+    } catch (err) {
+      slot.resources = void 0;
+      ctx.recordFailure(slot, "protocol", "resource-discovery-failed");
+      ctx.log.warn(`MCP server "${slot.cfg.name}" resource discovery failed`, err);
+    }
+    try {
+      slot.resourceTemplates = await collectCatalogPages(
+        (cursor) => client.listResourceTemplates(cursor ? { cursor } : {}),
+        (page) => page.resourceTemplates
+      );
+    } catch (err) {
+      slot.resourceTemplates = void 0;
+      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 (capabilities?.prompts) {
+    try {
+      slot.prompts = await collectCatalogPages(
+        (cursor) => client.listPrompts(cursor ? { cursor } : {}),
+        (page) => page.prompts
+      );
+    } catch (err) {
+      slot.prompts = void 0;
+      ctx.recordFailure(slot, "protocol", "prompt-discovery-failed");
+      ctx.log.warn(`MCP server "${slot.cfg.name}" prompt discovery failed`, err);
+    }
+  } else {
+    slot.prompts = void 0;
+  }
+  const durationMs = Date.now() - startedAt;
+  pushBounded(slot.operations.discoverySamples, durationMs, MCP_OPERATION_LIMITS.LATENCY_SAMPLES);
+  ctx.recordOperation(slot, "discover", "complete", void 0, durationMs, false);
+}
+async function persistSlotCapabilityManifest(cacheDir, slot) {
+  if (!slot.lazy || !cacheDir) return;
+  const previous = slot.manifestWrite ?? Promise.resolve();
+  const pending = previous.then(
+    () => writeCapabilityManifest(cacheDir, slot.cfg.name, manifestConfigHash(slot.cfg), {
+      tools: slot.client?.listTools() ?? [],
+      serverMetadata: slot.serverMetadata,
+      resources: slot.resources,
+      resourceTemplates: slot.resourceTemplates,
+      prompts: slot.prompts
+    })
+  );
+  slot.manifestWrite = pending;
+  await pending;
+  if (slot.manifestWrite === pending) slot.manifestWrite = void 0;
+}
+async function attemptConnectSlot(ctx, slot) {
+  const MAX_ATTEMPTS = MCP_CONSTANTS.RECONNECT.MAX_ATTEMPTS;
+  let attempt = 0;
+  while (attempt < MAX_ATTEMPTS) {
+    if (ctx.servers.has(slot.cfg.name) && ctx.servers.get(slot.cfg.name) !== slot) {
+      return;
+    }
+    attempt++;
+    const startedAt = Date.now();
+    slot.state = attempt === 1 ? "connecting" : "reconnecting";
+    slot.attempts = attempt;
+    let client;
+    let boundDisconnect;
+    try {
+      client = new MCPClient({
+        name: slot.cfg.name,
+        transport: slot.cfg.transport,
+        command: slot.cfg.command,
+        args: slot.cfg.args,
+        env: slot.cfg.env,
+        url: slot.cfg.url,
+        headers: slot.cfg.headers,
+        startupTimeoutMs: slot.cfg.startupTimeoutMs,
+        requestTimeoutMs: slot.cfg.requestTimeoutMs,
+        passthroughEnv: slot.cfg.passthroughEnv,
+        authorizationProvider: ctx.authorizationProviderFactory?.(slot.cfg)
+      });
+      if (slot.cfg.transport === "stdio") {
+        client.addExitListener(ctx.onChildExit);
+      } else {
+        boundDisconnect = () => ctx.onTransportDisconnect(slot.cfg.name);
+        client.addDisconnectListener(boundDisconnect);
+      }
+      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) {
+        client.removeExitListener(ctx.onChildExit);
+        if (boundDisconnect) client.removeDisconnectListener(boundDisconnect);
+        client.removeToolsChangedListener(ctx.onToolsChanged);
+        ctx.removeCatalogListeners(client);
+        await client.close().catch(() => {
+        });
+        return;
+      }
+      if (slot.client && slot.client !== client) {
+        const prior = slot.client;
+        const priorDisconnect = slot.onDisconnect;
+        slot.client.removeExitListener(ctx.onChildExit);
+        if (priorDisconnect) prior.removeDisconnectListener(priorDisconnect);
+        prior.removeToolsChangedListener(ctx.onToolsChanged);
+        ctx.removeCatalogListeners(prior);
+        prior.close().catch(() => {
+        });
+      }
+      slot.client = client;
+      slot.onDisconnect = boundDisconnect;
+      const isReconnect = slot.reconnectCycles > 0 || attempt > 1;
+      slot.state = "connected";
+      slot.reconnectCycles = 0;
+      const mc = client;
+      const discovered = mc.listTools();
+      await discoverSlotCapabilities(ctx, slot, mc);
+      await persistSlotCapabilityManifest(ctx.cacheDir, slot);
+      applySlotTools(ctx, slot, discovered, mc);
+      const durationMs = Date.now() - startedAt;
+      pushBounded(
+        slot.operations.connectionSamples,
+        durationMs,
+        MCP_OPERATION_LIMITS.LATENCY_SAMPLES
+      );
+      ctx.recordSuccess(slot, (slot.operations.lastFailureAt ?? 0) < startedAt);
+      ctx.recordOperation(
+        slot,
+        isReconnect ? "reconnect" : "connect",
+        "connected",
+        void 0,
+        durationMs
+      );
+      slot.lastUsed = Date.now();
+      if (slot.lazy) ctx.ensureIdleSweep();
+      ctx.events.emit(isReconnect ? "mcp.server.reconnected" : "mcp.server.connected", {
+        name: slot.cfg.name,
+        toolCount: slot.toolNames.length
+      });
+      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);
+        client.removeToolsChangedListener(ctx.onToolsChanged);
+        ctx.removeCatalogListeners(client);
+        await client.close().catch(() => {
+        });
+      }
+      if (attempt >= MAX_ATTEMPTS) {
+        ctx.log.error(
+          `MCP server "${slot.cfg.name}" connect exhausted after ${MAX_ATTEMPTS} attempts`,
+          err
+        );
+        slot.state = "failed";
+        slot.client = void 0;
+        if (slot.reconnectTimer) {
+          clearTimeout(slot.reconnectTimer);
+          slot.reconnectTimer = void 0;
+        }
+        slot.reconnectPending = false;
+        ctx.events.emit("mcp.server.disconnected", {
+          name: slot.cfg.name,
+          reason: err instanceof Error ? err.message : "unknown"
+        });
+        return;
+      }
+      const delay = 500 * 2 ** attempt;
+      await new Promise((r) => setTimeout(r, delay));
+      if (slot.state === "disconnected" || ctx.servers.has(slot.cfg.name) && ctx.servers.get(slot.cfg.name) !== slot) {
+        return;
+      }
+    }
+  }
+}
+
+// src/registry-idle.ts
+async function sleepIdleSlot(ctx, slot) {
+  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();
+    slot.client = void 0;
+  }
+  slot.onDisconnect = void 0;
+  slot.state = "dormant";
+  slot.operations.sleepCount++;
+  ctx.recordOperation(slot, "sleep", "idle-timeout");
+  ctx.log.info(`MCP server "${slot.cfg.name}" idle \u2014 sleeping (tools stay registered)`);
+  ctx.events.emit("mcp.server.disconnected", { name: slot.cfg.name, reason: "idle-sleep" });
+}
+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) {
+      await sleepIdleSlot(ctx, slot);
+    }
+  }
+  return [...ctx.servers.values()].some(
+    (slot) => slot.lazy && slot.state === "connected" && slot.client
+  );
+}
+
 // src/registry.ts
 var MCPRegistry = class _MCPRegistry {
   servers = /* @__PURE__ */ new Map();
@@ -3871,7 +4142,7 @@ var MCPRegistry = class _MCPRegistry {
    * cache yet, do a one-time cold discovery connect to learn + cache the tools.
    */
   async startLazy(slot) {
-    const cacheDir = expectDefined(this.cacheDir);
+    const cacheDir = expectDefined2(this.cacheDir);
     const hash = manifestConfigHash(slot.cfg);
     const cached = await readCapabilityManifest(cacheDir, slot.cfg.name, hash);
     if (cached) {
@@ -4118,121 +4389,45 @@ var MCPRegistry = class _MCPRegistry {
   toolNamesForSlot(s) {
     return s.toolNames.length > 0 ? s.toolNames.slice() : (s.lazyTools ?? []).map((t) => t.name);
   }
-  /**
-   * Wrap + register (or cache) a server's tools. Lazy servers get resolver-backed
-   * wrappers that spawn the process on first use; eager servers bind the live
-   * client directly. Honours token-saving `lazyMode` (cache, don't register) and
-   * a register-once guard for lazy resolver wrappers (so a wake/reconnect reuses
-   * the existing registrations rather than churning the tool list).
-   */
-  applyTools(slot, tools, client) {
-    if (slot.lazy && slot.registeredLazy && !this.lazyMode) return;
-    const allowed = slot.cfg.allowedTools;
-    const filtered = tools.filter((t) => !allowed || allowed.includes(t.name));
-    const clientArg = slot.lazy ? () => this.ensureConnected(slot.cfg.name) : expectDefined(client);
-    const wrapped = filtered.map(
-      (t) => wrapMCPTool(slot.cfg.name, t, clientArg, slot.cfg.permission ?? "confirm", {
-        onStart: () => {
-          slot.operations.inFlightCalls++;
-          slot.operations.peakInFlightCalls = Math.max(
-            slot.operations.peakInFlightCalls,
-            slot.operations.inFlightCalls
-          );
-          this.recordOperation(slot, "call", "started", void 0, void 0, false);
-        },
-        onFinish: ({ durationMs, ok }) => {
-          slot.operations.inFlightCalls = Math.max(0, slot.operations.inFlightCalls - 1);
-          pushBounded(
-            slot.operations.callSamples,
-            durationMs,
-            MCP_OPERATION_LIMITS.LATENCY_SAMPLES
-          );
-          if (ok) {
-            this.recordSuccess(slot);
-            this.recordOperation(slot, "call", "ok", void 0, durationMs, false);
-          } else {
-            this.recordFailure(slot, "tool", "tool-call-failed", durationMs);
-          }
-        }
-      })
-    );
-    if (this.lazyMode) {
-      slot.lazyTools = wrapped;
-      return;
-    }
-    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 registered`, err);
-      }
-    }
-    if (slot.lazy && wrapped.length > 0) slot.registeredLazy = true;
+  connectContext() {
+    return {
+      servers: this.servers,
+      toolRegistry: this.toolRegistry,
+      events: this.events,
+      log: this.log,
+      lazyMode: this.lazyMode,
+      cacheDir: this.cacheDir,
+      authorizationProviderFactory: this.authorizationProviderFactory,
+      operationListeners: this.operationListeners,
+      ensureConnected: (name) => this.ensureConnected(name),
+      recordOperation: (slot, kind, reason, failureKind, durationMs, retain) => this.recordOperation(slot, kind, reason, failureKind, durationMs, retain),
+      recordSuccess: (slot, resetFailures) => this.recordSuccess(slot, resetFailures),
+      recordFailure: (slot, failureKind, reason, durationMs) => this.recordFailure(slot, failureKind, reason, durationMs),
+      onChildExit: this.onChildExit,
+      onTransportDisconnect: this.onTransportDisconnect,
+      onToolsChanged: this.onToolsChanged,
+      addCatalogListeners: (client) => this.addCatalogListeners(client),
+      removeCatalogListeners: (client) => this.removeCatalogListeners(client),
+      ensureIdleSweep: () => this.ensureIdleSweep()
+    };
   }
-  async discoverCapabilities(slot, client) {
-    const startedAt = Date.now();
-    slot.serverMetadata = client.getServerMetadata();
-    const capabilities = slot.serverMetadata?.capabilities;
-    if (capabilities?.resources) {
-      try {
-        slot.resources = await collectCatalogPages(
-          (cursor) => client.listResources(cursor ? { cursor } : {}),
-          (page) => page.resources
-        );
-      } catch (err) {
-        slot.resources = void 0;
-        this.recordFailure(slot, "protocol", "resource-discovery-failed");
-        this.log.warn(`MCP server "${slot.cfg.name}" resource discovery failed`, err);
-      }
-      try {
-        slot.resourceTemplates = await collectCatalogPages(
-          (cursor) => client.listResourceTemplates(cursor ? { cursor } : {}),
-          (page) => page.resourceTemplates
-        );
-      } catch (err) {
-        slot.resourceTemplates = void 0;
-        this.recordFailure(slot, "protocol", "resource-template-discovery-failed");
-        this.log.warn(`MCP server "${slot.cfg.name}" resource template discovery failed`, err);
-      }
-    } else {
-      slot.resources = void 0;
-      slot.resourceTemplates = void 0;
-    }
-    if (capabilities?.prompts) {
-      try {
-        slot.prompts = await collectCatalogPages(
-          (cursor) => client.listPrompts(cursor ? { cursor } : {}),
-          (page) => page.prompts
-        );
-      } catch (err) {
-        slot.prompts = void 0;
-        this.recordFailure(slot, "protocol", "prompt-discovery-failed");
-        this.log.warn(`MCP server "${slot.cfg.name}" prompt discovery failed`, err);
-      }
-    } else {
-      slot.prompts = void 0;
-    }
-    const durationMs = Date.now() - startedAt;
-    pushBounded(slot.operations.discoverySamples, durationMs, MCP_OPERATION_LIMITS.LATENCY_SAMPLES);
-    this.recordOperation(slot, "discover", "complete", void 0, durationMs, false);
+  idleContext() {
+    return {
+      servers: this.servers,
+      idleTimeoutMs: this.idleTimeoutMs,
+      events: this.events,
+      log: this.log,
+      recordOperation: (slot, kind, reason) => this.recordOperation(slot, kind, reason),
+      onChildExit: this.onChildExit,
+      onToolsChanged: this.onToolsChanged,
+      removeCatalogListeners: (client) => this.removeCatalogListeners(client)
+    };
+  }
+  applyTools(slot, tools, client) {
+    applySlotTools(this.connectContext(), slot, tools, client);
   }
   async persistCapabilityManifest(slot) {
-    if (!slot.lazy || !this.cacheDir) return;
-    const cacheDir = this.cacheDir;
-    const previous = slot.manifestWrite ?? Promise.resolve();
-    const pending = previous.then(
-      () => writeCapabilityManifest(cacheDir, slot.cfg.name, manifestConfigHash(slot.cfg), {
-        tools: slot.client?.listTools() ?? [],
-        serverMetadata: slot.serverMetadata,
-        resources: slot.resources,
-        resourceTemplates: slot.resourceTemplates,
-        prompts: slot.prompts
-      })
-    );
-    slot.manifestWrite = pending;
-    await pending;
-    if (slot.manifestWrite === pending) slot.manifestWrite = void 0;
+    return persistSlotCapabilityManifest(this.cacheDir, slot);
   }
   /** Start the shared idle sweep timer once (unref'd so it never holds the process). */
   ensureIdleSweep() {
@@ -4242,49 +4437,14 @@ var MCPRegistry = class _MCPRegistry {
     }, MCP_CONSTANTS.IDLE.SWEEP_INTERVAL_MS);
     this.idleTimer.unref?.();
   }
-  /** Auto-sleep connected lazy servers that have been idle past the timeout. */
   async sweepIdle() {
     if (this.idleTimeoutMs <= 0) return;
-    const now = Date.now();
-    for (const slot of this.servers.values()) {
-      if (slot.lazy && slot.state === "connected" && slot.client && now - slot.lastUsed > this.idleTimeoutMs) {
-        await this.sleepIdle(slot);
-      }
-    }
-    const hasConnectedLazyServer = [...this.servers.values()].some(
-      (slot) => slot.lazy && slot.state === "connected" && slot.client
-    );
-    if (!hasConnectedLazyServer && this.idleTimer) {
+    const hasConnectedLazy = await sweepIdleSlots(this.idleContext());
+    if (!hasConnectedLazy && this.idleTimer) {
       clearInterval(this.idleTimer);
       this.idleTimer = void 0;
     }
   }
-  /**
-   * Soft stop: close the server process but KEEP its resolver wrappers and
-   * cached manifest registered, so the next tool call transparently re-wakes it.
-   * Distinct from {@link stop} (full teardown for disable/remove).
-   */
-  async sleepIdle(slot) {
-    slot.reconnectPending = false;
-    if (slot.reconnectTimer) {
-      clearTimeout(slot.reconnectTimer);
-      slot.reconnectTimer = void 0;
-    }
-    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();
-      slot.client = void 0;
-    }
-    slot.onDisconnect = void 0;
-    slot.state = "dormant";
-    slot.operations.sleepCount++;
-    this.recordOperation(slot, "sleep", "idle-timeout");
-    this.log.info(`MCP server "${slot.cfg.name}" idle \u2014 sleeping (tools stay registered)`);
-    this.events.emit("mcp.server.disconnected", { name: slot.cfg.name, reason: "idle-sleep" });
-  }
   /**
    * Catalog of every server ever registered with this registry — includes
    * servers that are stopped, failed, or not yet started.
@@ -4452,134 +4612,14 @@ var MCPRegistry = class _MCPRegistry {
     );
   }
   async attemptConnect(slot) {
-    const MAX_ATTEMPTS = MCP_CONSTANTS.RECONNECT.MAX_ATTEMPTS;
-    let attempt = 0;
-    while (attempt < MAX_ATTEMPTS) {
-      if (this.servers.has(slot.cfg.name) && this.servers.get(slot.cfg.name) !== slot) {
-        return;
-      }
-      attempt++;
-      const startedAt = Date.now();
-      slot.state = attempt === 1 ? "connecting" : "reconnecting";
-      slot.attempts = attempt;
-      let client;
-      let boundDisconnect;
-      try {
-        client = new MCPClient({
-          name: slot.cfg.name,
-          transport: slot.cfg.transport,
-          command: slot.cfg.command,
-          args: slot.cfg.args,
-          env: slot.cfg.env,
-          url: slot.cfg.url,
-          headers: slot.cfg.headers,
-          startupTimeoutMs: slot.cfg.startupTimeoutMs,
-          requestTimeoutMs: slot.cfg.requestTimeoutMs,
-          passthroughEnv: slot.cfg.passthroughEnv,
-          authorizationProvider: this.authorizationProviderFactory?.(slot.cfg)
-        });
-        if (slot.cfg.transport === "stdio") {
-          client.addExitListener(this.onChildExit);
-        } else {
-          boundDisconnect = () => this.onTransportDisconnect(slot.cfg.name);
-          client.addDisconnectListener(boundDisconnect);
-        }
-        client.addToolsChangedListener(this.onToolsChanged);
-        this.addCatalogListeners(client);
-        await client.connect();
-        if (slot.state === "disconnected" || this.servers.has(slot.cfg.name) && this.servers.get(slot.cfg.name) !== slot) {
-          client.removeExitListener(this.onChildExit);
-          if (boundDisconnect) client.removeDisconnectListener(boundDisconnect);
-          client.removeToolsChangedListener(this.onToolsChanged);
-          this.removeCatalogListeners(client);
-          await client.close().catch(() => {
-          });
-          return;
-        }
-        if (slot.client && slot.client !== client) {
-          const prior = slot.client;
-          const priorDisconnect = slot.onDisconnect;
-          slot.client.removeExitListener(this.onChildExit);
-          if (priorDisconnect) prior.removeDisconnectListener(priorDisconnect);
-          prior.removeToolsChangedListener(this.onToolsChanged);
-          this.removeCatalogListeners(prior);
-          prior.close().catch(() => {
-          });
-        }
-        slot.client = client;
-        slot.onDisconnect = boundDisconnect;
-        const isReconnect = slot.reconnectCycles > 0 || attempt > 1;
-        slot.state = "connected";
-        slot.reconnectCycles = 0;
-        const mc = client;
-        const discovered = mc.listTools();
-        await this.discoverCapabilities(slot, mc);
-        await this.persistCapabilityManifest(slot);
-        this.applyTools(slot, discovered, mc);
-        const durationMs = Date.now() - startedAt;
-        pushBounded(
-          slot.operations.connectionSamples,
-          durationMs,
-          MCP_OPERATION_LIMITS.LATENCY_SAMPLES
-        );
-        this.recordSuccess(slot, (slot.operations.lastFailureAt ?? 0) < startedAt);
-        this.recordOperation(
-          slot,
-          isReconnect ? "reconnect" : "connect",
-          "connected",
-          void 0,
-          durationMs
-        );
-        slot.lastUsed = Date.now();
-        if (slot.lazy) this.ensureIdleSweep();
-        this.events.emit(isReconnect ? "mcp.server.reconnected" : "mcp.server.connected", {
-          name: slot.cfg.name,
-          toolCount: slot.toolNames.length
-        });
-        return;
-      } catch (err) {
-        this.recordFailure(slot, "transport", "connect-attempt-failed", Date.now() - startedAt);
-        this.log.warn(`MCP server "${slot.cfg.name}" connect attempt ${attempt} failed`, err);
-        if (client) {
-          client.removeExitListener(this.onChildExit);
-          if (boundDisconnect) client.removeDisconnectListener(boundDisconnect);
-          client.removeToolsChangedListener(this.onToolsChanged);
-          this.removeCatalogListeners(client);
-          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;
-          if (slot.reconnectTimer) {
-            clearTimeout(slot.reconnectTimer);
-            slot.reconnectTimer = void 0;
-          }
-          slot.reconnectPending = false;
-          this.events.emit("mcp.server.disconnected", {
-            name: slot.cfg.name,
-            reason: err instanceof Error ? err.message : "unknown"
-          });
-          return;
-        }
-        const delay = 500 * 2 ** attempt;
-        await new Promise((r) => setTimeout(r, delay));
-        if (slot.state === "disconnected" || this.servers.has(slot.cfg.name) && this.servers.get(slot.cfg.name) !== slot) {
-          return;
-        }
-      }
-    }
+    return attemptConnectSlot(this.connectContext(), slot);
   }
 };
 
 // src/server.ts
 import { timingSafeEqual as timingSafeEqual2 } from "node:crypto";
 import { createServer } from "node:http";
-import { expectDefined as expectDefined2, toErrorMessage as toErrorMessage2, validateAgainstSchema } from "@wrongstack/core/utils";
+import { expectDefined as expectDefined3, toErrorMessage as toErrorMessage2, validateAgainstSchema } from "@wrongstack/core/utils";
 var PARSE_ERROR = -32700;
 var INVALID_REQUEST = -32600;
 var METHOD_NOT_FOUND = -32601;
@@ -4627,7 +4667,7 @@ var MCPServer = class {
       const result = await this.dispatch(msg.method, msg.params);
       if (result === METHOD_NOT_FOUND_SENTINEL) {
         return this.encodeError(
-          expectDefined2(msg.id),
+          expectDefined3(msg.id),
           METHOD_NOT_FOUND,
           `Method not found: ${msg.method}`
         );
@@ -4637,7 +4677,7 @@ var MCPServer = class {
       const message = toErrorMessage2(err);
       this.logger?.warn?.(`MCP server: method "${msg.method}" threw: ${message}`);
       const code = err instanceof InvalidToolArgumentsError ? INVALID_PARAMS : INTERNAL_ERROR;
-      return this.encodeError(expectDefined2(msg.id), code, message);
+      return this.encodeError(expectDefined3(msg.id), code, message);
     }
   }
   async dispatch(method, params) {

package/dist/registry-connect-loop.d.ts

@@ -0,0 +1,34 @@
+import type { EventBus } from '@wrongstack/core/kernel';
+import type { ToolRegistry } from '@wrongstack/core/registry';
+import type { Logger } from '@wrongstack/core/types';
+import { MCPClient, type MCPTool } from './client.js';
+import { type MCPFailureKind, type MCPOperationKind, type MCPOperationListener } from './operations.js';
+import type { ServerSlot } from './registry-slots.js';
+import type { MCPRegistryOptions } from './registry-types.js';
+export interface RegistryConnectContext {
+    servers: Map<string, ServerSlot>;
+    toolRegistry: ToolRegistry;
+    events: EventBus;
+    log: Logger;
+    lazyMode: boolean;
+    cacheDir?: string | undefined;
+    authorizationProviderFactory?: MCPRegistryOptions['authorizationProviderFactory'] | undefined;
+    operationListeners: Set<MCPOperationListener>;
+    ensureConnected: (name: string) => Promise<MCPClient>;
+    recordOperation: (slot: ServerSlot, kind: MCPOperationKind, reason?: string, failureKind?: MCPFailureKind, durationMs?: number, retain?: boolean) => void;
+    recordSuccess: (slot: ServerSlot, resetFailures?: boolean) => void;
+    recordFailure: (slot: ServerSlot, failureKind: MCPFailureKind, reason: string, durationMs?: number) => void;
+    onChildExit: (name: string, code: number | null, signal: string | null) => void;
+    onTransportDisconnect: (name: string) => void;
+    onToolsChanged: (name: string, tools: {
+        name: string;
+    }[]) => void;
+    addCatalogListeners: (client: MCPClient) => void;
+    removeCatalogListeners: (client: MCPClient) => void;
+    ensureIdleSweep: () => void;
+}
+export declare function applySlotTools(ctx: RegistryConnectContext, slot: ServerSlot, tools: MCPTool[], client?: MCPClient | undefined): void;
+export declare function discoverSlotCapabilities(ctx: RegistryConnectContext, slot: ServerSlot, client: MCPClient): Promise<void>;
+export declare function persistSlotCapabilityManifest(cacheDir: string | undefined, slot: ServerSlot): Promise<void>;
+export declare function attemptConnectSlot(ctx: RegistryConnectContext, slot: ServerSlot): Promise<void>;
+//# sourceMappingURL=registry-connect-loop.d.ts.map

package/dist/registry-idle.d.ts

@@ -0,0 +1,20 @@
+import type { EventBus } from '@wrongstack/core/kernel';
+import type { Logger } from '@wrongstack/core/types';
+import type { MCPClient } from './client.js';
+import type { MCPOperationKind } from './operations.js';
+import type { ServerSlot } from './registry-slots.js';
+export interface RegistryIdleContext {
+    servers: Map<string, ServerSlot>;
+    idleTimeoutMs: number;
+    events: EventBus;
+    log: Logger;
+    recordOperation: (slot: ServerSlot, kind: MCPOperationKind, reason?: string) => void;
+    onChildExit: (name: string, code: number | null, signal: string | null) => void;
+    onToolsChanged: (name: string, tools: {
+        name: string;
+    }[]) => void;
+    removeCatalogListeners: (client: MCPClient) => void;
+}
+export declare function sleepIdleSlot(ctx: RegistryIdleContext, slot: ServerSlot): Promise<void>;
+export declare function sweepIdleSlots(ctx: RegistryIdleContext): Promise<boolean>;
+//# sourceMappingURL=registry-idle.d.ts.map

package/dist/registry.d.ts

@@ -105,26 +105,13 @@ export declare class MCPRegistry {
      * tools are connected but intentionally not registered).
      */
     private toolNamesForSlot;
-    /**
-     * Wrap + register (or cache) a server's tools. Lazy servers get resolver-backed
-     * wrappers that spawn the process on first use; eager servers bind the live
-     * client directly. Honours token-saving `lazyMode` (cache, don't register) and
-     * a register-once guard for lazy resolver wrappers (so a wake/reconnect reuses
-     * the existing registrations rather than churning the tool list).
-     */
+    private connectContext;
+    private idleContext;
     private applyTools;
-    private discoverCapabilities;
     private persistCapabilityManifest;
     /** Start the shared idle sweep timer once (unref'd so it never holds the process). */
     private ensureIdleSweep;
-    /** Auto-sleep connected lazy servers that have been idle past the timeout. */
     private sweepIdle;
-    /**
-     * Soft stop: close the server process but KEEP its resolver wrappers and
-     * cached manifest registered, so the next tool call transparently re-wakes it.
-     * Distinct from {@link stop} (full teardown for disable/remove).
-     */
-    private sleepIdle;
     /**
      * Catalog of every server ever registered with this registry — includes
      * servers that are stopped, failed, or not yet started.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrongstack/mcp",
-  "version": "0.306.4",
+  "version": "0.307.0",
   "license": "MIT",
   "description": "WrongStack Model Context Protocol client and registry: stdio, SSE, and streamable HTTP transports.",
   "repository": {
@@ -26,12 +26,12 @@
     "!dist/**/*.map"
   ],
   "dependencies": {
-    "@wrongstack/core": "0.306.4"
+    "@wrongstack/core": "0.307.0"
   },
   "devDependencies": {
-    "@types/node": "^26.1.2",
+    "@types/node": "^26.2.0",
     "typescript": "^7.0.2",
-    "undici-types": "^8.9.0",
+    "undici-types": "^8.10.0",
     "vitest": "^4.1.10"
   },
   "publishConfig": {