tiny-http-mcp-server 0.1.16 → 0.1.18

package/node_modules/tiny-mcp-client/dist/index.d.ts

@@ -1,7 +1,24 @@
 import { SpawnOptions, ChildProcessWithoutNullStreams } from 'node:child_process';
 import { Readable, Writable } from 'node:stream';
 import http from 'node:http';
-import { Server } from 'tiny-stdio-mcp-server';
+import { ContentItem as ContentItem$1, ResourceContents as ResourceContents$1, Implementation, Tool as Tool$1, Resource, ResourceTemplate, Prompt, Server } from 'tiny-stdio-mcp-server';
+export { ContentAnnotations, Icon, Implementation, Prompt, PromptArgument, Resource, ResourceLink, ResourceTemplate, ToolAnnotations, ToolExecution } from 'tiny-stdio-mcp-server';
+
+interface NotificationFilter {
+    toolsListChanged?: boolean;
+    promptsListChanged?: boolean;
+    resourcesListChanged?: boolean;
+    resourceSubscriptions?: string[];
+}
+interface SubscriptionOptions {
+    signal?: AbortSignal;
+}
+interface McpSubscription {
+    readonly id: RequestId;
+    readonly notifications: NotificationFilter;
+    readonly closed: Promise<void>;
+    cancel(): void;
+}
 
 interface MachineIdentity {
     hostname: string;
@@ -172,9 +189,12 @@ type OAuthClientProviderOptions = {
     provider: OAuthClientProvider;
 } | DefaultOAuthClientProviderOptions;
 
+declare function fetchMcpResponse(fetchImplementation: (input: string | URL, init?: RequestInit) => Promise<Response>, input: string | URL, init?: RequestInit): Promise<Response>;
+
 interface OAuthDiscoveryCache {
     get(resourceUrl: string): OAuthDiscoveryResult | null | undefined | Promise<OAuthDiscoveryResult | null | undefined>;
     set(resourceUrl: string, value: OAuthDiscoveryResult): void | Promise<void>;
+    delete?(resourceUrl: string): void | Promise<void>;
 }
 interface OAuthMetadataDiscoveryOptions {
     fetch?: OAuthMetadataFetch;
@@ -188,16 +208,18 @@ declare class OAuthMetadataDiscovery {
     private readonly cache;
     private readonly memoryCache;
     constructor({ fetch, cache }?: OAuthMetadataDiscoveryOptions);
+    private discoverProtectedResource;
     discover(resourceUrl: string | URL, { resourceMetadataUrl }?: OAuthMetadataLookupOptions): Promise<OAuthDiscoveryResult>;
 }
 declare function discoverOAuthMetadata(resourceUrl: string | URL, options?: OAuthMetadataDiscoveryOptions & OAuthMetadataLookupOptions): Promise<OAuthDiscoveryResult>;
 
 type RequestId = number | string;
-interface Implementation {
-    name: string;
-    version: string;
-}
 interface ClientCapabilities {
+    extensions?: Record<string, Record<string, unknown>>;
+    elicitation?: {
+        form?: Record<string, unknown>;
+        url?: Record<string, unknown>;
+    };
     roots?: {
         listChanged?: boolean;
         [key: string]: unknown;
@@ -208,6 +230,7 @@ interface ClientCapabilities {
     experimental?: Record<string, unknown>;
 }
 interface ServerCapabilities {
+    extensions?: Record<string, Record<string, unknown>>;
     prompts?: {
         listChanged?: boolean;
         [key: string]: unknown;
@@ -240,9 +263,32 @@ interface InitializeResult {
     serverInfo: Implementation;
     instructions?: string;
 }
+interface ConnectResult {
+    protocolVersion: string;
+    capabilities: ServerCapabilities;
+    serverInfo?: Implementation;
+    instructions?: string;
+}
+type ElicitationParams = {
+    mode?: "form";
+    message: string;
+    requestedSchema: Record<string, unknown>;
+} | {
+    mode: "url";
+    message: string;
+    url: string;
+    elicitationId: string;
+};
+interface ElicitationResult {
+    _meta?: Record<string, unknown>;
+    action: "accept" | "decline" | "cancel";
+    content?: Record<string, string | number | boolean | string[]>;
+}
 interface McpClientOptions {
     clientInfo: Implementation;
     requestTimeoutMs?: number;
+    maxConcurrentRequests?: number;
+    protocolVersion?: "2025-03-26" | "2026-07-28";
     capabilities?: ClientCapabilities;
     onToolsChanged?: () => void | Promise<void>;
     onResourcesChanged?: () => void | Promise<void>;
@@ -250,8 +296,9 @@ interface McpClientOptions {
     onPromptsChanged?: () => void | Promise<void>;
     onLog?: (message: LogMessage) => void | Promise<void>;
     onProgress?: (params: ProgressParams) => void | Promise<void>;
-    onSamplingRequest?: (params: CreateMessageParams) => CreateMessageResult | Promise<CreateMessageResult>;
-    onRootsList?: () => Root[] | Promise<Root[]>;
+    onSamplingRequest?: (params: CreateMessageParams, context: McpRequestContext) => CreateMessageResult | Promise<CreateMessageResult>;
+    onRootsList?: (context: McpRequestContext) => Root[] | Promise<Root[]>;
+    onElicitationRequest?: (params: ElicitationParams, context: McpRequestContext) => ElicitationResult | Promise<ElicitationResult>;
 }
 declare class McpClient {
     private currentState;
@@ -264,58 +311,70 @@ declare class McpClient {
     private readonly options;
     private transport;
     private messageLayer;
+    private subscriptions;
+    private readonly resourceSubscriptions;
     constructor(options: McpClientOptions);
     get state(): "disconnected" | "initializing" | "ready" | "closed";
     get serverCapabilities(): ServerCapabilities | null;
     get serverInfo(): Implementation | null;
     get instructions(): string | undefined;
     private getMessageLayerOrThrow;
-    connect(transport: McpTransport): Promise<InitializeResult>;
+    connect(transport: McpTransport, options?: {
+        signal?: AbortSignal;
+    }): Promise<ConnectResult>;
     private getServerCapabilitiesOrThrow;
-    listTools(params?: PaginatedParams): Promise<{
+    listTools(params?: PaginatedParams, options?: {
+        signal?: AbortSignal;
+    }): Promise<PaginatedResult & {
         tools: Tool[];
-        nextCursor?: string;
     }>;
     callTool(params: CallToolParams, options?: CallToolOptions): Promise<CallToolResult>;
-    listResources(params?: PaginatedParams): Promise<{
+    listResources(params?: PaginatedParams, options?: {
+        signal?: AbortSignal;
+    }): Promise<PaginatedResult & {
         resources: Resource[];
-        nextCursor?: string;
     }>;
-    listResourceTemplates(params?: PaginatedParams): Promise<{
+    listResourceTemplates(params?: PaginatedParams, options?: {
+        signal?: AbortSignal;
+    }): Promise<PaginatedResult & {
         resourceTemplates: ResourceTemplate[];
-        nextCursor?: string;
     }>;
-    readResource(params: ReadResourceParams): Promise<{
+    readResource(params: ReadResourceParams, options?: {
+        signal?: AbortSignal;
+    }): Promise<CacheableResultMetadata & {
         contents: ResourceContents[];
     }>;
-    subscribe(uri: string): Promise<void>;
-    unsubscribe(uri: string): Promise<void>;
-    listPrompts(params?: PaginatedParams): Promise<{
+    listenNotifications(filter: NotificationFilter, options?: SubscriptionOptions): Promise<McpSubscription>;
+    subscribe(uri: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    unsubscribe(uri: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    listPrompts(params?: PaginatedParams, options?: {
+        signal?: AbortSignal;
+    }): Promise<PaginatedResult & {
         prompts: Prompt[];
-        nextCursor?: string;
     }>;
-    getPrompt(params: GetPromptParams): Promise<GetPromptResult>;
-    complete(params: CompleteParams): Promise<CompleteResult>;
-    setLogLevel(level: LogLevel): Promise<void>;
+    getPrompt(params: GetPromptParams, options?: {
+        signal?: AbortSignal;
+    }): Promise<GetPromptResult>;
+    complete(params: CompleteParams, options?: {
+        signal?: AbortSignal;
+    }): Promise<CompleteResult>;
+    setLogLevel(level: LogLevel, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
     cancel(requestId: RequestId, reason?: string): Promise<void>;
     sendRootsChanged(): Promise<void>;
-    ping(): Promise<void>;
+    ping(options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
     close(): Promise<void>;
 }
-interface Tool {
-    name: string;
-    title?: string;
-    description?: string;
+interface Tool extends Omit<Tool$1, "inputSchema" | "outputSchema"> {
     inputSchema: Record<string, unknown>;
     outputSchema?: Record<string, unknown>;
-    annotations?: ToolAnnotations;
-}
-interface ToolAnnotations {
-    title?: string;
-    readOnlyHint?: boolean;
-    destructiveHint?: boolean;
-    idempotentHint?: boolean;
-    openWorldHint?: boolean;
 }
 interface CallToolParams {
     name: string;
@@ -328,70 +387,45 @@ interface CallToolOptions {
 interface ReadResourceParams {
     uri: string;
 }
-interface Resource {
-    uri: string;
-    name: string;
-    description?: string;
-    mimeType?: string;
-    size?: number;
-}
-interface ResourceTemplate {
-    uriTemplate: string;
-    name: string;
-    description?: string;
-    mimeType?: string;
-}
 interface PaginatedParams {
     cursor?: string;
 }
-interface PaginatedResult {
+interface ResultMetadata {
+    resultType?: "complete";
+    _meta?: Record<string, unknown>;
+}
+interface CacheableResultMetadata extends ResultMetadata {
+    ttlMs?: number;
+    cacheScope?: "public" | "private";
+}
+interface PaginatedResult extends CacheableResultMetadata {
     nextCursor?: string;
 }
-interface TextResourceContents {
-    uri: string;
-    mimeType?: string;
+type TextResourceContents = Extract<ResourceContents$1, {
     text: string;
-}
-interface BlobResourceContents {
-    uri: string;
-    mimeType?: string;
+}>;
+type BlobResourceContents = Extract<ResourceContents$1, {
     blob: string;
-}
-type ResourceContents = TextResourceContents | BlobResourceContents;
-interface TextContent {
+}>;
+type ResourceContents = ResourceContents$1;
+type TextContent = Extract<ContentItem$1, {
     type: "text";
-    text: string;
-}
-interface ImageContent {
+}>;
+type ImageContent = Extract<ContentItem$1, {
     type: "image";
-    data: string;
-    mimeType: string;
-}
-interface AudioContent {
+}>;
+type AudioContent = Extract<ContentItem$1, {
     type: "audio";
-    data: string;
-    mimeType: string;
-}
-interface EmbeddedResource {
+}>;
+type EmbeddedResource = Extract<ContentItem$1, {
     type: "resource";
-    resource: ResourceContents;
-}
-type ContentItem = TextContent | ImageContent | AudioContent | EmbeddedResource;
-interface Prompt {
-    name: string;
-    description?: string;
-    arguments?: PromptArgument[];
-}
-interface PromptArgument {
-    name: string;
-    description?: string;
-    required?: boolean;
-}
+}>;
+type ContentItem = ContentItem$1;
 interface PromptMessage {
     role: "user" | "assistant";
     content: ContentItem;
 }
-interface GetPromptResult {
+interface GetPromptResult extends ResultMetadata {
     description?: string;
     messages: PromptMessage[];
 }
@@ -399,12 +433,13 @@ interface GetPromptParams {
     name: string;
     arguments?: Record<string, string>;
 }
-interface CallToolResult {
+interface CallToolResult extends ResultMetadata {
     content: ContentItem[];
-    structuredContent?: Record<string, unknown>;
+    structuredContent?: unknown;
     isError?: boolean;
 }
 interface Root {
+    _meta?: Record<string, unknown>;
     uri: string;
     name?: string;
 }
@@ -430,9 +465,26 @@ interface ModelPreferences {
     speedPriority?: number;
     intelligencePriority?: number;
 }
+interface ToolUseContent {
+    _meta?: Record<string, unknown>;
+    type: "tool_use";
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+}
+interface ToolResultContent {
+    _meta?: Record<string, unknown>;
+    type: "tool_result";
+    toolUseId: string;
+    content: ContentItem[];
+    structuredContent?: unknown;
+    isError?: boolean;
+}
+type SamplingContent = TextContent | ImageContent | AudioContent | ToolUseContent | ToolResultContent;
 interface SamplingMessage {
+    _meta?: Record<string, unknown>;
     role: "user" | "assistant";
-    content: ContentItem | ContentItem[];
+    content: SamplingContent | SamplingContent[];
 }
 type IncludeContext = "none" | "thisServer" | "allServers";
 interface CreateMessageParams {
@@ -442,14 +494,19 @@ interface CreateMessageParams {
     includeContext?: IncludeContext;
     temperature?: number;
     maxTokens: number;
+    tools?: Tool[];
+    toolChoice?: {
+        mode: "auto" | "required" | "none";
+    };
     stopSequences?: string[];
     metadata?: Record<string, unknown>;
 }
 interface CreateMessageResult {
+    _meta?: Record<string, unknown>;
     model: string;
-    content: ContentItem | ContentItem[];
+    content: SamplingContent | SamplingContent[];
     role: "user" | "assistant";
-    stopReason: string;
+    stopReason?: string;
 }
 interface PromptReference {
     type: "ref/prompt";
@@ -464,6 +521,9 @@ interface CompleteArgument {
     value: string;
 }
 interface CompleteParams {
+    context?: {
+        arguments?: Record<string, string>;
+    };
     ref: PromptReference | ResourceReference;
     argument: CompleteArgument;
 }
@@ -472,7 +532,7 @@ interface Completion {
     hasMore?: boolean;
     total?: number;
 }
-interface CompleteResult {
+interface CompleteResult extends ResultMetadata {
     completion: Completion;
 }
 declare const ERROR_PARSE = -32700;
@@ -490,6 +550,7 @@ interface McpTransport {
     writable: Writable;
     closed: Promise<McpTransportClosedEvent>;
     dispose(reason?: Error): void;
+    filterTools?(tools: Tool[], reset?: boolean): Tool[];
 }
 interface InMemoryServerTransport {
     readable: Readable;
@@ -528,6 +589,8 @@ interface HttpTransportOptions {
     fetch?: HttpTransportFetch;
     oauth?: OAuthClientProviderOptions;
     oauthDiscoveryCache?: OAuthDiscoveryCache;
+    onWarning?: (message: string) => void;
+    maxResponseBytes?: number;
 }
 declare class StdioTransport implements McpTransport {
     readonly readable: Readable;
@@ -559,12 +622,18 @@ declare class HttpTransport implements McpTransport {
     private readonly oauthProvider;
     private readonly oauthMetadataDiscovery;
     private readonly inFlightFetchAbortControllers;
-    private readonly openSseReaders;
-    constructor({ url, headers, fetch: fetchImpl, oauth, oauthDiscoveryCache, }: HttpTransportOptions);
+    private readonly openResponseReaders;
+    private readonly modernRequests;
+    private modernMode;
+    private readonly maxResponseBytes;
+    private readonly toolParameterHeaders;
+    private readonly onWarning;
+    constructor({ url, headers, fetch: fetchImpl, oauth, oauthDiscoveryCache, onWarning, maxResponseBytes, }: HttpTransportOptions);
+    filterTools(tools: Tool[], reset?: boolean): Tool[];
     dispose(reason?: Error): void;
     private closeWithSessionTermination;
     private abortInFlightFetches;
-    private cancelOpenSseReaders;
+    private cancelOpenResponseReaders;
     private fetchWithAbort;
     private consumeWrittenLines;
     private sendPost;
@@ -620,35 +689,43 @@ interface JsonRpcErrorResponse {
 type JsonRpcResponse = JsonRpcSuccessResponse | JsonRpcErrorResponse;
 type JsonRpcMessage = JsonRpcRequest | JsonRpcNotification | JsonRpcResponse;
 interface JsonRpcRequestOptions {
-    timeoutMs?: number;
+    signal?: AbortSignal;
+    timeoutMs?: number | null;
     onRequestId?: (requestId: RequestId) => void;
     onTimeout?: (requestId: RequestId) => void;
 }
-interface JsonRpcRequestContext {
-    id: RequestId;
-    method: string;
+interface McpRequestContext {
+    readonly id: RequestId;
+    readonly method: string;
+    readonly signal: AbortSignal;
 }
-type JsonRpcRequestHandler = (params: unknown, context: JsonRpcRequestContext) => unknown | Promise<unknown>;
+type JsonRpcRequestHandler = (params: unknown, context: McpRequestContext) => unknown | Promise<unknown>;
 interface JsonRpcNotificationContext {
     method: string;
 }
 type JsonRpcNotificationHandler = (params: unknown, context: JsonRpcNotificationContext) => unknown | Promise<unknown>;
 declare class JsonRpcMessageLayer {
+    private readonly maxConcurrentRequests;
+    requestMetadata?: Record<string, unknown>;
     readonly requestTimeoutMs: number;
     private readonly input;
     private readonly output;
     private readonly inputClosedReason;
     private nextRequestId;
+    private readonly exchangeControllers;
     private disposedError;
     private readonly pendingRequests;
     private readonly activeIncomingRequests;
     private readonly requestHandlers;
+    private readonly inputRequestHandlers;
     private readonly notificationHandlers;
-    constructor(input: Readable, output: Writable, requestTimeoutMs?: number, inputClosedReason?: Promise<Error>);
+    constructor(input: Readable, output: Writable, requestTimeoutMs?: number, inputClosedReason?: Promise<Error>, maxConcurrentRequests?: number);
     sendNotification(method: string, params?: unknown): void;
     onRequest(method: string, handler: JsonRpcRequestHandler): void;
     onNotification(method: string, handler: JsonRpcNotificationHandler): void;
+    onInputRequest(method: string, handler: JsonRpcRequestHandler): void;
     sendRequest(method: string, params?: unknown, options?: JsonRpcRequestOptions): Promise<unknown>;
+    private sendRequestOnce;
     cancelRequest(requestId: RequestId, reason: unknown): boolean;
     dispose(reason?: Error): void;
     private consumeInput;
@@ -658,5 +735,5 @@ declare class JsonRpcMessageLayer {
     private handleCancellationNotification;
 }
 
-export { ERROR_INTERNAL, ERROR_INVALID_PARAMS, ERROR_INVALID_REQUEST, ERROR_METHOD_NOT_FOUND, ERROR_PARSE, HttpTransport, JsonRpcMessageLayer, McpClient, McpError, OAuthMetadataDiscovery, StdioTransport, createInMemoryTransportPair, createSdkTestPair, createTestPair, discoverOAuthMetadata };
-export type { AudioContent, BlobResourceContents, CallToolOptions, CallToolParams, CallToolResult, ClientCapabilities, CompleteArgument, CompleteParams, CompleteResult, Completion, ContentItem, CreateMessageParams, CreateMessageResult, EmbeddedResource, GetPromptParams, GetPromptResult, HttpTransportFetch, HttpTransportOptions, ImageContent, Implementation, InMemoryTransportPair, IncludeContext, InitializeParams, InitializeResult, JsonRpcErrorObject, JsonRpcErrorResponse, JsonRpcMessage, JsonRpcNotification, JsonRpcRequest, JsonRpcRequestOptions, JsonRpcResponse, JsonRpcSuccessResponse, LogLevel, LogMessage, McpClientConnection, McpClientOptions, McpTransport, McpTransportClosedEvent, ModelHint, ModelPreferences, OAuthAuthorizationServerMetadata, OAuthClientProvider, OAuthClientProviderOptions, OAuthDiscoveryCache, OAuthDiscoveryResult, OAuthMetadataFetch, OAuthProtectedResourceMetadata, OAuthSessionStore, OAuthUnauthorizedChallenge, PaginatedParams, PaginatedResult, ProgressParams, ProgressToken, Prompt, PromptArgument, PromptMessage, PromptReference, ReadResourceParams, RequestId, Resource, ResourceContents, ResourceReference, ResourceTemplate, Root, SamplingMessage, SdkTestPair, ServerCapabilities, StdioSpawn, StdioTransportOptions, StoredOAuthSession, TextContent, TextResourceContents, Tool, ToolAnnotations };
+export { ERROR_INTERNAL, ERROR_INVALID_PARAMS, ERROR_INVALID_REQUEST, ERROR_METHOD_NOT_FOUND, ERROR_PARSE, HttpTransport, JsonRpcMessageLayer, McpClient, McpError, OAuthMetadataDiscovery, StdioTransport, createInMemoryTransportPair, createSdkTestPair, createTestPair, discoverOAuthMetadata, fetchMcpResponse };
+export type { AudioContent, BlobResourceContents, CacheableResultMetadata, CallToolOptions, CallToolParams, CallToolResult, ClientCapabilities, CompleteArgument, CompleteParams, CompleteResult, Completion, ConnectResult, ContentItem, CreateMessageParams, CreateMessageResult, ElicitationParams, ElicitationResult, EmbeddedResource, GetPromptParams, GetPromptResult, HttpTransportFetch, HttpTransportOptions, ImageContent, InMemoryTransportPair, IncludeContext, InitializeParams, InitializeResult, JsonRpcErrorObject, JsonRpcErrorResponse, JsonRpcMessage, JsonRpcNotification, JsonRpcRequest, JsonRpcRequestOptions, JsonRpcResponse, JsonRpcSuccessResponse, LogLevel, LogMessage, McpClientConnection, McpClientOptions, McpRequestContext, McpSubscription, McpTransport, McpTransportClosedEvent, ModelHint, ModelPreferences, NotificationFilter, OAuthAuthorizationServerMetadata, OAuthClientProvider, OAuthClientProviderOptions, OAuthDiscoveryCache, OAuthDiscoveryResult, OAuthMetadataFetch, OAuthProtectedResourceMetadata, OAuthSessionStore, OAuthUnauthorizedChallenge, PaginatedParams, PaginatedResult, ProgressParams, ProgressToken, PromptMessage, PromptReference, ReadResourceParams, RequestId, ResourceContents, ResourceReference, ResultMetadata, Root, SamplingContent, SamplingMessage, SdkTestPair, ServerCapabilities, StdioSpawn, StdioTransportOptions, StoredOAuthSession, SubscriptionOptions, TextContent, TextResourceContents, Tool, ToolResultContent, ToolUseContent };