import type { ZodSchema } from 'zod';
import { LLMTask, type CortexConfig } from '@cortex/core';
import { AnthropicProvider } from './providers/anthropic.js';
import { OllamaProvider } from './providers/ollama.js';
import { OpenAICompatibleProvider } from './providers/openai-compatible.js';
import { TokenTracker } from './token-tracker.js';
import { ResponseCache } from './cache.js';
export type LLMMode = 'cloud-first' | 'hybrid' | 'local-first' | 'local-only';
export type TaskRouting = 'auto' | 'local' | 'cloud';
export interface RouterOptions {
    config: CortexConfig;
    apiKey?: string;
}
export interface CompleteRequest {
    systemPrompt?: string;
    userPrompt: string;
    promptId: string;
    promptVersion: string;
    task: LLMTask;
    modelPreference?: 'primary' | 'fast';
    temperature?: number;
    maxTokens?: number;
    contentHash?: string;
    forceProvider?: 'local' | 'cloud';
}
export interface CompleteResult {
    content: string;
    model: string;
    inputTokens: number;
    outputTokens: number;
    cached: boolean;
    latencyMs: number;
    costUsd: number;
    provider: 'anthropic' | 'ollama' | 'openai-compatible';
}
interface ProviderWithSystem {
    completeWithSystem(systemPrompt: string | undefined, userPrompt: string, options?: {
        temperature?: number;
        maxTokens?: number;
    }, modelPreference?: 'primary' | 'fast'): Promise<{
        content: string;
        inputTokens: number;
        outputTokens: number;
        model: string;
    }>;
    streamWithSystem(systemPrompt: string | undefined, userPrompt: string, options?: {
        temperature?: number;
        maxTokens?: number;
    }, modelPreference?: 'primary' | 'fast'): AsyncGenerator<string, {
        inputTokens: number;
        outputTokens: number;
        model: string;
    }>;
    getModel(preference?: 'primary' | 'fast'): string;
    isAvailable(): Promise<boolean>;
}
type CloudProvider = AnthropicProvider | OpenAICompatibleProvider;
export declare class Router {
    private cloudProvider;
    private localProvider;
    private mode;
    private taskRouting;
    private tracker;
    private cache;
    private config;
    private availabilityCache;
    private static readonly AVAILABILITY_TTL_MS;
    constructor(options: RouterOptions);
    /**
     * Select provider based on mode, task routing, and availability
     */
    private selectProvider;
    get provider(): ProviderWithSystem;
    complete(request: CompleteRequest): Promise<CompleteResult>;
    completeStructured<T>(request: CompleteRequest, schema: ZodSchema<T>): Promise<{
        data: T;
    } & CompleteResult>;
    stream(request: Omit<CompleteRequest, 'contentHash'>): AsyncGenerator<string, CompleteResult>;
    getTracker(): TokenTracker;
    getCache(): ResponseCache;
    getLocalProvider(): OllamaProvider | null;
    getCloudProvider(): CloudProvider | null;
    getMode(): LLMMode;
    isAvailable(): Promise<boolean>;
}
export {};
//# sourceMappingURL=router.d.ts.map