openoracle-sdk-js/dist/providers/base.d.ts

OpenOracle Node.js SDK - Intelligent Oracle Routing with Multiple LLM Providers

import { OracleConfig } from '../core/config';
import { OracleClient } from '../core/client';
import { OracleProvider, DataCategory, UpdateFrequency, OracleCapability, ConfidenceLevel } from '../types/enums';
import { OracleDataPoint, ProviderCapabilities, ProviderConfiguration } from '../schemas/oracle-schemas';
import { ProviderError } from '../core/exceptions';

export interface ProviderOptions {
    timeout?: number;
    retryAttempts?: number;
    cache?: boolean;
    rateLimit?: number;
}
export interface QueryRequest {
    query: string;
    category: DataCategory;
    parameters?: Record<string, any>;
    metadata?: Record<string, any>;
}
export interface QueryResponse {
    data: OracleDataPoint[];
    metadata: {
        provider: OracleProvider;
        responseTime: number;
        cached: boolean;
        confidence: ConfidenceLevel;
        cost?: number;
    };
}
export declare abstract class BaseOracleProvider {
    protected readonly config: OracleConfig;
    protected readonly client: OracleClient;
    protected readonly providerConfig: ProviderConfiguration;
    protected readonly capabilities: OracleCapability[];
    protected readonly supportedCategories: DataCategory[];
    private requestCount;
    private lastRequestTime;
    private readonly rateLimitQueue;
    constructor(config: OracleConfig, client: OracleClient, providerConfig: ProviderConfiguration);
    abstract getProviderName(): OracleProvider;
    abstract getProviderCapabilities(): OracleCapability[];
    abstract getSupportedCategories(): DataCategory[];
    abstract queryData(request: QueryRequest, options?: ProviderOptions): Promise<QueryResponse>;
    abstract getEndpointUrl(): string;
    protected getDefaultTimeout(): number;
    protected getDefaultRetries(): number;
    protected getCostPerQuery(): number;
    /**
     * Main query method with built-in retries, rate limiting, and error handling
     */
    query(request: QueryRequest, options?: ProviderOptions): Promise<QueryResponse>;
    /**
     * Execute query with timeout protection
     */
    private executeQueryWithTimeout;
    /**
     * Health check for the provider
     */
    healthCheck(): Promise<boolean>;
    /**
     * Get provider capabilities information
     */
    getCapabilities(): ProviderCapabilities;
    /**
     * Get supported update frequencies
     */
    protected getSupportedUpdateFrequencies(): UpdateFrequency[];
    /**
     * Get provider statistics
     */
    getStats(): {
        requestCount: number;
        lastRequestTime: number;
        averageResponseTime: number;
        reliability: number;
    };
    /**
     * Test provider connectivity
     */
    testConnection(): Promise<{
        connected: boolean;
        responseTime?: number;
        error?: string;
    }>;
    /**
     * Create standardized oracle data point
     */
    protected createDataPoint(value: any, source: string, confidence?: ConfidenceLevel, metadata?: Record<string, any>): OracleDataPoint;
    /**
     * Parse and normalize response data
     */
    protected normalizeResponse(rawData: any, request: QueryRequest, responseTime: number, cached?: boolean): QueryResponse;
    /**
     * Validate request before processing
     */
    private validateRequest;
    /**
     * Validate provider configuration
     */
    private validateConfiguration;
    /**
     * Apply rate limiting
     */
    private applyRateLimit;
    /**
     * Update request metrics
     */
    private updateMetrics;
    /**
     * Get average response time
     */
    private getAverageResponseTime;
    /**
     * Get reliability score (0-1)
     */
    private getReliability;
    /**
     * Get accuracy score (0-1)
     */
    private getAccuracy;
    /**
     * Format error message with provider context
     */
    protected createProviderError(message: string, originalError?: Error): ProviderError;
    /**
     * Helper method to check if API key is available
     */
    protected hasApiKey(): boolean;
    /**
     * Helper method to get authorization headers
     */
    protected getAuthHeaders(): Record<string, string>;
    /**
     * Helper method to build query parameters
     */
    protected buildQueryParams(params: Record<string, any>): Record<string, string>;
    /**
     * Cleanup resources
     */
    destroy(): void;
}