/**
 * LLM Provider Factory
 * Creates and manages LLM provider instances with intelligent fallback logic
 */
import type { LLMProvider, LLMRequest, LLMResponse, AnalyzeImageInput, ClassifyOptions, ClassifyResult, OpenAIConfig, AnthropicConfig, CloudflareConfig, CerebrasConfig, GroqConfig, NvidiaConfig, FallbackRule, ProviderMetrics, CircuitBreakerState, ProviderBalance, QuotaHook, ToolExecutor, ToolLoopOptions, ResponseCacheAdapter } from './types.js';
import type { Logger } from './utils/logger.js';
import type { ObservabilityHooks } from './utils/hooks.js';
import type { ProviderCostBreakdownEntry } from './utils/cost-tracker.js';
import type { CreditLedger } from './utils/credit-ledger.js';
import { type ModelRecommendationUseCase } from './model-catalog.js';
export interface ProviderFactoryConfig {
    openai?: OpenAIConfig;
    anthropic?: AnthropicConfig;
    cloudflare?: CloudflareConfig;
    cerebras?: CerebrasConfig;
    groq?: GroqConfig;
    nvidia?: NvidiaConfig;
    preferredProvider?: 'openai' | 'anthropic' | 'cloudflare' | 'cerebras' | 'groq' | 'nvidia' | 'auto';
    defaultProvider?: 'openai' | 'anthropic' | 'cloudflare' | 'cerebras' | 'groq' | 'nvidia' | 'auto';
    fallbackRules?: FallbackRule[];
    costOptimization?: boolean;
    enableCircuitBreaker?: boolean;
    enableRetries?: boolean;
    ledger?: CreditLedger;
    quotaHook?: QuotaHook;
    quotaFailPolicy?: 'closed' | 'open';
    defaultVisionModel?: string;
    logger?: Logger;
    hooks?: ObservabilityHooks;
    responseCache?: ResponseCacheAdapter;
    responseCacheDefaultTtl?: number;
}
export interface CostAnalytics {
    breakdown?: Record<string, ProviderCostBreakdownEntry>;
    total?: number;
    recommendations?: string[];
    message?: string;
}
export interface ProviderHealthEntry {
    healthy: boolean;
    metrics?: ProviderMetrics;
    circuitBreaker?: CircuitBreakerState | null;
    models?: string[];
    capabilities?: {
        streaming: boolean;
        tools: boolean;
        batching: boolean;
    };
    error?: string;
}
export declare class LLMProviderFactory {
    private providers;
    private config;
    private costTracker;
    private fallbackRules;
    private logger;
    private hooks;
    constructor(config: ProviderFactoryConfig);
    /**
     * Initialize all configured providers
     */
    private initializeProviders;
    /**
     * Generate response with intelligent provider selection and fallback
     */
    generateResponse(request: LLMRequest): Promise<LLMResponse>;
    generateResponseStream(request: LLMRequest): Promise<ReadableStream<string>>;
    generateResponseWithTools(request: LLMRequest, toolExecutor: ToolExecutor, opts?: ToolLoopOptions): Promise<LLMResponse>;
    classify<T = unknown>(input: string | LLMRequest, options?: ClassifyOptions<T>): Promise<ClassifyResult<T>>;
    analyzeImage(input: AnalyzeImageInput): Promise<LLMResponse>;
    getProviderBalance(provider?: string): Promise<ProviderBalance | Record<string, ProviderBalance>>;
    /**
     * Recommend a model dynamically from the declarative catalog.
     */
    getRecommendedModel(request: LLMRequest, useCase?: ModelRecommendationUseCase): string;
    /**
     * Build provider chain and provider-specific default models from the catalog.
     */
    private buildProviderPlan;
    /**
     * Get appropriate provider for a specific model
     */
    private getProviderForModel;
    /**
     * Check if we should fallback to another provider
     */
    private shouldFallback;
    /**
     * Get fallback routing decision for an error.
     */
    private getFallbackDecision;
    /**
     * Evaluate a fallback rule against an error
     */
    private evaluateFallbackRule;
    /**
     * Get default fallback rules
     */
    private getDefaultFallbackRules;
    /**
     * Get provider instance by name
     */
    getProvider(name: string): LLMProvider | undefined;
    /**
     * Get all available providers
     */
    getAvailableProviders(): string[];
    /**
     * Get provider health status
     */
    getProviderHealth(): Promise<Record<string, ProviderHealthEntry>>;
    /**
     * Get cost analytics
     */
    getCostAnalytics(): CostAnalytics;
    /**
     * Get cost optimization recommendations
     */
    private getCostRecommendations;
    /**
     * Get latency histogram data for all providers
     */
    getLatencyHistogram(): Record<string, import('./utils/latency-histogram').LatencySummary>;
    /**
     * Get currently exhausted providers
     */
    getExhaustedProviders(): string[];
    /**
     * Reset all provider metrics, circuit breakers, exhaustion, and histograms
     */
    reset(): void;
    /**
     * Update factory configuration
     */
    updateConfig(config: Partial<ProviderFactoryConfig>): void;
    private openStreamWithFirstChunk;
    private buildFactoryStream;
    private checkQuota;
    private recordQuota;
    private recordQuotaInput;
    private parseJsonResponse;
    private getDefaultVisionModel;
    private providerSupportsVision;
    private getSelectionHealth;
    private resolveUseCase;
    private getSingleProviderBalance;
    private getLedgerBalance;
    private isLedgerLimited;
    private requestForProvider;
    private applyFallbackDecision;
}
/**
 * Create a provider factory with common configurations
 */
export declare function createLLMProviderFactory(config: ProviderFactoryConfig): LLMProviderFactory;
/**
 * Create a cost-optimized provider factory
 */
export declare function createCostOptimizedFactory(config: ProviderFactoryConfig): LLMProviderFactory;
//# sourceMappingURL=factory.d.ts.map