poe-code 3.0.420 → 3.0.422-beta.1

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

@@ -1,2 +1,660 @@
-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";
+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/dist/index.js';
+
+interface MachineIdentity {
+    hostname: string;
+    username: string;
+}
+interface EncryptedFileStoreFileSystem {
+    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;
+}
+
+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;
+}
+
+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 {
+    authorizeRequest?(input: {
+        requestUrl: URL;
+        headers: Headers;
+        fetch: OAuthMetadataFetch;
+    }): Promise<void> | void;
+    handleUnauthorized(input: {
+        requestUrl: URL;
+        response: Response;
+        challenge: OAuthUnauthorizedChallenge | null;
+        discovery: OAuthDiscoveryResult;
+        fetch: OAuthMetadataFetch;
+    }): 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;
+}
+interface StoredOAuthSession {
+    resource: string;
+    authorizationServer: string;
+    client: {
+        clientId: string;
+        clientSecret?: string;
+    };
+    tokens?: StoredOAuthTokens;
+    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>;
+}
+interface DefaultOAuthClientProviderOptions {
+    client: {
+        mode: "dynamic";
+        clientId?: string;
+        clientSecret?: string;
+        metadata?: OAuthClientMetadata;
+    } | {
+        mode: "static";
+        clientId: string;
+        clientSecret?: string;
+        metadata?: OAuthClientMetadata;
+    };
+    browser: {
+        openBrowser(url: string): Promise<void>;
+        readLine?: () => Promise<string>;
+        createServer?: () => http.Server;
+        landingPage?: {
+            title: string;
+            body: string;
+        };
+    };
+    sessionStore?: OAuthSessionStore;
+    authStore?: CreateSecretStoreInput;
+    now?: () => number;
+}
+type OAuthClientProviderOptions = {
+    provider: OAuthClientProvider;
+} | DefaultOAuthClientProviderOptions;
+
+interface OAuthDiscoveryCache {
+    get(resourceUrl: string): OAuthDiscoveryResult | null | undefined | Promise<OAuthDiscoveryResult | null | undefined>;
+    set(resourceUrl: string, value: OAuthDiscoveryResult): void | Promise<void>;
+}
+interface OAuthMetadataDiscoveryOptions {
+    fetch?: OAuthMetadataFetch;
+    cache?: OAuthDiscoveryCache;
+}
+interface OAuthMetadataLookupOptions {
+    resourceMetadataUrl?: string | URL;
+}
+declare class OAuthMetadataDiscovery {
+    private readonly fetchImpl;
+    private readonly cache;
+    private readonly memoryCache;
+    constructor({ fetch, cache }?: OAuthMetadataDiscoveryOptions);
+    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 {
+    roots?: {
+        listChanged?: boolean;
+        [key: string]: unknown;
+    };
+    sampling?: {
+        [key: string]: unknown;
+    };
+    experimental?: Record<string, unknown>;
+}
+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>;
+}
+interface InitializeParams {
+    protocolVersion: string;
+    capabilities: ClientCapabilities;
+    clientInfo: Implementation;
+}
+interface InitializeResult {
+    protocolVersion: string;
+    capabilities: ServerCapabilities;
+    serverInfo: Implementation;
+    instructions?: string;
+}
+interface McpClientOptions {
+    clientInfo: Implementation;
+    requestTimeoutMs?: number;
+    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[]>;
+}
+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;
+    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>;
+}
+interface Tool {
+    name: string;
+    description?: string;
+    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;
+    arguments?: Record<string, unknown>;
+}
+interface CallToolOptions {
+    signal?: AbortSignal;
+    progressToken?: ProgressToken;
+}
+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 {
+    nextCursor?: string;
+}
+interface TextResourceContents {
+    uri: string;
+    mimeType?: string;
+    text: string;
+}
+interface BlobResourceContents {
+    uri: string;
+    mimeType?: string;
+    blob: string;
+}
+type ResourceContents = TextResourceContents | BlobResourceContents;
+interface TextContent {
+    type: "text";
+    text: string;
+}
+interface ImageContent {
+    type: "image";
+    data: string;
+    mimeType: string;
+}
+interface AudioContent {
+    type: "audio";
+    data: string;
+    mimeType: string;
+}
+interface EmbeddedResource {
+    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;
+}
+interface PromptMessage {
+    role: "user" | "assistant";
+    content: ContentItem;
+}
+interface GetPromptResult {
+    description?: string;
+    messages: PromptMessage[];
+}
+interface GetPromptParams {
+    name: string;
+    arguments?: Record<string, string>;
+}
+interface CallToolResult {
+    content: ContentItem[];
+    structuredContent?: Record<string, unknown>;
+    isError?: boolean;
+}
+interface Root {
+    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 SamplingMessage {
+    role: "user" | "assistant";
+    content: ContentItem | ContentItem[];
+}
+type IncludeContext = "none" | "thisServer" | "allServers";
+interface CreateMessageParams {
+    messages: SamplingMessage[];
+    modelPreferences?: ModelPreferences;
+    systemPrompt?: string;
+    includeContext?: IncludeContext;
+    temperature?: number;
+    maxTokens: number;
+    stopSequences?: string[];
+    metadata?: Record<string, unknown>;
+}
+interface CreateMessageResult {
+    model: string;
+    content: ContentItem | ContentItem[];
+    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 {
+    ref: PromptReference | ResourceReference;
+    argument: CompleteArgument;
+}
+interface Completion {
+    values: string[];
+    hasMore?: boolean;
+    total?: number;
+}
+interface CompleteResult {
+    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>;
+    dispose(reason?: Error): 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>;
+interface HttpTransportOptions {
+    url: string;
+    headers?: HeadersInit;
+    fetch?: HttpTransportFetch;
+    oauth?: OAuthClientProviderOptions;
+    oauthDiscoveryCache?: OAuthDiscoveryCache;
+}
+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;
+}
+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 closeWithSessionTermination;
+    private abortInFlightFetches;
+    private cancelOpenSseReaders;
+    private fetchWithAbort;
+    private consumeWrittenLines;
+    private createPostHeaders;
+    private createGetHeaders;
+    private createDeleteHeaders;
+    private authorizeRequestHeaders;
+    private captureSessionId;
+    private maybeOpenGetSseStream;
+    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 {
+    timeoutMs?: number;
+    onRequestId?: (requestId: RequestId) => void;
+    onTimeout?: (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>;
+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>;
+    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, 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 };