toolcraft 0.0.713 → 0.0.715

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

@@ -0,0 +1,888 @@
+import { SpawnOptions, ChildProcessWithoutNullStreams } from 'node:child_process';
+import { Readable, Writable } from 'node:stream';
+import http from 'node:http';
+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 SecretStoreLockFileSystem {
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+        mode?: number;
+    }): Promise<unknown>;
+    readdir(path: string): Promise<string[]>;
+    readFile(path: string, encoding: BufferEncoding): Promise<string>;
+    writeFile(path: string, value: string, options: {
+        encoding: BufferEncoding;
+        flag: string;
+        mode: number;
+    }): Promise<void>;
+    rename(from: string, to: string): Promise<void>;
+    unlink(path: string): Promise<void>;
+    lstat(path: string): Promise<{
+        isSymbolicLink(): boolean;
+    }>;
+}
+
+interface MachineIdentity {
+    hostname: string;
+    username: string;
+}
+interface EncryptedFileStoreFileSystem {
+    readdir?(path: string): Promise<string[]>;
+    readFile(path: string, encoding: BufferEncoding): Promise<string>;
+    writeFile(path: string, data: string | NodeJS.ArrayBufferView, options?: {
+        encoding?: BufferEncoding;
+        flag?: string;
+        mode?: number;
+    }): Promise<void>;
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void | string | undefined>;
+    rename(oldPath: string, newPath: string): Promise<void>;
+    lstat(path: string): Promise<{
+        isSymbolicLink(): boolean;
+    }>;
+    unlink(path: string): Promise<void>;
+    chmod(path: string, mode: number): Promise<void>;
+}
+interface EncryptedFileStoreInput {
+    fs?: EncryptedFileStoreFileSystem;
+    filePath?: string;
+    salt: string;
+    defaultDirectory?: string;
+    defaultFileName?: string;
+    getMachineIdentity?: () => MachineIdentity | Promise<MachineIdentity>;
+    getHomeDirectory?: () => string;
+    getRandomBytes?: (size: number) => Buffer;
+    /** Fail closed instead of treating malformed or unauthenticated documents as absent. */
+    throwOnInvalidDocument?: boolean;
+}
+
+interface KeychainCommandResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+interface KeychainCommandOptions {
+    stdin?: string;
+}
+type KeychainCommandRunner = (command: string, args: string[], options?: KeychainCommandOptions) => Promise<KeychainCommandResult>;
+interface KeychainStoreInput {
+    runCommand?: KeychainCommandRunner;
+    service: string;
+    account: string;
+    lock?: {
+        fs?: SecretStoreLockFileSystem;
+        directory?: string;
+    };
+}
+
+type StoreBackend = "file" | "keychain";
+interface CreateSecretStoreInput {
+    backend?: StoreBackend;
+    env?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
+    backendEnvVar?: string;
+    fileStore?: EncryptedFileStoreInput;
+    keychainStore?: KeychainStoreInput;
+}
+
+type OAuthMetadataFetch = (input: string | URL, init?: RequestInit) => Promise<Response>;
+interface OAuthProtectedResourceMetadata extends Record<string, unknown> {
+    resource: string;
+    authorization_servers: string[];
+}
+interface OAuthAuthorizationServerMetadata extends Record<string, unknown> {
+    issuer: string;
+    authorization_endpoint: string;
+    token_endpoint: string;
+    registration_endpoint?: string;
+    response_types_supported: string[];
+    code_challenge_methods_supported: string[];
+    authorization_response_iss_parameter_supported?: boolean;
+}
+interface OAuthDiscoveryResult {
+    resource: string;
+    resourceMetadataUrl: string;
+    resourceMetadata: OAuthProtectedResourceMetadata;
+    authorizationServer: string;
+    authorizationServerMetadataUrl: string;
+    authorizationServerMetadata: OAuthAuthorizationServerMetadata;
+}
+interface OAuthUnauthorizedChallenge {
+    scheme: "Bearer";
+    params: Record<string, string>;
+    raw: string;
+}
+interface OAuthClientProvider {
+    /** Establish a grant explicitly, including when resource initialization is public. */
+    authenticate?(input: {
+        requestUrl: URL;
+        fetch: OAuthMetadataFetch;
+        /** Lazy validated discovery. Without it, recover/reuse known grants only. */
+        discover?: () => Promise<OAuthDiscoveryResult>;
+        signal?: AbortSignal;
+    }): Promise<StoredOAuthTokens | void>;
+    authorizeRequest?(input: {
+        requestUrl: URL;
+        headers: Headers;
+        fetch: OAuthMetadataFetch;
+        signal?: AbortSignal;
+    }): Promise<StoredOAuthTokens | void> | StoredOAuthTokens | void;
+    handleUnauthorized(input: {
+        requestUrl: URL;
+        response: Response;
+        challenge: OAuthUnauthorizedChallenge | null;
+        /** Validated metadata supplied by direct callers, if already available. */
+        discovery?: OAuthDiscoveryResult;
+        /** Lazy validated metadata; invoke only when OAuth recovery needs it. */
+        discover?: () => Promise<OAuthDiscoveryResult>;
+        fetch: OAuthMetadataFetch;
+        signal?: AbortSignal;
+        /** Headers actually attached to this rejected request. */
+        requestHeaders?: Headers;
+        /** Owned snapshot returned when this request was authorized, or null if absent. */
+        presentedTokens?: StoredOAuthTokens | null;
+    }): Promise<{
+        action: "retry";
+    } | {
+        action: "fail";
+        error?: Error;
+    }> | {
+        action: "retry";
+    } | {
+        action: "fail";
+        error?: Error;
+    };
+}
+interface OAuthClientMetadata {
+    clientName?: string;
+    scope?: string;
+    softwareId?: string;
+    softwareVersion?: string;
+}
+interface StoredOAuthTokens {
+    accessToken: string;
+    refreshToken?: string;
+    tokenType: "Bearer";
+    expiresAt: number | null;
+    scope?: string;
+}
+/** Import-time lifetimes are normalized once into persisted epoch milliseconds. */
+interface ImportedOAuthTokens extends Omit<StoredOAuthTokens, "expiresAt"> {
+    expiresAt?: number | null;
+    /** Remaining lifetime at import, or total lifetime when issuedAt is provided. */
+    expiresIn?: number;
+    /** Original issuance time in Unix epoch milliseconds. */
+    issuedAt?: number;
+}
+/** Full RFC 7591 response, including JSON provider extensions. */
+interface OAuthClientRegistration extends Record<string, unknown> {
+    client_id: string;
+    client_secret?: string | null;
+    redirect_uris?: string[] | null;
+    grant_types?: string[] | null;
+    response_types?: string[] | null;
+    contacts?: string[] | null;
+    client_id_issued_at?: number | null;
+    client_secret_expires_at?: number | null;
+    token_endpoint_auth_method?: string | null;
+}
+interface StoredOAuthClient {
+    clientId: string;
+    /** Externally registered apps must never be replaced by native DCR on reload. */
+    registrationOwnership?: "caller";
+    /** Actual listener URI submitted when this native client was registered. */
+    requestedRedirectUri?: string;
+    clientSecret?: string;
+    registration?: OAuthClientRegistration;
+    tokenEndpointAuthMethod?: OAuthTokenEndpointAuthMethod;
+}
+type OAuthTokenEndpointAuthMethod = "none" | "client_secret_post" | "client_secret_basic";
+interface StoredOAuthSession {
+    resource: string;
+    authorizationServer: string;
+    client: StoredOAuthClient;
+    tokens?: StoredOAuthTokens;
+    /** A refresh was begun; its winning response may not have been persisted. */
+    refreshState?: "pending";
+    /** Canonical explicitly requested scope set when the server omits token scope. */
+    requestedScope?: string;
+    discovery: {
+        resourceMetadataUrl: string;
+        resourceMetadata: Record<string, unknown>;
+        authorizationServerMetadata: Record<string, unknown>;
+    };
+}
+interface OAuthSessionStore {
+    load(resource: string): Promise<StoredOAuthSession | null>;
+    save(resource: string, session: StoredOAuthSession): Promise<void>;
+    clear(resource: string): Promise<void>;
+    /** Backend-wide lock covering a complete read/redeem/write transaction. */
+    withLock?<T>(resource: string, operation: () => Promise<T>, options: {
+        signal?: AbortSignal;
+        timeoutMs: number;
+    }): Promise<T>;
+}
+/** Configuration values are captured at creation; selected host dependencies remain live. */
+interface DefaultOAuthClientProviderOptions {
+    client: {
+        mode: "dynamic";
+        clientId?: string;
+        clientSecret?: string;
+        metadata?: OAuthClientMetadata;
+        /** Import a complete registration owned by the caller. */
+        registration?: OAuthClientRegistration;
+        tokenEndpointAuthMethod?: OAuthTokenEndpointAuthMethod;
+    } | {
+        mode: "static";
+        clientId: string;
+        clientSecret?: string;
+        metadata?: OAuthClientMetadata;
+        registration?: OAuthClientRegistration;
+        tokenEndpointAuthMethod?: OAuthTokenEndpointAuthMethod;
+    };
+    /** Disable interactive authorization while allowing cached tokens and silent refresh. */
+    allowInteractive?: boolean;
+    /** Maximum wait to acquire a session transaction lock (default 30,000 ms). */
+    sessionLockTimeoutMs?: number;
+    /** Isolate native persisted sessions and registrations for a named profile. */
+    persistenceNamespace?: string;
+    /** Native-owned durable logical server identity; changing URL retires its credentials. */
+    resourceIdentity?: string;
+    /** Import an existing grant for one resource. Persisted sessions take precedence. */
+    initialGrant?: {
+        resource: string;
+        tokens: ImportedOAuthTokens;
+    };
+    browser: {
+        openBrowser?(url: string): Promise<void>;
+        /** Exact registered HTTP loopback redirect URI. */
+        redirectUri?: string;
+        signal?: AbortSignal;
+        timeoutMs?: number;
+        readLine?: () => Promise<string>;
+        createServer?: () => http.Server;
+        landingPage?: {
+            title: string;
+            body: string;
+        };
+    };
+    sessionStore?: OAuthSessionStore;
+    authStore?: CreateSecretStoreInput;
+    now?: () => number;
+}
+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;
+    cache?: OAuthDiscoveryCache;
+}
+interface OAuthMetadataLookupOptions {
+    resourceMetadataUrl?: string | URL;
+    signal?: AbortSignal;
+}
+/** Native metadata failure with complete SDK diagnostics and a safe phase. */
+declare class OAuthMetadataError extends Error {
+    readonly phase: "protected-resource" | "authorization-server";
+    readonly status?: number | undefined;
+    static is(value: unknown): value is OAuthMetadataError;
+    constructor(phase: "protected-resource" | "authorization-server", message: string, status?: number | undefined);
+}
+declare class OAuthMetadataDiscovery {
+    private readonly fetchImpl;
+    private readonly cache;
+    private readonly memoryCache;
+    constructor({ fetch, cache }?: OAuthMetadataDiscoveryOptions);
+    private discoverProtectedResource;
+    discover(resourceUrl: string | URL, { resourceMetadataUrl, signal }?: OAuthMetadataLookupOptions): Promise<OAuthDiscoveryResult>;
+}
+declare function discoverOAuthMetadata(resourceUrl: string | URL, options?: OAuthMetadataDiscoveryOptions & OAuthMetadataLookupOptions): Promise<OAuthDiscoveryResult>;
+
+type RequestId = number | string;
+interface ClientCapabilities {
+    extensions?: Record<string, Record<string, unknown>>;
+    elicitation?: {
+        form?: Record<string, unknown>;
+        url?: Record<string, unknown>;
+    };
+    roots?: {
+        listChanged?: boolean;
+        [key: string]: unknown;
+    };
+    sampling?: {
+        [key: string]: unknown;
+    };
+    experimental?: Record<string, unknown>;
+}
+interface ServerCapabilities {
+    extensions?: Record<string, Record<string, unknown>>;
+    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>;
+}
+interface InitializeParams {
+    protocolVersion: string;
+    capabilities: ClientCapabilities;
+    clientInfo: Implementation;
+}
+interface InitializeResult {
+    protocolVersion: string;
+    capabilities: ServerCapabilities;
+    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[]>;
+}
+declare const MCP_PROTOCOL_VERSIONS: readonly ["2025-03-26", "2025-06-18", "2025-11-25", "2026-07-28"];
+type McpProtocolVersion = typeof MCP_PROTOCOL_VERSIONS[number];
+interface McpClientOptions {
+    clientInfo: Implementation;
+    requestTimeoutMs?: number;
+    maxConcurrentRequests?: number;
+    protocolVersion?: McpProtocolVersion;
+    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, context: McpRequestContext) => CreateMessageResult | Promise<CreateMessageResult>;
+    onRootsList?: (context: McpRequestContext) => Root[] | Promise<Root[]>;
+    onElicitationRequest?: (params: ElicitationParams, context: McpRequestContext) => ElicitationResult | Promise<ElicitationResult>;
+}
+declare class McpClient {
+    private currentState;
+    private currentServerCapabilities;
+    private currentClientCapabilities;
+    private currentServerInfo;
+    private currentInstructions;
+    private readonly subscribedResourceUris;
+    private readonly activeProgressTokens;
+    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, options?: {
+        signal?: AbortSignal;
+    }): Promise<ConnectResult>;
+    private getServerCapabilitiesOrThrow;
+    listTools(params?: PaginatedParams, options?: {
+        signal?: AbortSignal;
+    }): Promise<PaginatedResult & {
+        tools: Tool[];
+    }>;
+    callTool(params: CallToolParams, options?: CallToolOptions): Promise<CallToolResult>;
+    listResources(params?: PaginatedParams, options?: {
+        signal?: AbortSignal;
+    }): Promise<PaginatedResult & {
+        resources: Resource[];
+    }>;
+    listResourceTemplates(params?: PaginatedParams, options?: {
+        signal?: AbortSignal;
+    }): Promise<PaginatedResult & {
+        resourceTemplates: ResourceTemplate[];
+    }>;
+    readResource(params: ReadResourceParams, options?: {
+        signal?: AbortSignal;
+    }): Promise<CacheableResultMetadata & {
+        contents: ResourceContents[];
+    }>;
+    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[];
+    }>;
+    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(options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    close(): Promise<void>;
+}
+interface Tool extends Omit<Tool$1, "inputSchema" | "outputSchema"> {
+    inputSchema: Record<string, unknown>;
+    outputSchema?: Record<string, unknown>;
+}
+interface CallToolParams {
+    name: string;
+    arguments?: Record<string, unknown>;
+}
+interface CallToolOptions {
+    signal?: AbortSignal;
+    progressToken?: ProgressToken;
+}
+interface ReadResourceParams {
+    uri: string;
+}
+interface PaginatedParams {
+    cursor?: string;
+}
+interface ResultMetadata {
+    resultType?: "complete";
+    _meta?: Record<string, unknown>;
+}
+interface CacheableResultMetadata extends ResultMetadata {
+    ttlMs?: number;
+    cacheScope?: "public" | "private";
+}
+interface PaginatedResult extends CacheableResultMetadata {
+    nextCursor?: string;
+}
+type TextResourceContents = Extract<ResourceContents$1, {
+    text: string;
+}>;
+type BlobResourceContents = Extract<ResourceContents$1, {
+    blob: string;
+}>;
+type ResourceContents = ResourceContents$1;
+type TextContent = Extract<ContentItem$1, {
+    type: "text";
+}>;
+type ImageContent = Extract<ContentItem$1, {
+    type: "image";
+}>;
+type AudioContent = Extract<ContentItem$1, {
+    type: "audio";
+}>;
+type EmbeddedResource = Extract<ContentItem$1, {
+    type: "resource";
+}>;
+type ContentItem = ContentItem$1;
+interface PromptMessage {
+    role: "user" | "assistant";
+    content: ContentItem;
+}
+interface GetPromptResult extends ResultMetadata {
+    description?: string;
+    messages: PromptMessage[];
+}
+interface GetPromptParams {
+    name: string;
+    arguments?: Record<string, string>;
+}
+interface CallToolResult extends ResultMetadata {
+    content: ContentItem[];
+    structuredContent?: unknown;
+    isError?: boolean;
+}
+interface Root {
+    _meta?: Record<string, unknown>;
+    uri: string;
+    name?: string;
+}
+type LogLevel = "debug" | "info" | "notice" | "warning" | "error" | "critical" | "alert" | "emergency";
+interface LogMessage {
+    level: LogLevel;
+    logger?: string;
+    data: unknown;
+}
+type ProgressToken = RequestId;
+interface ProgressParams {
+    progressToken: ProgressToken;
+    progress: number;
+    total?: number;
+    message?: string;
+}
+interface ModelHint {
+    name?: string;
+}
+interface ModelPreferences {
+    hints?: ModelHint[];
+    costPriority?: number;
+    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: SamplingContent | SamplingContent[];
+}
+type IncludeContext = "none" | "thisServer" | "allServers";
+interface CreateMessageParams {
+    messages: SamplingMessage[];
+    modelPreferences?: ModelPreferences;
+    systemPrompt?: string;
+    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: SamplingContent | SamplingContent[];
+    role: "user" | "assistant";
+    stopReason?: string;
+}
+interface PromptReference {
+    type: "ref/prompt";
+    name: string;
+}
+interface ResourceReference {
+    type: "ref/resource";
+    uri: string;
+}
+interface CompleteArgument {
+    name: string;
+    value: string;
+}
+interface CompleteParams {
+    context?: {
+        arguments?: Record<string, string>;
+    };
+    ref: PromptReference | ResourceReference;
+    argument: CompleteArgument;
+}
+interface Completion {
+    values: string[];
+    hasMore?: boolean;
+    total?: number;
+}
+interface CompleteResult extends ResultMetadata {
+    completion: Completion;
+}
+declare const ERROR_PARSE = -32700;
+declare const ERROR_INVALID_REQUEST = -32600;
+declare const ERROR_METHOD_NOT_FOUND = -32601;
+declare const ERROR_INVALID_PARAMS = -32602;
+declare const ERROR_INTERNAL = -32603;
+interface McpTransportClosedEvent {
+    reason: Error;
+    code?: number;
+    signal?: NodeJS.Signals;
+}
+interface McpTransport {
+    readable: Readable;
+    writable: Writable;
+    closed: Promise<McpTransportClosedEvent>;
+    /** Primary close reason, available before asynchronous transport cleanup finishes. */
+    readonly closeReason?: Promise<Error>;
+    dispose(reason?: Error): void;
+    filterTools?(tools: Tool[], reset?: boolean): Tool[];
+    /** Complete a legacy initialization handshake before the client reports ready. */
+    completeInitialization?(options: {
+        signal?: AbortSignal;
+        timeoutMs: number;
+        protocolVersion?: string;
+    }): Promise<void>;
+}
+interface InMemoryServerTransport {
+    readable: Readable;
+    writable: Writable;
+}
+interface InMemoryTransportPair {
+    clientTransport: McpTransport;
+    serverTransport: InMemoryServerTransport;
+}
+declare function createInMemoryTransportPair(): InMemoryTransportPair;
+interface McpClientConnection {
+    connect(transport: McpTransport): Promise<void>;
+    close(): Promise<void>;
+}
+interface SdkServerConnection {
+    connect(transport: unknown): Promise<void>;
+}
+interface SdkTestPair<TClient extends McpClientConnection> {
+    client: TClient;
+    cleanup: () => Promise<void>;
+}
+declare function createSdkTestPair<TClient extends McpClientConnection>(server: SdkServerConnection, createClient: () => TClient): Promise<SdkTestPair<TClient>>;
+declare function createTestPair<TClient extends McpClientConnection>(server: Server, createClient: () => TClient): Promise<SdkTestPair<TClient>>;
+type StdioSpawn = (command: string, args: ReadonlyArray<string>, options: SpawnOptions) => ChildProcessWithoutNullStreams;
+interface StdioTransportOptions {
+    command: string;
+    args?: string[];
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    spawn?: StdioSpawn;
+}
+type HttpTransportFetch = (input: string | URL, init?: RequestInit) => Promise<Response>;
+declare class HttpTransportError extends Error {
+    readonly status: number;
+    readonly method: "GET" | "POST" | "DELETE";
+    readonly rpcMethod?: string | undefined;
+    constructor(message: string, status: number, method: "GET" | "POST" | "DELETE", rpcMethod?: string | undefined);
+}
+interface HttpTransportOptions {
+    url: string;
+    /** Legacy SSE uses a GET stream that announces the RPC POST endpoint. */
+    mode?: "streamable-http" | "sse";
+    headers?: RequestInit["headers"];
+    fetch?: HttpTransportFetch;
+    oauth?: OAuthClientProviderOptions;
+    oauthDiscoveryCache?: OAuthDiscoveryCache;
+    onWarning?: (message: string) => void;
+    /** Maximum JSON response bytes or individual SSE event bytes; not a stream lifetime cap. */
+    maxResponseBytes?: number;
+}
+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;
+    private appendStderrOutput;
+    dispose(reason?: Error): void;
+}
+/** Own and validate static HTTP headers without reflecting malformed values. */
+declare function snapshotHttpTransportHeaders(headers?: RequestInit["headers"]): Headers;
+declare class HttpTransport implements McpTransport {
+    readonly readable: Readable;
+    readonly writable: Writable;
+    readonly closed: Promise<McpTransportClosedEvent>;
+    readonly closeReason: Promise<Error>;
+    private resolveCloseReason;
+    private readonly url;
+    private readonly mode;
+    private legacyEndpoint;
+    private legacyEndpointReady;
+    private resolveLegacyEndpoint;
+    private rejectLegacyEndpoint;
+    private readonly headers;
+    private readonly fetchImpl;
+    private readonly readStream;
+    private readonly writeStream;
+    private resolveClosed;
+    private sessionId;
+    private legacyProtocolVersion;
+    private initializationRequestId;
+    private lastEventId;
+    private getSseStreamStarted;
+    private disposed;
+    private readonly oauthProvider;
+    private readonly oauthMetadataDiscovery;
+    private readonly inFlightFetchAbortControllers;
+    private readonly inFlightOAuthAbortControllers;
+    private readonly oauthRequestTokens;
+    private readonly openResponseReaders;
+    private readonly modernRequests;
+    private modernMode;
+    private readonly maxResponseBytes;
+    private readonly toolParameterHeaders;
+    private readonly onWarning;
+    constructor({ url, mode, headers, fetch: fetchImpl, oauth, oauthDiscoveryCache, onWarning, maxResponseBytes, }: HttpTransportOptions);
+    completeInitialization(options: {
+        signal?: AbortSignal;
+        timeoutMs: number;
+        protocolVersion?: string;
+    }): Promise<void>;
+    filterTools(tools: Tool[], reset?: boolean): Tool[];
+    dispose(reason?: Error): void;
+    private closeWithSessionTermination;
+    private abortInFlightFetches;
+    private cancelOpenResponseReaders;
+    private fetchWithAbort;
+    private consumeWrittenLines;
+    private sendPost;
+    private createPostHeaders;
+    private createGetHeaders;
+    private createDeleteHeaders;
+    private authorizeRequestHeaders;
+    private captureSessionId;
+    private maybeOpenGetSseStream;
+    private ensureLegacyEndpoint;
+    private sendSessionTerminationRequest;
+    private consumeGetSseStream;
+    private throwForPostHttpError;
+    private maybeHandleUnauthorizedResponse;
+    private forwardResponseMessages;
+    private forwardSseResponseMessages;
+    private forwardJsonResponseMessage;
+    private writeSseMessages;
+    private writeReadableLine;
+    private fetchWithOAuthRetry;
+    private readOAuthChallengeError;
+}
+interface JsonRpcRequest {
+    jsonrpc: "2.0";
+    id: RequestId;
+    method: string;
+    params?: unknown;
+}
+interface JsonRpcNotification {
+    jsonrpc: "2.0";
+    method: string;
+    params?: unknown;
+}
+interface JsonRpcErrorObject {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+declare class McpError extends Error {
+    readonly code: number;
+    readonly data?: unknown;
+    constructor(code: number, message: string, data?: unknown);
+}
+interface JsonRpcSuccessResponse {
+    jsonrpc: "2.0";
+    id: RequestId;
+    result: unknown;
+}
+interface JsonRpcErrorResponse {
+    jsonrpc: "2.0";
+    id: RequestId;
+    error: JsonRpcErrorObject;
+}
+type JsonRpcResponse = JsonRpcSuccessResponse | JsonRpcErrorResponse;
+type JsonRpcMessage = JsonRpcRequest | JsonRpcNotification | JsonRpcResponse;
+interface JsonRpcRequestOptions {
+    signal?: AbortSignal;
+    timeoutMs?: number | null;
+    onRequestId?: (requestId: RequestId) => void;
+    onTimeout?: (requestId: RequestId) => void;
+}
+interface McpRequestContext {
+    readonly id: RequestId;
+    readonly method: string;
+    readonly signal: AbortSignal;
+}
+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>, 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;
+    private resolveInputStreamClosedReason;
+    private processParsedMessage;
+    private handleIncomingRequest;
+    private handleCancellationNotification;
+}
+
+export { ERROR_INTERNAL, ERROR_INVALID_PARAMS, ERROR_INVALID_REQUEST, ERROR_METHOD_NOT_FOUND, ERROR_PARSE, HttpTransport, HttpTransportError, JsonRpcMessageLayer, MCP_PROTOCOL_VERSIONS, McpClient, McpError, OAuthMetadataDiscovery, OAuthMetadataError, StdioTransport, createInMemoryTransportPair, createSdkTestPair, createTestPair, discoverOAuthMetadata, fetchMcpResponse, snapshotHttpTransportHeaders };
+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, McpProtocolVersion, 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 };