@wrongstack/mcp 1.0.9 → 1.0.11

package/dist/registry-connect-loop.d.ts

@@ -13,6 +13,7 @@ export interface RegistryConnectContext {
     log: Logger;
     lazyMode: boolean;
     cacheDir?: string | undefined;
+    cwd?: string | undefined;
     authorizationProviderFactory?: MCPRegistryOptions['authorizationProviderFactory'] | undefined;
     operationListeners: Set<MCPOperationListener>;
     ensureConnected: (name: string) => Promise<MCPClient>;

package/dist/registry-slots.d.ts

@@ -1,6 +1,6 @@
 import type { MCPServerConfig, Tool } from '@wrongstack/core/types';
 import type { MCPClient } from './client.js';
-import type { ConnectionState } from './contracts.js';
+import type { ConnectionState, MCPTool } from './contracts.js';
 import type { MCPServerOperationState } from './operations.js';
 import type { MCPPrompt, MCPResource, MCPResourceTemplate, MCPServerMetadata } from './protocol.js';
 export interface ServerSlot {
@@ -11,6 +11,16 @@ export interface ServerSlot {
     toolNames: string[];
     /** Cached tools when lazyMode is active (not registered in toolRegistry). */
     lazyTools: Tool[];
+    /**
+     * Raw tool list last learned from the server (live `tools/list` or the
+     * manifest cache). The manifest is written from THIS, never from
+     * `client.listTools()`: a write queued behind an idle sleep or crash runs
+     * after the client is gone, and persisting `[]` then would boot the server
+     * dormant with no tools — invisible until its config changes.
+     */
+    discoveredTools?: MCPTool[] | undefined;
+    /** Signature of the wrapped tool set, so an unchanged lazy wake does not re-register. */
+    toolSignature?: string | undefined;
     serverMetadata?: MCPServerMetadata | undefined;
     resources?: MCPResource[] | undefined;
     resourceTemplates?: MCPResourceTemplate[] | undefined;

package/dist/registry-types.d.ts

@@ -10,6 +10,12 @@ export interface MCPRegistryOptions {
     events: EventBus;
     log: Logger;
     cacheDir?: string | undefined;
+    /**
+     * Working directory for stdio servers — the project root the host serves.
+     * Omitted: children inherit the process cwd (only correct for a host that
+     * runs from the project root).
+     */
+    cwd?: string | undefined;
     idleTimeoutMs?: number | undefined;
     lazyMode?: boolean | undefined;
     authorizationProviderFactory?: ((server: Readonly<MCPServerConfig>) => MCPAuthorizationProvider | undefined) | undefined;

package/dist/registry.d.ts

@@ -16,6 +16,7 @@ export declare class MCPRegistry {
     private readonly log;
     private readonly lazyMode;
     private readonly cacheDir?;
+    private readonly cwd?;
     private readonly idleTimeoutMs;
     private readonly authorizationProviderFactory?;
     private readonly authorizationManager?;
@@ -65,12 +66,41 @@ export declare class MCPRegistry {
      * Returns the number of tools that were deactivated.
      */
     deactivateServer(name: string): number;
+    /**
+     * The tools a server offers — bare names, descriptions and input schemas —
+     * without activating, registering or waking it. In token-saving mode the
+     * model reaches MCP only through `mcp_use`, which needs the bare tool name
+     * and its input shape; before this there was no way to learn either short
+     * of guessing and reading the error. Honors `allowedTools`. Returns
+     * `undefined` for an unknown server, `[]` when nothing was discovered yet.
+     */
+    describeTools(name: string): {
+        name: string;
+        description?: string | undefined;
+        inputSchema: Record<string, unknown>;
+    }[] | undefined;
     /**
      * Check whether a server's tools are currently registered.
      */
     isActivated(name: string): boolean;
     stop(name: string): Promise<void>;
-    restart(name: string): Promise<void>;
+    /**
+     * Stop and start a registered server. Pass `nextCfg` to apply an edited
+     * configuration: without it the slot reconnects with the config it was
+     * started with, so an update/enable routed through restart() silently kept
+     * the old command, url, env, permission and lazy flag until the next boot.
+     */
+    /**
+     * Put a running server to sleep while keeping its configuration enabled.
+     *
+     * A lazy server goes `dormant`: the process stops but its tools stay
+     * registered and the next call wakes it. Surfaces previously used stop() for
+     * this, which unregistered a lazy server's tools — "sleep" silently became
+     * "unreachable until restarted". Eager servers have no dormant state, so
+     * for them sleep is a stop.
+     */
+    sleep(name: string): Promise<void>;
+    restart(name: string, nextCfg?: MCPServerConfig | undefined): Promise<void>;
     list(): {
         name: string;
         state: ConnectionState;

package/dist/sse-reader.d.ts

@@ -1,6 +1,14 @@
 export declare class SSEReader {
     private buffer;
     private dataLines;
+    private eventName;
+    private endpointListeners;
+    /**
+     * Legacy HTTP+SSE transport: the server's first event is
+     * `event: endpoint` whose data is the (relative) URL to POST requests to.
+     * Its payload is a URL, not JSON, so it is dispatched separately.
+     */
+    onEndpoint(cb: (endpoint: string) => void): () => void;
     private listeners;
     onMessage(cb: (data: {
         jsonrpc?: string | undefined;

package/dist/token-store.d.ts

@@ -42,6 +42,8 @@ export declare class MCPVaultTokenStore {
 export declare class MCPRefreshingAuthorizationProvider implements MCPAuthorizationProvider {
     private readonly options;
     private refreshPromise?;
+    /** Refresh token the authorization server rejected; cleared by a new authorization. */
+    private rejectedRefreshToken?;
     private readonly resource;
     private readonly refreshSkewMs;
     constructor(options: MCPRefreshingAuthorizationProviderOptions);

package/dist/tool-schema.d.ts

@@ -1,3 +1,17 @@
 import type { MCPTool } from './contracts.js';
+/**
+ * Collect every page of `tools/list`.
+ *
+ * The result carries `nextCursor` when a server paginates, and every transport
+ * used to read only the first page — a server with a large catalog silently
+ * lost the rest of its tools. Returns `null` when the FIRST page is a JSON-RPC
+ * error (callers keep their previous catalog instead of wiping it); a failure
+ * on a later page keeps the pages already collected. A transport exception on
+ * the first page propagates, as it did before.
+ */
+export declare function listAllTools(requestPage: (params: Record<string, unknown>) => Promise<{
+    result?: unknown | undefined;
+    error?: unknown | undefined;
+}>): Promise<MCPTool[] | null>;
 export declare function normalizeMCPTools(value: unknown): MCPTool[];
 //# sourceMappingURL=tool-schema.d.ts.map

package/dist/transport-jsonrpc.d.ts

@@ -15,6 +15,12 @@ type JsonRpcMethodEnvelope = {
     params?: unknown | undefined;
 };
 type JsonRpcEnvelope = JsonRpcResult | JsonRpcMethodEnvelope;
+/**
+ * Encode an outgoing JSON-RPC message. A `notifications/*` method is a
+ * notification and MUST NOT carry an `id` — with one it is a request, which a
+ * strict server answers with an error (or never marks the session initialized).
+ */
+export declare function encodeJsonRpcMessage(id: number, method: string, params: unknown): string;
 export declare function isJsonRpcResult(v: unknown): v is JsonRpcResult;
 /**
  * Extract JSON-RPC envelopes from a streamable-http response body. Handles BOTH

package/dist/transport-sse.d.ts

@@ -1,24 +1,46 @@
 import type { JsonRpcResponse, ToolCallResult } from './contracts.js';
 import { BaseHTTPTransport, type HttpTransportOptions } from './transport-base.js';
 /**
- * SSE transport for MCP over HTTP.
+ * SSE transport for MCP over HTTP (the 2024-11-05 "HTTP with SSE" transport).
  *
- * Uses native fetch API with ReadableStream to consume SSE events.
- * HTTP POST is used to send JSON-RPC requests.
+ * The client opens a GET event stream. A compliant server first sends
+ * `event: endpoint` naming the URL to POST JSON-RPC to, answers each POST with
+ * `202 Accepted`, and delivers the response over the stream. Servers that
+ * answer in the POST body instead are also supported: a JSON body is taken as
+ * the response, an empty/202 body waits for the stream.
  */
 export declare class SSETransport extends BaseHTTPTransport {
     private _nextId;
     private readerDone;
+    private closed;
     private readLoopAbort?;
     private reader?;
+    /** POST target announced by the server's `endpoint` event. */
+    private endpointUrl?;
+    /** Wakes connect() once the endpoint is known (or will not arrive). */
+    private streamSignal?;
+    /** Requests whose response is expected over the event stream, keyed by id. */
+    private readonly streamPending;
     constructor(opts: HttpTransportOptions);
     protected genId(): number;
     /** Refresh tool list when server sends notifications/tools/list_changed. */
     private handleToolsListChanged;
     connect(): Promise<void>;
+    /** Resolve once the stream announced its endpoint, emitted anything, ended, or the cap passed. */
+    private waitForStream;
+    /**
+     * Adopt the server's POST endpoint. It must stay on the configured origin:
+     * a cross-origin endpoint would move every request — Authorization header
+     * included — to a host that never passed configuration review.
+     */
+    private acceptEndpoint;
     private readSSEBody;
+    private rejectStreamPending;
     private buildSSEUrl;
+    /** Register interest in a stream-delivered response before the POST goes out. */
+    private awaitStreamResponse;
     private httpPost;
+    private postJsonRpc;
     callTool(name: string, input: unknown, opts?: {
         signal?: AbortSignal | undefined;
     }): Promise<ToolCallResult>;

package/dist/transport-streamable.d.ts

@@ -7,6 +7,7 @@ import { BaseHTTPTransport, type HttpTransportOptions } from './transport-base.j
  */
 export declare class StreamableHTTPTransport extends BaseHTTPTransport {
     private _nextId;
+    private closed;
     private sessionId?;
     constructor(opts: HttpTransportOptions);
     protected genId(): number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrongstack/mcp",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "license": "MIT",
   "description": "WrongStack Model Context Protocol client and registry: stdio, SSE, and streamable HTTP transports.",
   "repository": {
@@ -26,7 +26,7 @@
     "!dist/**/*.map"
   ],
   "dependencies": {
-    "@wrongstack/core": "1.0.9",
+    "@wrongstack/core": "1.0.11",
     "undici": "^8.10.2"
   },
   "devDependencies": {