@wrongstack/mcp 1.0.24 → 1.0.27

package/dist/manage.d.ts

@@ -17,6 +17,10 @@ export interface McpServerInput {
     bearerTokenEnv?: string | undefined;
     allowedTools?: string[] | undefined;
     permission?: Permission | undefined;
+    /** Connect/startup timeout in ms. Defaults to 10s when omitted. */
+    startupTimeoutMs?: number | undefined;
+    /** Per-request JSON-RPC timeout in ms. Defaults to 60s when omitted. */
+    requestTimeoutMs?: number | 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. */

package/dist/protocol.d.ts

@@ -88,4 +88,14 @@ export declare function parseListResourceTemplatesResult(value: unknown): MCPLis
 export declare function parseReadResourceResult(value: unknown): MCPReadResourceResult;
 export declare function parseListPromptsResult(value: unknown): MCPListPromptsResult;
 export declare function parseGetPromptResult(value: unknown): MCPGetPromptResult;
+/**
+ * Extract the `uri` from a `notifications/resources/updated` payload.
+ *
+ * The notification is the whole point of `resources/subscribe`, which the
+ * client already supported — every transport parsed the three `list_changed`
+ * notifications and silently dropped this one, so a subscription produced
+ * nothing. Returns `undefined` for a malformed payload rather than throwing:
+ * a notification has no reply, so a bad one is ignored, not answered.
+ */
+export declare function resourceUpdatedUri(params: unknown): string | undefined;
 //# sourceMappingURL=protocol.d.ts.map

package/dist/registry-authorization.d.ts

@@ -1,10 +1,11 @@
 import type { MCPServerConfig } from '@wrongstack/core/types';
-import type { MCPAuthorizationManager, MCPAuthorizationStartResult, MCPAuthorizationStatus } from './authorization-manager.js';
+import type { MCPAuthorizationLoginHandle, MCPAuthorizationLoginInput, MCPAuthorizationManager, MCPAuthorizationStartResult, MCPAuthorizationStatus } from './authorization-manager.js';
 import type { ServerSlot } from './registry-slots.js';
 export declare function requireAuthorizationManager(manager: MCPAuthorizationManager | undefined): MCPAuthorizationManager;
 export declare function requireHttpServerConfig(servers: Map<string, ServerSlot>, disabledServers: Map<string, MCPServerConfig>, name: string): MCPServerConfig;
+export declare function loginRegistryAuthorization(manager: MCPAuthorizationManager | undefined, cfg: MCPServerConfig, name: string, input: Omit<MCPAuthorizationLoginInput, 'serverName' | 'resource'>): Promise<MCPAuthorizationLoginHandle>;
 export declare function beginRegistryAuthorization(manager: MCPAuthorizationManager | undefined, cfg: MCPServerConfig, name: string, input: {
-    clientId: string;
+    clientId?: string | undefined;
     redirectUri: string;
     scopes?: readonly string[] | undefined;
     challengeHeader?: string | null | undefined;

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

@@ -15,6 +15,7 @@ export interface RegistryConnectContext {
     cacheDir?: string | undefined;
     cwd?: string | undefined;
     authorizationProviderFactory?: MCPRegistryOptions['authorizationProviderFactory'] | undefined;
+    elicitationHandler?: MCPRegistryOptions['elicitationHandler'] | undefined;
     operationListeners: Set<MCPOperationListener>;
     ensureConnected: (name: string) => Promise<MCPClient>;
     recordOperation: (slot: ServerSlot, kind: MCPOperationKind, reason?: string, failureKind?: MCPFailureKind, durationMs?: number, retain?: boolean) => void;

package/dist/registry-slots.d.ts

@@ -1,6 +1,7 @@
 import type { MCPServerConfig, Tool } from '@wrongstack/core/types';
 import type { MCPClient } from './client.js';
 import type { ConnectionState, MCPTool } from './contracts.js';
+import type { ElicitationRequester } from './elicitation.js';
 import type { MCPServerOperationState } from './operations.js';
 import type { MCPPrompt, MCPResource, MCPResourceTemplate, MCPServerMetadata } from './protocol.js';
 export interface ServerSlot {
@@ -40,6 +41,11 @@ export interface ServerSlot {
     connecting?: Promise<MCPClient | undefined> | undefined;
     /** Whether this lazy server's resolver wrappers are registered (register once). */
     registeredLazy: boolean;
+    /**
+     * Runs with a tool call to this server in flight, oldest first. A server
+     * elicitation asks the newest — the spec does not tie a request to a call.
+     */
+    activeCallers?: ElicitationRequester[] | undefined;
     /** Bounded, payload-free operational telemetry for this server. */
     operations: MCPServerOperationState;
 }

package/dist/registry-types.d.ts

@@ -4,6 +4,7 @@ import type { Logger, MCPServerConfig } from '@wrongstack/core/types';
 import type { MCPAuthorizationProvider } from './authorization.js';
 import type { MCPAuthorizationManager } from './authorization-manager.js';
 import type { ConnectionState } from './contracts.js';
+import type { MCPElicitationHandler } from './elicitation.js';
 import type { MCPPrompt, MCPResource, MCPResourceTemplate, MCPServerMetadata } from './protocol.js';
 export interface MCPRegistryOptions {
     toolRegistry: ToolRegistry;
@@ -20,6 +21,11 @@ export interface MCPRegistryOptions {
     lazyMode?: boolean | undefined;
     authorizationProviderFactory?: ((server: Readonly<MCPServerConfig>) => MCPAuthorizationProvider | undefined) | undefined;
     authorizationManager?: MCPAuthorizationManager | undefined;
+    /**
+     * Puts a server's `elicitation/create` form in front of the user. Without
+     * it the capability is not declared, so servers never send the request.
+     */
+    elicitationHandler?: MCPElicitationHandler | undefined;
 }
 export interface MCPRegistryCatalog {
     name: string;

package/dist/registry.d.ts

@@ -20,13 +20,17 @@ export declare class MCPRegistry {
     private readonly idleTimeoutMs;
     private readonly authorizationProviderFactory?;
     private readonly authorizationManager?;
+    private readonly elicitationHandler?;
     private readonly operationListeners;
+    /** Starts still in flight, for {@link whenStarted}. */
+    private readonly startups;
     /** Single shared idle sweep timer (started lazily; unref'd; cleared on stopAll). */
     private idleTimer?;
     constructor(opts: MCPRegistryOptions);
     private requireSlot;
+    loginAuthorization(name: string, input: Omit<import('./authorization-manager.js').MCPAuthorizationLoginInput, 'serverName' | 'resource'>): Promise<import('./authorization-manager.js').MCPAuthorizationLoginHandle>;
     beginAuthorization(name: string, input: {
-        clientId: string;
+        clientId?: string | undefined;
         redirectUri: string;
         scopes?: readonly string[] | undefined;
         challengeHeader?: string | null | undefined;
@@ -37,6 +41,12 @@ export declare class MCPRegistry {
     disconnectAuthorization(name: string): Promise<boolean>;
     private requireHttpServerConfig;
     start(cfg: MCPServerConfig): Promise<void>;
+    /**
+     * Resolves once every start already in flight has connected or failed. A
+     * host that starts its servers in the background and then runs a single
+     * turn waits here, so the turn's tool list includes theirs.
+     */
+    whenStarted(): Promise<void>;
     /** Record an intentionally disabled configuration without opening a transport. */
     markDisabled(cfg: MCPServerConfig): void;
     /** Remove residual operational/configuration state after a management delete. */
@@ -175,6 +185,7 @@ export declare class MCPRegistry {
      */
     private readonly onToolsChanged;
     private readonly onResourcesChanged;
+    private readonly onResourceUpdated;
     private readonly onPromptsChanged;
     private addCatalogListeners;
     private removeCatalogListeners;

package/dist/structured-result.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The model-facing text of a successful call: the rendered content, plus the
+ * structured result when the content does not already contain it, plus a
+ * notice when the result breaks the tool's own `outputSchema`.
+ */
+export declare function renderStructuredResult(rendered: string, content: unknown, structured: Record<string, unknown> | undefined, outputSchema: Record<string, unknown> | undefined): string;
+//# sourceMappingURL=structured-result.d.ts.map

package/dist/token-store.d.ts

@@ -4,16 +4,20 @@ export interface MCPStoredAuthorization {
     serverName: string;
     resource: string;
     clientId: string;
+    /** Present only for a confidential client issued by dynamic registration. */
+    clientSecret?: string | undefined;
     authorizationServer: MCPAuthorizationServerMetadata;
     tokenSet: MCPTokenSet;
     updatedAt: string;
 }
 export interface MCPAuthorizationStateEvent {
     serverName: string;
-    state: 'authorized' | 'refreshed' | 'reauth_required' | 'removed';
+    state: 'authorized' | 'refreshed' | 'reauth_required' | 'removed' | 'failed';
     resource: string;
     expiresAt?: number | undefined;
     scopes?: string[] | undefined;
+    /** Non-secret reason, set for `failed`. Never contains a token or code. */
+    message?: string | undefined;
 }
 export interface MCPRefreshingAuthorizationProviderOptions {
     serverName: string;

package/dist/tool-schema.d.ts

@@ -1,4 +1,17 @@
-import type { MCPTool } from './contracts.js';
+import type { MCPTool, ToolCallResult } from './contracts.js';
+/**
+ * The ONE reading of a `tools/call` response, shared by every transport. A
+ * JSON-RPC error becomes an error result; `structuredContent` is kept only
+ * when it is the object the spec requires.
+ */
+export declare function toToolCallResult(response: {
+    result?: unknown | undefined;
+    error?: {
+        message: string;
+        code?: number | undefined;
+        data?: unknown;
+    } | undefined;
+}): ToolCallResult;
 /**
  * Collect every page of `tools/list`.
  *

package/dist/transport-base.d.ts

@@ -1,6 +1,7 @@
 import * as https from 'node:https';
 import { type MCPAuthorizationProvider } from './authorization.js';
 import type { ConnectionState, MCPTool } from './contracts.js';
+import { type ServerRequest, ServerRequestResponder } from './elicitation.js';
 import type { MCPServerMetadata } from './protocol.js';
 import { type TransportDnsLookup } from './transport-security.js';
 export interface HttpTransportOptions {
@@ -43,18 +44,21 @@ export interface HttpTransportOptions {
      * record is policy-checked before the dial.
      */
     lookup?: TransportDnsLookup | undefined;
+    /** The owning client's answerer for server→client requests (shared across reconnects). */
+    serverRequests?: ServerRequestResponder | undefined;
 }
 /**
  * Abort error whose `name` is `'AbortError'` so the core executor's
  * classifyToolError maps it to FATAL / not-retryable (user cancellation).
  */
+/**
+ * `scheme://host:port` of a server URL, for log lines. The path and query can
+ * hold an expanded `${SECRET}` (config-env), and userinfo is a credential.
+ */
+export declare function urlOriginForLog(raw: string): string;
 export declare function makeAbortError(method: string): Error;
 /** Advance a JSON-RPC number id without leaving JavaScript's safe-integer range. */
 export declare function nextJsonRpcId(id: number): number;
-export declare function createTimeoutSignal(parent: AbortSignal | undefined, timeoutMs: number): {
-    signal: AbortSignal;
-    dispose: () => void;
-};
 /**
  * Fields and methods shared by all HTTP-based MCP transports.
  * Subclasses override `connect()`, `close()`, `callTool()`, `request()`.
@@ -80,8 +84,10 @@ export declare abstract class BaseHTTPTransport {
     protected readonly disconnectHandlers: Array<() => void>;
     protected readonly toolsChangedListeners: Set<(tools: MCPTool[]) => void>;
     protected readonly resourcesChangedListeners: Set<() => void>;
+    protected readonly resourceUpdatedListeners: Set<(uri: string) => void>;
     protected readonly promptsChangedListeners: Set<() => void>;
     protected protocolVersion?: string | undefined;
+    protected readonly serverRequests: ServerRequestResponder;
     constructor(opts: HttpTransportOptions, transportName: string);
     getState(): ConnectionState;
     protected fetchWithAuthorization(input: string | URL, init: RequestInit, signal?: AbortSignal | undefined): Promise<Response>;
@@ -91,6 +97,7 @@ export declare abstract class BaseHTTPTransport {
     onToolsChanged(cb: (tools: MCPTool[]) => void): () => void;
     onResourcesChanged(cb: () => void): () => void;
     onPromptsChanged(cb: () => void): () => void;
+    onResourceUpdated(cb: (uri: string) => void): () => void;
     /**
      * Fire all disconnect handlers. Subclasses call this when the connection
      * drops so the registry can schedule reconnects.
@@ -98,6 +105,7 @@ export declare abstract class BaseHTTPTransport {
     protected notifyDisconnect(): void;
     protected notifyResourcesChanged(): void;
     protected notifyPromptsChanged(): void;
+    protected notifyResourceUpdated(uri: string): void;
     private dispatcherFetch;
     private pinnedDispatcher;
     private applyPinnedDispatcher;
@@ -117,6 +125,20 @@ export declare abstract class BaseHTTPTransport {
      * these same TLS options plus the resolution-bound lookup.
      */
     protected applyTlsAgent(fetchOpts: RequestInit): void;
+    /**
+     * Request timeout for a call. It holds while the server waits on the user's
+     * elicitation answer — that wait is the user typing, not the server stalling.
+     */
+    protected requestTimeoutSignal(parent: AbortSignal | undefined, timeoutMs: number): {
+        signal: AbortSignal;
+        dispose: () => void;
+    };
+    /**
+     * Answer a server→client request. Over HTTP the reply is POSTed back like
+     * any client message; the server acknowledges it with 202. A failed reply is
+     * not retried — the server times its request out on its side.
+     */
+    protected replyToServer(request: ServerRequest, url: string, headers: Record<string, string>): Promise<void>;
     /** Generate the next JSON-RPC request id. Subclasses provide the counter. */
     protected abstract genId(): number;
 }

package/dist/transport-streamable.d.ts

@@ -11,7 +11,20 @@ export declare class StreamableHTTPTransport extends BaseHTTPTransport {
     private sessionId?;
     constructor(opts: HttpTransportOptions);
     protected genId(): number;
-    private consumeResponseText;
+    /**
+     * Read a POST's reply. A `text/event-stream` reply is consumed event by
+     * event: the server may put notifications and its OWN requests (elicitation)
+     * ahead of our response and then wait for our answer to them, so buffering
+     * the whole body first would deadlock the call.
+     */
+    private readResponse;
+    /**
+     * Dispatch the notifications and server requests in `text`, and return the
+     * response to `requestId` — falling back to the first other response, which
+     * the caller's id check then rejects.
+     */
+    private takeEnvelopes;
+    private sessionHeaders;
     private handleNotification;
     private refreshTools;
     connect(): Promise<void>;

package/dist/wrap-tool.d.ts

@@ -1,6 +1,7 @@
 import type { Permission, Tool } from '@wrongstack/core/types';
 import type { MCPClient } from './client.js';
 import type { MCPTool } from './contracts.js';
+import type { ElicitationRequester } from './elicitation.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
@@ -8,11 +9,12 @@ import type { MCPTool } from './contracts.js';
  */
 export type MCPClientResolver = MCPClient | (() => Promise<MCPClient>);
 export interface MCPToolCallObserver {
-    onStart(): void;
+    /** `caller` is the run making the call — who a server elicitation mid-call should ask. */
+    onStart(caller?: ElicitationRequester | undefined): void;
     onFinish(result: {
         durationMs: number;
         ok: boolean;
-    }): void;
+    }, caller?: ElicitationRequester | undefined): void;
 }
 export declare function wrapMCPTool(serverName: string, mcpTool: MCPTool, client: MCPClientResolver, permission?: Permission, observer?: MCPToolCallObserver | undefined): Tool;
 //# sourceMappingURL=wrap-tool.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrongstack/mcp",
-  "version": "1.0.24",
+  "version": "1.0.27",
   "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.24",
+    "@wrongstack/core": "1.0.27",
     "undici": "^8.10.2"
   },
   "devDependencies": {