@akon-labs/nexus-cli 0.1.9 → 0.1.10

package/dist/extensions/mcp/index.js

@@ -1,95 +1,1077 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
 import { Type } from "typebox";
-import { HttpTransport, McpClient, StdioTransport } from "./client.js";
-import { loadMcpConfig } from "./config.js";
-/**
- * MCP adapter: connects the servers named in mcp.json and exposes their tools
- * to the model.
- *
- * Every failure here is non-fatal. A server that is missing, misconfigured, or
- * down costs you its tools and a startup notice — it must never stop the agent
- * from running, the same contract the gitnexus extension follows.
- */
-/** Tool names are namespaced by server, so two servers can both export "search". */
-export function toolName(serverName, tool) {
-    const safe = `${serverName}_${tool}`.replace(/[^a-zA-Z0-9_-]/g, "_");
-    // Keep well under provider name limits; collisions stay unlikely because the
-    // server prefix is preserved.
-    return safe.length <= 64 ? safe : safe.slice(0, 64);
-}
-/** Flatten an MCP result into the text the agent shows and feeds back to the model. */
-export function resultToText(result) {
-    const text = (result.content ?? [])
-        .filter((block) => block.type === "text" && typeof block.text === "string")
-        .map((block) => block.text)
-        .join("\n");
-    if (text)
-        return text;
-    // A server that answers with only non-text blocks should say so rather than
-    // handing the model a blank string it will read as success-with-no-data.
-    const kinds = [...new Set((result.content ?? []).map((block) => block.type))];
-    return kinds.length > 0 ? `[no text content: ${kinds.join(", ")}]` : "[no content]";
-}
-function connect(server) {
-    const transport = server.type === "stdio"
-        ? new StdioTransport(server.command, server.args, server.env, server.cwd)
-        : new HttpTransport(server.url, server.headers);
-    return new McpClient(server.name, transport);
+import { authenticateServer, logoutServer, manageBearerToken, openMcpAuthPanel, openMcpPanel, openMcpSetup, reconnectServer, reconnectServers, showPrompts, showStatus, showTools, } from "./commands.js";
+import { cloneMcpConfig, loadMcpConfig, writeProjectServerDisabledOverride } from "./config.js";
+import { buildProxyDescription, createDirectToolExecutor, getMissingConfiguredDirectToolServers, resolveDirectTools, } from "./direct-tools.js";
+import { toolErrorOverride } from "./error-signal.js";
+import { flushMetadataCache, initializeMcp, updateStatusBar } from "./init.js";
+import { logger } from "./logger.js";
+import { createOAuthRuntime, shutdownOAuth } from "./mcp-auth-flow.js";
+import { runMcpScript } from "./mcp-code.js";
+import { publishMcpStatusShutdown } from "./mcp-status.js";
+import { loadMetadataCache } from "./metadata-cache.js";
+import { createPromptCommand, resolveCachedPrompts } from "./prompts.js";
+import { executeAuthComplete, executeAuthStart, executeCall, executeConnect, executeDescribe, executeInstructions, executeList, executeSearch, executeStatus, executeUiMessages, } from "./proxy-modes.js";
+import { createMcpRuntimeOwner, createOwnedUi, isAbortError } from "./runtime-owner.js";
+import { cleanupMaterializedBinaryResources } from "./tool-registrar.js";
+import { createMcpDirectToolCallRenderer, createMcpProxyToolCallRenderer, createMcpToolResultRenderer, resolveMcpToolRenderOptions, } from "./tool-result-renderer.js";
+import { formatTerminalError, getConfigPathFromArgv, normalizeDirectToolInputSchema, truncateAtWord } from "./utils.js";
+export { MCP_STATUS_EVENT, MCP_STATUS_SNAPSHOT_VERSION, MCP_TOOL_APPROVAL_REQUEST_EVENT, } from "./types.js";
+const INIT_WAIT_TIMEOUT_MS = 30_000;
+const INIT_WAIT_TIMED_OUT = Symbol("init-wait-timed-out");
+// Routes runtime registrations to the adapter installed for a specific Nexus
+// instance, so a process with several adapters cannot cross-register.
+const runtimeRegistrars = new WeakMap();
+async function awaitWithTimeout(promise, timeoutMs) {
+    let timer;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((resolve) => {
+                timer = setTimeout(() => resolve(INIT_WAIT_TIMED_OUT), timeoutMs);
+                timer.unref?.();
+            }),
+        ]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
 }
