/**
 * Base Provider
 * Abstract base class for all LLM providers with common functionality
 */
import type { LLMProvider, LLMImageInput, LLMRequest, LLMResponse, ProviderConfig, ModelCapabilities, ProviderMetrics, ToolCall, TokenUsage } from '../types.js';
import type { Logger } from '../utils/logger.js';
import { RetryManager } from '../utils/retry.js';
import { CircuitBreaker } from '../utils/circuit-breaker.js';
import { CostTracker } from '../utils/cost-tracker.js';
export declare abstract class BaseProvider implements LLMProvider {
    abstract name: string;
    abstract models: string[];
    abstract supportsStreaming: boolean;
    abstract supportsTools: boolean;
    abstract supportsBatching: boolean;
    abstract supportsVision?: boolean;
    protected config: ProviderConfig;
    protected logger: Logger;
    protected retryManager: RetryManager;
    protected circuitBreaker: CircuitBreaker;
    protected costTracker: CostTracker;
    protected metrics: ProviderMetrics;
    constructor(config?: ProviderConfig);
    /**
     * Abstract method that must be implemented by each provider
     */
    abstract generateResponse(request: LLMRequest): Promise<LLMResponse>;
    /**
     * Abstract method for configuration validation
     */
    abstract validateConfig(): boolean;
    /**
     * Abstract method to get available models
     */
    abstract getModels(): string[];
    /**
     * Abstract method to estimate cost
     */
    abstract estimateCost(request: LLMRequest): number;
    /**
     * Abstract method for health check
     */
    abstract healthCheck(): Promise<boolean>;
    /**
     * Common HTTP request method with timeout and error handling
     */
    protected makeRequest(url: string, options?: RequestInit, timeoutMs?: number): Promise<Response>;
    /**
     * Execute request with circuit breaker and retry logic
     */
    protected executeWithResiliency<T>(operation: () => Promise<T>): Promise<T>;
    /**
     * Update metrics after request
     */
    protected updateMetrics(responseTime: number, success: boolean, cost?: number): void;
    /**
     * Get provider metrics
     */
    getMetrics(): ProviderMetrics;
    /**
     * Reset metrics
     */
    resetMetrics(): void;
    /**
     * Get provider health status
     */
    getHealth(): {
        healthy: boolean;
        circuitBreakerState: string;
        metrics: ProviderMetrics;
        lastError?: number;
    };
    /**
     * Update provider configuration
     */
    updateConfig(config: Partial<ProviderConfig>): void;
    /**
     * Get current configuration (without sensitive data)
     */
    getConfig(): Omit<ProviderConfig, 'apiKey'>;
    /**
     * Providers share the named singleton breaker so factory-level routing and
     * per-provider execution observe the same failure history.
     */
    protected getCircuitBreaker(): CircuitBreaker;
    /**
     * Common model capability definitions
     */
    protected getModelCapabilities(): Record<string, ModelCapabilities>;
    /**
     * Validate request before processing
     */
    protected validateRequest(request: LLMRequest): void;
    protected estimateTextTokens(request: LLMRequest): number;
    protected validateImageInput(image: LLMImageInput): void;
    protected getAIGatewayHeaders(request?: LLMRequest): Record<string, string>;
    /**
     * Validate and sanitize tool calls returned by the provider.
     *
     * Ensures each tool call has the required fields (`id`, `type`, `function.name`,
     * `function.arguments`) and that their types are correct. Malformed entries are
     * dropped and logged rather than propagated to the caller.
     *
     * Returns `undefined` when the input is empty or all entries are invalid, so the
     * result can be assigned directly to `response.toolCalls`.
     */
    protected validateToolCalls(toolCalls: ToolCall[] | undefined): ToolCall[] | undefined;
    /**
     * Calculate token usage cost
     */
    protected calculateCost(inputTokens: number, outputTokens: number, model: string): number;
    protected parseOpenAICompatibleStreamUsage(rawUsage: unknown, model: string): TokenUsage | undefined;
    /**
     * Common response formatting
     */
    protected buildResponse(content: string, usage: {
        inputTokens: number;
        outputTokens: number;
    }, model: string, responseTime: number, metadata?: Record<string, unknown>): LLMResponse;
    /**
     * Log request/response for debugging
     */
    protected logRequest(request: LLMRequest, response?: LLMResponse, error?: Error): void;
}
//# sourceMappingURL=base.d.ts.map