@fitchmultz/pi-mcp-adapter 8.0.1 → 8.0.2

package/dist/host-html-template.js

@@ -332,11 +332,6 @@ export function buildHostHtmlTemplate(input) {
         bridge.setHostContext(JSON.parse(event.data));
       } catch {}
     });
-    eventSource.addEventListener("session-complete", async () => {
-      await bridge.teardownResource({}).catch(() => {});
-      eventSource.close();
-      closeOrShowDone();
-    });
     eventSource.onerror = () => {
       setStatus("Connection lost", true);
     };
@@ -345,18 +340,35 @@ export function buildHostHtmlTemplate(input) {
       post("/proxy/ui/heartbeat", {}).catch(() => {});
     }, 10000);
 
-    const complete = async (reason) => {
-      try {
-        await post("/proxy/ui/complete", { reason });
-      } catch {}
-      try {
-        await bridge.teardownResource({});
-      } catch {}
+    let completionRequested = false;
+    let finished = false;
+    const finish = async () => {
+      if (finished) return;
+      finished = true;
       clearInterval(heartbeat);
       eventSource.close();
+
+      try {
+        await bridge.teardownResource({});
+      } catch (error) {
+        // Apps may omit the optional teardown handler.
+        if (error?.code !== -32601) console.error("[host] Resource teardown failed:", error);
+      }
       closeOrShowDone();
     };
 
+    const complete = async (reason) => {
+      if (completionRequested || finished) return;
+      completionRequested = true;
+      try {
+        await post("/proxy/ui/complete", { reason });
+      } catch (error) {
+        console.error("[host] Session completion failed:", error);
+      }
+      await finish();
+    };
+
+    eventSource.addEventListener("session-complete", finish);
     doneBtn.addEventListener("click", () => complete("done"));
     cancelBtn.addEventListener("click", () => complete("cancel"));
     window.addEventListener("keydown", (event) => {

package/dist/index.js

@@ -1,22 +1,17 @@
 import { Type } from "typebox";
-import { showStatus, showTools, showPrompts, reconnectServer, reconnectServers, authenticateServer, logoutServer, openMcpAuthPanel, openMcpPanel, openMcpSetup } from "./commands.js";
 import { cloneMcpConfig, isPathInsideProject, loadMcpConfig, writeProjectServerDisabledOverride } from "./config.js";
 import { buildProxyDescription, directToolSelection, getMissingConfiguredDirectToolServers } from "./direct-tools.js";
-import { flushMetadataCache, initializeMcp, lazyConnect, updateStatusBar } from "./init.js";
 import { getMetadataCachePath, isServerCacheValid, loadMetadataCache, reconstructToolMetadata } from "./metadata-cache.js";
 import { createPromptCommand, resolveCachedPrompts } from "./prompts.js";
 import { logger } from "./logger.js";
-import { executeAuthComplete, executeAuthStart, executeCall, executeConnect, executeDescribe, executeInstructions, executeList, executeSearch, executeStatus, executeUiMessages } from "./proxy-modes.js";
-import { formatTerminalError } from "./utils.js";
-import { createOAuthRuntime, shutdownOAuth } from "./mcp-auth-flow.js";
+import { DEFAULT_MCP_SCRIPT_TIMEOUT_MS, formatTerminalError } from "./utils.js";
+import { createOAuthRuntime, shutdownOAuth } from "./mcp-oauth-runtime.js";
 import { renderMcpProxyToolCall, renderMcpToolResult } from "./tool-result-renderer.js";
 import { createMcpRuntimeOwner, createOwnedUi, isAbortError } from "./runtime-owner.js";
 import { publishMcpStatusShutdown } from "./mcp-status.js";
-import { DEFAULT_MCP_SCRIPT_TIMEOUT_MS, runMcpScript } from "./mcp-code.js";
 import { MAX_PAGE_SIZE, paginate, rankToolMatches } from "./search-ranking.js";
 import { createToolLoader } from "./tool-loader.js";
 import { gatewayParameters, prepareGatewayArguments } from "./gateway-arguments.js";
-import { executeResourceList, executeResourceRead } from "./resource-tools.js";
 import { guardMcpOutput, guardedMcpDetails, readMcpResult, resolveMcpOutputGuardOptions } from "./mcp-output-guard.js";
 import { abortable, throwIfAborted } from "./abort.js";
 export { MCP_STATUS_EVENT, MCP_STATUS_SNAPSHOT_VERSION, } from "./types.js";
@@ -47,6 +42,9 @@ function installMcpAdapter(pi, options) {
     let currentOAuthRuntime = null;
     let lifecycleGeneration = 0;
     let currentConfigPath;
+    // init loads during session_start, after the cached surface registers, keeping it off the extension-load path.
+    // Command, panel, gateway, script and resource modules load on first use.
+    let initModule;
     async function shutdownState(currentState, reason) {
         if (!currentState) {
             publishMcpStatusShutdown(pi.events);
@@ -67,7 +65,7 @@ function installMcpAdapter(pi, options) {
         }
         currentState.uiServer = null;
         try {
-            flushMetadataCache(currentState);
+            initModule?.flushMetadataCache(currentState);
         }
         catch (error) {
             failures.push(error);
@@ -132,8 +130,8 @@ function installMcpAdapter(pi, options) {
         description: "Path to MCP config file",
         type: "string",
     });
-    function startInitialization(ctx, owner, oauthRuntime, runtimeConfig, generation) {
-        const promise = initializeMcp(pi, ctx, owner, {
+    function startInitialization(init, ctx, owner, oauthRuntime, runtimeConfig, generation) {
+        const promise = init.initializeMcp(pi, ctx, owner, {
             ...(programmaticConfig ? { config: runtimeConfig } : { resolvedConfig: runtimeConfig }),
             ...(options.outputDirectory !== undefined ? { outputDirectory: options.outputDirectory } : {}),
             oauthRuntime,
@@ -164,12 +162,12 @@ function installMcpAdapter(pi, options) {
             };
             for (const server of toolLoader.selectedServers()) {
                 if (!nextState.toolMetadata.has(server) && nextState.config.mcpServers[server])
-                    await lazyConnect(nextState, server, owner.signal);
+                    await init.lazyConnect(nextState, server, owner.signal);
             }
             owner.throwIfInactive();
             syncPromptCommands();
             syncToolSurface(ctx);
-            updateStatusBar(nextState);
+            init.updateStatusBar(nextState);
             initPromise = null;
             if (nextState.config.settings?.freezeDirectTools === true) {
                 directToolsFrozen = true;
@@ -246,7 +244,11 @@ function installMcpAdapter(pi, options) {
         registerPromptCommands(resolveCachedPrompts(runtimeConfig, metadataCacheEnabled));
         const runtimeCache = loadMetadataCache(metadataCacheEnabled);
         toolLoader.sync(runtimeConfig, runtimeCache, envRaw === "__none__" ? null : envDirectToolOverride, specs => syncGateways(runtimeConfig, runtimeCache, specs));
-        const initialization = startInitialization(ctx, owner, oauthRuntime, runtimeConfig, generation);
+        const init = await import("./init.js");
+        initModule = init;
+        if (generation !== lifecycleGeneration || !owner.isActive())
+            return;
+        const initialization = startInitialization(init, ctx, owner, oauthRuntime, runtimeConfig, generation);
         if (envRaw !== undefined && envRaw !== "__none__") {
             const missingEnvDirectTools = getMissingConfiguredDirectToolServers(runtimeConfig, runtimeCache, envDirectToolOverride);
             if (missingEnvDirectTools.length > 0) {
@@ -358,6 +360,7 @@ function installMcpAdapter(pi, options) {
             const commandState = await ensureCommandState(commandOwner, commandCtx);
             if (!commandState)
                 return;
+            const { showStatus, showTools, showPrompts, reconnectServers, logoutServer, openMcpPanel, openMcpSetup } = await import("./commands.js");
             const parts = args?.trim()?.split(/\s+/) ?? [];
             const subcommand = parts[0] ?? "";
             const targetServer = parts[1];
@@ -467,6 +470,7 @@ function installMcpAdapter(pi, options) {
             const commandState = await ensureCommandState(commandOwner, commandCtx);
             if (!commandState)
                 return;
+            const { authenticateServer, openMcpAuthPanel, reconnectServer } = await import("./commands.js");
             if (!serverName) {
                 if (programmaticConfig) {
                     commandCtx.ui?.notify("Use /mcp-auth <server> to authenticate a server from the in-memory SDK config.", "info");
@@ -519,8 +523,9 @@ function installMcpAdapter(pi, options) {
         const ready = await getToolState(signal);
         if ("content" in ready)
             return { ...ready, tools: [] };
+        const proxy = await import("./proxy-modes.js");
         if (params.server && !ready.toolMetadata.has(params.server)) {
-            const discovery = await executeConnect(ready, params.server, signal);
+            const discovery = await proxy.executeConnect(ready, params.server, signal);
             if (discovery.details.error)
                 return { ...discovery, tools: [] };
         }
@@ -531,7 +536,7 @@ function installMcpAdapter(pi, options) {
         const tools = toolLoader.activate(page.items, params.enable);
         const unavailable = unavailableFeatures(params.enable, tools);
         const typedCount = tools.filter(tool => tool.name !== "mcp" && tool.name !== "mcp_script").length;
-        const result = executeSearch(ready, params.query, params.server, typedCount < page.items.length, params.limit ?? 5, params.offset, "mcp_search");
+        const result = proxy.executeSearch(ready, params.query, params.server, typedCount < page.items.length, params.limit ?? 5, params.offset, "mcp_search");
         const guarded = await guardMcpOutput([
             ...result.content,
             { type: "text", text: tools.length ? `Loaded for the next request: ${JSON.stringify(tools)}` : 'No direct tools loaded. Enable gateway or script with mcp_search({ enable: ["gateway"] }) or mcp_search({ enable: ["script"] }), then use mcp action call or tools.call with the returned exact names.' },
@@ -548,7 +553,7 @@ function installMcpAdapter(pi, options) {
             server: Type.Optional(Type.String()),
             limit: Type.Optional(Type.Integer({ minimum: 1, maximum: MAX_PAGE_SIZE, description: "Tools to load (default 5)." })),
             offset: Type.Optional(Type.Integer({ minimum: 0 })),
-        }, { anyOf: [{ required: ["query"] }, { required: ["enable"] }] }),
+        }, { anyOf: [{ type: "object", required: ["query"] }, { type: "object", required: ["enable"] }] }),
         renderResult: renderMcpToolResult,
         async execute(toolCallId, params, signal, _onUpdate, ctx) {
             if (beforeExecute) {
@@ -582,6 +587,7 @@ function installMcpAdapter(pi, options) {
                 const ready = await getToolState(signal);
                 if ("content" in ready)
                     return ready;
+                const { runMcpScript } = await import("./mcp-code.js");
                 return runMcpScript(ready, params.code, params.timeoutMs ?? options.defaultScriptTimeoutMs, getPiTools, signal, toolCallId, beforeExecute ? (callSignal, operation) => beforeExecute(toolCallId, { ...ctx, signal: callSignal }, operation) : undefined);
             },
         });
@@ -607,6 +613,7 @@ function installMcpAdapter(pi, options) {
                 const ready = await getToolState(signal);
                 if ("content" in ready)
                     return ready;
+                const proxy = await import("./proxy-modes.js");
                 const present = async (result) => {
                     const guarded = await guardMcpOutput(result.content, resolveMcpOutputGuardOptions(ready.config.settings, ready.outputDirectory));
                     return { content: guarded.content, details: { ...result.details, ...guardedMcpDetails(guarded) } };
@@ -615,34 +622,34 @@ function installMcpAdapter(pi, options) {
                     ? (callSignal, operation) => beforeExecute(toolCallId, { ...ctx, signal: callSignal }, operation)
                     : undefined;
                 if (params.server && ["list", "search", "describe", "instructions"].includes(params.action) && !ready.toolMetadata.has(params.server)) {
-                    const discovery = await executeConnect(ready, params.server, signal);
+                    const discovery = await proxy.executeConnect(ready, params.server, signal);
                     if (discovery.details.error)
                         return discovery;
                     syncToolSurface(ctx);
                 }
                 switch (params.action) {
-                    case "ui-messages": return executeUiMessages(ready);
-                    case "auth-start": return executeAuthStart(ready, params.server, signal);
+                    case "ui-messages": return proxy.executeUiMessages(ready);
+                    case "auth-start": return proxy.executeAuthStart(ready, params.server, signal);
                     case "auth-complete": {
                         const input = params.args?.redirectUrl ?? params.args?.code ?? params.args?.input;
                         if (input !== undefined && (typeof input !== "string" || input.trim().length === 0))
                             throw new Error("auth-complete requires a non-empty redirectUrl, code, or input");
-                        return executeAuthComplete(ready, params.server, input, signal);
+                        return proxy.executeAuthComplete(ready, params.server, input, signal);
                     }
-                    case "call": return executeCall(ready, params.tool, params.args, params.server, getPiTools, signal, { toolCallId }, beforeDispatch);
+                    case "call": return proxy.executeCall(ready, params.tool, params.args, params.server, getPiTools, signal, { toolCallId }, beforeDispatch);
                     case "connect": {
-                        const result = await executeConnect(ready, params.server, signal, params.limit, params.offset);
+                        const result = await proxy.executeConnect(ready, params.server, signal, params.limit, params.offset);
                         syncToolSurface(ctx);
                         return present(result);
                     }
-                    case "describe": return present(executeDescribe(ready, params.tool, params.server));
-                    case "instructions": return present(executeInstructions(ready, params.server));
-                    case "search": return present(executeSearch(ready, params.query, params.server, params.includeSchemas, params.limit, params.offset));
-                    case "list": return present(executeList(ready, params.server, params.limit, params.offset));
-                    case "resources": return present(await executeResourceList(ready, params.server, params.limit, params.offset, signal));
-                    case "read-resource": return executeResourceRead(ready, params.server, params.uri, signal, { toolCallId }, beforeDispatch);
+                    case "describe": return present(proxy.executeDescribe(ready, params.tool, params.server));
+                    case "instructions": return present(proxy.executeInstructions(ready, params.server));
+                    case "search": return present(proxy.executeSearch(ready, params.query, params.server, params.includeSchemas, params.limit, params.offset));
+                    case "list": return present(proxy.executeList(ready, params.server, params.limit, params.offset));
+                    case "resources": return present(await (await import("./resource-tools.js")).executeResourceList(ready, params.server, params.limit, params.offset, signal));
+                    case "read-resource": return (await import("./resource-tools.js")).executeResourceRead(ready, params.server, params.uri, signal, { toolCallId }, beforeDispatch);
                     case "read-result": return readMcpResult({ ref: params.ref, ...(params.path !== undefined ? { path: params.path } : {}), ...(params.fields ? { fields: params.fields } : {}), ...(params.offset !== undefined ? { offset: params.offset } : {}), ...(params.limit !== undefined ? { limit: params.limit } : {}) }, resolveMcpOutputGuardOptions(ready.config.settings, ready.outputDirectory));
-                    case "status": return present(executeStatus(ready));
+                    case "status": return present(proxy.executeStatus(ready));
                 }
             },
         });

package/dist/init.d.ts

@@ -1,7 +1,7 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { McpExtensionState } from "./state.ts";
 import { type McpAdapterOptions, type McpConfig } from "./types.ts";
-import { type McpOAuthRuntime } from "./mcp-auth-flow.ts";
+import { type McpOAuthRuntime } from "./mcp-oauth-runtime.ts";
 import { type McpRuntimeOwner } from "./runtime-owner.ts";
 export declare function clearFailure(state: McpExtensionState, serverName: string): void;
 export declare function recordFailure(state: McpExtensionState, serverName: string, message: string): void;

package/dist/init.js

@@ -10,7 +10,7 @@ import { formatMcpStatus, openUrl, parallelLimit, sanitizeTerminalText } from ".
 import { logger } from "./logger.js";
 import { throwIfAborted } from "./abort.js";
 import { getAuthStorageOptions } from "./mcp-auth.js";
-import { createOAuthRuntime, hasPendingAuth, shutdownOAuth } from "./mcp-auth-flow.js";
+import { createOAuthRuntime, hasPendingAuth, shutdownOAuth } from "./mcp-oauth-runtime.js";
 import { combineAbortSignals, createMcpRuntimeOwner, createOwnedUi, isAbortError, } from "./runtime-owner.js";
 import { publishMcpStatusSnapshot } from "./mcp-status.js";
 const FAILURE_BACKOFF_MS = 60 * 1000;
@@ -229,40 +229,48 @@ export async function initializeMcp(pi, ctx, owner = createMcpRuntimeOwner(), op
     if (initialSignal?.aborted)
         return state;
     owner.throwIfInactive();
-    for (const { name, definition, connection, error } of results) {
-        owner.throwIfInactive();
-        if (error || !connection) {
-            if (initialSignal?.aborted)
+    const startupCache = { entries: new Map() };
+    try {
+        for (const { name, definition, connection, error } of results) {
+            owner.throwIfInactive();
+            if (error || !connection) {
+                if (initialSignal?.aborted)
+                    continue;
+                saveMetadataCacheUpdates(state, startupCache);
+                if (error)
+                    recordFailure(state, name, error);
+                const displayError = sanitizeTerminalText(error ?? "Unknown connection failure");
+                if (ui) {
+                    ui.notify(`MCP: Failed to connect to ${name}: ${displayError}`, "error");
+                }
+                console.error(`MCP: Failed to connect to ${name}: ${displayError}`);
                 continue;
-            if (error)
-                recordFailure(state, name, error);
-            const displayError = sanitizeTerminalText(error ?? "Unknown connection failure");
-            if (ui) {
-                ui.notify(`MCP: Failed to connect to ${name}: ${displayError}`, "error");
             }
-            console.error(`MCP: Failed to connect to ${name}: ${displayError}`);
-            continue;
-        }
-        const { metadata, failedTools } = buildToolMetadata(connection.tools, connection.resources, definition, name, prefix);
-        toolMetadata.set(name, metadata);
-        resourceCounts.set(name, connection.resources.length);
-        if (!connection.promptDiscoveryFailed) {
-            promptMetadata.set(name, reconstructPromptMetadata(name, connection.prompts ?? [], prefix, definition));
-            promptMetadataLive.add(name);
-        }
-        if (connection.instructions) {
-            serverInstructions.set(name, connection.instructions);
-        }
-        else {
-            serverInstructions.delete(name);
-        }
-        updateMetadataCache(state, name);
-        notifyToolMetadataUpdated(state, name, "startup");
-        markKeepAliveAfterConnect(state, name);
-        if (failedTools.length > 0 && ui) {
-            ui.notify(`MCP: ${name} - ${failedTools.length} tools skipped`, "warning");
+            const { metadata, failedTools } = buildToolMetadata(connection.tools, connection.resources, definition, name, prefix);
+            toolMetadata.set(name, metadata);
+            resourceCounts.set(name, connection.resources.length);
+            if (!connection.promptDiscoveryFailed) {
+                promptMetadata.set(name, reconstructPromptMetadata(name, connection.prompts ?? [], prefix, definition));
+                promptMetadataLive.add(name);
+            }
+            if (connection.instructions) {
+                serverInstructions.set(name, connection.instructions);
+            }
+            else {
+                serverInstructions.delete(name);
+            }
+            collectMetadataCacheUpdate(state, name, startupCache);
+            notifyToolMetadataUpdated(state, name, "startup");
+            markKeepAliveAfterConnect(state, name);
+            if (failedTools.length > 0 && ui) {
+                saveMetadataCacheUpdates(state, startupCache);
+                ui.notify(`MCP: ${name} - ${failedTools.length} tools skipped`, "warning");
+            }
         }
     }
+    finally {
+        saveMetadataCacheUpdates(state, startupCache);
+    }
     const connectedCount = results.filter(r => r.connection).length;
     const failedCount = results.filter(r => r.error).length;
     if (ui && connectedCount > 0) {
@@ -382,7 +390,7 @@ export function updateServerMetadata(state, serverName) {
         state.serverInstructions?.delete(serverName);
     }
 }
-export function updateMetadataCache(state, serverName, options = {}) {
+function collectMetadataCacheUpdate(state, serverName, updates, options = {}) {
     const connection = state.manager.getConnection(serverName);
     if (!connection || connection.status !== "connected")
         return;
@@ -390,8 +398,9 @@ export function updateMetadataCache(state, serverName, options = {}) {
     if (!definition || isServerDisabled(definition))
         return;
     const configHash = computeServerHash(definition);
-    const existing = loadMetadataCache(state.metadataCacheEnabled);
-    const existingEntry = existing?.servers?.[serverName];
+    if (updates.existing === undefined)
+        updates.existing = loadMetadataCache(state.metadataCacheEnabled);
+    const existingEntry = updates.existing?.servers?.[serverName];
     const tools = serializeTools(connection.tools);
     let resources = definition.exposeResources === false ? [] : serializeResources(connection.resources);
     const prompts = connection.promptDiscoveryFailed
@@ -412,7 +421,20 @@ export function updateMetadataCache(state, serverName, options = {}) {
         ...(connection.instructions !== undefined ? { instructions: connection.instructions } : {}),
         cachedAt: Date.now(),
     };
-    saveMetadataCache({ version: 1, servers: { [serverName]: entry } }, state.metadataCacheEnabled);
+    updates.entries.set(serverName, entry);
+}
+function saveMetadataCacheUpdates(state, updates) {
+    if (updates.entries.size === 0)
+        return;
+    const servers = Object.fromEntries(updates.entries);
+    updates.entries.clear();
+    delete updates.existing;
+    saveMetadataCache({ version: 1, servers }, state.metadataCacheEnabled, Object.keys(state.config.mcpServers));
+}
+export function updateMetadataCache(state, serverName, options = {}) {
+    const updates = { entries: new Map() };
+    collectMetadataCacheUpdate(state, serverName, updates, options);
+    saveMetadataCacheUpdates(state, updates);
 }
 export function notifyToolMetadataUpdated(state, serverName, reason) {
     try {
@@ -430,11 +452,17 @@ export function notifyToolMetadataUpdated(state, serverName, reason) {
     }
 }
 export function flushMetadataCache(state) {
-    for (const [name, connection] of state.manager.getAllConnections()) {
-        if (connection.status === "connected") {
-            updateMetadataCache(state, name);
+    const updates = { entries: new Map() };
+    try {
+        for (const [name, connection] of state.manager.getAllConnections()) {
+            if (connection.status === "connected") {
+                collectMetadataCacheUpdate(state, name, updates);
+            }
         }
     }
+    finally {
+        saveMetadataCacheUpdates(state, updates);
+    }
 }
 export function updateStatusBar(state) {
     publishMcpStatusSnapshot(state);

package/dist/lifecycle.d.ts

@@ -1,6 +1,6 @@
 import { type ServerDefinition } from "./types.ts";
 import type { McpServerManager } from "./server-manager.ts";
-import { hasPendingAuth } from "./mcp-auth-flow.ts";
+import { hasPendingAuth } from "./mcp-oauth-runtime.ts";
 export type ReconnectCallback = (serverName: string) => void;
 export type ReconnectFailureCallback = (serverName: string, error: unknown) => void;
 export declare class McpLifecycleManager {

package/dist/lifecycle.js

@@ -1,5 +1,5 @@
 import { isServerDisabled } from "./types.js";
-import { hasPendingAuth } from "./mcp-auth-flow.js";
+import { hasPendingAuth } from "./mcp-oauth-runtime.js";
 import { logger } from "./logger.js";
 import { formatTerminalError, sanitizeTerminalText } from "./utils.js";
 export class McpLifecycleManager {

package/dist/mcp-auth-flow.d.ts

@@ -5,36 +5,14 @@
  */
 import { UnauthorizedError, InsufficientScopeError, SdkHttpError } from "@modelcontextprotocol/client";
 import { type McpOAuthConfig } from "./mcp-oauth-provider.ts";
-import { type AuthStorageOptions } from "./mcp-auth.ts";
 import { type ServerEntry } from "./types.ts";
-/** Auth status for a server */
-export type AuthStatus = "authenticated" | "expired" | "not_authenticated";
-export interface McpOAuthRuntime {
-    readonly signal: AbortSignal;
-}
-export interface AuthenticateOptions {
-    onAuthorizationUrl?: (authorizationUrl: string) => void | Promise<void>;
-    authStorageOptions?: AuthStorageOptions;
-    signal?: AbortSignal;
-    runtime?: McpOAuthRuntime;
-}
-export declare function createOAuthRuntime(signal?: AbortSignal): McpOAuthRuntime;
-type OAuthRequest = {
-    serverName: string;
-    serverUrl: string;
-    requestedScope?: string;
-    challenge?: {
-        requiredScope?: string;
-        resourceMetadataUrl?: URL;
-    };
-    issuer?: string;
-};
+import { type AuthStatus, type AuthenticateOptions, type McpOAuthRuntime, type OAuthRequest } from "./mcp-oauth-runtime.ts";
+export { createOAuthRuntime, hasPendingAuth, initializeOAuth, shutdownOAuth, supportsOAuth, type AuthStatus, type AuthenticateOptions, type McpOAuthRuntime, } from "./mcp-oauth-runtime.ts";
 export declare function isOAuthChallenge(error: unknown): error is InsufficientScopeError | UnauthorizedError | SdkHttpError;
 export declare function getOAuthRequest(serverName: string, serverUrl: string, storageBase: string, runtime?: McpOAuthRuntime): OAuthRequest | undefined;
 /** Observe native challenges only; no credential reads or auth work here. */
 export declare function recordOAuthChallenge(serverName: string, serverUrl: string, storageBase: string, error: unknown, runtime?: McpOAuthRuntime): void;
 export declare function bindOAuthRequestIssuer(serverName: string, serverUrl: string, storageBase: string, issuer: string, runtime?: McpOAuthRuntime): void;
-export declare function hasPendingAuth(serverName: string, options?: AuthStorageOptions, runtime?: McpOAuthRuntime): boolean;
 /**
  * Extract OAuth configuration from a ServerEntry.
  */
@@ -86,22 +64,3 @@ export declare function authenticate(serverName: string, serverUrl: string, defi
  * @param serverName - The name of the MCP server
  */
 export declare function removeAuth(serverName: string, options?: AuthenticateOptions): Promise<void>;
-/**
- * Check if OAuth is supported for a server configuration.
- * OAuth is supported for HTTP servers unless explicitly disabled.
- *
- * @param definition - The server definition
- * @returns True if OAuth is supported
- */
-export declare function supportsOAuth(definition: ServerEntry): boolean;
-/**
- * Initialize the OAuth system on startup.
- * OAuth callback binding is lazy and starts from startAuth() only.
- */
-export declare function initializeOAuth(runtimeOrSignal?: McpOAuthRuntime | AbortSignal): Promise<McpOAuthRuntime>;
-/**
- * Shutdown one OAuth runtime. The callback server remains process-shared while
- * another runtime has pending/reserved callback state or is still active.
- */
-export declare function shutdownOAuth(runtime?: McpOAuthRuntime): Promise<void>;
-export {};