@wrongstack/mcp 1.0.29 → 1.0.33

package/dist/client-stdio-protocol.d.ts

@@ -0,0 +1,24 @@
+import type { JsonRpcServerRequest, MCPClientOptions } from './client-types.js';
+import type { JsonRpcResponse } from './contracts.js';
+import type { ServerRequestResponder } from './elicitation.js';
+export interface ClientStdioProtocolHost {
+    rxBufferBytes: number;
+    rxParts: string[];
+    failPending(reason: string): void;
+    readonly opts: MCPClientOptions;
+    close(): Promise<void>;
+    onLine(line: string): void;
+    handleServerRequest(request: JsonRpcServerRequest): Promise<void>;
+    readonly serverRequests: ServerRequestResponder;
+    handleToolsListChanged(): Promise<void>;
+    emitCapabilityChanged(capability: 'resources' | 'prompts'): void;
+    emitResourceUpdated(uri: string): void;
+    readonly pending: Map<number, {
+        resolve: (res: JsonRpcResponse) => void;
+        reject: (err: Error) => void;
+        timer: NodeJS.Timeout;
+    }>;
+}
+export declare function receiveStdioData(host: ClientStdioProtocolHost, s: string): void;
+export declare function receiveStdioLine(host: ClientStdioProtocolHost, line: string): void;
+//# sourceMappingURL=client-stdio-protocol.d.ts.map

package/dist/client-stdio.d.ts

@@ -0,0 +1,32 @@
+import { type ChildProcess } from 'node:child_process';
+import { StringDecoder } from 'node:string_decoder';
+import type { ExitListener, MCPClientOptions } from './client-types.js';
+import type { ConnectionState, JsonRpcResponse, MCPTool } from './contracts.js';
+import type { ServerRequestResponder } from './elicitation.js';
+import { type MCPServerMetadata } from './protocol.js';
+export interface ClientStdioHost {
+    readonly opts: MCPClientOptions;
+    state: ConnectionState;
+    rxBuffer: string;
+    rxBufferBytes: number;
+    rxDecoder: StringDecoder;
+    child: ChildProcess | undefined;
+    onData(s: string): void;
+    onLine(line: string): void;
+    failPending(reason: string): void;
+    readonly exitListeners: Set<ExitListener>;
+    request(method: string, params: unknown, timeoutMs?: number | undefined, opts?: {
+        signal?: AbortSignal | undefined;
+    }): Promise<JsonRpcResponse>;
+    readonly serverRequests: ServerRequestResponder;
+    _serverMetadata: MCPServerMetadata | undefined;
+    notify(method: string, params: unknown): Promise<void>;
+    readonly toolCatalogRevision: number;
+    _tools: MCPTool[];
+    _toolsCache: MCPTool[] | undefined;
+    _drainPending: boolean;
+    _lastNotifySkipped: boolean;
+}
+export declare function connectStdio(host: ClientStdioHost): Promise<void>;
+export declare function notifyStdio(host: ClientStdioHost, method: string, params: unknown): Promise<void>;
+//# sourceMappingURL=client-stdio.d.ts.map

package/dist/client.d.ts

@@ -1,22 +1,13 @@
 import type { ExitListener, MCPClientOptions, MCPListChangedListener, MCPPageOptions, MCPRequestOptions, MCPResourceUpdatedListener, ToolsChangedListener } from './client-types.js';
 import type { ConnectionState, JsonRpcResponse, MCPTool, ToolCallResult } from './contracts.js';
 import { ServerRequestResponder, type UrlElicitation } from './elicitation.js';
-import { type MCPGetPromptResult, type MCPListPromptsResult, type MCPListResourcesResult, type MCPListResourceTemplatesResult, type MCPReadResourceResult, type MCPServerMetadata } from './protocol.js';
+import type { MCPGetPromptResult, MCPListPromptsResult, MCPListResourcesResult, MCPListResourceTemplatesResult, MCPReadResourceResult, MCPServerMetadata } from './protocol.js';
 export { forceKillTree } from './client-process.js';
 export { quoteWindowsArg } from './client-protocol-helpers.js';
 export type { ConnectionState, JsonRpcResponse, MCPTool, ToolCallResult };
 export declare class MCPClient {
     readonly opts: MCPClientOptions;
     private readonly capabilityClient;
-    /**
-     * Maximum bytes the rx buffer may accumulate before the connection is
-     * forcefully closed. A well-behaved JSON-RPC server emits newline-delimited
-     * messages that are individually much smaller than this; a server that never
-     * sends a newline would grow the buffer without limit and OOM the process.
-     * 16 MiB is generous for any legitimate single message while bounding the
-     * worst-case memory to a predictable cap.
-     */
-    private static readonly MAX_RX_BUFFER_BYTES;
     private state;
     private child?;
     private nextId;
@@ -53,6 +44,8 @@ export declare class MCPClient {
     private _lastNotifySkipped;
     private closePromise?;
     private connectPromise?;
+    private toolCatalogVersion;
+    private toolCatalogRevision;
     private sseTransport?;
     private httpTransport?;
     /** Notified when the stdio child process exits so the registry can attempt reconnect. */
@@ -137,6 +130,8 @@ export declare class MCPClient {
     private emitResourceUpdated;
     private emitCapabilityChanged;
     private clientHttpConnectionHost;
+    private clientStdioHost;
+    private clientStdioProtocolHost;
 }
 export type { MCPClientOptions, MCPListChangedListener, MCPPageOptions, MCPRequestOptions, MCPResourceUpdatedListener, Transport, } from './client-types.js';
 //# sourceMappingURL=client.d.ts.map