@wrongstack/mcp 0.284.0 → 0.285.0

package/dist/manage.d.ts

@@ -0,0 +1,82 @@
+import type { MCPServerConfig, Permission } from '@wrongstack/core';
+import type { MCPRegistry } from './registry.js';
+/** 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. */
+export 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. */
+export 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;
+}
+export 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;
+}
+export 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. */
+export 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.
+ */
+export declare function addMcp(input: McpServerInput, deps: McpManageDeps): Promise<McpOpResult>;
+/** Update an existing server's config, then re-apply it to the live registry. */
+export declare function updateMcp(input: McpServerInput, deps: McpManageDeps): Promise<McpOpResult>;
+/** Remove a server from config and stop it if running. */
+export declare function removeMcp(name: string, deps: McpManageDeps): Promise<McpOpResult>;
+/** Enable a server in config and start it. */
+export declare function enableMcp(name: string, deps: McpManageDeps): Promise<McpOpResult>;
+/** Disable a server in config and stop it. */
+export declare function disableMcp(name: string, deps: McpManageDeps): Promise<McpOpResult>;
+/** Restart a running server (or start it from config if registered but stopped). */
+export 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.
+ */
+export declare function discoverMcp(name: string, deps: McpManageDeps): Promise<McpOpResult>;
+export {};
+//# sourceMappingURL=manage.d.ts.map

package/dist/manage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manage.d.ts","sourceRoot":"","sources":["../src/manage.ts"],"names":[],"mappings":"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"}

package/dist/manifest-cache.d.ts

@@ -0,0 +1,16 @@
+import type { MCPTool } from './client.js';
+/** Stable hash of the fields that define how/where we connect to a server. */
+export 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).
+ */
+export declare function readManifest(cacheDir: string, name: string, configHash: string): Promise<MCPTool[] | null>;
+/** Persist a server's discovered tools. Best-effort — IO errors are swallowed. */
+export declare function writeManifest(cacheDir: string, name: string, configHash: string, tools: MCPTool[]): Promise<void>;
+//# sourceMappingURL=manifest-cache.d.ts.map

package/dist/manifest-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest-cache.d.ts","sourceRoot":"","sources":["../src/manifest-cache.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAO3C,8EAA8E;AAC9E,wBAAgB,kBAAkB,CAAC,GAAG,EAAE;IACtC,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;IAC5B,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC1B,GAAG,MAAM,CAQT;AAQD;;;GAGG;AACH,wBAAsB,YAAY,CAChC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,CAS3B;AAED,kFAAkF;AAClF,wBAAsB,aAAa,CACjC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,OAAO,EAAE,GACf,OAAO,CAAC,IAAI,CAAC,CAWf"}

package/dist/registry.d.ts

@@ -0,0 +1,151 @@
+import type { EventBus, Logger, MCPServerConfig, ToolRegistry } from '@wrongstack/core';
+import { type ConnectionState, MCPClient } from './client.js';
+export 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;
+}
+export 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;
+}
+//# sourceMappingURL=registry.d.ts.map

package/dist/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"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"}

package/dist/server.d.ts

