@fitchmultz/pi-mcp-adapter 5.0.0

package/dist/server-manager.d.ts

@@ -0,0 +1,114 @@
+import type { McpCheckpointEvent } from "./checkpoint.ts";
+import { Client, type RequestOptions, type GetPromptResult, type ReadResourceResult, type UrlElicitationRequiredError } from "@modelcontextprotocol/client";
+import { type McpTool, type McpResource, type McpPrompt, type ServerDefinition, type ServerStreamResultPatchNotification, type Transport, type McpTraceSettings } from "./types.ts";
+import { type McpOAuthRuntime } from "./mcp-auth-flow.ts";
+import { type AuthStorageOptions } from "./mcp-auth.ts";
+import { type ServerSamplingConfig } from "./sampling-handler.ts";
+import { type ServerElicitationConfig } from "./elicitation-handler.ts";
+export interface ServerConnection {
+    client: Client;
+    transport: Transport;
+    definition: ServerDefinition;
+    tools: McpTool[];
+    resources: McpResource[];
+    prompts: McpPrompt[];
+    /** True when prompts were advertised but prompts/list failed. */
+    promptDiscoveryFailed?: boolean;
+    instructions?: string;
+    lastUsedAt: number;
+    inFlight: number;
+    status: "connected" | "closed" | "needs-auth";
+    /** Whether this connection was constructed with the native OAuth provider. */
+    oauthProvider?: boolean;
+}
+type UiStreamListener = (serverName: string, notification: ServerStreamResultPatchNotification["params"]) => void;
+type MetadataListChangedListener = (serverName: string, reason: string) => void;
+export declare class McpServerManager {
+    private readonly defaultCwd?;
+    private ownedClients;
+    private connections;
+    private connectPromises;
+    private reconnectPromises;
+    private retiredConnections;
+    private disposePromises;
+    private uiStreamListeners;
+    private samplingConfig;
+    private metadataListChangedListener;
+    private elicitationConfig;
+    private authStorageOptions;
+    private oauthRuntime;
+    private acceptedUrlElicitations;
+    private defaultRequestTimeoutMs;
+    private runtimeSignal;
+    private closePromises;
+    private closeGenerations;
+    private connectAttempts;
+    private traceSettings;
+    private traceWriter;
+    private stopped;
+    private checkpoint;
+    private readonly beforeActivity;
+    holdCheckpoint(event: McpCheckpointEvent): () => void;
+    getCheckpointBlocker(): string | undefined;
+    flushForCheckpoint(): Promise<void>;
+    private releaseClientWhenSettled;
+    /** Fence before SDK callbacks AND before trace observers; retain native transport identity.
+     * Preserve existing property setters (including tracing) rather than replacing their behavior. */
+    private fenceTransport;
+    /** Default cwd for stdio servers without an explicit config `cwd`. */
+    constructor(defaultCwd?: string | undefined);
+    setSamplingConfig(config: ServerSamplingConfig | undefined): void;
+    setMetadataListChangedListener(listener: MetadataListChangedListener | undefined): void;
+    setElicitationConfig(config: ServerElicitationConfig | undefined): void;
+    setRuntimeSignal(signal: AbortSignal | undefined): void;
+    setDefaultRequestTimeoutMs(timeoutMs: number | undefined): void;
+    setTraceConfig(settings: McpTraceSettings | undefined): void;
+    setAuthStorageOptions(options: AuthStorageOptions): void;
+    setOAuthRuntime(runtime: McpOAuthRuntime): void;
+    getRequestOptions(name: string, signal?: AbortSignal): RequestOptions | undefined;
+    private getResolvedRequestTimeoutMs;
+    private buildRequestOptions;
+    connect(name: string, definition: ServerDefinition, signal?: AbortSignal): Promise<ServerConnection>;
+    /**
+     * Reconnect a server whose connection was proven stale (e.g. by a 404
+     * "session no longer exists" response). Single-flight per server name —
+     * concurrent callers that raced to the same failure share one reconnect —
+     * and identity-guarded: `staleConnection` is only retired if it is
+     * still the manager's current connection for `name`. If a concurrent
+     * reconnect (or an unrelated connect()) already replaced it with a fresh
+     * connection, that fresh connection is returned untouched.
+     */
+    reconnect(name: string, definition: ServerDefinition, staleConnection: ServerConnection, signal?: AbortSignal): Promise<ServerConnection>;
+    private doReconnect;
+    /** Retire only the expected current client; accepted native work drains before close. */
+    retire(name: string, connection: ServerConnection): void;
+    private createConnection;
+    private connectClientWithAbort;
+    private buildClientCapabilities;
+    private createClient;
+    private handleToolsListChanged;
+    private handlePromptsListChanged;
+    private handleResourcesListChanged;
+    handleUrlElicitationRequired(serverName: string, error: UrlElicitationRequiredError): Promise<"accept" | "decline" | "cancel">;
+    private rememberUrlElicitation;
+    private createHttpTransport;
+    private fetchAllTools;
+    private fetchAllPrompts;
+    private fetchAllResources;
+    private attachAdapterNotificationHandlers;
+    registerUiStreamListener(streamToken: string, listener: UiStreamListener): void;
+    removeUiStreamListener(streamToken: string): void;
+    getPrompt(name: string, promptName: string, args?: Record<string, string>, signal?: AbortSignal): Promise<GetPromptResult>;
+    readResource(name: string, uri: string, signal?: AbortSignal): Promise<ReadResourceResult>;
+    close(name: string): Promise<void>;
+    private disposeConnection;
+    closeAll(): Promise<void>;
+    private containsCleanupFailure;
+    getConnection(name: string): ServerConnection | undefined;
+    getAllConnections(): Map<string, ServerConnection>;
+    touch(name: string): void;
+    incrementInFlight(name: string): void;
+    decrementInFlight(name: string): void;
+    isIdle(name: string, timeoutMs: number): boolean;
+}
+export {};