import { Client as SDKClient, SdkHttpError, type ClientOptions } from '@modelcontextprotocol/client';
import type { Transport, ProtocolEra } from '@modelcontextprotocol/client';
import type { Implementation, DiscoverResult, ListToolsResult, CallToolResult, ListResourcesResult, ListResourceTemplatesResult, ReadResourceResult, ListPromptsResult, GetPromptResult, LoggingLevel, GetTaskResult, ListTasksResult, CancelTaskResult, Tool } from '@modelcontextprotocol/client';
import { type Logger } from '../lib/logger.js';
import type { IMcpClient, ServerDetails, TaskUpdate } from '../lib/types.js';
export interface McpClientOptions extends ClientOptions {
    logger?: Logger;
    requestTimeoutMillis?: number;
    stdioTransport?: boolean;
    protocolVersion?: string;
}
export declare function resolveVersionOptions(protocolVersion: string | undefined, stdioTransport: boolean | undefined): Pick<ClientOptions, 'versionNegotiation' | 'supportedProtocolVersions'>;
export declare function isExpectedProbeRejection(error: unknown): error is SdkHttpError;
export declare class McpClient implements IMcpClient {
    private client;
    private logger;
    private negotiatedProtocolVersion?;
    private mcpSessionId?;
    private transport?;
    private hasConnected;
    private requestTimeoutMillis;
    private readonly configuredRequestTimeoutMillis;
    private cachedTools;
    private cachedToolsExpiresAt;
    private isClosing;
    private readonly autoNegotiates;
    private modernSubscribedUris;
    private modernListen;
    constructor(clientInfo: Implementation, options?: McpClientOptions);
    setRequestTimeout(timeoutMillis: number): void;
    resetRequestTimeout(): void;
    private getRequestOptions;
    connect(transport: Transport): Promise<void>;
    close(): Promise<void>;
    getServerDetails(): Promise<ServerDetails>;
    getProtocolEra(): ProtocolEra | undefined;
    getMcpSessionId(): string | undefined;
    private deriveConnectionMode;
    private deriveTransportKind;
    discover(): Promise<DiscoverResult>;
    ping(): Promise<void>;
    listTools(cursor?: string, refresh?: boolean): Promise<ListToolsResult>;
    listAllTools(options?: {
        refreshCache?: boolean;
    }): Promise<ListToolsResult>;
    private deriveToolsCacheExpiry;
    private isToolsCacheExpired;
    getCachedTools(): Tool[] | null;
    invalidateToolsCache(): void;
    callTool(name: string, args?: Record<string, unknown>, meta?: Record<string, unknown>): Promise<CallToolResult>;
    listResources(cursor?: string): Promise<ListResourcesResult>;
    listResourceTemplates(cursor?: string): Promise<ListResourceTemplatesResult>;
    readResource(uri: string): Promise<ReadResourceResult>;
    subscribeResource(uri: string): Promise<void>;
    unsubscribeResource(uri: string): Promise<void>;
    private reopenModernListen;
    private watchListChangedStream;
    private reopenListChanged;
    private relistenWithBackoff;
    listPrompts(cursor?: string): Promise<ListPromptsResult>;
    getPrompt(name: string, args?: Record<string, string>): Promise<GetPromptResult>;
    setLoggingLevel(level: LoggingLevel): Promise<void>;
    supportsTasksForToolCall(): boolean;
    assertTasksAvailable(): void;
    private createToolTask;
    callToolWithTask(name: string, args?: Record<string, unknown>, onUpdate?: (update: TaskUpdate) => void, meta?: Record<string, unknown>): Promise<CallToolResult>;
    callToolDetached(name: string, args?: Record<string, unknown>, meta?: Record<string, unknown>): Promise<TaskUpdate>;
    pollTask(taskId: string, onUpdate?: (update: TaskUpdate) => void): Promise<CallToolResult>;
    listTasks(cursor?: string): Promise<ListTasksResult>;
    getTask(taskId: string): Promise<GetTaskResult>;
    getTaskResult(taskId: string): Promise<CallToolResult>;
    cancelTask(taskId: string): Promise<CancelTaskResult>;
    getSDKClient(): SDKClient;
}
//# sourceMappingURL=mcp-client.d.ts.map