@@ -0,0 +1,109 @@
+/**
+ * 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`. */
+export interface MCPServerTool {
+    name: string;
+    description?: string | undefined;
+    inputSchema: Record<string, unknown>;
+}
+/** The result of a `tools/call`, as the host produces it. */
+export 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`.
+ */
+export interface MCPServerToolHost {
+    listTools(): MCPServerTool[] | Promise<MCPServerTool[]>;
+    callTool(name: string, args: Record<string, unknown>): Promise<MCPServerCallResult>;
+}
+export interface MCPServerLogger {
+    warn?(msg: string): void;
+    info?(msg: string): void;
+}
+export interface MCPServerOptions {
+    host: MCPServerToolHost;
+    /** Advertised in the `initialize` handshake. Defaults to the wrongstack identity. */
+    serverInfo?: {
+        name: string;
+        version: string;
+    };
+    logger?: MCPServerLogger | undefined;
+}
+export 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. */
+export declare function toContentBlocks(content: unknown): Array<{
+    type: 'text';
+    text: string;
+}>;
+export interface ServeStdioHandle {
+    /** Stop reading and detach listeners. Does not exit the process. */
+    close(): void;
+    /** Resolves when the input stream ends (EOF). */
+    done: Promise<void>;
+}
+export 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.
+ */
+export declare function serveStdio(server: MCPServer, opts?: ServeStdioOptions): ServeStdioHandle;
+export 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;
+}
+export 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.
+ */
+export declare function serveHttp(server: MCPServer, opts?: ServeHttpOptions): Promise<ServeHttpHandle>;
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"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"}

package/dist/test-helpers/mock-server.d.ts

@@ -0,0 +1,34 @@
+import type { MCPTool } from '../client.js';
+export interface MockToolResponse {
+    content: unknown;
+    isError?: boolean | undefined;
+}
+export interface MockMCPServerOptions {
+    /** Delay injected between receiving a request and sending the response (ms). */
+    responseDelayMs?: number | undefined;
+}
+/**
+ * Minimal in-process MCP server that speaks JSON-RPC over stdio.
+ * Writes a self-contained Node.js script to a temp file and exposes the path
+ * for spawning as a child process.
+ */
+export declare class MockMCPServer {
+    private readonly tools;
+    private readonly delayMs;
+    /** Responses keyed by `JSON.stringify(params)` for tools/call. */
+    private readonly responses;
+    private scriptPath?;
+    constructor(tools?: MCPTool[], opts?: MockMCPServerOptions);
+    setResponse(params: unknown, response: MockToolResponse | string): void;
+    setTools(tools: MCPTool[]): void;
+    /**
+     * Write the mock server script to a temp file and return the path.
+     * The script is self-contained and requires no external dependencies.
+     */
+    writeScript(): Promise<string>;
+    /** Delete the temp script. Call after test completes. */
+    cleanup(): Promise<void>;
+    /** Path to the script if already written via writeScript(). */
+    get path(): string | undefined;
+}
+//# sourceMappingURL=mock-server.d.ts.map

package/dist/test-helpers/mock-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-server.d.ts","sourceRoot":"","sources":["../../src/test-helpers/mock-server.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAE5C,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAC/B;AAED,MAAM,WAAW,oBAAoB;IACnC,gFAAgF;IAChF,eAAe,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACtC;AAED;;;;GAIG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAY;IAClC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,kEAAkE;IAClE,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAuC;IACjE,OAAO,CAAC,UAAU,CAAC,CAAqB;IAExC,YAAY,KAAK,GAAE,OAAO,EAAO,EAAE,IAAI,GAAE,oBAAyB,EAGjE;IAED,WAAW,CAAC,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,gBAAgB,GAAG,MAAM,GAAG,IAAI,CAKtE;IAED,QAAQ,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,IAAI,CAG/B;IAED;;;OAGG;IACG,WAAW,IAAI,OAAO,CAAC,MAAM,CAAC,CAoDnC;IAED,yDAAyD;IACnD,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAS7B;IAED,+DAA+D;IAC/D,IAAI,IAAI,IAAI,MAAM,GAAG,SAAS,CAE7B;CACF"}

package/dist/tool-schema.d.ts

@@ -0,0 +1,3 @@
+import type { MCPTool } from './client.js';
+export declare function normalizeMCPTools(value: unknown): MCPTool[];
+//# sourceMappingURL=tool-schema.d.ts.map

package/dist/tool-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-schema.d.ts","sourceRoot":"","sources":["../src/tool-schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,EAAE,CA8B3D"}

package/dist/transport.d.ts

@@ -0,0 +1,145 @@
+import * as https from 'node:https';
+import type { ConnectionState, JsonRpcResponse, MCPTool, ToolCallResult } from './client.js';
+export type JsonRpcResult = {
+    jsonrpc: string;
+    id?: number | undefined;
+    result?: unknown | undefined;
+    error?: {
+        code: number | undefined;
+        message: string;
+        data?: unknown | undefined;
+    } | undefined;
+};
+export 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;
+    };
+}
+export 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;
+}
+/**
+ * Extract JSON-RPC envelopes from a streamable-http response body. Handles BOTH
+ * plain NDJSON (one JSON object per line) AND SSE framing
+ * (`event: message\ndata: {...}` blocks) — modern MCP servers (e.g. Context7)
+ * reply with `text/event-stream` even on a single POST, so the data must be
+ * un-prefixed before parsing. Multi-line `data:` values within one event are
+ * joined per the SSE spec.
+ */
+export declare function extractJsonRpcResults(text: string): JsonRpcResult[];
+/**
+ * Fields and methods shared by all HTTP-based MCP transports.
+ * Subclasses override `connect()`, `close()`, `callTool()`, `request()`.
+ */
+export 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.
+ */
+export 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.
+ */
+export 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>;
+}
+//# sourceMappingURL=transport.d.ts.map

package/dist/transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../src/transport.ts"],"names":[],"mappings":"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"}

package/dist/wrap-tool.d.ts

@@ -0,0 +1,10 @@
+import { type Permission, type Tool } from '@wrongstack/core';
+import type { MCPClient, MCPTool } from './client.js';
+/**
+ * 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)`).
+ */
+export type MCPClientResolver = MCPClient | (() => Promise<MCPClient>);
+export declare function wrapMCPTool(serverName: string, mcpTool: MCPTool, client: MCPClientResolver, permission?: Permission): Tool;
+//# sourceMappingURL=wrap-tool.d.ts.map

package/dist/wrap-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrap-tool.d.ts","sourceRoot":"","sources":["../src/wrap-tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,KAAK,UAAU,EAAE,KAAK,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAChF,OAAO,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAwBtD;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,GAAG,SAAS,GAAG,CAAC,MAAM,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC;AAEvE,wBAAgB,WAAW,CACzB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,iBAAiB,EACzB,UAAU,GAAE,UAAsB,GACjC,IAAI,CAwBN"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrongstack/mcp",
-  "version": "0.284.0",
+  "version": "0.285.0",
   "license": "MIT",
   "description": "WrongStack Model Context Protocol client and registry: stdio, SSE, and streamable HTTP transports.",
   "repository": {
@@ -25,12 +25,11 @@
     "dist"
   ],
   "dependencies": {
-    "@wrongstack/core": "0.284.0"
+    "@wrongstack/core": "0.285.0"
   },
   "devDependencies": {
     "@types/node": "^26.0.1",
-    "tsup": "^8.5.1",
-    "typescript": "^6.0.3",
+    "typescript": "^7.0.2",
     "undici": "^8.5.0",
     "undici-types": "^8.5.0",
     "vitest": "^4.1.9"
@@ -39,7 +38,7 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsup",
+    "build": "node ../../scripts/build-package.mjs",
     "typecheck": "tsc --noEmit -p tsconfig.test.json",
     "test": "vitest run",
     "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\""