toolcraft 0.0.5 → 0.0.7

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

@@ -0,0 +1,2 @@
+export { createInMemoryTransportPair, discoverOAuthMetadata, createSdkTestPair, createTestPair, ERROR_INTERNAL, ERROR_INVALID_PARAMS, ERROR_INVALID_REQUEST, ERROR_METHOD_NOT_FOUND, ERROR_PARSE, HttpTransport, JsonRpcMessageLayer, McpClient, McpError, OAuthMetadataDiscovery, StdioTransport, } from "./internal.js";
+export type { AudioContent, BlobResourceContents, CallToolOptions, CallToolParams, CallToolResult, ClientCapabilities, CompleteArgument, CompleteParams, CompleteResult, Completion, ContentItem, CreateMessageParams, CreateMessageResult, EmbeddedResource, GetPromptParams, GetPromptResult, HttpTransportFetch, HttpTransportOptions, ImageContent, Implementation, IncludeContext, InitializeParams, InitializeResult, InMemoryTransportPair, JsonRpcErrorObject, JsonRpcErrorResponse, JsonRpcMessage, JsonRpcNotification, JsonRpcRequest, JsonRpcRequestOptions, JsonRpcResponse, JsonRpcSuccessResponse, LogLevel, LogMessage, McpClientConnection, McpClientOptions, McpTransport, McpTransportClosedEvent, ModelHint, ModelPreferences, OAuthAuthorizationServerMetadata, OAuthClientProvider, OAuthClientProviderOptions, OAuthDiscoveryCache, OAuthDiscoveryResult, OAuthMetadataFetch, OAuthSessionStore, OAuthProtectedResourceMetadata, OAuthUnauthorizedChallenge, PaginatedParams, PaginatedResult, ProgressParams, ProgressToken, Prompt, PromptArgument, PromptMessage, PromptReference, ReadResourceParams, RequestId, Resource, ResourceContents, ResourceReference, ResourceTemplate, Root, SamplingMessage, SdkTestPair, ServerCapabilities, StdioSpawn, StdioTransportOptions, TextContent, TextResourceContents, Tool, ToolAnnotations, StoredOAuthSession, } from "./internal.js";

package/node_modules/tiny-mcp-client/dist/index.js

@@ -0,0 +1 @@
+export { createInMemoryTransportPair, discoverOAuthMetadata, createSdkTestPair, createTestPair, ERROR_INTERNAL, ERROR_INVALID_PARAMS, ERROR_INVALID_REQUEST, ERROR_METHOD_NOT_FOUND, ERROR_PARSE, HttpTransport, JsonRpcMessageLayer, McpClient, McpError, OAuthMetadataDiscovery, StdioTransport, } from "./internal.js";

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

