recoder-shared/dist/ai-provider-router.d.ts

Shared types, utilities, and configurations for Recoder

/**
 * Unified AI Provider Router for Cross-Platform Integration
 * Manages AI providers with health monitoring, cost tracking, and intelligent routing
 */
import { EventEmitter } from 'events';
export interface AIProvider {
    id: string;
    name: string;
    type: 'anthropic' | 'openai' | 'groq' | 'gemini' | 'ollama' | 'huggingface' | 'custom';
    baseURL: string;
    apiKey?: string;
    models: AIModel[];
    capabilities: AICapability[];
    config: AIProviderConfig;
    status: AIProviderStatus;
    costs: AIProviderCosts;
}
export interface AIModel {
    id: string;
    name: string;
    contextLength: number;
    inputCostPer1k?: number;
    outputCostPer1k?: number;
    capabilities: string[];
    supportedPlatforms: string[];
}
export interface AICapability {
    type: 'text-generation' | 'code-generation' | 'image-analysis' | 'function-calling' | 'streaming';
    supported: boolean;
    limitations?: string[];
}
export interface AIProviderConfig {
    timeout: number;
    retries: number;
    rateLimit: {
        requestsPerMinute: number;
        tokensPerMinute: number;
    };
    healthCheck: {
        enabled: boolean;
        interval: number;
        timeout: number;
    };
}
export interface AIProviderStatus {
    status: 'healthy' | 'degraded' | 'offline' | 'error';
    lastChecked: string;
    responseTime: number;
    errorRate: number;
    uptime: number;
    errors: AIProviderError[];
}
export interface AIProviderError {
    timestamp: string;
    type: 'timeout' | 'rate_limit' | 'auth_error' | 'api_error' | 'network_error';
    message: string;
    context?: any;
}
export interface AIProviderCosts {
    totalTokens: number;
    totalCost: number;
    inputTokens: number;
    outputTokens: number;
    requestCount: number;
    lastReset: string;
}
export interface AIRequest {
    id: string;
    provider: string;
    model: string;
    platform: string;
    messages: any[];
    options: AIRequestOptions;
    metadata: AIRequestMetadata;
}
export interface AIRequestOptions {
    temperature?: number;
    maxTokens?: number;
    stream?: boolean;
    functions?: any[];
    systemPrompt?: string;
}
export interface AIRequestMetadata {
    userId?: string;
    deviceId?: string;
    platform: string;
    timestamp: string;
    requestType: 'chat' | 'completion' | 'embedding' | 'function-call';
}
export interface AIResponse {
    id: string;
    provider: string;
    model: string;
    content: string;
    usage: {
        inputTokens: number;
        outputTokens: number;
        totalTokens: number;
        cost: number;
    };
    metadata: {
        responseTime: number;
        timestamp: string;
        cached: boolean;
    };
}
export interface RoutingStrategy {
    name: 'round-robin' | 'least-loaded' | 'cost-optimized' | 'quality-optimized' | 'speed-optimized';
    config: any;
}
export declare class AIProviderRouter extends EventEmitter {
    private config;
    private providers;
    private api;
    private healthCheckInterval;
    private usageTracking;
    private requestQueue;
    private routingStrategy;
    constructor(config?: {
        baseURL?: string;
        healthCheckInterval?: number;
        enableCostTracking?: boolean;
        enableHealthMonitoring?: boolean;
        routingStrategy?: RoutingStrategy;
    });
    private initializeDefaultProviders;
    private createProviderWithDefaults;
    addProvider(provider: AIProvider): void;
    removeProvider(providerId: string): boolean;
    getProvider(providerId: string): AIProvider | undefined;
    getAllProviders(): AIProvider[];
    getHealthyProviders(): AIProvider[];
    getAvailableModels(platform?: string): AIModel[];
    getBestModelFor(task: string, platform: string, constraints?: {
        maxCost?: number;
        maxResponseTime?: number;
        requiresCapability?: string[];
    }): {
        provider: AIProvider;
        model: AIModel;
    } | null;
    private calculateModelScore;
    routeRequest(request: AIRequest): Promise<AIResponse>;
    private executeRequest;
    private calculateCost;
    private startHealthMonitoring;
    private performHealthChecks;
    private checkProviderHealth;
    private handleProviderError;
    private updateUsageTracking;
    getProviderAnalytics(timeframe?: 'hour' | 'day' | 'week' | 'month'): any;
    getRecommendation(task: 'coding' | 'chat' | 'analysis' | 'multimodal', priority?: 'speed' | 'cost' | 'quality'): {
        provider: AIProvider;
        model: AIModel;
        reason: string;
    } | null;
    destroy(): void;
    private setupEventHandlers;
    get isHealthy(): boolean;
    get totalProviders(): number;
    get routingMode(): string;
}
export default AIProviderRouter;
//# sourceMappingURL=ai-provider-router.d.ts.map