@ouro.bot/cli 0.1.0-alpha.92 → 0.1.0-alpha.920

package/dist/repertoire/mcp-manager.js

@@ -1,195 +1,483 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.McpManager = void 0;
 exports.getSharedMcpManager = getSharedMcpManager;
+exports.releaseRuntimeMcpServers = releaseRuntimeMcpServers;
 exports.shutdownSharedMcpManager = shutdownSharedMcpManager;
 exports.resetSharedMcpManager = resetSharedMcpManager;
+const path = __importStar(require("node:path"));
 const mcp_client_1 = require("./mcp-client");
 const identity_1 = require("../heart/identity");
 const runtime_1 = require("../nerves/runtime");
+const credential_access_1 = require("./credential-access");
+const plugin_mcp_1 = require("./plugin-mcp");
+const tool_arguments_1 = require("./tool-arguments");
+const mcp_tools_1 = require("./mcp-tools");
 const MAX_RESTART_RETRIES = 5;
 const RESTART_DELAY_MS = 1000;
+function isOwner(value) {
+    return typeof value === "object" && value !== null
+        && "agentName" in value && typeof value.agentName === "string" && value.agentName.length > 0
+        && "agentRoot" in value && typeof value.agentRoot === "string" && path.isAbsolute(value.agentRoot);
+}
+function captureOwner(owner) {
+    if (!isOwner(owner)) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn", event: "mcp.owner_invalid", component: "repertoire",
+            message: "MCP requires an explicit owner", meta: { reason: "agent name and absolute root are required" },
+        });
+        throw new mcp_tools_1.McpCallRejectedError("MCP requires an explicit owner");
+    }
+    return Object.freeze({ agentName: owner.agentName, agentRoot: owner.agentRoot });
+}
+function sameOwner(left, right) {
+    return left.agentName === right.agentName && left.agentRoot === right.agentRoot;
+}
+function serverKey(owner, name) {
+    return JSON.stringify([owner.agentName, owner.agentRoot, name]);
+}
+function buildMergedServerConfig(owner, runtimeServers) {
+    const config = (0, identity_1.loadAgentConfig)(owner);
+    const desired = new Map();
+    for (const plugin of (0, plugin_mcp_1.listPluginMcpServers)(undefined, owner)) {
+        if (desired.has(plugin.serverName))
+            throw new mcp_tools_1.McpCallRejectedError(`MCP server name collision: ${plugin.serverName}`);
+        desired.set(plugin.serverName, {
+            config: (0, plugin_mcp_1.pluginMcpServerToConfig)(plugin), source: "plugin", pluginId: plugin.pluginId,
+        });
+    }
+    for (const [name, server] of Object.entries(config.mcpServers ?? {})) {
+        desired.set(name, { config: server, source: "builtin" });
+    }
+    for (const [name, server] of Object.entries(runtimeServers ?? {})) {
+        desired.set(name, { config: server, source: "runtime" });
+    }
+    return desired;
+}
+function configurationDigest(owner, desired) {
+    return (0, tool_arguments_1.digestJson)({
+        agentName: owner.agentName, agentRoot: owner.agentRoot,
+        source: desired.source, pluginId: desired.pluginId ?? null,
+        command: desired.config.command, args: desired.config.args ?? [],
+        env: desired.config.env ?? {}, cwd: desired.config.cwd ?? "",
+    });
+}
 class McpManager {
     servers = new Map();
-    shuttingDown = false;
-    async start(servers) {
+    desiredGenerations = new Map();
+    nextGeneration = 0;
+    lifecycle = Promise.resolve();
+    shutdownPromise;
+    constructor() {
         (0, runtime_1.emitNervesEvent)({
-            event: "mcp.manager_start",
-            component: "repertoire",
-            message: "starting MCP manager",
-            meta: { serverCount: Object.keys(servers).length },
+            event: "mcp.manager_start", component: "repertoire",
+            message: "starting MCP manager", meta: { serverCount: 0 },
         });
-        const entries = Object.entries(servers);
-        for (const [name, config] of entries) {
-            await this.connectServer(name, config);
-        }
     }
-    listAllTools() {
-        const result = [];
-        for (const [name, entry] of this.servers) {
-            result.push({ server: name, tools: entry.cachedTools });
-        }
+    // One lifecycle tail; external tool and canary results do not hold it.
+    enqueue(operation) {
+        const result = this.lifecycle.then(operation);
+        this.lifecycle = result.then(() => undefined, () => undefined);
         return result;
     }
-    async callTool(server, tool, args) {
-        const entry = this.servers.get(server);
-        if (!entry) {
-            throw new Error(`Unknown server: ${server}`);
+    enqueueBackground(operation) {
+        void this.enqueue(operation).catch((error) => {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error", event: "mcp.lifecycle_error", component: "repertoire",
+                message: "MCP background lifecycle operation failed",
+                meta: { reason: error instanceof Error ? error.message : String(error) },
+            });
+        });
+    }
+    async start(ownerInput, servers, pluginOrigins = {}) {
+        const owner = captureOwner(ownerInput);
+        const desired = new Map(Object.entries(structuredClone(servers)).map(([name, config]) => [
+            name, { config, source: pluginOrigins[name] ? "plugin" : "builtin", pluginId: pluginOrigins[name] },
+        ]));
+        return this.enqueue(async () => {
+            if (this.shutdownPromise)
+                return null;
+            await this.applyDesired(owner, desired);
+            return this.shutdownPromise ? null : this.freezeView(owner);
+        });
+    }
+    async reconcile(ownerInput, runtimeServers) {
+        const owner = captureOwner(ownerInput);
+        const runtime = runtimeServers ? structuredClone(runtimeServers) : undefined;
+        return this.enqueue(async () => {
+            if (this.shutdownPromise)
+                return null;
+            try {
+                const desired = buildMergedServerConfig(owner, runtime);
+                await this.applyDesired(owner, desired);
+                return this.shutdownPromise || desired.size === 0 ? null : this.freezeView(owner);
+            }
+            catch (error) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn", event: "mcp.reconcile_error", component: "repertoire",
+                    message: "failed to reconcile MCP servers",
+                    meta: { reason: error instanceof Error ? error.message : String(error) },
+                });
+                for (const entry of this.ownedEntries(owner))
+                    this.removeEntry(entry);
+                return null;
+            }
+        });
+    }
+    listAllTools(owner) {
+        captureOwner(owner);
+        return this.ownedEntries(owner).filter((entry) => this.isCurrentEntry(entry)).map((entry) => ({
+            server: entry.name, tools: structuredClone(entry.cachedTools), pluginId: entry.pluginId,
+        }));
+    }
+    async callTool(binding, args, ownerInput) {
+        const owner = captureOwner(ownerInput);
+        const call = await this.enqueue(async () => {
+            let entry = this.currentBinding(binding, owner);
+            if (!entry.client.isConnected()) {
+                await this.recoverStaleTransport(entry, "pre-call disconnected");
+                entry = this.currentBinding(binding, owner);
+                if (!entry.client.isConnected())
+                    throw new mcp_tools_1.McpCallRejectedError(`Server "${entry.name}" is disconnected`);
+            }
+            return { entry, result: entry.client.callTool(binding.rawName, args) };
+        });
+        try {
+            return await call.result;
         }
-        if (!entry.client.isConnected()) {
-            throw new Error(`Server "${server}" is disconnected`);
+        catch (error) {
+            if (!(0, mcp_client_1.isMcpTransportError)(error))
+                throw error;
+            const reason = error instanceof Error ? error.message : String(error);
+            // Recovery prepares later calls; the server may already have performed this one.
+            this.enqueueBackground(async () => {
+                if (this.isCurrentEntry(call.entry))
+                    await this.recoverStaleTransport(call.entry, reason);
+            });
+            throw error;
+        }
+    }
+    async validateToolBinding(binding, ownerInput) {
+        const owner = captureOwner(ownerInput);
+        await this.enqueue(() => { this.currentBinding(binding, owner); });
+    }
+    async runCanaries(ownerInput) {
+        const owner = captureOwner(ownerInput);
+        const entries = await this.enqueue(() => this.ownedEntries(owner));
+        const results = [];
+        for (const entry of entries) {
+            let current = entry;
+            try {
+                const refresh = await this.enqueue(async () => {
+                    if (!this.isCurrentEntry(entry))
+                        return null;
+                    if (!entry.client.isConnected())
+                        await this.recoverStaleTransport(entry, "canary disconnected");
+                    const recovered = this.servers.get(serverKey(owner, entry.name));
+                    if (!recovered || !this.isCurrentEntry(recovered) || !recovered.client.isConnected())
+                        return null;
+                    current = recovered;
+                    return { result: recovered.client.refreshTools() };
+                });
+                if (!refresh) {
+                    results.push({ server: entry.name, ok: false, detail: "disconnected after recovery attempt" });
+                    continue;
+                }
+                const tools = await refresh.result;
+                const updated = await this.enqueue(() => {
+                    if (!this.isCurrentEntry(current))
+                        return false;
+                    current.cachedTools = structuredClone(tools);
+                    current.consecutiveFailures = 0;
+                    return true;
+                });
+                results.push({
+                    server: entry.name, ok: updated,
+                    detail: updated ? `${tools.length} tools listed` : "server changed during canary",
+                });
+            }
+            catch (error) {
+                const reason = error instanceof Error ? error.message : String(error);
+                if ((0, mcp_client_1.isMcpTransportError)(error)) {
+                    await this.enqueue(async () => {
+                        if (this.isCurrentEntry(current))
+                            await this.recoverStaleTransport(current, reason);
+                    });
+                }
+                results.push({ server: entry.name, ok: false, detail: reason });
+            }
         }
-        return entry.client.callTool(tool, args);
+        return results;
     }
     shutdown() {
-        this.shuttingDown = true;
-        (0, runtime_1.emitNervesEvent)({
-            event: "mcp.manager_stop",
-            component: "repertoire",
-            message: "shutting down MCP manager",
-            meta: { serverCount: this.servers.size },
+        if (this.shutdownPromise)
+            return this.shutdownPromise;
+        // Publish closing before queued cleanup so pending network work cannot revive clients.
+        this.shutdownPromise = this.enqueue(() => {
+            (0, runtime_1.emitNervesEvent)({
+                event: "mcp.manager_end", component: "repertoire",
+                message: "shutting down MCP manager", meta: { serverCount: this.servers.size },
+            });
+            for (const entry of [...this.servers.values()])
+                this.removeEntry(entry);
+            this.desiredGenerations.clear();
         });
-        for (const [, entry] of this.servers) {
-            entry.client.shutdown();
+        return this.shutdownPromise;
+    }
+    ownedEntries(owner) {
+        return [...this.servers.values()].filter((entry) => sameOwner(entry.owner, owner));
+    }
+    isCurrentEntry(entry) {
+        const key = serverKey(entry.owner, entry.name);
+        return !this.shutdownPromise && this.servers.get(key) === entry
+            && this.desiredGenerations.get(key) === entry.generation;
+    }
+    freezeView(owner) {
+        const entries = this.ownedEntries(owner).filter((entry) => this.isCurrentEntry(entry)).map((entry) => Object.freeze({
+            server: entry.name, source: entry.source, pluginId: entry.pluginId,
+            configDigest: entry.configDigest, generation: entry.generation,
+            tools: (0, tool_arguments_1.freezeToolValue)(structuredClone(entry.cachedTools)),
+        }));
+        return Object.freeze({ manager: this, owner, entries: Object.freeze(entries) });
+    }
+    matchesBinding(entry, binding, owner) {
+        if (binding.manager !== this || !sameOwner(binding, owner) || !sameOwner(entry.owner, owner)
+            || !this.isCurrentEntry(entry) || entry.name !== binding.server
+            || entry.source !== binding.source || entry.pluginId !== binding.pluginId
+            || entry.configDigest !== binding.configDigest || entry.generation !== binding.generation)
+            return false;
+        const tools = entry.cachedTools.filter((tool) => tool.name === binding.rawName);
+        if (tools.length !== 1)
+            return false;
+        const schema = (0, mcp_tools_1.mcpToolSchema)({ server: entry.name, pluginId: entry.pluginId }, tools[0]);
+        return schema.function.name === binding.surfacedName && (0, tool_arguments_1.digestJson)(schema) === binding.schemaDigest;
+    }
+    currentBinding(binding, owner) {
+        const entry = this.servers.get(serverKey(owner, binding.server));
+        if (!entry || !this.matchesBinding(entry, binding, owner)) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn", event: "mcp.tool_rejected", component: "repertoire",
+                message: "MCP tool binding is no longer current", meta: { reason: "stale or unavailable owned tool" },
+            });
+            throw new mcp_tools_1.McpCallRejectedError("MCP tool binding is stale or unavailable");
         }
-        this.servers.clear();
+        return entry;
     }
-    async connectServer(name, config) {
-        const client = new mcp_client_1.McpClient(config);
-        const entry = {
-            name,
-            config,
-            client,
-            cachedTools: [],
-            consecutiveFailures: 0,
-        };
-        this.servers.set(name, entry);
-        client.onClose(() => {
-            if (this.shuttingDown)
+    removeEntry(entry) {
+        const key = serverKey(entry.owner, entry.name);
+        this.desiredGenerations.delete(key);
+        if (entry.restartTimer)
+            clearTimeout(entry.restartTimer);
+        entry.client.shutdown();
+        this.servers.delete(key);
+    }
+    async applyDesired(owner, desired) {
+        for (const [name, requested] of desired) {
+            if (this.shutdownPromise)
                 return;
-            this.handleServerCrash(name);
-        });
+            const descriptor = { ...requested, config: structuredClone(requested.config) };
+            const configDigest = configurationDigest(owner, descriptor);
+            const current = this.servers.get(serverKey(owner, name));
+            if (current && this.isCurrentEntry(current) && current.configDigest === configDigest)
+                continue;
+            if (current) {
+                (0, runtime_1.emitNervesEvent)({
+                    event: "mcp.server_changed", component: "repertoire",
+                    message: `reconnecting changed MCP server: ${name}`, meta: { server: name },
+                });
+                this.removeEntry(current);
+            }
+            else {
+                (0, runtime_1.emitNervesEvent)({
+                    event: "mcp.server_added", component: "repertoire",
+                    message: `connecting new MCP server: ${name}`, meta: { server: name },
+                });
+            }
+            await this.connectServer({
+                ...descriptor, owner, name, configDigest, generation: ++this.nextGeneration, consecutiveFailures: 0,
+            });
+        }
+        for (const entry of this.ownedEntries(owner)) {
+            if (desired.has(entry.name))
+                continue;
+            (0, runtime_1.emitNervesEvent)({
+                event: "mcp.server_removed", component: "repertoire",
+                message: `disconnecting removed MCP server: ${entry.name}`, meta: { server: entry.name },
+            });
+            this.removeEntry(entry);
+        }
+    }
+    async resolveVaultEnv(env, owner) {
+        const resolved = { ...env };
+        if (!Object.values(resolved).some((value) => /^vault:/.test(value)))
+            return resolved;
+        const store = (0, credential_access_1.getCredentialStore)(owner.agentName);
+        for (const [key, value] of Object.entries(resolved)) {
+            const match = value.match(/^vault:([^/]+)\/(.+)$/);
+            if (!match)
+                continue;
+            const [, domain, field] = match;
+            try {
+                resolved[key] = await store.getRawSecret(domain, field);
+            }
+            catch (error) {
+                const reason = error instanceof Error ? error.message : String(error);
+                const classification = reason.includes("no credential found") ? "item not found"
+                    : reason.includes("field") && reason.includes("not found") ? "field empty" : "vault unreachable";
+                throw new Error(`vault:${domain}/${field} could not be resolved: ${classification}`);
+            }
+        }
+        return resolved;
+    }
+    async connectServer(desired) {
+        const key = serverKey(desired.owner, desired.name);
+        this.desiredGenerations.set(key, desired.generation);
+        let config = desired.config;
+        if (config.env) {
+            try {
+                config = { ...config, env: await this.resolveVaultEnv(config.env, desired.owner) };
+            }
+            catch (error) {
+                const reason = error instanceof Error ? error.message : String(error);
+                (0, runtime_1.emitNervesEvent)({
+                    level: "error", event: "mcp.vault_resolve_error", component: "repertoire",
+                    message: `skipping MCP server "${desired.name}": ${reason}`, meta: { server: desired.name, reason },
+                });
+                this.desiredGenerations.delete(key);
+                return;
+            }
+        }
+        if (this.shutdownPromise || this.desiredGenerations.get(key) !== desired.generation)
+            return;
+        const client = new mcp_client_1.McpClient(config);
+        const entry = { ...desired, client, cachedTools: [] };
+        this.servers.set(key, entry);
+        client.onClose(() => { this.enqueueBackground(() => this.handleServerCrash(entry)); });
         try {
             await client.connect();
+            if (!this.isCurrentEntry(entry)) {
+                client.shutdown();
+                return;
+            }
             const tools = await client.listTools();
-            entry.cachedTools = tools;
-            entry.consecutiveFailures = 0;
+            if (!this.isCurrentEntry(entry)) {
+                client.shutdown();
+                return;
+            }
+            entry.cachedTools = structuredClone(tools);
         }
         catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
             (0, runtime_1.emitNervesEvent)({
-                level: "error",
-                event: "mcp.connect_error",
-                component: "repertoire",
-                message: `failed to connect MCP server: ${name}`,
-                meta: {
-                    server: name,
-                    reason: error instanceof Error ? error.message : String(error),
-                },
+                level: "error", event: "mcp.connect_error", component: "repertoire",
+                message: `failed to connect MCP server "${desired.name}"`,
+                meta: { server: desired.name, reason },
             });
         }
     }
-    handleServerCrash(name) {
-        const entry = this.servers.get(name);
-        /* v8 ignore next -- defensive: entry removed between close event and handler @preserve */
-        if (!entry)
+    handleServerCrash(entry) {
+        if (!this.isCurrentEntry(entry) || entry.restartTimer)
             return;
         entry.consecutiveFailures++;
         if (entry.consecutiveFailures > MAX_RESTART_RETRIES) {
             (0, runtime_1.emitNervesEvent)({
-                level: "error",
-                event: "mcp.connect_error",
-                component: "repertoire",
-                message: `MCP server "${name}" exceeded max restart retries (${MAX_RESTART_RETRIES})`,
-                meta: { server: name, failures: entry.consecutiveFailures },
+                level: "error", event: "mcp.connect_error", component: "repertoire",
+                message: `MCP server "${entry.name}" exceeded max restart retries`,
+                meta: { server: entry.name, failures: entry.consecutiveFailures },
             });
             return;
         }
         (0, runtime_1.emitNervesEvent)({
-            level: "warn",
-            event: "mcp.server_restart",
-            component: "repertoire",
-            message: `restarting crashed MCP server: ${name}`,
-            meta: { server: name, attempt: entry.consecutiveFailures },
+            level: "warn", event: "mcp.server_restart", component: "repertoire",
+            message: `restarting crashed MCP server: ${entry.name}`,
+            meta: { server: entry.name, attempt: entry.consecutiveFailures },
         });
-        /* v8 ignore start -- timer callback: covered by mcp-manager.test.ts via fake timers but v8 can't trace @preserve */
-        setTimeout(() => {
-            if (this.shuttingDown)
-                return;
-            this.restartServer(name).catch(() => {
-                // Error handling is inside restartServer
+        entry.restartTimer = setTimeout(() => {
+            this.enqueueBackground(async () => {
+                if (!this.isCurrentEntry(entry))
+                    return;
+                delete entry.restartTimer;
+                await this.restartServer(entry);
             });
         }, RESTART_DELAY_MS);
-        /* v8 ignore stop */
     }
-    /* v8 ignore start -- called from timer callback: covered by mcp-manager.test.ts via fake timers but v8 can't trace @preserve */
-    async restartServer(name) {
-        const entry = this.servers.get(name);
-        if (!entry)
-            return;
-        // Remove old entry and reconnect
-        this.servers.delete(name);
-        await this.connectServer(name, entry.config);
-        // Preserve failure count
-        const newEntry = this.servers.get(name);
-        if (newEntry) {
-            newEntry.consecutiveFailures = entry.consecutiveFailures;
-        }
+    async restartServer(entry) {
+        this.removeEntry(entry);
+        await this.connectServer({
+            owner: entry.owner, name: entry.name, config: entry.config,
+            source: entry.source, pluginId: entry.pluginId,
+            configDigest: entry.configDigest, generation: entry.generation,
+            consecutiveFailures: entry.consecutiveFailures,
+        });
+    }
+    async recoverStaleTransport(entry, reason) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn", event: "mcp.transport_recovery", component: "repertoire",
+            message: `recovering stale MCP transport: ${entry.name}`, meta: { server: entry.name, reason },
+        });
+        await this.restartServer(entry);
     }
 }
 exports.McpManager = McpManager;
 let _sharedManager = null;
-let _sharedManagerPromise = null;
-/**
- * Get or create a shared McpManager instance from the agent's config.
- * Returns null if no mcpServers are configured.
- * Safe to call from multiple senses — will only create one instance.
- */
-async function getSharedMcpManager() {
+/** Every caller applies its own desired state and freezes its own view in the shared manager's lifecycle tail. */
+async function getSharedMcpManager(options) {
+    if (!isOwner(options)) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn", event: "mcp.owner_invalid", component: "repertoire",
+            message: "MCP requires an explicit owner", meta: { reason: "agent name and absolute root are required" },
+        });
+        return null;
+    }
+    const manager = _sharedManager ??= new McpManager();
+    return manager.reconcile(options, options.runtimeServers);
+}
+async function releaseRuntimeMcpServers(owner) {
     if (_sharedManager)
-        return _sharedManager;
-    /* v8 ignore next -- race guard: deduplicates concurrent initialization calls @preserve */
-    if (_sharedManagerPromise)
-        return _sharedManagerPromise;
-    _sharedManagerPromise = (async () => {
-        try {
-            const config = (0, identity_1.loadAgentConfig)();
-            const servers = config.mcpServers;
-            if (!servers || Object.keys(servers).length === 0)
-                return null;
-            const manager = new McpManager();
-            await manager.start(servers);
-            _sharedManager = manager;
-            return manager;
-        }
-        catch (error) {
-            (0, runtime_1.emitNervesEvent)({
-                level: "error",
-                event: "mcp.manager_start",
-                component: "repertoire",
-                message: "failed to initialize shared MCP manager",
-                /* v8 ignore next -- both branches tested: Error in wiring test, non-Error is defensive @preserve */
-                meta: { reason: error instanceof Error ? error.message : String(error) },
-            });
-            return null;
-        }
-        finally {
-            _sharedManagerPromise = null;
-        }
-    })();
-    return _sharedManagerPromise;
+        await _sharedManager.reconcile(owner);
 }
-/**
- * Shut down the shared MCP manager and clear the singleton.
- * Called during daemon/agent shutdown.
- */
-function shutdownSharedMcpManager() {
-    if (_sharedManager) {
-        _sharedManager.shutdown();
+async function shutdownSharedMcpManager() {
+    const manager = _sharedManager;
+    if (!manager)
+        return;
+    await manager.shutdown();
+    if (_sharedManager === manager)
         _sharedManager = null;
-    }
 }
-/** Reset for testing only */
-function resetSharedMcpManager() {
-    _sharedManager = null;
-    _sharedManagerPromise = null;
+/** Reset for testing only. */
+async function resetSharedMcpManager() {
+    await shutdownSharedMcpManager();
 }