import { B as BaseProvider, P as ProviderConfig, C as ChatRequest, M as ModelResponse, S as StreamEvent, a as ChatMessage, A as APIToolDefinition, T as TokenUsage, b as Provider } from '../types-BJqLgf36.cjs';
export { R as RetryableError } from '../types-BJqLgf36.cjs';
import '../router-w_4lkJaq.cjs';
import 'zod';

interface AnthropicProviderConfig extends ProviderConfig {
    apiKey: string;
    baseURL?: string;
    dangerouslySkipAuth?: boolean;
    enableCaching?: boolean;
}
declare class AnthropicProvider extends BaseProvider {
    private readonly apiKey;
    private readonly baseURL?;
    private readonly dangerouslySkipAuth?;
    private readonly enableCaching;
    private client;
    constructor(config: AnthropicProviderConfig);
    chat(request: ChatRequest): Promise<ModelResponse>;
    chatStream(request: ChatRequest): AsyncGenerator<StreamEvent>;
    protected mapMessages(messages: ChatMessage[]): unknown[];
    protected mapTools(tools?: APIToolDefinition[]): unknown[] | undefined;
    protected mapUsage(providerUsage: unknown): TokenUsage;
    private mapOutgoingBlock;
}

interface OpenAIProviderConfig extends ProviderConfig {
    apiKey: string;
    baseURL?: string;
    organization?: string;
}
declare class OpenAIProvider extends BaseProvider {
    private readonly apiKey;
    private readonly baseURL?;
    private readonly organization?;
    private client;
    constructor(config: OpenAIProviderConfig);
    chat(request: ChatRequest): Promise<ModelResponse>;
    chatStream(request: ChatRequest): AsyncGenerator<StreamEvent>;
    protected mapMessages(messages: ChatMessage[]): unknown[];
    protected mapTools(tools?: APIToolDefinition[]): unknown[] | undefined;
    protected mapUsage(providerUsage: unknown): TokenUsage;
}

interface OllamaProviderConfig {
    model: string;
    baseURL?: string;
}
declare class OllamaProvider implements Provider {
    readonly model: string;
    private readonly baseURL;
    constructor(config: OllamaProviderConfig);
    chat(request: ChatRequest): Promise<ModelResponse>;
    chatStream(request: ChatRequest): AsyncGenerator<StreamEvent>;
}

interface ClusterSlot {
    model: string;
    role: "planner" | "worker" | "reviewer" | "drafter";
    baseURL?: string;
    maxTokens?: number;
    temperature?: number;
}
interface ClusterConfig {
    slots: ClusterSlot[];
    baseURL?: string;
    timeoutMs?: number;
    strategy?: "auto" | "draft-verify" | "debate" | "majority" | "single";
    draftCount?: number;
    debateRounds?: number;
}
declare class ClusterProvider implements Provider {
    readonly model: string;
    private config;
    private stats;
    constructor(config?: Partial<ClusterConfig>);
    getStats(): {
        calls: number;
        tokensIn: number;
        tokensOut: number;
        byModel: Record<string, number>;
    };
    chat(request: ChatRequest): Promise<ModelResponse>;
    private speculative;
    private draftVerify;
    private debate;
    private safeCall;
    private fallback;
}

type ModelTier = "fast" | "standard" | "powerful";
interface TieredRouterConfig {
    fast: Provider;
    standard: Provider;
    powerful?: Provider;
}
declare const DEFAULT_TOOL_TIER_MAP: Record<string, ModelTier>;
interface RouterStats {
    totalRequests: number;
    byTier: Record<ModelTier, {
        requests: number;
        inputTokens: number;
        outputTokens: number;
    }>;
    estimatedCostSaved: number;
}
declare class TieredRouter implements Provider {
    private tiers;
    private toolMap;
    private currentTier;
    private stats;
    constructor(config: TieredRouterConfig);
    get model(): string;
    chat(request: ChatRequest): Promise<ModelResponse>;
    setTier(tier: ModelTier): void;
    getTierForTool(toolName: string): ModelTier;
    routeByToolCalls(toolCalls: Array<{
        name: string;
    }>): ModelTier;
    getStats(): RouterStats;
    private determineTier;
    private extractToolCalls;
    private resolveTier;
    private recordUsage;
    private estimateSavings;
}

interface ModelCost {
    inputPer1M: number;
    outputPer1M: number;
}
declare const MODEL_COSTS: Record<string, ModelCost>;
declare function estimateRequestCost(model: string, inputTokens: number, outputTokens: number): number;

declare function anthropic(config: AnthropicProviderConfig): AnthropicProvider;
declare function openai(config: OpenAIProviderConfig): OpenAIProvider;
declare function ollama(config: OllamaProviderConfig): OllamaProvider;
declare function cluster(config?: Partial<ClusterConfig>): ClusterProvider;
interface CustomProviderConfig {
    provider: 'custom';
    model: string;
    chat: (request: ChatRequest) => Promise<ModelResponse>;
}
type OllamaProviderConfigWithProvider = OllamaProviderConfig & {
    provider: 'ollama';
};
declare function createProvider(config: (AnthropicProviderConfig & {
    provider: 'anthropic';
}) | (OpenAIProviderConfig & {
    provider: 'openai';
}) | OllamaProviderConfigWithProvider | CustomProviderConfig): Provider;

export { APIToolDefinition, AnthropicProvider, type AnthropicProviderConfig, BaseProvider, ChatMessage, ChatRequest, type ClusterConfig, ClusterProvider, type ClusterSlot, type CustomProviderConfig, DEFAULT_TOOL_TIER_MAP, MODEL_COSTS, type ModelCost, type ModelTier, OllamaProvider, type OllamaProviderConfig, type OllamaProviderConfigWithProvider, OpenAIProvider, type OpenAIProviderConfig, Provider, type RouterStats, TieredRouter, type TieredRouterConfig, anthropic, cluster, createProvider, estimateRequestCost, ollama, openai };