@@ -0,0 +1,547 @@
+import type { ChildProcessWithoutNullStreams, SpawnOptions } from "node:child_process";
+import type { Readable, Writable } from "node:stream";
+import type { JSONRPCMessage as SdkJsonRpcMessage } from "@modelcontextprotocol/sdk/types.js";
+import { type OAuthClientProviderOptions } from "mcp-oauth";
+import type { Server as TinyStdioMcpServer } from "tiny-stdio-mcp-server";
+import type { OAuthDiscoveryCache } from "./oauth-discovery.js";
+export { OAuthMetadataDiscovery, discoverOAuthMetadata, parseBearerWwwAuthenticateHeader, resolveAuthorizationServerMetadataUrl, resolveProtectedResourceMetadataUrl, } from "./oauth-discovery.js";
+export { createAuthStoreSessionStore, createDefaultOAuthClientProvider, } from "mcp-oauth";
+export type { OAuthDiscoveryCache, } from "./oauth-discovery.js";
+export type { OAuthAuthorizationServerMetadata, OAuthDiscoveryResult, OAuthMetadataFetch, OAuthProtectedResourceMetadata, OAuthUnauthorizedChallenge } from "./oauth-discovery.js";
+export type { DefaultOAuthClientProviderOptions, OAuthClientProvider, OAuthClientProviderOptions, OAuthSessionStore, StoredOAuthSession, } from "mcp-oauth";
+export type RequestId = number | string;
+export interface Implementation {
+    name: string;
+    version: string;
+}
+export interface ClientCapabilities {
+    roots?: {
+        listChanged?: boolean;
+        [key: string]: unknown;
+    };
+    sampling?: {
+        [key: string]: unknown;
+    };
+    experimental?: Record<string, unknown>;
+}
+export interface ServerCapabilities {
+    prompts?: {
+        listChanged?: boolean;
+        [key: string]: unknown;
+    };
+    resources?: {
+        subscribe?: boolean;
+        listChanged?: boolean;
+        [key: string]: unknown;
+    };
+    tools?: {
+        listChanged?: boolean;
+        [key: string]: unknown;
+    };
+    logging?: {
+        [key: string]: unknown;
+    };
+    completions?: {
+        [key: string]: unknown;
+    };
+    experimental?: Record<string, unknown>;
+}
+export interface InitializeParams {
+    protocolVersion: string;
+    capabilities: ClientCapabilities;
+    clientInfo: Implementation;
+}
+export interface InitializeResult {
+    protocolVersion: string;
+    capabilities: ServerCapabilities;
+    serverInfo: Implementation;
+    instructions?: string;
+}
+export interface McpClientOptions {
+    clientInfo: Implementation;
+    capabilities?: ClientCapabilities;
+    onToolsChanged?: () => void | Promise<void>;
+    onResourcesChanged?: () => void | Promise<void>;
+    onResourceUpdated?: (uri: string) => void | Promise<void>;
+    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[]>;
+}
+export declare class McpClient {
+    private currentState;
+    private currentServerCapabilities;
+    private currentServerInfo;
+    private currentInstructions;
+    private readonly options;
+    private transport;
+    private messageLayer;
+    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>;
+    private getServerCapabilitiesOrThrow;
+    listTools(params?: PaginatedParams): Promise<{
+        tools: Tool[];
+        nextCursor?: string;
+    }>;
+    callTool(params: CallToolParams, options?: CallToolOptions): Promise<CallToolResult>;
+    listResources(params?: PaginatedParams): Promise<{
+        resources: Resource[];
+        nextCursor?: string;
+    }>;
+    listResourceTemplates(params?: PaginatedParams): Promise<{
+        resourceTemplates: ResourceTemplate[];
+        nextCursor?: string;
+    }>;
+    readResource(params: ReadResourceParams): Promise<{
+        contents: ResourceContents[];
+    }>;
+    subscribe(uri: string): Promise<void>;
+    unsubscribe(uri: string): Promise<void>;
+    listPrompts(params?: PaginatedParams): Promise<{
+        prompts: Prompt[];
+        nextCursor?: string;
+    }>;
+    getPrompt(params: GetPromptParams): Promise<GetPromptResult>;
+    complete(params: CompleteParams): Promise<CompleteResult>;
+    setLogLevel(level: LogLevel): Promise<void>;
+    cancel(requestId: RequestId, reason?: string): Promise<void>;
+    sendRootsChanged(): Promise<void>;
+    ping(): Promise<void>;
+    close(): Promise<void>;
+}
+export interface Tool {
+    name: string;
+    description?: string;
+    inputSchema: Record<string, unknown>;
+    annotations?: ToolAnnotations;
+}
+export interface ToolAnnotations {
+    title?: string;
+    readOnlyHint?: boolean;
+    destructiveHint?: boolean;
+    idempotentHint?: boolean;
+    openWorldHint?: boolean;
+}
+export interface CallToolParams {
+    name: string;
+    arguments?: Record<string, unknown>;
+}
+export interface CallToolOptions {
+    signal?: AbortSignal;
+    progressToken?: ProgressToken;
+}
+export interface ReadResourceParams {
+    uri: string;
+}
+export interface Resource {
+    uri: string;
+    name: string;
+    description?: string;
+    mimeType?: string;
+    size?: number;
+}
+export interface ResourceTemplate {
+    uriTemplate: string;
+    name: string;
+    description?: string;
+    mimeType?: string;
+}
+export interface PaginatedParams {
+    cursor?: string;
+}
+export interface PaginatedResult {
+    nextCursor?: string;
+}
+export interface TextResourceContents {
+    uri: string;
+    mimeType?: string;
+    text: string;
+}
+export interface BlobResourceContents {
+    uri: string;
+    mimeType?: string;
+    blob: string;
+}
+export type ResourceContents = TextResourceContents | BlobResourceContents;
+export interface TextContent {
+    type: "text";
+    text: string;
+}
+export interface ImageContent {
+    type: "image";
+    data: string;
+    mimeType: string;
+}
+export interface AudioContent {
+    type: "audio";
+    data: string;
+    mimeType: string;
+}
+export interface EmbeddedResource {
+    type: "resource";
+    resource: ResourceContents;
+}
+export type ContentItem = TextContent | ImageContent | AudioContent | EmbeddedResource;
+export interface Prompt {
+    name: string;
+    description?: string;
+    arguments?: PromptArgument[];
+}
+export interface PromptArgument {
+    name: string;
+    description?: string;
+    required?: boolean;
+}
+export interface PromptMessage {
+    role: "user" | "assistant";
+    content: ContentItem;
+}
+export interface GetPromptResult {
+    description?: string;
+    messages: PromptMessage[];
+}
+export interface GetPromptParams {
+    name: string;
+    arguments?: Record<string, string>;
+}
+export interface CallToolResult {
+    content: ContentItem[];
+    isError?: boolean;
+}
+export interface Root {
+    uri: string;
+    name?: string;
+}
+export type LogLevel = "debug" | "info" | "notice" | "warning" | "error" | "critical" | "alert" | "emergency";
+export interface LogMessage {
+    level: LogLevel;
+    logger?: string;
+    data: unknown;
+}
+export type ProgressToken = RequestId;
+export interface ProgressParams {
+    progressToken: ProgressToken;
+    progress: number;
+    total?: number;
+    message?: string;
+}
+export interface ModelHint {
+    name?: string;
+}
+export interface ModelPreferences {
+    hints?: ModelHint[];
+    costPriority?: number;
+    speedPriority?: number;
+    intelligencePriority?: number;
+}
+export interface SamplingMessage {
+    role: "user" | "assistant";
+    content: ContentItem | ContentItem[];
+}
+export type IncludeContext = "none" | "thisServer" | "allServers";
+export interface CreateMessageParams {
+    messages: SamplingMessage[];
+    modelPreferences?: ModelPreferences;
+    systemPrompt?: string;
+    includeContext?: IncludeContext;
+    temperature?: number;
+    maxTokens: number;
+    stopSequences?: string[];
+    metadata?: Record<string, unknown>;
+}
+export interface CreateMessageResult {
+    model: string;
+    content: ContentItem | ContentItem[];
+    role: "user" | "assistant";
+    stopReason: string;
+}
+export interface PromptReference {
+    type: "ref/prompt";
+    name: string;
+}
+export interface ResourceReference {
+    type: "ref/resource";
+    uri: string;
+}
+export interface CompleteArgument {
+    name: string;
+    value: string;
+}
+export interface CompleteParams {
+    ref: PromptReference | ResourceReference;
+    argument: CompleteArgument;
+}
+export interface Completion {
+    values: string[];
+    hasMore?: boolean;
+    total?: number;
+}
+export interface CompleteResult {
+    completion: Completion;
+}
+export declare const ERROR_PARSE = -32700;
+export declare const ERROR_INVALID_REQUEST = -32600;
+export declare const ERROR_METHOD_NOT_FOUND = -32601;
+export declare const ERROR_INVALID_PARAMS = -32602;
+export declare const ERROR_INTERNAL = -32603;
+export interface McpTransportClosedEvent {
+    reason: Error;
+    code?: number;
+    signal?: NodeJS.Signals;
+}
+export interface McpTransport {
+    readable: Readable;
+    writable: Writable;
+    closed: Promise<McpTransportClosedEvent>;
+    dispose(reason?: Error): void;
+}
+export interface InMemoryServerTransport {
+    readable: Readable;
+    writable: Writable;
+}
+export interface InMemoryTransportPair {
+    clientTransport: McpTransport;
+    serverTransport: InMemoryServerTransport;
+}
+export declare function createInMemoryTransportPair(): InMemoryTransportPair;
+interface SdkTransportAdapterInput {
+    onclose?: () => void;
+    onerror?: (error: Error) => void;
+    onmessage?: (message: SdkJsonRpcMessage, extra?: any) => void;
+    start(): Promise<void>;
+    close(): Promise<void>;
+    send(message: SdkJsonRpcMessage): Promise<void>;
+}
+export interface McpClientConnection {
+    connect(transport: McpTransport): Promise<void>;
+    close(): Promise<void>;
+}
+interface SdkServerConnection {
+    connect(transport: unknown): Promise<void>;
+}
+export interface SdkTestPair<TClient extends McpClientConnection> {
+    client: TClient;
+    cleanup: () => Promise<void>;
+}
+export declare class SdkTransportAdapter implements McpTransport {
+    readonly readable: Readable;
+    readonly writable: Writable;
+    readonly closed: Promise<McpTransportClosedEvent>;
+    private readonly sdkTransport;
+    private readonly readStream;
+    private readonly writeStream;
+    private resolveClosed;
+    private disposed;
+    constructor(sdkTransport: SdkTransportAdapterInput);
+    dispose(reason?: Error): void;
+    private consumeWrittenLines;
+}
+export declare function createSdkTestPair<TClient extends McpClientConnection>(server: SdkServerConnection, createClient: () => TClient): Promise<SdkTestPair<TClient>>;
+export declare function createMockEchoToolServer(): Promise<SdkServerConnection>;
+export declare function createMockMultiToolServer(): Promise<SdkServerConnection>;
+export declare function createMockPaginatedToolsServer(): Promise<SdkServerConnection>;
+export declare function createMockResourceServer(): Promise<SdkServerConnection>;
+export declare function createMockSubscribableResourceServer(): Promise<SdkServerConnection & {
+    triggerResourceUpdated: (uri: string, updatedText?: string) => Promise<void>;
+    triggerResourceListChanged: () => Promise<void>;
+}>;
+export declare function createMockPromptServer(): Promise<SdkServerConnection>;
+export declare function createMockCompletionServer(): Promise<SdkServerConnection>;
+export declare function createMockProgressServer(): Promise<SdkServerConnection>;
+export interface MockSlowToolServerOptions {
+    delayMs?: number;
+    pollIntervalMs?: number;
+}
+export declare function createMockSlowToolServer(options?: MockSlowToolServerOptions): Promise<SdkServerConnection & {
+    wasStarted: () => boolean;
+    getStartedRequestIds: () => RequestId[];
+    wasCancelled: () => boolean;
+    getCancelledRequestIds: () => RequestId[];
+}>;
+export declare function createMockErrorServer(): Promise<SdkServerConnection>;
+export declare function createMockSamplingServer(): Promise<SdkServerConnection>;
+export declare function createMockRootsServer(): Promise<SdkServerConnection>;
+export declare function createMockLoggingServer(): Promise<SdkServerConnection>;
+export declare function createMockFullFeaturedServer(): Promise<SdkServerConnection>;
+export declare function createTestPair<TClient extends McpClientConnection>(server: TinyStdioMcpServer, createClient: () => TClient): Promise<SdkTestPair<TClient>>;
+export type StdioSpawn = (command: string, args: ReadonlyArray<string>, options: SpawnOptions) => ChildProcessWithoutNullStreams;
+export interface StdioTransportOptions {
+    command: string;
+    args?: string[];
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    spawn?: StdioSpawn;
+}
+export type HttpTransportFetch = (input: string | URL, init?: RequestInit) => Promise<Response>;
+export interface HttpTransportOptions {
+    url: string;
+    headers?: HeadersInit;
+    fetch?: HttpTransportFetch;
+    oauth?: OAuthClientProviderOptions;
+    oauthDiscoveryCache?: OAuthDiscoveryCache;
+}
+export declare class StdioTransport implements McpTransport {
+    readonly readable: Readable;
+    readonly writable: Writable;
+    readonly closed: Promise<McpTransportClosedEvent>;
+    private readonly child;
+    private disposed;
+    private stderrOutput;
+    private static readonly STDERR_MAX_LENGTH;
+    constructor({ command, args, cwd, env, spawn: spawnProcess, }: StdioTransportOptions);
+    getStderrOutput(): string;
+    dispose(reason?: Error): void;
+}
+export declare class HttpTransport implements McpTransport {
+    readonly readable: Readable;
+    readonly writable: Writable;
+    readonly closed: Promise<McpTransportClosedEvent>;
+    private readonly url;
+    private readonly headers;
+    private readonly fetchImpl;
+    private readonly readStream;
+    private readonly writeStream;
+    private resolveClosed;
+    private sessionId;
+    private lastEventId;
+    private getSseStreamStarted;
+    private disposed;
+    private readonly oauthProvider;
+    private readonly oauthMetadataDiscovery;
+    private readonly inFlightFetchAbortControllers;
+    private readonly openSseReaders;
+    constructor({ url, headers, fetch: fetchImpl, oauth, oauthDiscoveryCache, }: HttpTransportOptions);
+    dispose(reason?: Error): void;
+    private abortInFlightFetches;
+    private cancelOpenSseReaders;
+    private fetchWithAbort;
+    private consumeWrittenLines;
+    private createPostHeaders;
+    private createGetHeaders;
+    private createDeleteHeaders;
+    private authorizeRequestHeaders;
+    private captureSessionId;
+    private maybeOpenGetSseStream;
+    private terminateSession;
+    private sendSessionTerminationRequest;
+    private consumeGetSseStream;
+    private throwForPostHttpError;
+    private maybeHandleUnauthorizedResponse;
+    private forwardResponseMessages;
+    private forwardSseResponseMessages;
+    private forwardJsonResponseMessage;
+    private writeSseMessages;
+    private writeReadableLine;
+    private fetchWithOAuthRetry;
+    private readOAuthChallengeError;
+}
+export interface JsonRpcRequest {
+    jsonrpc: "2.0";
+    id: RequestId;
+    method: string;
+    params?: unknown;
+}
+export interface JsonRpcNotification {
+    jsonrpc: "2.0";
+    method: string;
+    params?: unknown;
+}
+export interface JsonRpcErrorObject {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+export declare class McpError extends Error {
+    readonly code: number;
+    readonly data?: unknown;
+    constructor(code: number, message: string, data?: unknown);
+}
+export interface JsonRpcSuccessResponse {
+    jsonrpc: "2.0";
+    id: RequestId;
+    result: unknown;
+}
+export interface JsonRpcErrorResponse {
+    jsonrpc: "2.0";
+    id: RequestId;
+    error: JsonRpcErrorObject;
+}
+export type JsonRpcResponse = JsonRpcSuccessResponse | JsonRpcErrorResponse;
+export type JsonRpcMessage = JsonRpcRequest | JsonRpcNotification | JsonRpcResponse;
+export type ParsedJsonRpcMessage = {
+    type: "request";
+    message: JsonRpcRequest;
+} | {
+    type: "notification";
+    message: JsonRpcNotification;
+} | {
+    type: "response";
+    message: JsonRpcResponse;
+} | {
+    type: "invalid";
+    id: RequestId | null;
+    error: McpError;
+};
+export declare function serializeJsonRpcMessage(message: JsonRpcMessage): string;
+export declare function readLines(stream: Readable): AsyncGenerator<string>;
+export interface ParsedSseMessage {
+    data: string;
+    id?: string;
+}
+export declare class SseParser {
+    private buffer;
+    private eventType;
+    private dataLines;
+    private eventId;
+    private hasEventId;
+    private _lastEventId;
+    get lastEventId(): string | undefined;
+    push(chunk: string): ParsedSseMessage[];
+    flush(): ParsedSseMessage[];
+    private consumeLine;
+    private emitEvent;
+    private resetEvent;
+}
+export interface JsonRpcRequestOptions {
+    timeoutMs?: number;
+    onRequestId?: (requestId: RequestId) => void;
+}
+interface JsonRpcRequestContext {
+    id: RequestId;
+    method: string;
+}
+type JsonRpcRequestHandler = (params: unknown, context: JsonRpcRequestContext) => unknown | Promise<unknown>;
+interface JsonRpcNotificationContext {
+    method: string;
+}
+type JsonRpcNotificationHandler = (params: unknown, context: JsonRpcNotificationContext) => unknown | Promise<unknown>;
+export declare class JsonRpcMessageLayer {
+    readonly requestTimeoutMs: number;
+    private readonly input;
+    private readonly output;
+    private readonly inputClosedReason;
+    private nextRequestId;
+    private disposedError;
+    private readonly pendingRequests;
+    private readonly activeIncomingRequests;
+    private readonly requestHandlers;
+    private readonly notificationHandlers;
+    constructor(input: Readable, output: Writable, requestTimeoutMs?: number, inputClosedReason?: Promise<Error>);
+    sendNotification(method: string, params?: unknown): void;
+    onRequest(method: string, handler: JsonRpcRequestHandler): void;
+    onNotification(method: string, handler: JsonRpcNotificationHandler): void;
+    sendRequest(method: string, params?: unknown, options?: JsonRpcRequestOptions): Promise<unknown>;
+    dispose(reason?: Error): void;
+    private consumeInput;
+    private resolveInputStreamClosedReason;
+    private processParsedMessage;
+    private handleIncomingRequest;
+    private handleCancellationNotification;
+}
+export declare function parseJsonRpcMessage(line: string): ParsedJsonRpcMessage;