anon-identity/dist/mcp/client.d.ts

Decentralized identity framework with DIDs, Verifiable Credentials, and privacy-preserving selective disclosure

/**
 * MCP (Model Context Protocol) Client Implementation
 *
 * Core client for connecting to MCP servers and managing LLM provider interactions
 */
import { EventEmitter } from 'events';
import { LLMRequest, LLMResponse, LLMResponseChunk, MCPProvider, MCPConnection, ConnectionStatus, MCPConfig, MCPClientConfig, UsageInfo } from './types';
/**
 * Connection manager for individual MCP connections
 */
declare class MCPConnectionManager extends EventEmitter {
    private config;
    private connections;
    private connectionAttempts;
    private lastHeartbeat;
    constructor(config: MCPClientConfig);
    /**
     * Create connection to MCP server
     */
    connect(providerId: string, endpoint: string): Promise<MCPConnection>;
    /**
     * Get connection by provider ID
     */
    getConnection(providerId: string): MCPConnection | undefined;
    /**
     * Get all active connections
     */
    getAllConnections(): Map<string, MCPConnection>;
    /**
     * Disconnect from provider
     */
    disconnect(providerId: string): Promise<void>;
    /**
     * Disconnect from all providers
     */
    disconnectAll(): Promise<void>;
    /**
     * Handle connection disconnection
     */
    private handleDisconnection;
    /**
     * Handle connection errors
     */
    private handleConnectionError;
    /**
     * Monitor connection health via heartbeats
     */
    private startHeartbeatMonitoring;
}
/**
 * Concrete implementation of MCPConnection
 */
declare class MCPConnectionImpl extends EventEmitter implements MCPConnection {
    private readonly endpoint;
    private readonly config;
    readonly id: string;
    readonly providerId: string;
    status: ConnectionStatus;
    lastHeartbeat: Date;
    createdAt: Date;
    metadata: any;
    private ws;
    private requestId;
    private pendingRequests;
    constructor(providerId: string, endpoint: string, config: MCPClientConfig);
    /**
     * Connect to MCP server
     */
    connect(): Promise<void>;
    /**
     * Disconnect from MCP server
     */
    disconnect(): Promise<void>;
    /**
     * Send LLM request and await response
     */
    sendRequest(request: LLMRequest): Promise<LLMResponse>;
    /**
     * Send streaming LLM request
     */
    streamRequest(request: LLMRequest): AsyncIterable<LLMResponseChunk>;
    /**
     * Check connection health
     */
    health(): Promise<{
        status: 'healthy' | 'unhealthy';
        latency?: number;
    }>;
    /**
     * Handle incoming messages from MCP server
     */
    private handleMessage;
    /**
     * Handle response messages
     */
    private handleResponse;
    /**
     * Handle error messages
     */
    private handleError;
    /**
     * Send heartbeat to maintain connection
     */
    private sendHeartbeat;
    /**
     * Start periodic heartbeat
     */
    private startHeartbeat;
}
/**
 * Main MCP Client class
 */
export declare class MCPClient extends EventEmitter {
    private config;
    private connectionManager;
    private providers;
    private defaultProvider?;
    private requestMetrics;
    constructor(config: MCPConfig);
    /**
     * Initialize MCP client and connect to providers
     */
    initialize(): Promise<void>;
    /**
     * Add and connect to a provider
     */
    addProvider(providerConfig: any): Promise<void>;
    /**
     * Send request to specific provider
     */
    sendRequest(request: LLMRequest, providerId?: string): Promise<LLMResponse>;
    /**
     * Send streaming request
     */
    streamRequest(request: LLMRequest, providerId?: string): AsyncIterable<LLMResponseChunk>;
    /**
     * Get available providers
     */
    getAvailableProviders(): string[];
    /**
     * Get provider information
     */
    getProvider(providerId: string): MCPProvider | undefined;
    /**
     * Get usage statistics for provider
     */
    getUsageStats(providerId: string): UsageInfo[];
    /**
     * Set default provider
     */
    setDefaultProvider(providerId: string): void;
    /**
     * Health check for all providers
     */
    healthCheck(): Promise<Map<string, any>>;
    /**
     * Get connection for provider
     */
    getConnection(providerId: string): Promise<MCPConnection | null>;
    /**
     * Get provider capabilities
     */
    getProviderCapabilities(providerId: string): Promise<any>;
    /**
     * Shutdown MCP client
     */
    shutdown(): Promise<void>;
}
export { MCPConnectionManager, MCPConnectionImpl };
//# sourceMappingURL=client.d.ts.map