export interface OpenRouterModel {
    id: string;
    name: string;
    description: string;
    pricing: {
        prompt: string;
        completion: string;
    };
    context_length: number;
    architecture: {
        modality: string;
        tokenizer: string;
        instruct_type?: string;
    };
    top_provider: {
        context_length: number;
        max_completion_tokens?: number;
        is_moderated: boolean;
    };
    per_request_limits?: {
        prompt_tokens: string;
        completion_tokens: string;
    };
}
export interface OpenRouterResponse {
    id: string;
    choices: Array<{
        message: {
            role: string;
            content: string;
        };
        finish_reason: string;
    }>;
    usage: {
        prompt_tokens: number;
        completion_tokens: number;
        total_tokens: number;
    };
    model: string;
}
export interface ChatMessage {
    role: 'user' | 'assistant' | 'system';
    content: string;
}
export interface ChatCompletionOptions {
    model: string;
    messages: ChatMessage[];
    maxTokens?: number;
    temperature?: number;
    topP?: number;
    stream?: boolean;
}
export declare class OpenRouterClient {
    private client;
    private logger;
    private modelsCache;
    private cacheExpiry;
    private readonly CACHE_DURATION;
    private rateLimiter;
    private apiKey;
    constructor(apiKey?: string, baseURL?: string);
    private validateAPIKeyForRequest;
    private validateAPIKeyStrict;
    validateAPIKeyWithService(): Promise<{
        valid: boolean;
        reason?: string;
    }>;
    updateAPIKey(apiKey: string): void;
    hasValidAPIKey(): boolean;
    getAvailableModels(forceRefresh?: boolean): Promise<OpenRouterModel[]>;
    getModelsByType(type?: 'chat' | 'completion' | 'vision'): Promise<OpenRouterModel[]>;
    getClaudeModels(): Promise<OpenRouterModel[]>;
    isModelAvailable(modelId: string): Promise<boolean>;
    getBestClaudeModel(prioritizePricing?: boolean): Promise<string>;
    private selectMostCostEffectiveModel;
    selectBestModelForAgent(agentType: string, taskComplexity?: 'simple' | 'medium' | 'complex', prioritizePricing?: boolean, manualOverride?: string): Promise<string>;
    private filterModelsByCapability;
    private selectBestPerformanceModel;
    compareModelCosts(modelIds: string[], estimatedPromptTokens?: number, estimatedCompletionTokens?: number): Promise<Array<{
        modelId: string;
        cost: number;
        available: boolean;
    }>>;
    chatCompletion(options: ChatCompletionOptions): Promise<OpenRouterResponse>;
    getModelInfo(modelId: string): Promise<OpenRouterModel | null>;
    streamChatCompletion(_options: ChatCompletionOptions, _onChunk: (chunk: string) => void): Promise<void>;
    estimateCost(modelId: string, promptTokens: number, completionTokens: number): Promise<number>;
    getRateLimitStatus(): any;
    getAPIMetrics(): any;
    resetRateLimit(): void;
    destroy(): void;
    private validateChatCompletionOptions;
    private sanitizeMessages;
    private sanitizeModels;
    private sanitizeChatResponse;
    private sanitizeErrorMessage;
    private sanitizeString;
}
//# sourceMappingURL=openrouter-client.d.ts.map