@wrongstack/mcp 0.284.1 → 0.286.0

package/dist/index.d.ts

@@ -1,665 +1,15 @@
-import { Permission, Tool, ToolRegistry, EventBus, Logger, MCPServerConfig } from '@wrongstack/core';
-import * as https from 'node:https';
-
-type Transport = 'stdio' | 'sse' | 'streamable-http';
-interface MCPClientOptions {
-    name: string;
-    transport: Transport;
-    command?: string | undefined;
-    args?: string[] | undefined;
-    env?: Record<string, string> | undefined;
-    url?: string | undefined;
-    headers?: Record<string, string> | undefined;
-    startupTimeoutMs?: number | undefined;
-    requestTimeoutMs?: number | undefined;
-    /**
-     * Allowlist of env var names to forward from the parent process (process.env)
-     * to the child. Values are resolved at spawn time and merged into `env`
-     * via the `extra` path of `buildChildEnv` (unfiltered). This is how built-in
-     * MCP server presets (GitHub, Slack, Brave Search, …) get their API tokens
-     * without storing them in config.json or being scrubbed by the secret filter.
-     */
-    passthroughEnv?: string[] | undefined;
-}
-type ConnectionState = 'idle' | 'connecting' | 'connected' | 'disconnected' | 'reconnecting' | 'failed'
-/** Lazy server: registered from a cached manifest, process not spawned. */
- | 'dormant';
-interface MCPTool {
-    name: string;
-    description?: string | undefined;
-    inputSchema: Record<string, unknown>;
-}
-interface ToolCallResult {
-    content: unknown;
-    isError: boolean;
-}
-interface JsonRpcResponse {
-    jsonrpc: '2.0';
-    id: number;
-    result?: unknown | undefined;
-    error?: {
-        code: number | undefined;
-        message: string;
-        data?: unknown | undefined;
-    } | undefined;
-}
-type ExitListener = (name: string, code: number | null, signal: string | null) => void;
-/**
- * Fired when the server sends `notifications/tools/list_changed`. The
- * client refreshes its cached tool list before invoking listeners, so
- * subscribers can call `listTools()` for the fresh set.
- */
-type ToolsChangedListener = (name: string, tools: MCPTool[]) => void;
-/**
- * Lightweight MCP client supporting three transport types:
- * - stdio: spawns a child process and communicates over pipes
- * - sse: connects to an HTTP SSE endpoint for server events, POST for requests
- * - streamable-http: session-based HTTP transport with NDJSON responses
- */
-declare class MCPClient {
-    readonly opts: MCPClientOptions;
-    private state;
-    private child?;
-    private nextId;
-    /**
-     * In-flight JSON-RPC calls keyed by id. `resolve` settles the call; `reject`
-     * is invoked from {@link failPending} when the underlying transport dies
-     * (stdio child exit, `close()`) so callers don't hang forever.
-     */
-    private readonly pending;
-    private rxBuffer;
-    private _tools;
-    /** Cached tool list — survives reconnects so the registry can re-register without re-discovering. */
-    private _toolsCache?;
-    private _drainPending;
-    private _lastNotifySkipped;
-    private sseTransport?;
-    private httpTransport?;
-    /** Notified when the stdio child process exits so the registry can attempt reconnect. */
-    private readonly exitListeners;
-    /** Notified when the server announces a tools/list_changed notification. */
-    private readonly toolsChangedListeners;
-    /** Notified when an HTTP transport (SSE or streamable-http) disconnects. */
-    private readonly disconnectListeners;
-    constructor(opts: MCPClientOptions);
-    getState(): ConnectionState;
-    listTools(): MCPTool[];
-    /** Returns true if a prior notify() call was skipped due to backpressure. */
-    hadNotifySkipped(): boolean;
-    /**
-     * Register a listener for child-process exit events.
-     * The registry uses this to trigger reconnection.
-     */
-    addExitListener(listener: ExitListener): void;
-    removeExitListener(listener: ExitListener): void;
-    /**
-     * Register a listener for transport disconnect events (SSE / streamable-http).
-     * Used by the registry to trigger reconnection for HTTP-based servers.
-     */
-    addDisconnectListener(listener: () => void): void;
-    removeDisconnectListener(listener: () => void): void;
-    connect(): Promise<void>;
-    private connectStdio;
-    private connectSSE;
-    private connectStreamableHTTP;
-    callTool(name: string, input: unknown, opts?: {
-        signal?: AbortSignal | undefined;
-    }): Promise<ToolCallResult>;
-    close(): Promise<void>;
-    private request;
-    /**
-     * Reject every in-flight {@link request} call. Used when the underlying
-     * transport dies — without this, callers awaiting `tools/call` over a
-     * killed stdio child or a closed transport would hang indefinitely.
-     */
-    private failPending;
-    private notify;
-    private onData;
-    private onLine;
-    /**
-     * L2-C: refresh the cached tool list when the server announces a
-     * `tools/list_changed`. Listeners (the registry) re-wrap and
-     * re-register. Failures are swallowed — a stale cache is preferable
-     * to a hard crash on a transient notification glitch.
-     */
-    private handleToolsListChanged;
-    addToolsChangedListener(listener: ToolsChangedListener): void;
-    removeToolsChangedListener(listener: ToolsChangedListener): void;
-}
-
-/**
- * Resolves the live client for a tool call. A plain {@link MCPClient} for eager
- * servers, or a thunk that connects-on-demand for lazy/dormant servers (the
- * registry passes `() => this.ensureConnected(name)`).
- */
-type MCPClientResolver = MCPClient | (() => Promise<MCPClient>);
-declare function wrapMCPTool(serverName: string, mcpTool: MCPTool, client: MCPClientResolver, permission?: Permission): Tool;
-
-interface MCPRegistryOptions {
-    toolRegistry: ToolRegistry;
-    events: EventBus;
-    log: Logger;
-    /**
-     * Directory for the on-disk tool-manifest cache (lazy-connect). Without it,
-     * `lazy` servers cannot register tools cold and fall back to eager connect.
-     * Typically `wpaths.cacheDir` (`~/.wrongstack/cache`).
-     */
-    cacheDir?: string | undefined;
-    /**
-     * Idle window (ms) after which a connected lazy server is auto-stopped and
-     * re-woken on the next tool call. 0 disables idle auto-sleep.
-     * Default: {@link MCP_CONSTANTS.IDLE.DEFAULT_TIMEOUT_MS}.
-     */
-    idleTimeoutMs?: number | undefined;
-    /**
-     * Lazy mode: when true, MCP server tools are NOT registered into the
-     * tool registry on connect. They are cached internally and can be
-     * activated on demand via `activateServer(name)`. This is used in
-     * token-saving mode to avoid bloating the system prompt with 50-100+
-     * MCP tool descriptions. The model uses `mcp_control({ action: "activate", server: "..." })`
-     * to temporarily enable tools when needed.
-     * Default: false.
-     */
-    lazyMode?: boolean | undefined;
-}
-declare class MCPRegistry {
-    private readonly servers;
-    private readonly toolRegistry;
-    private readonly events;
-    private readonly log;
-    private readonly lazyMode;
-    private readonly cacheDir?;
-    private readonly idleTimeoutMs;
-    /** Single shared idle sweep timer (started lazily; unref'd; cleared on stopAll). */
-    private idleTimer?;
-    constructor(opts: MCPRegistryOptions);
-    start(cfg: MCPServerConfig): Promise<void>;
-    /**
-     * Boot a lazy server WITHOUT spawning it. If a tool manifest is cached (from a
-     * prior connect with matching config), register resolver-backed wrappers and
-     * go `dormant` — the process spawns on the first tool call. If there is no
-     * cache yet, do a one-time cold discovery connect to learn + cache the tools.
-     */
-    private startLazy;
-    /**
-     * Ensure a lazy server is connected, spawning it on demand. Single-flight:
-     * concurrent first-calls share one connect. Resolver wrappers call this.
-     */
-    ensureConnected(name: string): Promise<MCPClient>;
-    /**
-     * Register all cached tools for a given server into the tool registry.
-     * No-op if tools are already registered or the server is not connected.
-     * The server connection stays alive — this only toggles tool visibility.
-     */
-    activateServer(name: string): void;
-    /**
-     * Unregister all tools for a given server from the tool registry.
-     * The server connection stays alive — this only toggles tool visibility.
-     * Returns the number of tools that were deactivated.
-     */
-    deactivateServer(name: string): number;
-    /**
-     * Check whether a server's tools are currently registered.
-     */
-    isActivated(name: string): boolean;
-    stop(name: string): Promise<void>;
-    restart(name: string): Promise<void>;
-    list(): {
-        name: string;
-        state: ConnectionState;
-        toolCount: number;
-        tools: string[];
-    }[];
-    /**
-     * Resolve the live tool names for a slot — the registered names in normal
-     * mode, or the cached lazy-tool names when running in lazy mode (where
-     * tools are connected but intentionally not registered).
-     */
-    private toolNamesForSlot;
-    /**
-     * Wrap + register (or cache) a server's tools. Lazy servers get resolver-backed
-     * wrappers that spawn the process on first use; eager servers bind the live
-     * client directly. Honours token-saving `lazyMode` (cache, don't register) and
-     * a register-once guard for lazy resolver wrappers (so a wake/reconnect reuses
-     * the existing registrations rather than churning the tool list).
-     */
-    private applyTools;
-    /** Start the shared idle sweep timer once (unref'd so it never holds the process). */
-    private ensureIdleSweep;
-    /** Auto-sleep connected lazy servers that have been idle past the timeout. */
-    private sweepIdle;
-    /**
-     * Soft stop: close the server process but KEEP its resolver wrappers and
-     * cached manifest registered, so the next tool call transparently re-wakes it.
-     * Distinct from {@link stop} (full teardown for disable/remove).
-     */
-    private sleepIdle;
-    /**
-     * Catalog of every server ever registered with this registry — includes
-     * servers that are stopped, failed, or not yet started.
-     * Useful for the `mcp_control` tool to show all known servers without
-     * triggering connections.
-     */
-    describe(): {
-        name: string;
-        state: ConnectionState;
-        toolCount: number;
-        enabled: boolean;
-        tools: string[];
-    }[];
-    stopAll(): Promise<void>;
-    /**
-     * Health check — returns 'ok' for connected servers, the current state otherwise.
-     * For HTTP-based transports this could also ping the server.
-     */
-    health(): {
-        name: string;
-        alive: boolean;
-        latencyMs?: number | undefined;
-    }[];
-    /**
-     * L2-C: handle `notifications/tools/list_changed` from the server.
-     * Unregister the previous wrapper set, then re-register the fresh
-     * tool list. The client has already refreshed its cache before
-     * dispatching — we just need to re-wrap and re-register.
-     * In lazy mode, only update the internal cache without registering.
-     */
-    private readonly onToolsChanged;
-    private readonly onChildExit;
-    /** Handles SSE / streamable-http disconnect — same recovery as stdio child exit. */
-    private readonly onTransportDisconnect;
-    /**
-     * L2-B: maximum number of reconnect cycles before staying `failed`.
-     * One cycle = one full `attemptConnect` (which itself may try up to 3
-     * times). Caps total reconnect storm at ~5 cycles, then the slot
-     * needs an explicit `restart()` to re-engage.
-     */
-    private static readonly MAX_RECONNECT_CYCLES;
-    /** Base delay between cycles, in ms. Real delay adds jitter. */
-    private static readonly BASE_RECONNECT_DELAY_MS;
-    /** Hard ceiling on the inter-cycle delay so the user doesn't wait minutes. */
-    private static readonly MAX_RECONNECT_DELAY_MS;
-    private scheduleReconnect;
-    private attemptReconnect;
-    private attemptConnect;
-}
-
-/** Transport values accepted from UI surfaces (UI also offers a bare "http"). */
-type TransportInput = 'stdio' | 'sse' | 'streamable-http' | 'http';
-/** Loosely-typed server input as it arrives from a UI or command surface. */
-interface McpServerInput {
-    name: string;
-    transport?: TransportInput | string | undefined;
-    description?: string | undefined;
-    enabled?: boolean | undefined;
-    command?: string | undefined;
-    args?: string[] | undefined;
-    env?: Record<string, string> | undefined;
-    url?: string | undefined;
-    headers?: Record<string, string> | undefined;
-    allowedTools?: string[] | undefined;
-    permission?: Permission | undefined;
-    /** Lazy connect — spawn the process only on first tool call (see config). */
-    lazy?: boolean | undefined;
-    /** Env var names to forward from parent process at spawn time. */
-    passthroughEnv?: string[] | undefined;
-}
-/** Projected view of one server, merging disk config with live registry state. */
-interface McpServerInfo {
-    name: string;
-    transport: MCPServerConfig['transport'];
-    description?: string | undefined;
-    enabled: boolean;
-    /** Raw registry state ('connected' | 'connecting' | … | 'failed'), or 'stopped' when not running. */
-    status: string;
-    /** Real tool names discovered from the live server (empty when not connected). */
-    tools: string[];
-    url?: string | undefined;
-    command?: string | undefined;
-    /** Lazy-connect opt-in (spawn on first tool call). */
-    lazy?: boolean | undefined;
-}
-interface McpOpResult {
-    ok: boolean;
-    message: string;
-    /** The affected server's projected view, when applicable. */
-    server?: McpServerInfo | undefined;
-    /** Raw registry state after a start/restart attempt. */
-    state?: string | undefined;
-    /** Real tool names after a start/restart attempt. */
-    tools?: string[] | undefined;
-    /** Set when a config change persisted but the registry start/stop failed. */
-    registryError?: string | undefined;
-}
-interface McpManageDeps {
-    /** Absolute path to the global config.json that owns `mcpServers`. */
-    configPath: string;
-    /** Live registry for runtime start/stop/restart. */
-    registry: MCPRegistry;
-    /** Built-in presets (from core `allServers()`), used by name-only `add`. */
-    presets?: Record<string, MCPServerConfig> | undefined;
-}
-/** List all configured servers, merged with live registry status + tool names. */
-declare function listMcp(deps: McpManageDeps): Promise<McpServerInfo[]>;
-/**
- * Add a new server. `input` may be a fully-specified config, or just a `name`
- * matching a known preset (`deps.presets`). Fails if the server already exists.
- * When enabled, the server is started immediately via the registry.
- */
-declare function addMcp(input: McpServerInput, deps: McpManageDeps): Promise<McpOpResult>;
-/** Update an existing server's config, then re-apply it to the live registry. */
-declare function updateMcp(input: McpServerInput, deps: McpManageDeps): Promise<McpOpResult>;
-/** Remove a server from config and stop it if running. */
-declare function removeMcp(name: string, deps: McpManageDeps): Promise<McpOpResult>;
-/** Enable a server in config and start it. */
-declare function enableMcp(name: string, deps: McpManageDeps): Promise<McpOpResult>;
-/** Disable a server in config and stop it. */
-declare function disableMcp(name: string, deps: McpManageDeps): Promise<McpOpResult>;
-/** Restart a running server (or start it from config if registered but stopped). */
-declare function restartMcp(name: string, deps: McpManageDeps): Promise<McpOpResult>;
-/**
- * Discover a server's tools. Tools are discovered on connect, so this ensures
- * the server is running and returns its live tool list.
- */
-declare function discoverMcp(name: string, deps: McpManageDeps): Promise<McpOpResult>;
-
-/**
- * Server-side MCP. The mirror image of `MCPClient`: instead of consuming a
- * remote MCP server, this lets WrongStack *be* an MCP server — exposing its
- * tools to any MCP client (Claude Desktop, another agent, an IDE) over a
- * JSON-RPC 2.0 stream.
- *
- * The protocol core (`MCPServer`) is transport-agnostic: feed it a raw JSON
- * line via `handleMessage`, get back a response string (or `null` for
- * notifications). `serveStdio` wires it to stdin/stdout for the canonical
- * stdio transport.
- */
-/** A tool descriptor advertised over `tools/list`. */
-interface MCPServerTool {
-    name: string;
-    description?: string | undefined;
-    inputSchema: Record<string, unknown>;
-}
-/** The result of a `tools/call`, as the host produces it. */
-interface MCPServerCallResult {
-    /** Text or pre-built MCP content blocks. Strings are wrapped as a text block. */
-    content: unknown;
-    isError: boolean;
-}
-/**
- * Bridges the MCP server to a tool backend (in the CLI, the `ToolRegistry`).
- * Kept narrow so the protocol core has no dependency on `@wrongstack/core`.
- */
-interface MCPServerToolHost {
-    listTools(): MCPServerTool[] | Promise<MCPServerTool[]>;
-    callTool(name: string, args: Record<string, unknown>): Promise<MCPServerCallResult>;
-}
-interface MCPServerLogger {
-    warn?(msg: string): void;
-    info?(msg: string): void;
-}
-interface MCPServerOptions {
-    host: MCPServerToolHost;
-    /** Advertised in the `initialize` handshake. Defaults to the wrongstack identity. */
-    serverInfo?: {
-        name: string;
-        version: string;
-    };
-    logger?: MCPServerLogger | undefined;
-}
-declare class MCPServer {
-    private readonly host;
-    private readonly serverInfo;
-    private readonly logger?;
-    constructor(opts: MCPServerOptions);
-    /**
-     * Handle one raw JSON-RPC line. Returns the response JSON string for
-     * requests, or `null` for notifications (no `id`) and for blank input —
-     * the caller should write the string to its output stream when non-null.
-     */
-    handleMessage(raw: string): Promise<string | null>;
-    private dispatch;
-    private encodeError;
-}
-/** Normalize a host result's content into MCP content blocks. */
-declare function toContentBlocks(content: unknown): Array<{
-    type: 'text';
-    text: string;
-}>;
-interface ServeStdioHandle {
-    /** Stop reading and detach listeners. Does not exit the process. */
-    close(): void;
-    /** Resolves when the input stream ends (EOF). */
-    done: Promise<void>;
-}
-interface ServeStdioOptions {
-    stdin?: NodeJS.ReadableStream | undefined;
-    stdout?: NodeJS.WritableStream | undefined;
-}
-/**
- * Run an `MCPServer` over stdio: newline-delimited JSON-RPC in on stdin,
- * responses out on stdout. CRITICAL: nothing else may write to stdout while
- * this runs — it is the JSON-RPC channel. Route all logging to stderr.
- */
-declare function serveStdio(server: MCPServer, opts?: ServeStdioOptions): ServeStdioHandle;
-interface ServeHttpOptions {
-    /** TCP port. 0 picks an ephemeral port (resolved in the handle). Default 0. */
-    port?: number | undefined;
-    /** Bind address. Default '127.0.0.1' (loopback only). */
-    host?: string | undefined;
-    /**
-     * Bearer token required on every request (`Authorization: Bearer <token>`).
-     * REQUIRED when binding to a non-loopback host — `serveHttp` refuses to
-     * expose tools to the network without one.
-     */
-    token?: string | undefined;
-    logger?: MCPServerLogger | undefined;
-}
-interface ServeHttpHandle {
-    port: number;
-    host: string;
-    url: string;
-    close(): Promise<void>;
-}
-/**
- * Run an `MCPServer` over HTTP: POST a single JSON-RPC request, get the JSON
- * response (notifications → 202 with no body). Reuses `handleMessage`, so the
- * protocol is identical to the stdio transport.
- *
- * Security: binds to loopback by default. Binding to any other host (e.g.
- * `0.0.0.0`) REQUIRES a `token` — otherwise this rejects, because it would
- * otherwise expose tool execution to the whole network unauthenticated.
- */
-declare function serveHttp(server: MCPServer, opts?: ServeHttpOptions): Promise<ServeHttpHandle>;
-
-/**
- * Shared constants for the MCP package.
- *
- * Centralizing these values means:
- * - Protocol version and client identity are updated in one place
- * - Reconnect parameters can be overridden via config in the future
- * - No scattered magic values across multiple files
- */
-declare const MCP_CONSTANTS: Readonly<{
-    /** MCP protocol version advertised during handshake. */
-    readonly PROTOCOL_VERSION: "2024-11-05";
-    /** Identity announced to MCP servers during `initialize`. */
-    readonly CLIENT_INFO: Readonly<{
-        name: "wrongstack";
-        version: "0.1.10";
-    }>;
-    /** Reconnection behaviour when a transport disconnects. */
-    readonly RECONNECT: Readonly<{
-        /** Max full reconnect cycles before the slot is marked `failed`. */
-        MAX_CYCLES: 5;
-        /** Base delay between cycles (exponential backoff applied on top). */
-        BASE_DELAY_MS: 1000;
-        /** Jitter factor applied to the backoff (0 = no jitter, 1 = full). */
-        JITTER_FACTOR: 0.2;
-        /** Max connection attempts within a single cycle. */
-        MAX_ATTEMPTS: 3;
-        /** Base multiplier for the exponential backoff formula (`delay = BASE * multiplier^attempt`). */
-        BACKOFF_MULTIPLIER: 2;
-    }>;
-    /** Timing for graceful / forced disconnect. */
-    readonly DISCONNECT: Readonly<{
-        /** Ms to wait for in-flight requests to complete before force-closing. */
-        GRACEFUL_MS: 800;
-        /** Ms after which the force disconnect is triggered. */
-        FORCE_TIMEOUT_MS: 1200;
-    }>;
-    /** Lazy-connect idle lifecycle. */
-    readonly IDLE: Readonly<{
-        /** Default ms a lazy server stays connected with no tool calls before auto-sleep. */
-        DEFAULT_TIMEOUT_MS: 300000;
-        /** How often the idle sweep runs (kept well below the timeout). */
-        SWEEP_INTERVAL_MS: 30000;
-    }>;
-    /** JSON-RPC response timeout for outstanding requests. */
-    readonly RESPONSE_TIMEOUT_MS: 500;
-    /** Max buffer size for the SSE reader. */
-    readonly SSE_READER_MAX_BUFFER: number;
-    /** Max characters logged from a request body. */
-    readonly REQUEST_LOG_CAP: 1024;
-}>;
-
-/** Stable hash of the fields that define how/where we connect to a server. */
-declare function manifestConfigHash(cfg: {
-    transport: string;
-    command?: string | undefined;
-    args?: string[] | undefined;
-    url?: string | undefined;
-}): string;
-/**
- * Read a server's cached tools. Returns null when there is no cache or when the
- * stored `configHash` no longer matches (server config changed → stale).
- */
-declare function readManifest(cacheDir: string, name: string, configHash: string): Promise<MCPTool[] | null>;
-/** Persist a server's discovered tools. Best-effort — IO errors are swallowed. */
-declare function writeManifest(cacheDir: string, name: string, configHash: string, tools: MCPTool[]): Promise<void>;
-
-interface HttpTransportOptions {
-    name: string;
-    url: string;
-    headers?: Record<string, string> | undefined;
-    startupTimeoutMs?: number | undefined;
-    requestTimeoutMs?: number | undefined;
-    /**
-     * Per-request TLS configuration. When set, an https.Agent is created
-     * and passed to fetch via the `dispatch` option. This avoids globally
-     * disabling certificate validation (NODE_TLS_REJECT_UNAUTHORIZED) which
-     * would affect all provider API calls in the same process.
-     *
-     * ⚠️ Security gate: `rejectUnauthorized: false` REQUIRES
-     * `WRONGSTACK_UNSAFE_MCP_TLS=1` as an explicit opt-in.
-     *
-     * Without this gate, an active network attacker between the client and the
-     * MCP server can read and modify tool calls and responses. Only use this
-     * for local development with self-signed certificates; production MCP
-     * servers must present a valid certificate.
-     */
-    tls?: {
-        ca?: string | undefined;
-        rejectUnauthorized?: boolean | undefined;
-    };
-}
-declare class SSEReader {
-    private buffer;
-    private dataLines;
-    private listeners;
-    onMessage(cb: (data: {
-        jsonrpc?: string | undefined;
-        method?: string | undefined;
-        params?: unknown | undefined;
-        id?: number | undefined;
-    }) => void): () => void;
-    feed(chunk: string): void;
-    private processLine;
-    private flush;
-    private dispatch;
-    reset(): void;
-}
-/**
- * Fields and methods shared by all HTTP-based MCP transports.
- * Subclasses override `connect()`, `close()`, `callTool()`, `request()`.
- */
-declare abstract class BaseHTTPTransport {
-    protected state: ConnectionState;
-    protected readonly url: string;
-    protected readonly headers: Record<string, string>;
-    protected readonly timeout: number;
-    protected readonly requestTimeout: number;
-    /** Per-request TLS agent — created once from HttpTransportOptions.tls */
-    protected readonly tlsAgent?: https.Agent | undefined;
-    protected readonly tools: MCPTool[];
-    protected abortController?: AbortController | undefined;
-    protected readonly disconnectHandlers: Array<() => void>;
-    protected readonly toolsChangedListeners: Set<(tools: MCPTool[]) => void>;
-    constructor(opts: HttpTransportOptions, transportName: string);
-    getState(): ConnectionState;
-    listTools(): MCPTool[];
-    onDisconnect(cb: () => void): () => void;
-    onToolsChanged(cb: (tools: MCPTool[]) => void): () => void;
-    /**
-     * Fire all disconnect handlers. Subclasses call this when the connection
-     * drops so the registry can schedule reconnects.
-     */
-    protected notifyDisconnect(): void;
-    /**
-     * Apply the pinned TLS agent (if configured) to a `RequestInit` object.
-     * Uses `HttpDispatcher` from `@wrongstack/core`'s dispatcher-types shim,
-     * which declares `https.Agent` compatible with `RequestInit.dispatcher`.
-     * Verified safe: https.Agent implements the `dispatch(req, opts)` method
-     * that fetch requires at runtime.
-     */
-    protected applyTlsAgent(fetchOpts: RequestInit): void;
-    /** Generate the next JSON-RPC request id. Subclasses provide the counter. */
-    protected abstract genId(): number;
-}
-/**
- * SSE transport for MCP over HTTP.
- *
- * Uses native fetch API with ReadableStream to consume SSE events.
- * HTTP POST is used to send JSON-RPC requests.
- */
-declare class SSETransport extends BaseHTTPTransport {
-    private _nextId;
-    private readerDone;
-    private readLoopAbort?;
-    private reader?;
-    constructor(opts: HttpTransportOptions);
-    protected genId(): number;
-    /** Refresh tool list when server sends notifications/tools/list_changed. */
-    private handleToolsListChanged;
-    connect(): Promise<void>;
-    private readSSEBody;
-    private buildSSEUrl;
-    private httpPost;
-    callTool(name: string, input: unknown, opts?: {
-        signal?: AbortSignal | undefined;
-    }): Promise<ToolCallResult>;
-    /** Generic JSON-RPC request — used by MCPClient.request() for SSE transports. */
-    request(method: string, params: unknown, timeoutMs?: number): Promise<JsonRpcResponse>;
-    close(): Promise<void>;
-}
-/**
- * Streamable HTTP transport for MCP.
- *
- * Uses session-based HTTP with NDJSON responses.
- */
-declare class StreamableHTTPTransport extends BaseHTTPTransport {
-    private _nextId;
-    private sessionId?;
-    constructor(opts: HttpTransportOptions);
-    protected genId(): number;
-    connect(): Promise<void>;
-    private postRaw;
-    /** Generic JSON-RPC request — used by MCPClient.request() for SSE/streamable-http transports. */
-    request(method: string, params: unknown, timeoutMs?: number): Promise<JsonRpcResponse>;
-    callTool(name: string, input: unknown, opts?: {
-        signal?: AbortSignal | undefined;
-    }): Promise<ToolCallResult>;
-    close(): Promise<void>;
-}
-
-export { type ConnectionState, type HttpTransportOptions, MCPClient, type MCPClientOptions, MCPRegistry, type MCPRegistryOptions, MCPServer, type MCPServerCallResult, type MCPServerLogger, type MCPServerOptions, type MCPServerTool, type MCPServerToolHost, type MCPTool, MCP_CONSTANTS, type McpManageDeps, type McpOpResult, type McpServerInfo, type McpServerInput, SSEReader, SSETransport, type ServeHttpHandle, type ServeHttpOptions, type ServeStdioHandle, type ServeStdioOptions, StreamableHTTPTransport, type ToolCallResult, type Transport, addMcp, disableMcp, discoverMcp, enableMcp, listMcp, manifestConfigHash, readManifest, removeMcp, restartMcp, serveHttp, serveStdio, toContentBlocks, updateMcp, wrapMCPTool, writeManifest };
+export { authorizationHeaderForToken, authorizationServerMetadataUrls, canonicalMcpResource, createMcpAuthorizationRequest, discoverMcpAuthorization, exchangeMcpAuthorizationCode, type MCPAccessToken, type MCPAuthorizationChallenge, type MCPAuthorizationContext, type MCPAuthorizationDiscoveryOptions, type MCPAuthorizationDiscoveryResult, type MCPAuthorizationJsonFetcher, type MCPAuthorizationProvider, type MCPAuthorizationRequestOptions, type MCPAuthorizationServerMetadata, type MCPAuthorizationSession, type MCPProtectedResourceMetadata, type MCPTokenExchangeOptions, type MCPTokenRefreshOptions, type MCPTokenSet, parseAuthorizationServerMetadata, parseMcpAuthorizationCallback, parseMcpBearerChallenge, parseProtectedResourceMetadata, protectedResourceMetadataUrls, refreshMcpAccessToken, validateMcpAuthorizationServerMetadata, } from './authorization.js';
+export { type MCPAuthorizationCompleteInput, MCPAuthorizationManager, type MCPAuthorizationManagerOptions, type MCPAuthorizationStartInput, type MCPAuthorizationStartResult, type MCPAuthorizationStatus, } from './authorization-manager.js';
+export { type ConnectionState, MCPClient, type MCPClientOptions, type MCPListChangedListener, type MCPPageOptions, type MCPRequestOptions, type MCPTool, type ToolCallResult, type Transport, } from './client.js';
+export { MCP_CONSTANTS } from './constants.js';
+export { DEFAULT_MCP_INSERTION_MAX_BYTES, DEFAULT_MCP_RESOURCE_SCHEMES, type MCPContentProvenance, type MCPInsertionPolicy, type MCPPromptInsertion, type MCPResourceInsertion, preparePromptInsertion, prepareResourceInsertion, } from './content-selection.js';
+export { addMcp, disableMcp, discoverMcp, enableMcp, listMcp, type McpManageDeps, type McpOpResult, type McpServerInfo, type McpServerInput, removeMcp, restartMcp, updateMcp, } from './manage.js';
+export { type MCPCapabilityManifest, manifestConfigHash, readCapabilityManifest, readManifest, writeCapabilityManifest, writeManifest, } from './manifest-cache.js';
+export { MCP_OPERATION_LIMITS, type MCPFailureKind, type MCPHealthState, type MCPLatencySummary, type MCPOperationEvent, type MCPOperationKind, type MCPServerOperationalHealth, } from './operations.js';
+export { type MCPGetPromptResult, type MCPImplementationInfo, type MCPListPromptsResult, type MCPListResourcesResult, type MCPListResourceTemplatesResult, type MCPPrompt, type MCPPromptArgument, type MCPPromptMessage, type MCPReadResourceResult, type MCPResource, type MCPResourceContents, type MCPResourceTemplate, type MCPServerCapabilities, type MCPServerMetadata, parseGetPromptResult, parseListPromptsResult, parseListResourcesResult, parseListResourceTemplatesResult, parseReadResourceResult, parseServerMetadata, } from './protocol.js';
+export { MCPRegistry, type MCPRegistryCatalog, type MCPRegistryOptions } from './registry.js';
+export { MCPServer, type MCPServerCallResult, type MCPServerLogger, type MCPServerOptions, type MCPServerPrompt, type MCPServerResource, type MCPServerTool, type MCPServerToolHost, type ServeHttpHandle, type ServeHttpOptions, type ServeStdioHandle, type ServeStdioOptions, serveHttp, serveStdio, toContentBlocks, } from './server.js';
+export { createVaultBackedMcpAuthorizationProviderFactory, type MCPAuthorizationStateEvent, MCPRefreshingAuthorizationProvider, type MCPRefreshingAuthorizationProviderOptions, type MCPStoredAuthorization, type MCPVaultProviderFactoryOptions, MCPVaultTokenStore, } from './token-store.js';
+export { type HttpTransportOptions, SSEReader, SSETransport, StreamableHTTPTransport, } from './transport.js';
+export { type MCPToolCallObserver, wrapMCPTool } from './wrap-tool.js';
+//# sourceMappingURL=index.d.ts.map