@comake/skl-js-engine/dist/JsExecutor/jsonRpc/JsonRpcClient.d.ts

Standard Knowledge Language Javascript Engine

import type { JsonRpcClientConfig, JsonRpcId, JsonRpcParams, JsonRpcRequest, JsonRpcResponse } from './types';
/**
 * Event emitter interface for JSON-RPC client events
 */
export interface JsonRpcClientEvents {
    request: (request: JsonRpcRequest) => void;
    response: (response: JsonRpcResponse) => void;
    error: (error: Error) => void;
    timeout: (request: JsonRpcRequest) => void;
}
/**
 * Transport interface for sending messages
 */
export interface ClientTransport {
    send: (message: string) => Promise<void>;
    onMessage: (handler: (message: string) => void) => void;
    close: () => Promise<void>;
}
/**
 * JSON-RPC 2.0 Client implementation
 */
export declare class JsonRpcClient {
    private readonly config;
    private readonly pendingRequests;
    private readonly listeners;
    private requestIdCounter;
    private transport?;
    constructor(config?: JsonRpcClientConfig);
    /**
     * Set the transport for sending messages
     * @param transport - Transport implementation
     */
    setTransport(transport: ClientTransport): void;
    /**
     * Send a JSON-RPC request and wait for response
     * @param method - Method name
     * @param params - Method parameters
     * @param options - Request options
     * @returns Promise resolving to the response result
     */
    request<TParams = JsonRpcParams, TResult = any>(method: string, params?: TParams, options?: {
        timeout?: number;
        retries?: number;
    }): Promise<TResult>;
    /**
     * Send a JSON-RPC notification (no response expected)
     * @param method - Method name
     * @param params - Method parameters
     */
    notify<TParams = JsonRpcParams>(method: string, params?: TParams): Promise<void>;
    /**
     * Send a batch of requests
     * @param requests - Array of request specifications
     * @returns Promise resolving to array of results
     */
    batch(requests: {
        method: string;
        params?: any;
        id?: JsonRpcId;
    }[]): Promise<any[]>;
    /**
     * Handle incoming message from transport
     * @param messageData - Raw message data
     */
    handleIncomingMessage(messageData: string): Promise<void>;
    /**
     * Handle a single response message
     * @param response - JSON-RPC response
     */
    private handleResponse;
    /**
     * Send a request with timeout handling
     * @param request - JSON-RPC request
     * @param timeout - Timeout in milliseconds
     * @returns Promise resolving to the result
     */
    private sendRequestWithTimeout;
    /**
     * Create a pending request promise with timeout
     * @param request - JSON-RPC request
     * @param timeout - Timeout in milliseconds
     * @returns Promise resolving to the result
     */
    private createPendingRequest;
    /**
     * Create a JSON-RPC request
     * @param method - Method name
     * @param params - Method parameters
     * @param id - Optional request ID
     * @returns JSON-RPC request object
     */
    private createRequest;
    /**
     * Create a JSON-RPC notification
     * @param method - Method name
     * @param params - Method parameters
     * @returns JSON-RPC notification object
     */
    private createNotification;
    /**
     * Generate a unique request ID
     * @returns Unique request ID
     */
    private generateId;
    /**
     * Check if response is a success response
     * @param response - JSON-RPC response
     * @returns True if success response
     */
    private isSuccessResponse;
    /**
     * Check if an error should not be retried
     * @param error - Error to check
     * @returns True if error should not be retried
     */
    private shouldNotRetry;
    /**
     * Delay execution for specified milliseconds
     * @param ms - Delay in milliseconds
     * @returns Promise that resolves after delay
     */
    private delay;
    /**
     * Register event listener
     * @param event - Event name
     * @param listener - Event listener
     */
    on<TKey extends keyof JsonRpcClientEvents>(event: TKey, listener: JsonRpcClientEvents[TKey]): void;
    /**
     * Remove event listener
     * @param event - Event name
     * @param listener - Event listener
     */
    off<TKey extends keyof JsonRpcClientEvents>(event: TKey, listener: JsonRpcClientEvents[TKey]): void;
    /**
     * Emit event
     * @param event - Event name
     * @param args - Event arguments
     */
    private emit;
    /**
     * Get client statistics
     * @returns Client statistics
     */
    getStats(): {
        pendingRequests: number;
        totalRequests: number;
        config: Required<JsonRpcClientConfig>;
    };
    /**
     * Cancel all pending requests
     */
    cancelAllRequests(): void;
    /**
     * Cancel a specific request
     * @param id - Request ID to cancel
     * @returns True if request was cancelled
     */
    cancelRequest(id: JsonRpcId): boolean;
    /**
     * Close the client and cleanup resources
     */
    close(): Promise<void>;
}