-/** Build a nexus tool that proxies one MCP tool. */
-export function defineProxyTool(client, serverName, schema) {
-    return {
-        name: toolName(serverName, schema.name),
-        label: `${serverName}:${schema.name}`,
-        description: schema.description ?? `${schema.name} (via ${serverName} MCP server)`,
-        // Pass the server's own JSON Schema straight through. Type.Unsafe wraps it
-        // without reinterpreting it, so the model sees the parameters the server
-        // documented and we never reject a payload the server would have accepted.
-        parameters: Type.Unsafe(schema.inputSchema ?? { type: "object", properties: {} }),
-        execute: async (_id, params, signal) => {
-            const result = await client.callTool(schema.name, (params ?? {}), signal);
-            return {
-                content: [{ type: "text", text: resultToText(result) }],
-                isError: result.isError === true,
-                details: { server: serverName, tool: schema.name },
-            };
-        },
-    };
+// TypeBox 1.x annotates raw objects passed to Type.Optional with an enumerable
+// "~optional" key that survives serialization into provider tool schemas (Gemini
+// rejects it with 400 INVALID_ARGUMENT). Prefer a real Type.Number schema; fall
+// back to a plain raw schema for host TypeBox shims that omit Type.Number, since
+// a property left out of `required` is optional by default.
+function optionalNumber(options) {
+    const number = Type.Number;
+    return typeof number === "function"
+        ? Type.Optional(number(options))
+        : { type: "number", ...options };
 }
-export default function mcpExtension(pi) {
-    const clients = [];
-    pi.on("session_start", async (_event, ctx) => {
-        const { servers, diagnostics } = loadMcpConfig(process.cwd());
-        const notices = [...diagnostics];
-        const enabled = servers.filter((server) => server.enabled);
-        for (const server of enabled) {
-            const client = connect(server);
-            try {
-                const tools = await client.listTools();
-                if (tools.length === 0) {
-                    notices.push(`MCP ${server.name}: connected but exposes no tools`);
-                    client.close();
+function installMcpAdapter(nexus, options) {
+    const sessionConfig = options.config !== undefined ? cloneMcpConfig(options.config) : undefined;
+    const programmaticConfig = sessionConfig !== undefined;
+    let state = null;
+    let initPromise = null;
+    let currentOwner = null;
+    let currentOAuthRuntime = null;
+    let currentModel;
+    let lifecycleGeneration = 0;
+    async function shutdownState(currentState, reason) {
+        if (!currentState) {
+            publishMcpStatusShutdown(nexus.events);
+            return;
+        }
+        publishMcpStatusShutdown(currentState.statusEvents);
+        if (currentState.uiServer) {
+            currentState.uiServer.close(reason);
+            currentState.uiServer = null;
+        }
+        let flushError;
+        try {
+            flushMetadataCache(currentState);
+        }
+        catch (error) {
+            flushError = error;
+        }
+        try {
+            if (currentState.owner) {
+                await currentState.owner.stop(reason);
+            }
+            else {
+                await currentState.lifecycle.gracefulShutdown();
+            }
+        }
+        catch (error) {
+            if (flushError) {
+                console.error(`MCP: graceful shutdown failed after metadata flush error: ${formatTerminalError(error)}`);
+            }
+            else {
+                throw error;
+            }
+        }
+        if (flushError) {
+            throw flushError;
+        }
+    }
+    const earlyConfigPath = programmaticConfig ? undefined : (options.configPath ?? getConfigPathFromArgv());
+    const earlyConfig = programmaticConfig
+        ? cloneMcpConfig(sessionConfig)
+        : loadMcpConfig(earlyConfigPath, process.cwd(), false);
+    const earlyCache = loadMetadataCache();
+    const envRaw = process.env.MCP_DIRECT_TOOLS;
+    const envDirectToolOverride = envRaw
+        ?.split(",")
+        .map((s) => s.trim())
+        .filter(Boolean);
+    const registeredDirectTools = new Map();
+    const fallbackDeactivatedTools = new Set();
+    const toolRenderOptions = resolveMcpToolRenderOptions(earlyConfig.settings);
+    const toolRenderShell = toolRenderOptions.resultRendering === "compact" ? "self" : "default";
+    const renderMcpToolResult = createMcpToolResultRenderer(toolRenderOptions);
+    let proxyToolRegistered = false;
+    let proxyToolDescription = null;
+    let directToolsFrozen = false;
+    // Session/runtime scoped server registrations from other extensions. They
+    // survive session restarts within this install and die with the process.
+    const runtimeServers = new Map();
+    // Mirrors init's per-server lifecycle registration so runtime servers get
+    // idle cleanup and keep-alive health recovery like configured servers.
+    function attachRuntimeServerLifecycle(targetState, name, definition) {
+        const lifecycleMode = definition.lifecycle ?? "lazy";
+        const persistsAfterFirstSpawn = lifecycleMode === "eager" || lifecycleMode === "lazy-keep-alive";
+        const idleOverride = definition.idleTimeout ?? (persistsAfterFirstSpawn ? 0 : undefined);
+        targetState.lifecycle.registerServer(name, definition, idleOverride !== undefined ? { idleTimeout: idleOverride } : undefined);
+        if (lifecycleMode === "keep-alive")
+            targetState.lifecycle.markKeepAlive(name, definition);
+    }
+    // OMP remaps `typebox` to a host shim that historically lacked Type.Unsafe.
+    // Prefer Unsafe when present (real TypeBox / fixed OMP shim); otherwise pass
+    // the normalized JSON Schema through as a plain object so toolWireSchema and
+    // validateToolArguments still treat it as JSON Schema.
+    const toToolParameters = (schema) => typeof Type.Unsafe === "function"
+        ? Type.Unsafe(schema)
+        : schema;
+    function directToolFingerprint(spec) {
+        return JSON.stringify({
+            serverName: spec.serverName,
+            originalName: spec.originalName,
+            prefixedName: spec.prefixedName,
+            description: spec.description,
+            inputSchema: spec.inputSchema,
+            resourceUri: spec.resourceUri,
+            uiResourceUri: spec.uiResourceUri,
+            uiStreamMode: spec.uiStreamMode,
+        });
+    }
+    function registerDirectTool(spec) {
+        nexus.registerTool({
+            name: spec.prefixedName,
+            label: `MCP: ${spec.originalName}`,
+            description: spec.description || "(no description)",
+            promptSnippet: truncateAtWord(spec.description, 100) || `MCP tool from ${spec.serverName}`,
+            parameters: toToolParameters(normalizeDirectToolInputSchema(spec.inputSchema)),
+            execute: createDirectToolExecutor(() => state, () => initPromise, spec),
+            renderShell: toolRenderShell,
+            renderCall: createMcpDirectToolCallRenderer(spec.prefixedName, toolRenderOptions),
+            renderResult: renderMcpToolResult,
+        });
+    }
+    function resolveCurrentDirectTools(config, cache) {
+        if (envRaw === "__none__")
+            return [];
+        const prefix = config.settings?.toolPrefix ?? "server";
+        return resolveDirectTools(config, cache, prefix, envDirectToolOverride);
+    }
+    function getActiveToolsIfReady() {
+        try {
+            return nexus.getActiveTools?.();
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                error.message.includes("Action methods cannot be called during extension loading"))
+                return undefined;
+            throw error;
+        }
+    }
+    function deactivateTools(toolNames) {
+        if (toolNames.length === 0)
+            return [];
+        const unregisterTool = nexus.unregisterTool;
+        const unregistered = toolNames.filter((toolName) => unregisterTool?.(toolName) === true);
+        const fallbackNames = toolNames.filter((toolName) => !unregistered.includes(toolName));
+        const remove = new Set(toolNames);
+        const activeTools = getActiveToolsIfReady();
+        if (!activeTools || activeTools.length === 0) {
+            for (const toolName of fallbackNames)
+                fallbackDeactivatedTools.add(toolName);
+            return unregistered;
+        }
+        const nextActiveTools = activeTools.filter((name) => !remove.has(name));
+        if (nextActiveTools.length !== activeTools.length) {
+            for (const toolName of fallbackNames)
+                fallbackDeactivatedTools.add(toolName);
+            nexus.setActiveTools(nextActiveTools);
+        }
+        return unregistered;
+    }
+    function syncDirectTools(config, cache) {
+        const specs = resolveCurrentDirectTools(config, cache);
+        const nextNames = new Set(specs.map((spec) => spec.prefixedName));
+        const added = [];
+        const updated = [];
+        const deactivated = [];
+        for (const spec of specs) {
+            const fingerprint = directToolFingerprint(spec);
+            const previous = registeredDirectTools.get(spec.prefixedName);
+            if (previous !== fingerprint) {
+                registerDirectTool(spec);
+                registeredDirectTools.set(spec.prefixedName, fingerprint);
+                if (fallbackDeactivatedTools.delete(spec.prefixedName)) {
+                    const activeTools = getActiveToolsIfReady();
+                    if (activeTools && !activeTools.includes(spec.prefixedName)) {
+                        nexus.setActiveTools([...activeTools, spec.prefixedName]);
+                    }
+                }
+                (previous ? updated : added).push(spec.prefixedName);
+            }
+        }
+        for (const toolName of [...registeredDirectTools.keys()]) {
+            if (nextNames.has(toolName))
+                continue;
+            registeredDirectTools.delete(toolName);
+            deactivated.push(toolName);
+        }
+        deactivateTools(deactivated);
+        return { specs, added, updated, deactivated };
+    }
+    function applyDirectToolConfigChanges(changes) {
+        if (!state)
+            return;
+        for (const [serverName, value] of changes) {
+            const definition = state.config.mcpServers[serverName];
+            if (!definition)
+                continue;
+            state.config.mcpServers[serverName] = { ...definition, directTools: value };
+        }
+    }
+    function syncToolSurface(ctx) {
+        const config = state?.config ?? earlyConfig;
+        const cache = loadMetadataCache();
+        const result = syncDirectTools(config, cache);
+        syncProxyTool(config, cache, result.specs);
+        const changed = result.added.length + result.updated.length + result.deactivated.length;
+        if (changed > 0 && ctx?.hasUI) {
+            ctx.ui.notify(`MCP: direct tools refreshed (+${result.added.length}, ~${result.updated.length}, -${result.deactivated.length})`, "info");
+        }
+    }
+    const registeredPromptCommands = new Set();
+    function registerPromptCommands(specs) {
+        for (const spec of specs) {
+            if (registeredPromptCommands.has(spec.commandName)) {
+                logger.debug(`MCP: prompt "${spec.originalName}" on ${spec.serverName} skipped; /${spec.commandName} is already registered`);
+                continue;
+            }
+            registeredPromptCommands.add(spec.commandName);
+            nexus.registerCommand(spec.commandName, createPromptCommand(nexus, () => state, spec));
+        }
+    }
+    function syncPromptCommands() {
+        registerPromptCommands([...(state?.promptMetadata?.values() ?? [])].flat());
+    }
+    registerPromptCommands(resolveCachedPrompts(earlyConfig));
+    runtimeRegistrars.set(nexus, (name, definition) => {
+        if (typeof name !== "string" || name.trim() === "") {
+            throw new Error("MCP server name must be a non-empty string");
+        }
+        if (typeof definition !== "object" || definition === null || Array.isArray(definition)) {
+            throw new Error(`MCP server definition for "${name}" must be an object`);
+        }
+        const effective = state?.config ?? earlyConfig;
+        if (runtimeServers.has(name) || Object.hasOwn(effective.mcpServers, name)) {
+            throw new Error(`MCP server "${name}" is already registered`);
+        }
+        // Runtime-registered servers are proxy-tool-only: direct tools are frozen
+        // at startup and must not be rebuilt for late registrations.
+        const entry = { ...structuredClone(definition), directTools: false };
+        runtimeServers.set(name, entry);
+        const registeredState = state;
+        if (registeredState) {
+            registeredState.config.mcpServers[name] = entry;
+            attachRuntimeServerLifecycle(registeredState, name, entry);
+            syncToolSurface();
+            updateStatusBar(registeredState);
+        }
+        let disposed = false;
+        return {
+            dispose: async () => {
+                if (disposed)
+                    return;
+                disposed = true;
+                runtimeServers.delete(name);
+                const currentState = state;
+                if (!currentState || currentState.config.mcpServers[name] !== entry)
+                    return;
+                delete currentState.config.mcpServers[name];
+                currentState.lifecycle.unregisterServer(name);
+                await currentState.manager.close(name);
+                syncToolSurface();
+                updateStatusBar(currentState);
+            },
+        };
+    });
+    const getNexusTools = () => nexus.getAllTools();
+    nexus.registerFlag("mcp-config", {
+        description: "Path to MCP config file",
+        type: "string",
+    });
+    function startInitialization(ctx, owner, oauthRuntime, generation, staleReason) {
+        owner.addCleanup(() => cleanupMaterializedBinaryResources(owner.signal));
+        const promise = initializeMcp(nexus, ctx, owner, {
+            ...(programmaticConfig || options.configPath !== undefined
+                ? {
+                    ...(earlyConfigPath !== undefined ? { configPath: earlyConfigPath } : {}),
+                    ...(sessionConfig !== undefined ? { config: sessionConfig } : {}),
+                }
+                : {}),
+            oauthRuntime,
+            getCurrentModel: () => currentModel,
+        });
+        initPromise = promise;
+        return promise
+            .then(async (nextState) => {
+            if (!owner.isActive() || generation !== lifecycleGeneration || initPromise !== promise) {
+                try {
+                    await shutdownState(nextState, staleReason);
+                }
+                catch (error) {
+                    console.error(`MCP: failed to clean stale initialization state: ${formatTerminalError(error)}`);
+                }
+                return;
+            }
+            state = nextState;
+            for (const [name, definition] of runtimeServers) {
+                if (Object.hasOwn(nextState.config.mcpServers, name)) {
+                    console.error(`MCP: runtime-registered server "${name}" now collides with a configured server; keeping the configured server`);
                     continue;
                 }
-                for (const tool of tools)
-                    pi.registerTool(defineProxyTool(client, server.name, tool));
-                clients.push(client);
-                notices.push(`MCP ${server.name}: ${tools.length} tool${tools.length === 1 ? "" : "s"}`);
+                nextState.config.mcpServers[name] = definition;
+                attachRuntimeServerLifecycle(nextState, name, definition);
+            }
+            nextState.onToolMetadataUpdated = (_serverName, _reason) => {
+                if (state !== nextState || !owner.isActive())
+                    return;
+                syncPromptCommands();
+                if (directToolsFrozen) {
+                    logger.debug(`MCP: metadata update for ${_serverName} (${_reason}) skipped — directTools frozen`);
+                    return;
+                }
+                syncToolSurface(ctx);
+            };
+            syncPromptCommands();
+            syncToolSurface(ctx);
+            // A connected snapshot is readiness-like external state. Publish it only
+            // after Nexus's model-facing direct-tool surface reflects live metadata.
+            nextState.statusEvents = nexus.events;
+            updateStatusBar(nextState);
+            initPromise = null;
+            if (nextState.config.settings?.freezeDirectTools === true) {
+                directToolsFrozen = true;
+                logger.info('MCP: direct tools frozen after initial sync — reconnects won\'t rebuild the system prompt; use mcp({ connect: "server" }) to rediscover');
+            }
+        })
+            .catch(async (err) => {
+            if (!owner.isActive() || generation !== lifecycleGeneration) {
+                return;
+            }
+            if (initPromise !== promise && initPromise !== null) {
+                return;
+            }
+            console.error(`MCP initialization failed: ${formatTerminalError(err)}`);
+            initPromise = null;
+            if (state)
+                return;
+            try {
+                await Promise.all([owner.stop("MCP initialization failed"), shutdownOAuth(oauthRuntime)]);
             }
             catch (error) {
-                // One unreachable server must not cost the others their tools.
-                client.close();
-                notices.push(`MCP ${server.name}: ${error instanceof Error ? error.message : String(error)}`);
+                console.error(`MCP: failed to clean rejected initialization: ${formatTerminalError(error)}`);
+            }
+        });
+    }
+    function startLoadTimeInitialization() {
+        const hasStartupServer = Object.values(earlyConfig.mcpServers).some((definition) => {
+            if (definition.disabled === true)
+                return false;
+            return definition.lifecycle === "eager" || definition.lifecycle === "keep-alive";
+        });
+        if (!hasStartupServer)
+            return;
+        setImmediate(() => {
+            if (lifecycleGeneration !== 0 || state || initPromise)
+                return;
+            const generation = ++lifecycleGeneration;
+            const owner = createMcpRuntimeOwner();
+            const oauthRuntime = createOAuthRuntime(owner.signal);
+            currentOwner = owner;
+            currentOAuthRuntime = oauthRuntime;
+            startInitialization({
+                mode: "print",
+                hasUI: false,
+                cwd: process.cwd(),
+                model: undefined,
+                modelRegistry: undefined,
+                signal: undefined,
+                isProjectTrusted: () => false,
+            }, owner, oauthRuntime, generation, "stale_load_time_initialization");
+        });
+    }
+    nexus.on("session_start", async (_event, ctx) => {
+        currentModel = ctx.model;
+        directToolsFrozen = false;
+        const generation = ++lifecycleGeneration;
+        const previousState = state;
+        const previousOwner = currentOwner;
+        const previousOAuthRuntime = currentOAuthRuntime;
+        const owner = createMcpRuntimeOwner();
+        const oauthRuntime = createOAuthRuntime(owner.signal);
+        currentOwner = owner;
+        currentOAuthRuntime = oauthRuntime;
+        state = null;
+        initPromise = null;
+        // Abort synchronously before awaiting cleanup so old callbacks and startup
+        // work cannot resume into a stale ExtensionContext.
+        const stopPrevious = previousOwner?.stop("MCP extension session restarted") ?? Promise.resolve();
+        try {
+            await Promise.all([
+                stopPrevious,
+                shutdownState(previousState, "session_restart"),
+                previousOAuthRuntime ? shutdownOAuth(previousOAuthRuntime) : Promise.resolve(),
+            ]);
+        }
+        catch (error) {
+            console.error(`MCP: failed to shut down previous session state: ${formatTerminalError(error)}`);
+        }
+        if (generation !== lifecycleGeneration || !owner.isActive())
+            return;
+        const initialization = startInitialization(ctx, owner, oauthRuntime, generation, "stale_session_start");
+        if (envRaw !== undefined && envRaw !== "__none__") {
+            const missingEnvDirectTools = getMissingConfiguredDirectToolServers(earlyConfig, loadMetadataCache(), envDirectToolOverride);
+            if (missingEnvDirectTools.length > 0) {
+                await initialization;
+            }
+        }
+    });
+    nexus.on("model_select", (event) => {
+        currentModel = event.model;
+    });
+    nexus.on("input", async () => {
+        const inputOwner = currentOwner;
+        if (!inputOwner?.isActive())
+            return;
+        if (!state && initPromise) {
+            try {
+                await awaitWithTimeout(initPromise, INIT_WAIT_TIMEOUT_MS);
+            }
+            catch {
+                return;
+            }
+        }
+        const inputState = state;
+        if (!inputState || !inputOwner.isActive())
+            return;
+        try {
+            await inputState.lifecycle.ensureConverged(inputOwner.signal);
+        }
+        catch (error) {
+            if (!isAbortError(error, inputOwner.signal)) {
+                logger.debug(`MCP: keep-alive convergence failed before input: ${formatTerminalError(error)}`);
             }
         }
-        if (notices.length > 0)
-            ctx.ui.notify(notices.join("\n"), "info");
     });
-    pi.on("session_shutdown", async () => {
-        // stdio servers are child processes; leaving them running would leak one
-        // per session.
-        for (const client of clients)
-            client.close();
-        clients.length = 0;
+    nexus.on("session_shutdown", async () => {
+        ++lifecycleGeneration;
+        const currentState = state;
+        const owner = currentOwner;
+        const oauthRuntime = currentOAuthRuntime;
+        currentOwner = null;
+        currentOAuthRuntime = null;
+        currentModel = undefined;
+        state = null;
+        initPromise = null;
+        // Abort before awaiting cleanup so delayed initialization cannot touch stale
+        // Nexus context after session shutdown.
+        const stopOwner = owner?.stop("MCP extension session shutdown") ?? Promise.resolve();
+        try {
+            await Promise.all([
+                stopOwner,
+                shutdownState(currentState, "session_shutdown"),
+                oauthRuntime ? shutdownOAuth(oauthRuntime) : Promise.resolve(),
+            ]);
+        }
+        catch (error) {
+            console.error(`MCP: session shutdown cleanup failed: ${formatTerminalError(error)}`);
+        }
+    });
+    // Re-flag returned MCP tool failures so nexus registers them as errors (see toolErrorOverride).
+    nexus.on("tool_result", (event) => toolErrorOverride(event.details));
+    const registerMcpCommand = (commandName) => nexus.registerCommand(commandName, {
+        description: "Show MCP server status",
+        getArgumentCompletions: (prefix) => {
+            const normalized = prefix.trimStart();
+            const argumentMatch = normalized.match(/^(\S+)\s+(.*)$/);
+            if (!argumentMatch) {
+                const subcommands = [
+                    { value: "reconnect", label: "reconnect — Reconnect servers" },
+                    { value: "tools", label: "tools — List all tools" },
+                    { value: "prompts", label: "prompts — List all MCP prompts" },
+                    { value: "setup", label: "setup — Configure MCP servers" },
+                    { value: "logout", label: "logout — Clear server credentials" },
+                    { value: "token", label: "token — Manage stored bearer tokens" },
+                    { value: "disable", label: "disable — Disable a server" },
+                    { value: "enable", label: "enable — Enable a server" },
+                    { value: "status", label: "status — Show server status" },
+                ].filter(({ value }) => value.startsWith(normalized));
+                return subcommands.length > 0 ? subcommands : null;
+            }
+            const [, subcommand, argumentPrefix] = argumentMatch;
+            if ((subcommand !== "reconnect" &&
+                subcommand !== "logout" &&
+                subcommand !== "disable" &&
+                subcommand !== "enable" &&
+                subcommand !== "token") ||
+                argumentPrefix === undefined ||
+                !state)
+                return null;
+            if (subcommand === "token") {
+                const tokenMatch = argumentPrefix.trimStart().match(/^(set|remove|status)\s+(.*)$/);
+                if (!tokenMatch) {
+                    const actions = ["set", "remove", "status"]
+                        .filter((action) => action.startsWith(argumentPrefix.trimStart()))
+                        .map((action) => ({ value: `token ${action} `, label: `${action} — Bearer token ${action}` }));
+                    return actions.length > 0 ? actions : null;
+                }
+                const action = tokenMatch[1] ?? "";
+                const serverPrefix = tokenMatch[2] ?? "";
+                const servers = Object.keys(state.config.mcpServers)
+                    .filter((serverName) => serverName.startsWith(serverPrefix.trimStart()))
+                    .map((serverName) => ({ value: `token ${action} ${serverName}`, label: serverName }));
+                return servers.length > 0 ? servers : null;
+            }
+            const servers = Object.keys(state.config.mcpServers)
+                .filter((serverName) => serverName.startsWith(argumentPrefix.trimStart()))
+                .map((serverName) => ({ value: `${subcommand} ${serverName}`, label: serverName }));
+            return servers.length > 0 ? servers : null;
+        },
+        handler: async (args, ctx) => {
+            const commandOwner = currentOwner;
+            const commandReload = typeof ctx.reload === "function" ? ctx.reload.bind(ctx) : async () => { };
+            const commandHasUI = ctx.hasUI;
+            const commandCtx = {
+                hasUI: commandHasUI,
+                ui: commandHasUI ? (commandOwner ? createOwnedUi(ctx.ui, commandOwner) : ctx.ui) : undefined,
+                cwd: ctx.cwd,
+                mode: ctx.mode,
+                signal: commandOwner?.signal ?? ctx.signal,
+                isProjectTrusted: () => ctx.isProjectTrusted(),
+            };
+            if (!state && initPromise) {
+                try {
+                    const initialized = await initPromise;
+                    commandOwner?.throwIfInactive();
+                    state = initialized;
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    if (commandCtx.hasUI)
+                        commandCtx.ui?.notify(`MCP initialization failed: ${message}`, "error");
+                    return;
+                }
+            }
+            if (!state) {
+                if (commandCtx.hasUI)
+                    commandCtx.ui?.notify("MCP not initialized", "error");
+                return;
+            }
+            const parts = args?.trim()?.split(/\s+/) ?? [];
+            const subcommand = parts[0] ?? "";
+            const targetServer = parts[1];
+            const rest = parts.slice(1).join(" ");
+            switch (subcommand) {
+                case "reconnect":
+                    commandOwner?.throwIfInactive();
+                    await reconnectServers(state, commandCtx, targetServer);
+                    if (directToolsFrozen)
+                        syncToolSurface(commandCtx);
+                    break;
+                case "tools":
+                    await showTools(state, commandCtx);
+                    break;
+                case "prompts":
+                    await showPrompts(state, commandCtx);
+                    break;
+                case "setup": {
+                    commandOwner?.throwIfInactive();
+                    if (!ctx.isProjectTrusted()) {
+                        commandCtx.ui?.notify("Trust this project before opening MCP setup.", "warning");
+                        break;
+                    }
+                    if (programmaticConfig) {
+                        commandCtx.ui?.notify("MCP setup is unavailable when config is supplied by createMcpAdapter().", "info");
+                        break;
+                    }
+                    const result = await openMcpSetup(state, nexus, commandCtx, earlyConfigPath, "setup");
+                    if (result?.configChanged) {
+                        commandOwner?.throwIfInactive();
+                        await commandReload();
+                        return;
+                    }
+                    break;
+                }
+                case "logout": {
+                    const serverName = rest;
+                    if (!serverName) {
+                        if (commandCtx.hasUI)
+                            commandCtx.ui?.notify("Usage: /mcp logout <server>", "error");
+                        return;
+                    }
+                    commandOwner?.throwIfInactive();
+                    await logoutServer(serverName, state, commandCtx);
+                    break;
+                }
+                case "token": {
+                    const action = parts[1];
+                    const serverName = parts.slice(2).join(" ");
+                    if (action !== "set" && action !== "remove" && action !== "status") {
+                        if (commandCtx.hasUI)
+                            commandCtx.ui?.notify("Usage: /mcp token set|remove|status <server>", "error");
+                        return;
+                    }
+                    if (!serverName) {
+                        if (commandCtx.hasUI)
+                            commandCtx.ui?.notify("Usage: /mcp token set|remove|status <server>", "error");
+                        return;
+                    }
+                    commandOwner?.throwIfInactive();
+                    await manageBearerToken(action, serverName, state, commandCtx);
+                    break;
+                }
+                case "disable":
+                case "enable": {
+                    const serverName = rest;
+                    if (!ctx.isProjectTrusted()) {
+                        commandCtx.ui?.notify(`Trust this project before running /mcp ${subcommand}.`, "warning");
+                        break;
+                    }
+                    if (programmaticConfig) {
+                        commandCtx.ui?.notify(`/mcp ${subcommand} is unavailable when config is supplied by createMcpAdapter().`, "info");
+                        break;
+                    }
+                    if (!serverName) {
+                        commandCtx.ui?.notify(`Usage: /mcp ${subcommand} <server>`, "error");
+                        break;
+                    }
+                    if (!state.config.mcpServers[serverName]) {
+                        commandCtx.ui?.notify(`Server "${serverName}" not found in effective config`, "error");
+                        break;
+                    }
+                    commandOwner?.throwIfInactive();
+                    const result = writeProjectServerDisabledOverride(earlyConfigPath, commandCtx.cwd, serverName, subcommand === "disable");
+                    if (result.changed) {
+                        commandCtx.ui?.notify(`${subcommand === "disable" ? "Disabled" : "Enabled"} server "${serverName}" in ${result.path} — run /reload to apply`, "info");
+                    }
+                    else {
+                        commandCtx.ui?.notify(`Server "${serverName}" is already ${subcommand === "disable" ? "disabled" : "enabled"}`, "info");
+                    }
+                    break;
+                }
+                default:
+                    if (commandCtx.hasUI) {
+                        commandOwner?.throwIfInactive();
+                        if (programmaticConfig || !ctx.isProjectTrusted()) {
+                            if (programmaticConfig) {
+                                commandCtx.ui?.notify("MCP status is shown from the in-memory SDK config; configuration discovery is unavailable.", "info");
+                            }
+                            await showStatus(state, commandCtx);
+                            break;
+                        }
+                        const result = await openMcpPanel(state, nexus, commandCtx, earlyConfigPath, (changes) => {
+                            applyDirectToolConfigChanges(changes);
+                            syncToolSurface(commandCtx);
+                        });
+                        if (result?.configChanged) {
+                            commandOwner?.throwIfInactive();
+                            await commandReload();
+                            return;
+                        }
+                    }
+                    else {
+                        await showStatus(state, commandCtx);
+                    }
+                    break;
+            }
+        },
+    });
+    registerMcpCommand("mcp");
+    nexus.registerCommand("mcp-auth", {
+        description: "Authenticate with an MCP server (OAuth)",
+        handler: async (args, ctx) => {
+            const commandOwner = currentOwner;
+            const commandHasUI = ctx.hasUI;
+            const commandCtx = {
+                hasUI: commandHasUI,
+                ui: commandHasUI ? (commandOwner ? createOwnedUi(ctx.ui, commandOwner) : ctx.ui) : undefined,
+                cwd: ctx.cwd,
+                mode: ctx.mode,
+                signal: commandOwner?.signal ?? ctx.signal,
+                isProjectTrusted: () => ctx.isProjectTrusted(),
+            };
+            const serverName = args?.trim();
+            if (!serverName && !commandCtx.hasUI) {
+                return;
+            }
+            if (!state && initPromise) {
+                try {
+                    const initialized = await initPromise;
+                    commandOwner?.throwIfInactive();
+                    state = initialized;
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    if (commandCtx.hasUI)
+                        commandCtx.ui?.notify(`MCP initialization failed: ${message}`, "error");
+                    return;
+                }
+            }
+            if (!state) {
+                if (commandCtx.hasUI)
+                    commandCtx.ui?.notify("MCP not initialized", "error");
+                return;
+            }
+            if (!serverName) {
+                if (!ctx.isProjectTrusted()) {
+                    commandCtx.ui?.notify("Trust this project or specify a global MCP server with /mcp-auth <server>.", "warning");
+                    return;
+                }
+                if (programmaticConfig) {
+                    commandCtx.ui?.notify("Use /mcp-auth <server> to authenticate a server from the in-memory SDK config.", "info");
+                    return;
+                }
+                await openMcpAuthPanel(state, nexus, commandCtx, earlyConfigPath);
+                return;
+            }
+            const result = await authenticateServer(serverName, state.config, commandCtx, commandCtx.signal, state.oauthRuntime);
+            if (result.ok) {
+                commandOwner?.throwIfInactive();
+                await reconnectServer(state, commandCtx, serverName);
+            }
+        },
+    });
+    if (earlyConfig.settings?.scriptMode !== false) {
+        nexus.registerTool({
+            name: "mcpScript",
+            label: "MCP Script",
+            description: "Run trusted JavaScript that makes multiple MCP tool calls in one request — loop, filter, chain, or fan out between calls. For a single MCP call, search, describe, status check, or auth action, use the mcp tool instead. Discover with await tools.search({ query }) — resolves to { items: [{ path, name, server, description? }], total, hasMore, nextOffset }, not an { ok, data } envelope. Inspect with await tools.describe({ path }) — resolves to the tool descriptor with inputTypeScript, or { path, error: { code, message, suggestions } }. Then call tools.call(path, args) — resolves to { ok: true, data } or { ok: false, error: { code, message } } — or use direct flat calls when the name is already known; use emit(value) for user-visible output. Load the mcp-scripting skill for the full workflow guide.",
+            promptSnippet: "Batch multiple MCP tool calls in one JavaScript request (loop, filter, chain)",
+            parameters: Type.Object({
+                code: Type.String({
+                    description: "Trusted JavaScript MCP script. Use tools.<prefixedToolName>(args) and emit(value).",
+                }),
+                timeoutMs: optionalNumber({
+                    minimum: 1,
+                    description: "Execution timeout in milliseconds (default: 30000)",
+                }),
+            }),
+            renderResult: renderMcpToolResult,
+            async execute(_toolCallId, params, signal) {
+                const executeOwner = currentOwner;
+                if (!state && initPromise) {
+                    try {
+                        const initialized = await awaitWithTimeout(initPromise, INIT_WAIT_TIMEOUT_MS);
+                        if (initialized === INIT_WAIT_TIMED_OUT) {
+                            return {
+                                content: [
+                                    {
+                                        type: "text",
+                                        text: "MCP initialization is still in progress. Try again shortly.",
+                                    },
+                                ],
+                                details: { mode: "script", error: "init_timeout", timeoutMs: INIT_WAIT_TIMEOUT_MS },
+                            };
+                        }
+                        executeOwner?.throwIfInactive();
+                        state = initialized;
+                    }
+                    catch (error) {
+                        if (executeOwner && isAbortError(error, executeOwner.signal))
+                            throw error;
+                        const message = error instanceof Error ? error.message : String(error);
+                        return {
+                            content: [{ type: "text", text: `MCP initialization failed: ${message}` }],
+                            details: { mode: "script", error: "init_failed", message },
+                        };
+                    }
+                }
+                if (!state) {
+                    return {
+                        content: [{ type: "text", text: "MCP not initialized" }],
+                        details: { mode: "script", error: "not_initialized" },
+                    };
+                }
+                executeOwner?.throwIfInactive();
+                return runMcpScript(state, params.code, params.timeoutMs, getNexusTools, signal);
+            },
+        });
+    }
+    function registerProxyTool(description) {
+        nexus.registerTool({
+            name: "mcp",
+            label: "MCP",
+            description,
+            promptSnippet: "MCP gateway — status, search, describe, auth, and single MCP tool calls",
+            renderShell: toolRenderShell,
+            renderCall: createMcpProxyToolCallRenderer(toolRenderOptions),
+            parameters: Type.Object({
+                tool: Type.Optional(Type.String({ description: "Tool name to call (e.g., 'xcodebuild_list_sims')" })),
+                args: Type.Optional(Type.Union([
+                    Type.String({ description: 'Arguments as a JSON string (e.g., \'{"key": "value"}\')' }),
+                    Type.Object({}, {
+                        additionalProperties: true,
+                        description: 'Arguments as a JSON object (e.g., { "key": "value" })',
+                    }),
+                ], { description: "Tool arguments as a JSON object, or as a JSON string encoding one" })),
+                connect: Type.Optional(Type.String({ description: "Server name to connect (lazy connect + metadata refresh)" })),
+                describe: Type.Optional(Type.String({ description: "Tool name to describe (shows parameters)" })),
+                instructions: Type.Optional(Type.String({ description: "Server name to show that server's usage instructions" })),
+                search: Type.Optional(Type.String({ description: "Search tools by name/description" })),
+                regex: Type.Optional(Type.Boolean({ description: "Treat search as regex (default: substring match)" })),
+                includeSchemas: Type.Optional(Type.Boolean({ description: "Include parameter schemas in search results (default: true)" })),
+                limit: optionalNumber({ minimum: 1, description: "Maximum search results to return (default: 12)" }),
+                offset: optionalNumber({ minimum: 0, description: "Search result offset (default: 0)" }),
+                server: Type.Optional(Type.String({ description: "Filter to specific server (also disambiguates tool calls)" })),
+                action: Type.Optional(Type.String({ description: "Action: 'ui-messages', 'auth-start', or 'auth-complete'" })),
+            }),
+            renderResult: renderMcpToolResult,
+            async execute(_toolCallId, params, signal, _onUpdate, _ctx) {
+                const executeOwner = currentOwner;
+                const parseArgs = (value) => {
+                    if (value === undefined || value === "")
+                        return undefined;
+                    let args;
+                    if (typeof value === "string") {
+                        try {
+                            args = JSON.parse(value);
+                        }
+                        catch (error) {
+                            if (error instanceof SyntaxError) {
+                                throw new Error(`Invalid args JSON: ${error.message}`, { cause: error });
+                            }
+                            throw error;
+                        }
+                    }
+                    else {
+                        args = value;
+                    }
+                    if (typeof args !== "object" || args === null || Array.isArray(args)) {
+                        const gotType = Array.isArray(args) ? "array" : args === null ? "null" : typeof args;
+                        throw new Error(`Invalid args: expected a JSON object, got ${gotType}`);
+                    }
+                    return args;
+                };
+                const validateNestedGatewayParams = (value) => {
+                    for (const key of [
+                        "tool",
+                        "connect",
+                        "describe",
+                        "instructions",
+                        "search",
+                        "server",
+                        "action",
+                    ]) {
+                        if (value[key] !== undefined && typeof value[key] !== "string") {
+                            throw new Error(`Invalid nested gateway param \`${key}\`: expected string, got ${Array.isArray(value[key]) ? "array" : typeof value[key]}`);
+                        }
+                    }
+                    for (const key of ["regex", "includeSchemas"]) {
+                        if (value[key] !== undefined && typeof value[key] !== "boolean") {
+                            throw new Error(`Invalid nested gateway param \`${key}\`: expected boolean, got ${Array.isArray(value[key]) ? "array" : typeof value[key]}`);
+                        }
+                    }
+                    for (const key of ["limit", "offset"]) {
+                        if (value[key] !== undefined && typeof value[key] !== "number") {
+                            throw new Error(`Invalid nested gateway param \`${key}\`: expected number, got ${Array.isArray(value[key]) ? "array" : typeof value[key]}`);
+                        }
+                    }
+                    const args = value.args;
+                    if (args !== undefined &&
+                        typeof args !== "string" &&
+                        (typeof args !== "object" || args === null || Array.isArray(args))) {
+                        throw new Error(`Invalid nested gateway param \`args\`: expected JSON object or JSON string, got ${Array.isArray(args) ? "array" : args === null ? "null" : typeof args}`);
+                    }
+                    return value;
+                };
+                let parsedArgs = parseArgs(params.args);
+                let dispatchParams = params;
+                const hasGatewayMode = (value) => value.tool !== undefined ||
+                    value.connect !== undefined ||
+                    value.describe !== undefined ||
+                    value.instructions !== undefined ||
+                    value.search !== undefined ||
+                    value.server !== undefined ||
+                    value.action !== undefined;
+                if (!hasGatewayMode(params) && parsedArgs) {
+                    const nestedParams = validateNestedGatewayParams(parsedArgs);
+                    if (hasGatewayMode(nestedParams)) {
+                        dispatchParams = nestedParams;
+                        parsedArgs = parseArgs(nestedParams.args);
+                    }
+                    else {
+                        throw new Error('Gateway params were nested inside `args`; pass them top-level (for example, mcp({ search: "..." }) or mcp({ tool: "...", args: {} })).');
+                    }
+                }
+                else if (!hasGatewayMode(params) && params.args !== undefined) {
+                    throw new Error('Gateway params were nested inside `args`; pass them top-level (for example, mcp({ search: "..." }) or mcp({ tool: "...", args: {} })).');
+                }
+                if (!state && initPromise) {
+                    try {
+                        const initialized = await awaitWithTimeout(initPromise, INIT_WAIT_TIMEOUT_MS);
+                        if (initialized === INIT_WAIT_TIMED_OUT) {
+                            return {
+                                content: [
+                                    {
+                                        type: "text",
+                                        text: "MCP initialization is still in progress. Try again shortly.",
+                                    },
+                                ],
+                                details: { error: "init_timeout", timeoutMs: INIT_WAIT_TIMEOUT_MS },
+                            };
+                        }
+                        executeOwner?.throwIfInactive();
+                        state = initialized;
+                    }
+                    catch (error) {
+                        if (executeOwner && isAbortError(error, executeOwner.signal))
+                            throw error;
+                        const message = error instanceof Error ? error.message : String(error);
+                        return {
+                            content: [{ type: "text", text: `MCP initialization failed: ${message}` }],
+                            details: { error: "init_failed", message },
+                        };
+                    }
+                }
+                if (!state) {
+                    return {
+                        content: [{ type: "text", text: "MCP not initialized" }],
+                        details: { error: "not_initialized" },
+                    };
+                }
+                executeOwner?.throwIfInactive();
+                if (dispatchParams.action === "ui-messages") {
+                    return executeUiMessages(state);
+                }
+                if (dispatchParams.action === "auth-start") {
+                    if (!dispatchParams.server) {
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: 'auth-start requires `server`. Example: mcp({ action: "auth-start", server: "linear-server" })',
+                                },
+                            ],
+                            details: { mode: "auth-start", error: "missing_server" },
+                        };
+                    }
+                    return signal
+                        ? executeAuthStart(state, dispatchParams.server, signal)
+                        : executeAuthStart(state, dispatchParams.server);
+                }
+                if (dispatchParams.action === "auth-complete") {
+                    if (!dispatchParams.server) {
+                        return {
+                            content: [{ type: "text", text: "auth-complete requires `server`." }],
+                            details: { mode: "auth-complete", error: "missing_server" },
+                        };
+                    }
+                    const input = parsedArgs?.redirectUrl ?? parsedArgs?.code ?? parsedArgs?.input;
+                    if (typeof input !== "string" || input.trim().length === 0) {
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: "auth-complete requires args with `redirectUrl`, `code`, or `input`.",
+                                },
+                            ],
+                            details: { mode: "auth-complete", error: "missing_input" },
+                        };
+                    }
+                    return signal
+                        ? executeAuthComplete(state, dispatchParams.server, input, signal)
+                        : executeAuthComplete(state, dispatchParams.server, input);
+                }
+                if (dispatchParams.tool) {
+                    return executeCall(state, dispatchParams.tool, parsedArgs, dispatchParams.server, getNexusTools, signal);
+                }
+                if (dispatchParams.connect) {
+                    const result = await executeConnect(state, dispatchParams.connect, signal);
+                    syncToolSurface(_ctx);
+                    return result;
+                }
+                if (dispatchParams.describe) {
+                    return executeDescribe(state, dispatchParams.describe);
+                }
+                if (dispatchParams.instructions) {
+                    return executeInstructions(state, dispatchParams.instructions);
+                }
+                if (dispatchParams.search !== undefined) {
+                    return executeSearch(state, dispatchParams.search, dispatchParams.regex, dispatchParams.server, dispatchParams.includeSchemas, dispatchParams.limit, dispatchParams.offset);
+                }
+                if (dispatchParams.server) {
+                    return executeList(state, dispatchParams.server);
+                }
+                return executeStatus(state);
+            },
+        });
+        proxyToolRegistered = true;
+        proxyToolDescription = description;
+    }
+    function syncProxyTool(config, cache, directSpecs) {
+        const missingConfiguredDirectToolServers = getMissingConfiguredDirectToolServers(config, cache, envRaw === undefined || envRaw === "__none__" ? undefined : envDirectToolOverride);
+        const shouldRegisterProxyTool = config.settings?.disableProxyTool !== true ||
+            directSpecs.length === 0 ||
+            missingConfiguredDirectToolServers.length > 0;
+        if (shouldRegisterProxyTool) {
+            const description = buildProxyDescription(config, cache, directSpecs);
+            if (!proxyToolRegistered || proxyToolDescription !== description) {
+                registerProxyTool(description);
+                return;
+            }
+            const activeTools = getActiveToolsIfReady();
+            if (activeTools && !activeTools.includes("mcp")) {
+                nexus.setActiveTools([...activeTools, "mcp"]);
+            }
+            return;
+        }
+        if (proxyToolRegistered) {
+            const unregistered = deactivateTools(["mcp"]);
+            if (unregistered.includes("mcp")) {
+                proxyToolRegistered = false;
+                proxyToolDescription = null;
+            }
+        }
+    }
+    nexus.on("resources_discover", () => {
+        const skillsPath = join(import.meta.dirname, "skills");
+        if (existsSync(skillsPath))
+            return { skillPaths: [skillsPath] };
     });
+    const initialDirectTools = syncDirectTools(earlyConfig, earlyCache).specs;
+    syncProxyTool(earlyConfig, earlyCache, initialDirectTools);
+    startLoadTimeInitialization();
+}
+export function createMcpAdapter(options = {}) {
+    const factoryConfig = options.config !== undefined ? cloneMcpConfig(options.config) : undefined;
+    return function mcpAdapter(nexus) {
+        installMcpAdapter(nexus, {
+            ...(options.configPath !== undefined ? { configPath: options.configPath } : {}),
+            ...(factoryConfig !== undefined ? { config: cloneMcpConfig(factoryConfig) } : {}),
+        });
+    };
+}
+/**
+ * Register an MCP server with the adapter installed for this Nexus instance.
+ * Registrations are session/runtime scoped and never persisted. Duplicate
+ * names fail closed. Registered servers are proxy-tool-only; their tools
+ * become visible at the next tool sync. To change a definition, dispose the
+ * registration and register again.
+ */
+export function registerMcpServer(options) {
+    const { nexus, name, definition } = options;
+    const register = runtimeRegistrars.get(nexus);
+    if (!register) {
+        throw new Error("The native Nexus MCP runtime is not installed for this instance");
+    }
+    return register(name, definition);
 }
+export default createMcpAdapter();
 //# sourceMappingURL=index.js.map