type Provider$1 = 'openai' | 'anthropic' | 'azure' | 'bedrock' | 'cerebras' | 'cohere' | 'deepseek' | 'fireworks' | 'google' | 'groq' | 'huggingface' | 'litellm' | 'local' | 'mistral' | 'ollama' | 'openrouter' | 'perplexity' | 'replicate' | 'together' | 'vertex' | 'vllm' | 'xai' | 'custom';
type RoutingStrategy$1 = 'adaptive' | 'cost_first' | 'quality_first' | 'speed_first' | 'semantic';
type QueryComplexity = 'trivial' | 'simple' | 'moderate' | 'hard' | 'expert';
type MessageRole = 'system' | 'user' | 'assistant' | 'tool';
interface Message {
    role: MessageRole;
    content: string;
    name?: string;
    tool_call_id?: string;
    tool_calls?: ToolCall$1[];
}
interface Tool {
    type: 'function';
    function: {
        name: string;
        description: string;
        parameters: Record<string, any>;
    };
}
interface ToolCall$1 {
    id: string;
    type: 'function';
    function: {
        name: string;
        arguments: string;
    };
}
interface UsageDetails {
    prompt_tokens: number;
    completion_tokens: number;
    total_tokens: number;
    input_tokens?: number;
    output_tokens?: number;
    cached_input_tokens?: number;
    reasoning_tokens?: number;
    completion_tokens_details?: {
        reasoning_tokens?: number;
        accepted_prediction_tokens?: number;
        rejected_prediction_tokens?: number;
    };
}
interface ThinkingBlock {
    type: 'thinking';
    thinking: string;
    signature?: string;
}
interface TextBlock {
    type: 'text';
    text: string;
}
type ContentBlock = ThinkingBlock | TextBlock;
interface ProviderResponse {
    content: string;
    model: string;
    usage?: UsageDetails;
    finish_reason?: string;
    tool_calls?: ToolCall$1[];
    logprobs?: number[];
    thinking?: string;
    content_blocks?: ContentBlock[];
    raw?: any;
}
interface CostBreakdown {
    draftCost: number;
    verifierCost: number;
    totalCost: number;
    costSaved: number;
    bigonlyCost: number;
    savingsPercentage: number;
    draftTokens: number;
    verifierTokens: number;
    totalTokens: number;
    wasCascaded: boolean;
    draftAccepted: boolean;
    metadata: Record<string, any>;
}
interface TimingBreakdown {
    complexityDetectionMs?: number;
    draftGenerationMs?: number;
    qualityVerificationMs?: number;
    verifierGenerationMs?: number;
    cascadeOverheadMs?: number;
    totalMs: number;
}
interface QualityValidation {
    passed: boolean;
    score: number;
    threshold: number;
    reason?: string;
}
type TierLevel = 'FREE' | 'STARTER' | 'PRO' | 'BUSINESS' | 'ENTERPRISE';
type CostSensitivity = 'aggressive' | 'balanced' | 'quality_first';
interface LatencyProfile {
    maxTotalMs: number;
    maxPerModelMs: number;
    preferParallel: boolean;
    skipCascadeThreshold: number;
}
interface OptimizationWeights {
    cost: number;
    speed: number;
    quality: number;
}
interface TierConfig {
    name: string;
    requestsPerHour?: number;
    requestsPerDay?: number;
    dailyBudget?: number;
    maxConcurrentRequests: number;
    enableCaching: boolean;
    enableSpeculative: boolean;
    minQuality: number;
    targetQuality: number;
}
interface UserProfile {
    userId: string;
    createdAt?: Date;
    tier: TierConfig;
    customDailyBudget?: number;
    customRequestsPerHour?: number;
    customRequestsPerDay?: number;
    preferredModels?: string[];
    costSensitivity?: CostSensitivity;
    preferredDomains?: string[];
    domainModels?: Record<string, string[]>;
    latency?: LatencyProfile;
    optimization?: OptimizationWeights;
    enableContentModeration?: boolean;
    enablePiiDetection?: boolean;
    metadata?: Record<string, any>;
}
interface WorkflowProfile {
    name: string;
    latencyOverride?: LatencyProfile;
    optimizationOverride?: OptimizationWeights;
    maxBudgetOverride?: number;
    qualityThresholdOverride?: number;
    forceModels?: string[];
    preferredModels?: string[];
    excludeModels?: string[];
    enableCaching?: boolean;
    enableParallel?: boolean;
    enableSpeculative?: boolean;
    enableStreaming?: boolean;
    description?: string;
    metadata?: Record<string, any>;
}
interface RateLimitState {
    userId: string;
    hourlyRequests: number[];
    dailyRequests: number[];
    dailyCost: number;
    lastReset: Date;
}
interface PiiMatch {
    piiType: 'email' | 'phone' | 'ssn' | 'credit_card' | 'ip_address';
    value: string;
    position: [number, number];
}
interface ModerationResult {
    isSafe: boolean;
    violations: string[];
    categories: string[];
    confidence: number;
}
interface GuardrailsCheck {
    isSafe: boolean;
    contentModeration?: ModerationResult;
    piiDetected?: PiiMatch[];
    violations: string[];
}
interface BatchItemResult {
    index: number;
    success: boolean;
    result?: any;
    error?: string;
    timingMs: number;
    cost: number;
}
interface HttpConfig {
    verifySsl?: boolean;
    caCertPath?: string;
    proxy?: string;
    timeout?: number;
    maxRetries?: number;
}

interface CascadeResult {
    content: string;
    modelUsed: string;
    totalCost: number;
    latencyMs: number;
    tokensUsed?: number;
    complexity: string;
    cascaded: boolean;
    draftAccepted: boolean;
    routingStrategy: string;
    reason: string;
    toolCalls?: ToolCall$1[];
    hasToolCalls: boolean;
    qualityScore?: number;
    qualityThreshold?: number;
    qualityCheckPassed?: boolean;
    rejectionReason?: string;
    draftResponse?: string;
    verifierResponse?: string;
    responseLength?: number;
    responseWordCount?: number;
    complexityDetectionMs?: number;
    draftGenerationMs?: number;
    qualityVerificationMs?: number;
    verifierGenerationMs?: number;
    cascadeOverheadMs?: number;
    draftCost?: number;
    verifierCost?: number;
    costSaved?: number;
    savingsPercentage?: number;
    costBreakdown?: any;
    timingBreakdown?: any;
    draftModel?: string;
    draftLatencyMs?: number;
    draftConfidence?: number;
    verifierModel?: string;
    verifierLatencyMs?: number;
    verifierConfidence?: number;
    speedup?: number;
    model?: string;
    provider?: string;
    metadata?: Record<string, any>;
}
declare function resultToObject(result: CascadeResult): Record<string, any>;

declare enum BatchStrategy {
    LITELLM_NATIVE = "litellm_native",
    SEQUENTIAL = "sequential",
    AUTO = "auto"
}
interface BatchConfig {
    batchSize?: number;
    maxParallel?: number;
    timeoutPerQuery?: number;
    totalTimeout?: number;
    strategy?: BatchStrategy;
    stopOnError?: boolean;
    retryFailed?: boolean;
    trackCost?: boolean;
    validateQuality?: boolean;
    preserveOrder?: boolean;
    metadata?: Record<string, any>;
}
interface BatchResult {
    results: (CascadeResult | null)[];
    successCount: number;
    failureCount: number;
    totalCost: number;
    totalTime: number;
    strategyUsed: string;
    errors: (string | null)[];
    metadata: Record<string, any>;
    successRate: number;
    averageCost: number;
    averageTime: number;
}
declare const DEFAULT_BATCH_CONFIG: Required<BatchConfig>;
declare function normalizeBatchConfig(config?: BatchConfig): Required<BatchConfig>;
declare class BatchProcessor {
    processBatch(queries: string[], runFn: (query: string, options?: RunOptions) => Promise<CascadeResult>, config?: BatchConfig, runOptions?: RunOptions): Promise<BatchResult>;
    private chooseStrategy;
    private processSequentialBatch;
}
declare class BatchProcessingError extends Error {
    constructor(message: string);
}

declare enum CallbackEvent {
    QUERY_START = "query_start",
    COMPLEXITY_DETECTED = "complexity_detected",
    MODELS_SCORED = "models_scored",
    STRATEGY_SELECTED = "strategy_selected",
    MODEL_CALL_START = "model_call_start",
    MODEL_CALL_COMPLETE = "model_call_complete",
    MODEL_CALL_ERROR = "model_call_error",
    CASCADE_DECISION = "cascade_decision",
    CACHE_HIT = "cache_hit",
    CACHE_MISS = "cache_miss",
    QUERY_COMPLETE = "query_complete",
    QUERY_ERROR = "query_error"
}
interface CallbackData {
    event: CallbackEvent;
    query: string;
    userTier?: string;
    workflow?: string;
    data: Record<string, any>;
    timestamp: number;
}
type CallbackFunction = (data: CallbackData) => void | Promise<void>;
interface CallbackStats {
    totalTriggers: number;
    byEvent: Record<CallbackEvent, number>;
    callbackErrors: number;
    registeredEvents: string[];
}
declare class CallbackManager {
    private callbacks;
    private stats;
    private verbose;
    constructor(verbose?: boolean);
    register(event: CallbackEvent, callback: CallbackFunction): void;
    unregister(event: CallbackEvent, callback: CallbackFunction): void;
    trigger(event: CallbackEvent, query: string, data: Record<string, any>, userTier?: string, workflow?: string): Promise<void>;
    clear(event?: CallbackEvent): void;
    getStats(): CallbackStats;
    resetStats(): void;
    printStats(): void;
}

type ToolFunction = (...args: any[]) => any | Promise<any>;
interface ToolParameters {
    type: 'object';
    properties: Record<string, any>;
    required?: string[];
    [key: string]: any;
}
interface ToolConfigOptions {
    name: string;
    description: string;
    parameters: ToolParameters;
    function?: ToolFunction;
}
declare class ToolConfig {
    readonly name: string;
    readonly description: string;
    readonly parameters: ToolParameters;
    readonly function?: ToolFunction;
    constructor(options: ToolConfigOptions);
    private validate;
    static fromFunction(func: ToolFunction, options: {
        description: string;
        parameters: ToolParameters;
        name?: string;
    }): ToolConfig;
    toOpenAIFormat(): {
        type: 'function';
        function: {
            name: string;
            description: string;
            parameters: ToolParameters;
        };
    };
    toAnthropicFormat(): {
        name: string;
        description: string;
        input_schema: ToolParameters;
    };
    toUniversalFormat(): {
        name: string;
        description: string;
        parameters: ToolParameters;
    };
    clone(): ToolConfig;
    toJSON(): {
        name: string;
        description: string;
        parameters: ToolParameters;
    };
}
declare function createTool(options: ToolConfigOptions): ToolConfig;
declare function tool(options: {
    description: string;
    parameters: ToolParameters;
    name?: string;
}): (func: ToolFunction) => ToolConfig;
declare function inferJsonType(value: any): string;
declare function buildParameterSchema(properties: Record<string, any>, required?: string[]): ToolParameters;

declare enum ToolCallFormat {
    OPENAI = "openai",
    ANTHROPIC = "anthropic",
    OLLAMA = "ollama",
    VLLM = "vllm",
    HUGGINGFACE = "huggingface"
}
declare function toOpenAIFormat(name: string, description: string, parameters: Record<string, any>): Record<string, any>;
declare function toAnthropicFormat(name: string, description: string, parameters: Record<string, any>): Record<string, any>;
declare function toOllamaFormat(name: string, description: string, parameters: Record<string, any>): Record<string, any>;
declare function toProviderFormat(provider: string, name: string, description: string, parameters: Record<string, any>): Record<string, any>;
declare function getProviderFormatType(provider: string): ToolCallFormat;

interface ToolCallOptions {
    id: string;
    name: string;
    arguments: Record<string, any>;
    providerFormat: ToolCallFormat;
}
declare class ToolCall {
    readonly id: string;
    readonly name: string;
    readonly arguments: Record<string, any>;
    readonly providerFormat: ToolCallFormat;
    constructor(options: ToolCallOptions);
    static fromOpenAI(toolCall: Record<string, any>): ToolCall;
    static fromAnthropic(toolUse: Record<string, any>): ToolCall;
    static fromOllama(toolCall: Record<string, any>): ToolCall;
    static fromVLLM(toolCall: Record<string, any>): ToolCall;
    static fromProvider(provider: string, toolCall: Record<string, any>): ToolCall;
    toJSON(): Record<string, any>;
}

interface ToolResultOptions {
    callId: string;
    name: string;
    result: any;
    error?: string;
    executionTimeMs?: number;
}
declare class ToolResult {
    readonly callId: string;
    readonly name: string;
    readonly result: any;
    readonly error?: string;
    readonly executionTimeMs?: number;
    constructor(options: ToolResultOptions);
    get success(): boolean;
    toOpenAIMessage(): Record<string, any>;
    toAnthropicMessage(): Record<string, any>;
    toOllamaMessage(): Record<string, any>;
    toVLLMMessage(): Record<string, any>;
    toProviderMessage(provider: string): Record<string, any>;
    toJSON(): Record<string, any>;
}

declare class ToolExecutor {
    private readonly tools;
    constructor(tools: ToolConfig[]);
    execute(toolCall: ToolCall): Promise<ToolResult>;
    executeParallel(toolCalls: ToolCall[], maxParallel?: number): Promise<ToolResult[]>;
    getTool(name: string): ToolConfig | undefined;
    hasTool(name: string): boolean;
    listTools(): string[];
    get toolCount(): number;
}

type ComplexityLevel = 'trivial' | 'simple' | 'moderate' | 'unknown';
interface ToolQualityScore {
    overallScore: number;
    thresholdUsed: number;
    isValid: boolean;
    jsonValid: boolean;
    schemaValid: boolean;
    toolExists: boolean;
    requiredFieldsPresent: boolean;
    parametersSensible: boolean;
    issues: string[];
    complexityLevel?: ComplexityLevel;
    adaptiveThreshold: boolean;
}
declare class ToolValidator {
    private static readonly ADAPTIVE_THRESHOLDS;
    private static readonly DEFAULT_THRESHOLD;
    private static readonly LEVEL_WEIGHTS;
    private readonly verbose;
    constructor(options?: {
        verbose?: boolean;
    });
    validate(toolCalls: Record<string, any> | Record<string, any>[], availableTools?: Record<string, any>[]): number;
    validateToolCalls(toolCalls: Record<string, any>[], availableTools: Record<string, any>[], complexityLevel?: ComplexityLevel): ToolQualityScore;
    private _getThreshold;
    private _validateSingleToolCall;
    private _validateJson;
    private _validateSchema;
    private _hasExpectedFields;
    private _validateToolExists;
    private _toolNameExists;
    private _validateRequiredFields;
    private _hasRequiredFields;
    private _validateParameters;
    private _parametersAreSensible;
    private _logValidation;
}
declare function formatToolQualityScore(score: ToolQualityScore): string;

interface QualityResult {
    passed: boolean;
    score: number;
    confidence: number;
    method: 'logprobs' | 'heuristic' | 'hybrid';
    reason: string;
    details?: {
        avgLogprob?: number;
        minLogprob?: number;
        lengthOk?: boolean;
        wordCount?: number;
        uncertaintyMarkers?: string[];
        alignmentScore?: number;
        alignmentReasoning?: string;
        semanticSimilarity?: number;
        productionConfidence?: {
            methodUsed: string;
            components: Record<string, number | string | boolean>;
            alignmentFloorApplied: boolean;
            queryDifficulty?: number;
        };
    };
}
interface QualityConfig$1 {
    minConfidence: number;
    confidenceThresholds?: {
        trivial?: number;
        simple?: number;
        moderate?: number;
        hard?: number;
        expert?: number;
    };
    minWordCount: number;
    useLogprobs: boolean;
    fallbackToHeuristic: boolean;
    strictMode: boolean;
    useAlignmentScoring: boolean;
    minAlignmentScore: number;
    useSemanticValidation?: boolean;
    semanticThreshold?: number;
    useProductionConfidence?: boolean;
    provider?: string;
}
declare const DEFAULT_QUALITY_CONFIG$1: QualityConfig$1;
declare const CASCADE_QUALITY_CONFIG: QualityConfig$1;
declare class QualityConfigFactory {
    static forProduction(): QualityConfig$1;
    static forDevelopment(): QualityConfig$1;
    static strict(): QualityConfig$1;
    static forCascade(): QualityConfig$1;
    static permissive(): QualityConfig$1;
}
declare function calculateConfidenceFromLogprobs(logprobs: number[]): number;
declare function estimateConfidenceFromContent(content: string, _query: string): number;
declare class QualityValidator {
    private config;
    private alignmentScorer;
    private semanticChecker;
    private semanticCheckerInitialized;
    private productionConfidenceEstimator;
    private complexityDetector;
    constructor(config?: Partial<QualityConfig$1>);
    private initSemanticChecker;
    private getThresholdForComplexity;
    validate(content: string, query: string, logprobs?: number[], complexity?: QueryComplexity, thresholdOverride?: number): Promise<QualityResult>;
    updateConfig(config: Partial<QualityConfig$1>): void;
    getConfig(): QualityConfig$1;
    static forProduction(): QualityValidator;
    static forDevelopment(): QualityValidator;
    static strict(): QualityValidator;
    static forCascade(): QualityValidator;
    static permissive(): QualityValidator;
}

declare enum Domain {
    CODE = "code",
    DATA = "data",
    STRUCTURED = "structured",
    RAG = "rag",
    CONVERSATION = "conversation",
    TOOL = "tool",
    CREATIVE = "creative",
    SUMMARY = "summary",
    TRANSLATION = "translation",
    MATH = "math",
    MEDICAL = "medical",
    LEGAL = "legal",
    FINANCIAL = "financial",
    MULTIMODAL = "multimodal",
    GENERAL = "general"
}
interface DomainKeywords {
    veryStrong: string[];
    strong: string[];
    moderate: string[];
    weak: string[];
}
interface DomainDetectionResult {
    domain: Domain;
    confidence: number;
    scores?: Record<string, number>;
    metadata?: {
        queryLength: number;
        threshold: number;
        isMcq: boolean;
        subjectHint: string | null;
    };
}
interface DomainRouterStats {
    totalDetections: number;
    byDomain: Record<string, number>;
    avgConfidence: number;
}
declare class DomainRouter {
    private verbose;
    private stats;
    constructor(config?: {
        verbose?: boolean;
    });
    detect(query: string): DomainDetectionResult;
    private detectMcqFormat;
    private detectSubjectDomain;
    getStats(): DomainRouterStats;
    resetStats(): void;
}
declare function createDomainRouter(config?: {
    verbose?: boolean;
}): DomainRouter;

declare enum ValidationMethod {
    NONE = "none",
    SYNTAX_CHECK = "syntax_check",
    FACT_CHECK = "fact_check",
    SAFETY_CHECK = "safety_check",
    QUALITY_CHECK = "quality_check",
    FULL_QUALITY = "full_quality",
    SEMANTIC = "semantic",
    CUSTOM = "custom"
}
declare enum StepStatus {
    PENDING = "pending",
    RUNNING = "running",
    SUCCESS = "success",
    FAILED_QUALITY = "failed_quality",
    FAILED_ERROR = "failed_error",
    SKIPPED = "skipped"
}
interface CascadeStep {
    name: string;
    model: string;
    provider: string;
    validation?: ValidationMethod;
    qualityThreshold?: number;
    fallbackOnly?: boolean;
    maxTokens?: number;
    temperature?: number;
    metadata?: Record<string, any>;
}
interface StepResult {
    stepName: string;
    status: StepStatus;
    response?: string;
    qualityScore: number;
    cost: number;
    latencyMs: number;
    tokensUsed: number;
    validationDetails?: Record<string, any>;
    error?: string;
    metadata?: Record<string, any>;
}
interface DomainCascadeStrategy {
    domain: Domain;
    steps: CascadeStep[];
    description?: string;
    enabled?: boolean;
    metadata?: Record<string, any>;
}
interface CascadeExecutionResult {
    success: boolean;
    domain: Domain;
    strategyUsed: string;
    finalResponse: string;
    stepsExecuted: StepResult[];
    totalCost: number;
    totalLatencyMs: number;
    totalTokens: number;
    qualityScore: number;
    fallbackUsed: boolean;
    metadata?: Record<string, any>;
}
declare function createCascadeStep(config: CascadeStep): CascadeStep;
declare function getStepByName(strategy: DomainCascadeStrategy, stepName: string): CascadeStep | undefined;
declare function getFallbackSteps(strategy: DomainCascadeStrategy): CascadeStep[];
declare function getStepResult(result: CascadeExecutionResult, stepName: string): StepResult | undefined;
declare function getCostBreakdown(result: CascadeExecutionResult): Record<string, number>;
declare function getSuccessfulSteps(result: CascadeExecutionResult): StepResult[];
declare function getCodeStrategy(): DomainCascadeStrategy;
declare function getMedicalStrategy(): DomainCascadeStrategy;
declare function getGeneralStrategy(): DomainCascadeStrategy;
declare function getDataStrategy(): DomainCascadeStrategy;
declare function getMathStrategy(): DomainCascadeStrategy;
declare function getStructuredStrategy(): DomainCascadeStrategy;
declare const BUILT_IN_STRATEGIES: Record<Domain, () => DomainCascadeStrategy>;
declare function getStrategyForDomain(domain: Domain): DomainCascadeStrategy | undefined;
declare function listAvailableStrategies(): Domain[];

type DomainValidationMethod = 'none' | 'syntax' | 'fact' | 'safety' | 'quality' | 'semantic' | 'custom';
interface DomainConfig {
    drafter: string | ModelConfig;
    verifier: string | ModelConfig;
    toolDrafter?: string | ModelConfig;
    toolVerifier?: string | ModelConfig;
    threshold?: number;
    validationMethod?: DomainValidationMethod;
    temperature?: number;
    maxTokens?: number;
    fallbackModels?: string[];
    requireVerifier?: boolean;
    adaptiveThreshold?: boolean;
    skipOnSimple?: boolean;
    enabled?: boolean;
    cascadeComplexities?: Array<'trivial' | 'simple' | 'moderate' | 'hard' | 'expert'>;
    description?: string;
    metadata?: Record<string, any>;
}
declare const DEFAULT_DOMAIN_CONFIG: Required<Omit<DomainConfig, 'drafter' | 'verifier' | 'toolDrafter' | 'toolVerifier' | 'fallbackModels' | 'description' | 'metadata' | 'cascadeComplexities'>>;
declare function createDomainConfig(config: DomainConfig): DomainConfig & {
    drafter: string | ModelConfig;
    verifier: string | ModelConfig;
};
declare function validateDomainConfig(config: DomainConfig): void;
type DomainConfigMap = Partial<Record<Domain, DomainConfig>>;
declare const BUILTIN_DOMAIN_CONFIGS: DomainConfigMap;
declare function getBuiltinDomainConfig(domain: Domain): DomainConfig | undefined;
declare function validationMethodToDomain(method: ValidationMethod): DomainValidationMethod;
declare function domainValidationToMethod(validation: DomainValidationMethod): ValidationMethod;

interface TierRouterConfig {
    name: string;
    allowedModels?: string[];
    excludeModels?: string[];
    maxBudget?: number;
    qualityThreshold?: number;
    maxLatencyMs?: number;
    metadata?: Record<string, any>;
}
interface TierConstraints {
    maxBudget?: number;
    qualityThreshold?: number;
    maxLatencyMs?: number;
    allowedModels?: string[];
    excludeModels?: string[];
}
interface TierRouterStats {
    totalFilters: number;
    byTier: Record<string, number>;
    modelsFilteredOut: number;
    avgFilteredPerQuery: number;
}
interface TierAwareRouterConfig {
    tiers: Record<string, TierRouterConfig>;
    models: ModelConfig[];
    verbose?: boolean;
}
interface FilterModelsOptions {
    tierName: string;
    availableModels?: ModelConfig[];
}
declare class TierRouter {
    private tiers;
    private allModels;
    private verbose;
    private stats;
    constructor(config: TierAwareRouterConfig);
    filterModels(options: FilterModelsOptions): ModelConfig[];
    private allowsModel;
    getTier(tierName: string): TierRouterConfig | undefined;
    getTierConstraints(tierName: string): TierConstraints;
    getStats(): TierRouterStats;
    resetStats(): void;
    getTierNames(): string[];
    hasTier(tierName: string): boolean;
}
declare function createTierRouter(config: TierAwareRouterConfig): TierRouter;

interface RuleContext {
    query: string;
    complexity?: QueryComplexity | string;
    complexityConfidence?: number;
    detectedDomain?: string;
    domainConfidence?: number;
    domainConfig?: DomainConfig;
    hasTools?: boolean;
    hasMultiTurn?: boolean;
    hasCode?: boolean;
    hasToolPrompt?: boolean;
    userTier?: string;
    tierConfig?: TierRouterConfig;
    workflowName?: string;
    workflowProfile?: WorkflowProfile;
    kpiFlags?: Record<string, any>;
    tenantId?: string;
    channel?: string;
}

declare enum RoutingStrategy {
    DIRECT_CHEAP = "direct_cheap",
    DIRECT_BEST = "direct_best",
    CASCADE = "cascade",
    PARALLEL = "parallel"
}
interface RoutingDecision {
    strategy: RoutingStrategy;
    reason: string;
    confidence: number;
    metadata: Record<string, any>;
    modelName?: string;
    maxCost?: number;
    minQuality?: number;
}
declare class RoutingDecisionHelper {
    static isDirect(decision: RoutingDecision): boolean;
    static isCascade(decision: RoutingDecision): boolean;
    static validate(decision: RoutingDecision): void;
    static create(strategy: RoutingStrategy, reason: string, confidence: number, metadata?: Record<string, any>): RoutingDecision;
}
declare abstract class Router {
    abstract route(query: string, context?: Record<string, any>): Promise<RoutingDecision>;
    getStats(): Record<string, any>;
    resetStats(): void;
}
declare class RouterChain {
    private routers;
    constructor(routers: Router[]);
    route(query: string, context?: Record<string, any>): Promise<RoutingDecision>;
}

interface RuleDecision {
    routingStrategy?: RoutingStrategy;
    reason?: string;
    confidence?: number;
    metadata?: Record<string, any>;
    preferredChannel?: string;
    modelName?: string;
    allowedModels?: string[];
    excludedModels?: string[];
    preferredModels?: string[];
    forcedModels?: string[];
    qualityThreshold?: number;
    maxBudget?: number;
    failoverChannel?: string;
}
type RuleDecisionLike = RuleDecision & {
    routing_strategy?: RoutingStrategy | string;
    preferred_channel?: string;
    model_name?: string;
    allowed_models?: string[];
    excluded_models?: string[];
    preferred_models?: string[];
    forced_models?: string[];
    quality_threshold?: number;
    max_budget?: number;
    failover_channel?: string;
};

interface RuleEngineConfig {
    enableDomainRouting?: boolean;
    tiers?: Record<string, TierRouterConfig>;
    workflows?: Record<string, WorkflowProfile>;
    tenantRules?: Record<string, RuleDecisionLike | Record<string, unknown>>;
    channelModels?: Record<string, string[]>;
    channelFailover?: Record<string, string>;
    channelStrategies?: Record<string, RoutingStrategy | string>;
    verbose?: boolean;
}
declare class RuleEngine {
    private enableDomainRouting;
    private tiers;
    private workflows;
    private tenantRules;
    private channelModels;
    private channelFailover;
    private channelStrategies;
    private verbose;
    constructor(config?: RuleEngineConfig);
    decide(context: RuleContext): RuleDecision | undefined;
    private applyDomainRules;
    private applyTierRules;
    private applyTenantRules;
    private applyChannelFailover;
    private applyWorkflowRules;
    private applyKpiRules;
    private decisionFromValue;
    private mergeDecisions;
    private coerceComplexity;
    private asStringArray;
    private getModelName;
}

interface ModelConfig {
    name: string;
    provider: Provider$1;
    cost: number;
    keywords?: string[];
    domains?: string[];
    maxTokens?: number;
    systemPrompt?: string;
    temperature?: number;
    apiKey?: string;
    baseUrl?: string;
    extra?: Record<string, any>;
    speedMs?: number;
    qualityScore?: number;
    supportsTools?: boolean;
    toolQuality?: number;
    qualityThreshold?: number;
    httpConfig?: HttpConfig;
}
type QualityValidatorParams = Partial<QualityConfig$1>;
interface QualityConfig extends QualityValidatorParams {
    threshold?: number;
    confidenceThresholds?: {
        trivial?: number;
        simple?: number;
        moderate?: number;
        hard?: number;
        expert?: number;
    };
    requireMinimumTokens?: number;
    requireValidation?: boolean;
    enableAdaptive?: boolean;
}
interface CascadeConfig {
    quality?: QualityConfig;
    maxBudget?: number;
    trackCosts?: boolean;
    maxRetries?: number;
    timeout?: number;
    routingStrategy?: RoutingStrategy$1;
    useSpeculative?: boolean;
    verbose?: boolean;
    trackMetrics?: boolean;
}
interface AgentConfig {
    models: ModelConfig[];
    toolExecutor?: ToolExecutor;
    cascade?: CascadeConfig;
    quality?: QualityConfig;
    callbacks?: CallbackManager;
    domainConfigs?: DomainConfigMap;
    enableDomainDetection?: boolean;
    tiers?: Record<string, TierRouterConfig>;
    workflows?: Record<string, WorkflowProfile>;
    tenantRules?: Record<string, Record<string, unknown>>;
    channelModels?: Record<string, string[]>;
    channelFailover?: Record<string, string>;
    channelStrategies?: Record<string, string>;
    ruleEngineConfig?: RuleEngineConfig;
    ruleEngine?: RuleEngine;
}
declare function validateModelConfig(config: ModelConfig): void;
declare const DEFAULT_QUALITY_CONFIG: QualityConfig;
declare const DEFAULT_CASCADE_CONFIG: Required<Omit<CascadeConfig, 'quality'>>;

declare enum StreamEventType {
    ROUTING = "routing",
    CHUNK = "chunk",
    DRAFT_DECISION = "draft_decision",
    SWITCH = "switch",
    COMPLETE = "complete",
    ERROR = "error"
}
interface StreamEventData {
    model?: string;
    phase?: 'draft' | 'verifier' | 'direct';
    provider?: string;
    strategy?: string;
    complexity?: string;
    accepted?: boolean;
    score?: number;
    confidence?: number;
    draft_model?: string;
    verifier_model?: string;
    reason?: string;
    checks_passed?: boolean;
    quality_threshold?: number;
    from_model?: string;
    to_model?: string;
    result?: any;
    error?: string;
    type?: string;
    streaming_supported?: boolean;
    [key: string]: any;
}
interface StreamEvent {
    type: StreamEventType;
    content: string;
    data: StreamEventData;
}
interface StreamChunk {
    content: string;
    done?: boolean;
    usage?: {
        prompt_tokens?: number;
        completion_tokens?: number;
        total_tokens?: number;
    };
    finish_reason?: string;
    tool_calls?: any[];
    logprob?: number;
    raw?: any;
}
interface StreamOptions {
    maxTokens?: number;
    temperature?: number;
    systemPrompt?: string;
    tools?: any[];
    extra?: Record<string, any>;
    forceDirect?: boolean;
    userTier?: string;
    workflow?: string;
    kpiFlags?: Record<string, any>;
    tenantId?: string;
    channel?: string;
    enableQualityCheck?: boolean;
    qualityThreshold?: number;
}
declare function createStreamEvent(type: StreamEventType, content?: string, data?: StreamEventData): StreamEvent;
declare function isChunkEvent(event: StreamEvent): boolean;
declare function isCompleteEvent(event: StreamEvent): boolean;
declare function isErrorEvent(event: StreamEvent): boolean;
declare function collectStream(stream: AsyncIterable<StreamEvent>): Promise<string>;
declare function collectResult(stream: AsyncIterable<StreamEvent>): Promise<any>;

interface RunOptions {
    maxTokens?: number;
    temperature?: number;
    systemPrompt?: string;
    tools?: Tool[];
    toolExecutor?: ToolExecutor;
    maxSteps?: number;
    extra?: Record<string, any>;
    forceDirect?: boolean;
    userTier?: string;
    workflow?: string;
    kpiFlags?: Record<string, any>;
    tenantId?: string;
    channel?: string;
}
declare class CascadeAgent {
    private models;
    private qualityValidator;
    private complexityDetector;
    private batchProcessor?;
    private preRouter;
    private toolRouter;
    private toolCallDetector;
    private toolCascadeRouter;
    private toolCascadeValidator;
    private tierRouter?;
    private callbackManager?;
    private domainRouter;
    private domainConfigs;
    private enableDomainDetection;
    private ruleEngine;
    private toolExecutor?;
    constructor(config: AgentConfig);
    private triggerCallback;
    private executeToolCalls;
    private applyRuleModelConstraints;
    private buildRuleContext;
    static fromEnv(options?: {
        quality?: Partial<QualityConfig$1>;
        enableCascade?: boolean;
    }): CascadeAgent;
    static fromProfile(profile: UserProfile, options?: {
        quality?: Partial<QualityConfig$1>;
    }): CascadeAgent;
    static forTier(tier: TierLevel, options?: {
        quality?: Partial<QualityConfig$1>;
    }): CascadeAgent;
    private getDefaultMaxTokens;
    run(input: string | Message[], options?: RunOptions): Promise<CascadeResult>;
    runBatch(queries: string[], batchConfig?: BatchConfig, runOptions?: RunOptions): Promise<BatchResult>;
    runStream(input: string | Message[], options?: StreamOptions): AsyncIterable<StreamEvent>;
    getModels(): ModelConfig[];
    getModelCount(): number;
    runStreaming(query: string, options?: RunStreamingOptions): Promise<CascadeResult>;
    streamEvents(input: string | Message[], options?: StreamEventsOptions): AsyncIterable<StreamEvent>;
    stream(input: string | Message[], options?: StreamOptions): AsyncIterable<StreamEvent>;
    getRouterStats(): {
        preRouter: Record<string, any>;
        toolRouter: Record<string, any>;
        tierRouter?: Record<string, any>;
    };
    resetRouterStats(): void;
}
interface RunStreamingOptions extends RunOptions {
    enableVisual?: boolean;
    complexityHint?: string;
    toolChoice?: any;
}
interface StreamEventsOptions extends RunOptions {
    complexityHint?: string;
    toolChoice?: any;
}

type HarnessMode = 'off' | 'observe' | 'enforce';
type HarnessConfig = {
    mode: HarnessMode;
    verbose: boolean;
    budget?: number;
    maxToolCalls?: number;
    maxLatencyMs?: number;
    maxEnergy?: number;
    kpiTargets?: Record<string, number>;
    kpiWeights?: Record<string, number>;
    compliance?: string;
};
type HarnessInitOptions = Partial<HarnessConfig>;
type HarnessRunOptions = {
    budget?: number;
    maxToolCalls?: number;
    maxLatencyMs?: number;
    maxEnergy?: number;
    kpiTargets?: Record<string, number>;
    kpiWeights?: Record<string, number>;
    compliance?: string;
};
type HarnessInitReport = {
    mode: HarnessMode;
    instrumented: string[];
    detectedButNotInstrumented: string[];
    configSources: Record<string, 'code' | 'env' | 'file' | 'default'>;
};
type HarnessRecordOptions = {
    applied?: boolean;
    decisionMode?: HarnessMode;
};
type HarnessTraceEntry = {
    action: string;
    reason: string;
    model?: string;
    runId: string;
    mode: HarnessMode;
    step: number;
    timestampMs: number;
    toolCallsTotal: number;
    costTotal: number;
    latencyUsedMs: number;
    energyUsed: number;
    budgetState: {
        max?: number;
        remaining?: number;
    };
    applied?: boolean;
    decisionMode?: HarnessMode;
};
type HarnessRunSummary = {
    runId: string;
    mode: HarnessMode;
    stepCount: number;
    toolCalls: number;
    cost: number;
    savings: number;
    latencyUsedMs: number;
    energyUsed: number;
    budgetMax?: number;
    budgetRemaining?: number;
    lastAction: string;
    modelUsed?: string;
    durationMs?: number;
};
declare class HarnessStopError extends Error {
    reason: string;
    constructor(message: string, reason?: string);
}
declare class BudgetExceededError extends HarnessStopError {
    remaining: number;
    constructor(message: string, remaining?: number);
}
declare class HarnessRunContext {
    runId: string;
    startedAtMs: number;
    endedAtMs?: number;
    durationMs?: number;
    mode: HarnessMode;
    budgetMax?: number;
    toolCallsMax?: number;
    latencyMaxMs?: number;
    energyMax?: number;
    kpiTargets?: Record<string, number>;
    kpiWeights?: Record<string, number>;
    compliance?: string;
    cost: number;
    savings: number;
    toolCalls: number;
    stepCount: number;
    latencyUsedMs: number;
    energyUsed: number;
    verbose: boolean;
    budgetRemaining?: number;
    modelUsed?: string;
    lastAction: string;
    draftAccepted?: boolean;
    private readonly _startedMonotonic;
    private readonly _trace;
    private _finalized;
    constructor(config: {
        mode: HarnessMode;
        budgetMax?: number;
        toolCallsMax?: number;
        latencyMaxMs?: number;
        energyMax?: number;
        kpiTargets?: Record<string, number>;
        kpiWeights?: Record<string, number>;
        compliance?: string;
        verbose?: boolean;
    });
    finish(): void;
    record(action: string, reason: string, model?: string, options?: HarnessRecordOptions): void;
    trace(): HarnessTraceEntry[];
    summary(): HarnessRunSummary;
}
declare function getHarnessConfig(): HarnessConfig;
declare function getCurrentRun(): HarnessRunContext | null;
declare function reset(): void;
declare function init(options?: HarnessInitOptions): HarnessInitReport;
type RunCallback<T> = (run: HarnessRunContext) => Promise<T> | T;
declare function run<T>(callback: RunCallback<T>): Promise<T>;
declare function run<T>(options: HarnessRunOptions, callback: RunCallback<T>): Promise<T>;
declare function agent(policy: HarnessRunOptions): <T extends (...args: any[]) => any>(fn: T) => T;
declare const cascadeflow: {
    init: typeof init;
    run: typeof run;
    agent: typeof agent;
    reset: typeof reset;
    getHarnessConfig: typeof getHarnessConfig;
    getCurrentRun: typeof getCurrentRun;
};
declare function isHarnessInstrumented(): boolean;

type EmbeddingService = {
    isAvailable(): Promise<boolean>;
    similarity(text1: string, text2: string): Promise<number | null>;
};
interface SemanticQualityResult {
    similarity: number;
    passed: boolean;
    reason?: string;
    metadata?: Record<string, any>;
}
declare class SemanticQualityChecker {
    private similarityThreshold;
    private useCache;
    private embedder?;
    private cache?;
    private _available;
    private initializeAttempted;
    private initPromise?;
    constructor(similarityThreshold?: number, embedder?: EmbeddingService, useCache?: boolean);
    private initializeEmbedder;
    isAvailable(): Promise<boolean>;
    checkSimilarity(query: string, response: string): Promise<SemanticQualityResult>;
    clearCache(): void;
    getCacheInfo(): any;
}

interface AlignmentAnalysis {
    alignmentScore: number;
    features: {
        baseline?: number;
        keywordCoverage?: number;
        importantCoverage?: number;
        lengthAppropriateness?: number;
        directness?: number;
        explanationDepth?: number;
        answerPattern?: number;
        reasoningChain?: number;
        isMcq?: boolean;
        validMcqResponse?: boolean;
        mcqBoost?: boolean;
        isClassification?: boolean;
        validClassificationResponse?: boolean;
        classificationBoost?: boolean;
        isLongContextQa?: boolean;
        validLongContextResponse?: boolean;
        longContextQaBoost?: boolean;
        isFunctionCall?: boolean;
        validFunctionCallResponse?: boolean;
        functionCallBoost?: boolean;
        isRoleplay?: boolean;
        validRoleplayResponse?: boolean;
        roleplayBoost?: boolean;
        isExtraction?: boolean;
        validExtractionResponse?: boolean;
        extractionBoost?: boolean;
        isMultiTurn?: boolean;
        validMultiTurnResponse?: boolean;
        multiTurnBoost?: boolean;
        isTrivial?: boolean;
        trivialBoost?: boolean;
        offTopicPenalty?: boolean;
        semanticFallback?: boolean;
        semanticScore?: number;
    };
    reasoning: string;
    isTrivial: boolean;
    baselineUsed: number;
}
declare class QueryResponseAlignmentScorer {
    private readonly BASELINE_STANDARD;
    private readonly BASELINE_TRIVIAL;
    private readonly OFF_TOPIC_CAP;
    private readonly SEMANTIC_FALLBACK_LOW;
    private readonly SEMANTIC_FALLBACK_HIGH;
    private useSemanticFallback;
    private getSemanticScoreFn;
    private readonly stopwords;
    private readonly abbreviations;
    private readonly synonyms;
    constructor(options?: {
        useSemanticFallback?: boolean;
        getSemanticScore?: (query: string, response: string) => number | null;
    });
    private extractKeywords;
    private isTrivialQuery;
    private isMcqFormat;
    private isValidMcqResponse;
    private isIntentClassificationFormat;
    private isValidClassificationResponse;
    private isLongContextQaFormat;
    private isValidLongContextResponse;
    private isFunctionCallFormat;
    private isValidFunctionCallResponse;
    private isRoleplayFormat;
    private isValidRoleplayResponse;
    private isExtractionFormat;
    private isValidExtractionResponse;
    private isMultiTurnConversationFormat;
    private isValidMultiTurnResponse;
    private analyzeKeywordCoverageEnhanced;
    private analyzeImportantWords;
    private analyzeLengthAppropriatenessEnhanced;
    private analyzeDirectness;
    private analyzeExplanationDepthCalibrated;
    private detectAnswerPattern;
    private detectReasoningChain;
    private generateReasoning;
    score(query: string, response: string): number;
    score(query: string, response: string, queryDifficulty: number): number;
    score(query: string, response: string, queryDifficulty: number, verbose: true): AlignmentAnalysis;
    score(query: string, response: string, queryDifficulty: number, verbose: false): number;
}

interface ComplexityResult {
    complexity: QueryComplexity;
    confidence: number;
    metadata?: {
        technicalTerms?: string[];
        domains?: Set<string>;
        mathNotation?: string[];
        domainScore?: number;
    };
}
declare class ComplexityDetector {
    private static readonly PHYSICS_TERMS;
    private static readonly MATHEMATICS_TERMS;
    private static readonly CS_TERMS;
    private static readonly ENGINEERING_TERMS;
    private static readonly TRIVIAL_PATTERNS;
    private static readonly TRIVIAL_CONCEPTS;
    private static readonly SIMPLE_KEYWORDS;
    private static readonly MODERATE_KEYWORDS;
    private static readonly HARD_KEYWORDS;
    private static readonly EXPERT_KEYWORDS;
    private static readonly CODE_PATTERNS;
    private allTechnicalTerms;
    constructor();
    detect(query: string, returnMetadata?: boolean): ComplexityResult;
    private detectTechnicalTerms;
    private calculateTechnicalBoost;
    private static readonly FUNCTION_CALL_INDICATORS;
    private isFunctionCallFormat;
    private isLongContextQAFormat;
    private hasTrivialConcepts;
}

interface ProviderCalibration {
    baseMultiplier: number;
    logprobsAvailable: boolean;
    finishReasonBoost: Record<string, number>;
    temperaturePenalty: (temp: number) => number;
    minConfidence: number;
    maxConfidence: number;
}
declare const PROVIDER_CONFIDENCE_CALIBRATION: Record<string, ProviderCalibration>;
interface ConfidenceAnalysis {
    finalConfidence: number;
    logprobsConfidence?: number;
    semanticConfidence: number;
    calibratedConfidence: number;
    components: Record<string, number | string | boolean>;
    methodUsed: 'logprobs' | 'semantic' | 'hybrid' | 'multi-signal-hybrid' | 'multi-signal-semantic';
    queryDifficulty?: number;
    alignmentScore?: number;
    alignmentFloorApplied: boolean;
}
interface ConfidenceEstimationOptions {
    query?: string;
    logprobs?: number[];
    tokens?: string[];
    temperature?: number;
    finishReason?: string;
    queryDifficulty?: number;
    metadata?: Record<string, any>;
}
declare class ProductionConfidenceEstimator {
    private calibration;
    private alignmentScorer;
    constructor(provider?: string);
    estimate(response: string, options?: ConfidenceEstimationOptions): ConfidenceAnalysis;
    private calculateFromLogprobs;
    private analyzeSemanticQuality;
    private applyCalibration;
    private estimateQueryDifficulty;
    explainConfidence(analysis: ConfidenceAnalysis): string;
}

interface LengthAnalysis {
    wordCount: number;
    charCount: number;
    appropriate: boolean;
    tooShort: boolean;
    tooLong: boolean;
    expectedRange: [number, number];
}
interface HedgingAnalysis {
    ratio: number;
    count: number;
    severe: boolean;
    acceptable: boolean;
}
interface SpecificityAnalysis {
    score: number;
    hasNumbers: boolean;
    hasExamples: boolean;
    vaguenessRatio: number;
    meetsRequirement: boolean;
    minRequired: number;
}
interface HallucinationAnalysis {
    suspiciousPatterns: number;
    hasContradiction: boolean;
    riskLevel: 'low' | 'medium' | 'high';
}
declare class ResponseAnalyzer {
    static readonly HEDGING_PHRASES: readonly ["might", "may", "could", "possibly", "perhaps", "maybe", "likely", "probably", "generally", "usually", "typically", "often", "sometimes", "can be", "tends to", "seems to", "appears to", "suggests", "indicates", "implies", "i think", "i believe", "in my opinion", "arguably", "somewhat", "rather", "relatively", "fairly", "quite", "to some extent", "in some cases", "it depends"];
    static readonly UNCERTAINTY_MARKERS: readonly ["i don't know", "i'm not sure", "i cannot", "i can't", "unclear", "uncertain", "not confident", "no information", "don't have", "unable to", "cannot provide", "insufficient", "i apologize", "i'm sorry", "unfortunately", "not able to", "beyond my knowledge", "outside my expertise"];
    static readonly HALLUCINATION_PATTERNS: readonly [RegExp, RegExp, RegExp, RegExp, RegExp];
    analyzeLength(content: string, complexity: QueryComplexity): LengthAnalysis;
    detectHedging(content: string): HedgingAnalysis;
    analyzeSpecificity(content: string, complexity: QueryComplexity): SpecificityAnalysis;
    detectHallucinations(content: string): HallucinationAnalysis;
    analyze(content: string, complexity?: QueryComplexity): {
        length: LengthAnalysis;
        hedging: HedgingAnalysis;
        specificity: SpecificityAnalysis;
        hallucinations: HallucinationAnalysis;
    };
}

interface ProviderRequest {
    messages: Message[] | string;
    model: string;
    maxTokens?: number;
    temperature?: number;
    systemPrompt?: string;
    tools?: Tool[];
    stream?: boolean;
    extra?: Record<string, any>;
}
interface Provider {
    readonly name: string;
    generate(request: ProviderRequest): Promise<ProviderResponse>;
    stream?(request: ProviderRequest): AsyncIterable<StreamChunk>;
    calculateCost(promptTokens: number, completionTokens: number, model: string): number;
    isAvailable(): boolean;
}
declare abstract class BaseProvider implements Provider {
    protected config: ModelConfig;
    abstract readonly name: string;
    constructor(config: ModelConfig);
    abstract generate(request: ProviderRequest): Promise<ProviderResponse>;
    abstract calculateCost(promptTokens: number, completionTokens: number, model: string): number;
    isAvailable(): boolean;
    protected validateConfig(config: ModelConfig): void;
    protected getApiKey(): string;
    protected getBaseUrl(defaultUrl: string): string;
    protected normalizeMessages(input: Message[] | string): Message[];
    protected formatError(error: any): Error;
}
declare class ProviderRegistry {
    private providers;
    register(name: string, provider: new (config: ModelConfig) => Provider): void;
    get(name: string, config: ModelConfig): Provider;
    has(name: string): boolean;
    list(): string[];
}
declare const providerRegistry: ProviderRegistry;
declare function getAvailableProviders(): string[];

declare class OpenAIProvider extends BaseProvider {
    readonly name = "openai";
    private client;
    private useSDK;
    private baseUrl;
    constructor(config: ModelConfig);
    generate(request: ProviderRequest): Promise<ProviderResponse>;
    stream(request: ProviderRequest): AsyncIterable<StreamChunk>;
    private streamWithSDK;
    private streamWithFetch;
    private generateWithSDK;
    private generateWithFetch;
    calculateCost(promptTokens: number, completionTokens: number, model: string, _reasoningTokens?: number): number;
    private convertToChatMessages;
    private convertTools;
}

declare class AnthropicProvider extends BaseProvider {
    readonly name = "anthropic";
    private client;
    private useSDK;
    private baseUrl;
    constructor(config: ModelConfig);
    generate(request: ProviderRequest): Promise<ProviderResponse>;
    stream(request: ProviderRequest): AsyncIterable<StreamChunk>;
    private streamWithSDK;
    private streamWithFetch;
    private generateWithSDK;
    private generateWithFetch;
    calculateCost(promptTokens: number, completionTokens: number, model: string): number;
    private convertToAnthropicMessages;
    private convertTools;
}

declare class GroqProvider extends BaseProvider {
    readonly name = "groq";
    private client;
    private useSDK;
    private baseUrl;
    constructor(config: ModelConfig);
    generate(request: ProviderRequest): Promise<ProviderResponse>;
    stream(request: ProviderRequest): AsyncIterable<StreamChunk>;
    private streamWithSDK;
    private streamWithFetch;
    private generateWithSDK;
    private generateWithFetch;
    calculateCost(promptTokens: number, completionTokens: number, model: string): number;
    private convertToGroqMessages;
    private convertTools;
}

declare class TogetherProvider extends BaseProvider {
    readonly name = "together";
    private baseUrl;
    constructor(config: ModelConfig);
    generate(request: ProviderRequest): Promise<ProviderResponse>;
    calculateCost(promptTokens: number, completionTokens: number, model: string): number;
    private convertToTogetherMessages;
    private convertTools;
}

declare class OllamaProvider extends BaseProvider {
    readonly name = "ollama";
    private baseUrl;
    private timeout;
    constructor(config: ModelConfig);
    generate(request: ProviderRequest): Promise<ProviderResponse>;
    calculateCost(_promptTokens: number, _completionTokens: number, _model: string): number;
    private convertToOllamaMessages;
    private convertTools;
    isAvailable(): boolean;
    protected getApiKey(): string;
    listModels(): Promise<string[]>;
}

declare enum HuggingFaceEndpointType {
    SERVERLESS = "serverless",
    INFERENCE_ENDPOINT = "inference_endpoint",
    INFERENCE_PROVIDERS = "inference_providers"
}
declare class HuggingFaceProvider extends BaseProvider {
    readonly name = "huggingface";
    private baseUrl;
    private endpointType;
    constructor(config: ModelConfig);
    generate(request: ProviderRequest): Promise<ProviderResponse>;
    private generateServerless;
    private generateOpenAICompatible;
    calculateCost(promptTokens: number, completionTokens: number, _model: string): number;
    private convertToHuggingFaceMessages;
    private convertTools;
    private detectEndpointType;
    private getHFBaseUrl;
    protected getApiKey(): string;
    static serverless(config: Omit<ModelConfig, 'provider'>): HuggingFaceProvider;
    static inferenceEndpoint(config: Omit<ModelConfig, 'provider'> & {
        endpointUrl: string;
    }): HuggingFaceProvider;
    static inferenceProviders(config: Omit<ModelConfig, 'provider'> & {
        providerName: string;
    }): HuggingFaceProvider;
}

declare class VLLMProvider extends BaseProvider {
    readonly name = "vllm";
    private baseUrl;
    private timeout;
    constructor(config: ModelConfig);
    generate(request: ProviderRequest): Promise<ProviderResponse>;
    calculateCost(_promptTokens: number, _completionTokens: number, _model: string): number;
    private convertToVLLMMessages;
    private convertTools;
    isAvailable(): boolean;
    protected getApiKey(): string;
    listModels(): Promise<string[]>;
}

declare class OpenRouterProvider extends BaseProvider {
    readonly name = "openrouter";
    private baseUrl;
    private modelCache?;
    private lastCacheFetch;
    private readonly CACHE_TTL;
    constructor(config: ModelConfig);
    generate(request: ProviderRequest): Promise<ProviderResponse>;
    stream(request: ProviderRequest): AsyncIterable<StreamChunk>;
    calculateCost(promptTokens: number, completionTokens: number, model: string): number;
    fetchAvailableModels(): Promise<any[]>;
    getModelPricing(modelId: string): Promise<{
        input: number;
        output: number;
    } | null>;
    private convertToChatMessages;
    private convertTools;
}

declare const VERCEL_AI_PROVIDER_NAMES: readonly string[];
declare function getVercelAiProviderNames(): string[];
declare class VercelAISDKProvider extends BaseProvider {
    readonly name: string;
    private providerSpec;
    private factoryOverride?;
    constructor(config: ModelConfig);
    isAvailable(): boolean;
    generate(request: ProviderRequest): Promise<ProviderResponse>;
    stream(request: ProviderRequest): AsyncIterable<StreamChunk>;
    calculateCost(promptTokens: number, completionTokens: number, _model: string): number;
    private loadModelFactory;
}

type VercelAIProviderId = 'openai' | 'anthropic' | 'google' | 'local' | 'litellm' | 'openrouter' | 'together' | 'groq' | 'mistral' | 'cohere' | 'fireworks' | 'perplexity' | 'deepseek' | 'xai' | 'azure' | 'bedrock' | 'vertex';
type ProviderRole = 'drafter' | 'verifier';
interface ProviderCost {
    input: number;
    output: number;
}
interface ProviderModelSpec {
    id: string;
    label: string;
    cost: ProviderCost;
    contextWindow?: number;
    supportsTools?: boolean;
    speedMs?: number;
}
interface ProviderEndpoint {
    name: string;
    baseUrl: string;
    description?: string;
}
interface ProviderRateLimitPolicy {
    requestsPerMinute?: number;
    tokensPerMinute?: number;
    concurrency?: number;
}
interface ProviderCapabilities {
    streaming: boolean;
    tools: boolean;
}
interface ProviderAdapterConfig {
    id: VercelAIProviderId;
    label: string;
    envKeys: string[];
    defaultBaseUrl?: string;
    endpoints?: ProviderEndpoint[];
    rateLimit: ProviderRateLimitPolicy;
    capabilities: ProviderCapabilities;
    models: ProviderModelSpec[];
}
interface ProviderAdapter extends ProviderAdapterConfig {
    getModel(modelId: string): ProviderModelSpec;
    toModelConfig(modelId: string, overrides?: Partial<ModelConfig>): ModelConfig;
}
interface CascadeStageConfig {
    providerId: VercelAIProviderId;
    model: string;
    role?: ProviderRole;
    overrides?: Partial<ModelConfig>;
}
interface CascadePlan {
    models: ModelConfig[];
    roles: ProviderRole[];
    fallbackOrder: string[];
    estimatedCostPer1k: number;
}

declare class VercelAIProviderRegistry {
    private providers;
    register(provider: ProviderAdapter): void;
    get(providerId: VercelAIProviderId): ProviderAdapter;
    list(): VercelAIProviderId[];
    values(): ProviderAdapter[];
}
declare const vercelAIProviderRegistry: VercelAIProviderRegistry;

declare function buildCascadePlan(stages: CascadeStageConfig[]): CascadePlan;
declare function buildFallbackCascade(primary: CascadeStageConfig, fallbacks: CascadeStageConfig[]): CascadePlan;
declare function createDraftVerifierCascade(drafter: CascadeStageConfig, verifier: CascadeStageConfig, fallbacks?: CascadeStageConfig[]): CascadePlan;

interface RateLimitDecision {
    allowed: boolean;
    retryAfterMs?: number;
}
declare class ProviderRateLimiter {
    private policy;
    private requestTimestamps;
    private tokenTimestamps;
    private inflight;
    constructor(policy: ProviderRateLimitPolicy);
    check(tokens?: number): RateLimitDecision;
    startRequest(tokens?: number): RateLimitDecision;
    endRequest(): void;
}

declare const openAIAdapter: ProviderAdapter;

declare const anthropicAdapter: ProviderAdapter;

declare const googleAdapter: ProviderAdapter;

declare const localAdapter: ProviderAdapter;

declare const liteLLMAdapter: ProviderAdapter;

declare const openRouterAdapter: ProviderAdapter;

declare const togetherAdapter: ProviderAdapter;

declare const groqAdapter: ProviderAdapter;

declare const mistralAdapter: ProviderAdapter;

declare const cohereAdapter: ProviderAdapter;

declare const fireworksAdapter: ProviderAdapter;

declare const perplexityAdapter: ProviderAdapter;

declare const deepseekAdapter: ProviderAdapter;

declare const xaiAdapter: ProviderAdapter;

declare const azureAdapter: ProviderAdapter;

declare const bedrockAdapter: ProviderAdapter;

declare const vertexAdapter: ProviderAdapter;

type VercelAIStreamProtocol = 'data' | 'text';
interface VercelAIChatHandlerOptions {
    protocol?: VercelAIStreamProtocol;
    stream?: boolean;
    systemPrompt?: string;
    maxTokens?: number;
    temperature?: number;
    tools?: Tool[];
    extra?: Record<string, any>;
    toolExecutor?: ToolExecutor;
    toolHandlers?: Record<string, (args: Record<string, any>) => unknown | Promise<unknown>>;
    maxSteps?: number;
    forceDirect?: boolean;
    userTier?: string;
    emitCascadeEvents?: boolean;
    requestOverrides?: {
        enabled?: boolean;
        secret?: string;
        headerName?: string;
        allowedFields?: Array<'forceDirect' | 'maxSteps' | 'userTier'>;
    };
}
declare function createChatHandler(agent: CascadeAgent, options?: VercelAIChatHandlerOptions): (request: Request) => Promise<Response>;
declare function createCompletionHandler(agent: CascadeAgent, options?: VercelAIChatHandlerOptions): (request: Request) => Promise<Response>;

type index_CascadePlan = CascadePlan;
type index_CascadeStageConfig = CascadeStageConfig;
type index_ProviderAdapter = ProviderAdapter;
type index_ProviderAdapterConfig = ProviderAdapterConfig;
type index_ProviderCapabilities = ProviderCapabilities;
type index_ProviderCost = ProviderCost;
type index_ProviderEndpoint = ProviderEndpoint;
type index_ProviderModelSpec = ProviderModelSpec;
type index_ProviderRateLimitPolicy = ProviderRateLimitPolicy;
type index_ProviderRateLimiter = ProviderRateLimiter;
declare const index_ProviderRateLimiter: typeof ProviderRateLimiter;
type index_ProviderRole = ProviderRole;
type index_VercelAIChatHandlerOptions = VercelAIChatHandlerOptions;
type index_VercelAIProviderId = VercelAIProviderId;
type index_VercelAIProviderRegistry = VercelAIProviderRegistry;
declare const index_VercelAIProviderRegistry: typeof VercelAIProviderRegistry;
type index_VercelAIStreamProtocol = VercelAIStreamProtocol;
declare const index_anthropicAdapter: typeof anthropicAdapter;
declare const index_azureAdapter: typeof azureAdapter;
declare const index_bedrockAdapter: typeof bedrockAdapter;
declare const index_buildCascadePlan: typeof buildCascadePlan;
declare const index_buildFallbackCascade: typeof buildFallbackCascade;
declare const index_cohereAdapter: typeof cohereAdapter;
declare const index_createChatHandler: typeof createChatHandler;
declare const index_createCompletionHandler: typeof createCompletionHandler;
declare const index_createDraftVerifierCascade: typeof createDraftVerifierCascade;
declare const index_deepseekAdapter: typeof deepseekAdapter;
declare const index_fireworksAdapter: typeof fireworksAdapter;
declare const index_googleAdapter: typeof googleAdapter;
declare const index_groqAdapter: typeof groqAdapter;
declare const index_liteLLMAdapter: typeof liteLLMAdapter;
declare const index_localAdapter: typeof localAdapter;
declare const index_mistralAdapter: typeof mistralAdapter;
declare const index_openAIAdapter: typeof openAIAdapter;
declare const index_openRouterAdapter: typeof openRouterAdapter;
declare const index_perplexityAdapter: typeof perplexityAdapter;
declare const index_togetherAdapter: typeof togetherAdapter;
declare const index_vercelAIProviderRegistry: typeof vercelAIProviderRegistry;
declare const index_vertexAdapter: typeof vertexAdapter;
declare const index_xaiAdapter: typeof xaiAdapter;
declare namespace index {
  export { type index_CascadePlan as CascadePlan, type index_CascadeStageConfig as CascadeStageConfig, type index_ProviderAdapter as ProviderAdapter, type index_ProviderAdapterConfig as ProviderAdapterConfig, type index_ProviderCapabilities as ProviderCapabilities, type index_ProviderCost as ProviderCost, type index_ProviderEndpoint as ProviderEndpoint, type index_ProviderModelSpec as ProviderModelSpec, type index_ProviderRateLimitPolicy as ProviderRateLimitPolicy, index_ProviderRateLimiter as ProviderRateLimiter, type index_ProviderRole as ProviderRole, type index_VercelAIChatHandlerOptions as VercelAIChatHandlerOptions, type index_VercelAIProviderId as VercelAIProviderId, index_VercelAIProviderRegistry as VercelAIProviderRegistry, type index_VercelAIStreamProtocol as VercelAIStreamProtocol, index_anthropicAdapter as anthropicAdapter, index_azureAdapter as azureAdapter, index_bedrockAdapter as bedrockAdapter, index_buildCascadePlan as buildCascadePlan, index_buildFallbackCascade as buildFallbackCascade, index_cohereAdapter as cohereAdapter, index_createChatHandler as createChatHandler, index_createCompletionHandler as createCompletionHandler, index_createDraftVerifierCascade as createDraftVerifierCascade, index_deepseekAdapter as deepseekAdapter, index_fireworksAdapter as fireworksAdapter, index_googleAdapter as googleAdapter, index_groqAdapter as groqAdapter, index_liteLLMAdapter as liteLLMAdapter, index_localAdapter as localAdapter, index_mistralAdapter as mistralAdapter, index_openAIAdapter as openAIAdapter, index_openRouterAdapter as openRouterAdapter, index_perplexityAdapter as perplexityAdapter, index_togetherAdapter as togetherAdapter, index_vercelAIProviderRegistry as vercelAIProviderRegistry, index_vertexAdapter as vertexAdapter, index_xaiAdapter as xaiAdapter };
}

type QualityMode = 'cost-optimized' | 'balanced' | 'strict';
type PerformanceMode = 'fast' | 'balanced' | 'reliable';
interface PresetConfig {
    quality?: QualityMode;
    performance?: PerformanceMode;
    includePremium?: boolean;
}
declare const PRESET_BEST_OVERALL: {
    models: ModelConfig[];
};
declare const PRESET_ULTRA_FAST: {
    models: ModelConfig[];
};
declare const PRESET_ULTRA_CHEAP: {
    models: ModelConfig[];
};
declare const PRESET_OPENAI_ONLY: {
    models: ModelConfig[];
};
declare const PRESET_ANTHROPIC_ONLY: {
    models: ModelConfig[];
};
declare const PRESET_FREE_LOCAL: {
    models: ModelConfig[];
};
declare function createPreset(config?: PresetConfig): {
    models: ModelConfig[];
    quality?: {
        threshold: number;
        mode: QualityMode;
    };
};
declare const PRESETS: {
    readonly BEST_OVERALL: {
        models: ModelConfig[];
    };
    readonly ULTRA_FAST: {
        models: ModelConfig[];
    };
    readonly ULTRA_CHEAP: {
        models: ModelConfig[];
    };
    readonly OPENAI_ONLY: {
        models: ModelConfig[];
    };
    readonly ANTHROPIC_ONLY: {
        models: ModelConfig[];
    };
    readonly FREE_LOCAL: {
        models: ModelConfig[];
    };
};
type PresetName = keyof typeof PRESETS;

interface ValidationError {
    field: string;
    message: string;
    severity: 'error' | 'warning';
}
interface ValidationResult$1 {
    valid: boolean;
    errors: ValidationError[];
    warnings: ValidationError[];
}
interface ConnectionTestResult {
    provider: Provider$1;
    connected: boolean;
    error?: string;
    latency?: number;
}
declare function validateModel(config: ModelConfig): ValidationResult$1;
declare function validateConfig(config: {
    models: ModelConfig[];
} | CascadeConfig): ValidationResult$1;
declare function testConnection(provider: Provider$1, apiKey?: string): Promise<ConnectionTestResult>;
declare function testConnections(config: {
    models: ModelConfig[];
} | CascadeConfig): Promise<ConnectionTestResult[]>;
declare function validateSetup(config: {
    models: ModelConfig[];
} | CascadeConfig, shouldTestConnections?: boolean): Promise<{
    configValid: boolean;
    errors: ValidationError[];
    warnings: ValidationError[];
    connectionTests?: ConnectionTestResult[];
}>;

declare class cascadeflowError extends Error {
    readonly code: string;
    readonly context?: Record<string, unknown>;
    constructor(message: string, code: string, context?: Record<string, unknown>);
}
declare class ConfigurationError extends cascadeflowError {
    readonly field: string;
    constructor(message: string, field: string, context?: Record<string, unknown>);
}
declare class ProviderError extends cascadeflowError {
    readonly provider: Provider$1;
    readonly statusCode?: number;
    readonly providerCode?: string;
    constructor(message: string, provider: Provider$1, statusCode?: number, context?: Record<string, unknown>, code?: string);
}
declare class AuthenticationError extends ProviderError {
    readonly envVarName: string;
    constructor(message: string, provider: Provider$1, envVarName: string, context?: Record<string, unknown>);
}
declare class RateLimitError$1 extends ProviderError {
    readonly retryAfter?: number;
    constructor(message: string, provider: Provider$1, retryAfter?: number, context?: Record<string, unknown>);
}
declare class QualityValidationError extends cascadeflowError {
    readonly confidence?: number;
    readonly threshold?: number;
    constructor(message: string, confidence?: number, threshold?: number, context?: Record<string, unknown>);
}
declare class TimeoutError extends ProviderError {
    readonly timeoutMs: number;
    constructor(message: string, provider: Provider$1, timeoutMs: number, context?: Record<string, unknown>);
}
declare class ToolExecutionError extends cascadeflowError {
    readonly toolName: string;
    readonly cause?: Error;
    constructor(message: string, toolName: string, cause?: Error, context?: Record<string, unknown>);
}
declare function iscascadeflowError(error: unknown): error is cascadeflowError;
declare function isProviderError(error: unknown): error is ProviderError;
declare function isConfigurationError(error: unknown): error is ConfigurationError;
declare function isAuthenticationError(error: unknown): error is AuthenticationError;
declare function isRateLimitError(error: unknown): error is RateLimitError$1;

declare function validateOptimizationWeights(weights: OptimizationWeights): void;
declare function createOptimizationWeights(cost: number, speed: number, quality: number): OptimizationWeights;
declare function createLatencyProfile(options?: Partial<LatencyProfile>): LatencyProfile;
declare const OPTIMIZATION_PRESETS: Record<CostSensitivity, OptimizationWeights>;
declare const LATENCY_PRESETS: {
    realtime: LatencyProfile;
    interactive: LatencyProfile;
    standard: LatencyProfile;
    batch: LatencyProfile;
};
declare const TIER_PRESETS: Record<TierLevel, TierConfig>;
declare function createUserProfile(tierLevel: TierLevel, userId: string, options?: Partial<Omit<UserProfile, 'userId' | 'tier'>>): UserProfile;
declare class UserProfileManager {
    private cache;
    private cacheTtlMs;
    private loadCallback?;
    private saveCallback?;
    constructor(options?: {
        cacheTtlMs?: number;
        loadProfile?: (userId: string) => Promise<UserProfile | null>;
        saveProfile?: (profile: UserProfile) => Promise<void>;
    });
    getProfile(userId: string): Promise<UserProfile>;
    saveProfile(profile: UserProfile): Promise<void>;
    updateTier(userId: string, newTier: TierLevel): Promise<UserProfile>;
    evictProfile(userId: string): void;
    clearCache(): void;
    getCacheStats(): {
        size: number;
        maxTtlMs: number;
    };
    private cacheProfile;
}
declare function serializeProfile(profile: UserProfile): Record<string, any>;
declare function deserializeProfile(data: Record<string, any>): UserProfile;
declare function getDailyBudget(profile: UserProfile): number | undefined;
declare function getRequestsPerHour(profile: UserProfile): number | undefined;
declare function getRequestsPerDay(profile: UserProfile): number | undefined;
declare function getOptimizationWeights(profile: UserProfile): OptimizationWeights;
declare function getLatencyProfile(profile: UserProfile): LatencyProfile;
declare function createWorkflowProfile(options: WorkflowProfile): WorkflowProfile;
declare function applyWorkflowProfile(baseProfile: UserProfile, workflow: WorkflowProfile): UserProfile;
declare function isModelAllowedByWorkflow(workflow: WorkflowProfile, modelName: string): boolean;
declare const WORKFLOW_PRESETS: Record<string, WorkflowProfile>;

declare class RateLimitError extends Error {
    retryAfterSeconds?: number | undefined;
    limitType?: "hourly" | "daily" | "budget" | undefined;
    constructor(message: string, retryAfterSeconds?: number | undefined, limitType?: "hourly" | "daily" | "budget" | undefined);
}
declare class RateLimiter {
    private states;
    private cleanupIntervalMs;
    private cleanupTimer?;
    constructor(options?: {
        cleanupIntervalMs?: number;
    });
    checkRateLimit(profile: UserProfile, estimatedCost?: number): Promise<void>;
    recordRequest(userId: string, cost?: number): Promise<void>;
    getUsageStats(userId: string, profile: UserProfile): {
        hourly: {
            used: number;
            limit?: number;
        };
        daily: {
            used: number;
            limit?: number;
        };
        cost: {
            used: number;
            limit?: number;
        };
    };
    resetUser(userId: string): void;
    clearAll(): void;
    destroy(): void;
    private getOrCreateState;
    private startCleanup;
}

declare class GuardrailViolation extends Error {
    violations: string[];
    constructor(message: string, violations: string[]);
}
declare class ContentModerator {
    private patterns;
    constructor(strictMode?: boolean);
    check(text: string): ModerationResult;
    checkAsync(text: string): Promise<ModerationResult>;
}
declare class PiiDetector {
    private emailPattern;
    private phonePatterns;
    private ssnPattern;
    private ccPatterns;
    private ipPattern;
    detect(text: string): PiiMatch[];
    redact(text: string): [string, PiiMatch[]];
    detectAsync(text: string): Promise<PiiMatch[]>;
    private luhnCheck;
}
declare class GuardrailsManager {
    private contentModerator;
    private piiDetector;
    constructor();
    checkContent(text: string, profile: UserProfile): Promise<GuardrailsCheck>;
    redactPii(text: string, profile: UserProfile): Promise<[string, PiiMatch[]]>;
}

interface ProviderInfo {
    name: string;
    displayName: string;
    valueProp: string;
    pricingAvailable: boolean;
    requiresApiKey: boolean;
    exampleModels: string[];
}
declare const SUPPORTED_PROVIDERS: Record<string, ProviderInfo>;
declare function validateProvider(provider: string): boolean;
declare function getProviderInfo(provider: string): ProviderInfo | undefined;
interface ModelPricing {
    inputCostPerToken: number;
    outputCostPerToken: number;
    maxTokens: number;
    supportsStreaming: boolean;
}
interface CostCalculationOptions {
    model: string;
    inputTokens?: number;
    outputTokens?: number;
}
declare class LiteLLMCostProvider {
    private fallbackEnabled;
    private readonly roughPricing;
    constructor(options?: {
        fallbackEnabled?: boolean;
    });
    calculateCost(options: CostCalculationOptions): Promise<number>;
    getModelCost(model: string): Promise<ModelPricing>;
    private fallbackCost;
    private fallbackPricing;
}
declare function getModelCost(model: string): Promise<ModelPricing>;
declare function calculateCost(options: CostCalculationOptions): Promise<number>;

interface MetricDimensions {
    userId?: string;
    userTier?: string;
    model?: string;
    provider?: string;
    domain?: string;
}
interface CascadeflowMetrics {
    cost: number;
    tokensInput: number;
    tokensOutput: number;
    latencyMs: number;
    dimensions?: MetricDimensions;
}
interface OpenTelemetryExporterConfig {
    endpoint?: string;
    serviceName?: string;
    environment?: string;
    enabled?: boolean;
    exportIntervalMs?: number;
}
declare class OpenTelemetryExporter {
    private enabled;
    private serviceName;
    private environment;
    private endpoint?;
    private exportIntervalMs;
    private meter;
    private metrics;
    private initialized;
    constructor(config?: OpenTelemetryExporterConfig);
    private dynamicImport;
    private initializeOtel;
    record(metrics: CascadeflowMetrics): void;
    flush(): Promise<void>;
    shutdown(): Promise<void>;
    isEnabled(): boolean;
    getEndpoint(): string | undefined;
    getServiceName(): string;
}
declare function createExporterFromEnv(): OpenTelemetryExporter | null;

interface CostCalculationFromTokensOptions {
    draftOutputTokens: number;
    verifierOutputTokens: number;
    queryInputTokens?: number;
    draftAccepted: boolean;
    draftModel: string;
    verifierModel: string;
    draftProvider?: string;
    verifierProvider?: string;
}
declare class CostCalculator {
    calculate(result: CascadeResult, queryText?: string): CostBreakdown;
    calculateFromTokens(options: CostCalculationFromTokensOptions): Promise<CostBreakdown>;
    static estimateTokens(text: string): number;
    private _calculateAcceptedCosts;
    private _calculateRejectedCosts;
    private _formatModelName;
}
declare function calculateCascadeCost(result: CascadeResult, queryText?: string): CostBreakdown;

interface MetricsSnapshot {
    totalQueries: number;
    totalCost: number;
    avgLatencyMs: number;
    byComplexity: Record<string, number>;
    byStrategy: Record<string, number>;
    acceptanceRate: number;
    avgSpeedup: number;
    qualityMean?: number;
    qualityMedian?: number;
    qualityMin?: number;
    qualityMax?: number;
    avgDraftMs?: number;
    avgVerificationMs?: number;
    p95DraftMs?: number;
    p95VerificationMs?: number;
    toolQueries: number;
    totalToolCalls: number;
    avgToolsPerQuery: number;
    timestamp: string;
}
declare class MetricsCollector {
    private maxRecentResults;
    private verbose;
    private startTime;
    private stats;
    private qualityScores;
    private acceptanceByComplexity;
    private timingByComponent;
    private recentResults;
    constructor(options?: {
        maxRecentResults?: number;
        verbose?: boolean;
    });
    get uptimeSeconds(): number;
    record(result: CascadeResult | null, routingStrategy: 'cascade' | 'direct', complexity: string, timingBreakdown?: Record<string, number>, streaming?: boolean, hasTools?: boolean): void;
    getSummary(): Record<string, any>;
    getSnapshot(): MetricsSnapshot;
    reset(): void;
    printSummary(): void;
    private mean;
    private median;
    private stdev;
    private percentile;
    private calculateAvgSpeedup;
}

declare enum ErrorType {
    RATE_LIMIT = "rate_limit",
    TIMEOUT = "timeout",
    SERVER_ERROR = "server_error",
    AUTH_ERROR = "auth_error",
    NOT_FOUND = "not_found",
    BAD_REQUEST = "bad_request",
    NETWORK_ERROR = "network_error",
    UNKNOWN = "unknown"
}
interface RetryConfig {
    maxAttempts: number;
    initialDelay: number;
    maxDelay: number;
    exponentialBase: number;
    jitter: boolean;
    rateLimitBackoff: number;
    retryableErrors: ErrorType[];
}
declare const DEFAULT_RETRY_CONFIG: RetryConfig;
interface RetryMetrics {
    totalAttempts: number;
    successfulAttempts: number;
    failedAttempts: number;
    retriesByError: Record<string, number>;
    totalRetryDelay: number;
}
interface RetryMetricsSummary {
    totalAttempts: number;
    successful: number;
    failed: number;
    successRate: string;
    totalRetryDelaySec: number;
    retriesByError: Record<string, number>;
}
declare class RetryManager {
    private config;
    private metrics;
    constructor(config?: Partial<RetryConfig>);
    classifyError(error: unknown): ErrorType;
    calculateDelay(attempt: number, errorType: ErrorType): number;
    shouldRetry(errorType: ErrorType, attempt: number): boolean;
    executeWithRetry<T>(fn: () => Promise<T>, context?: string): Promise<T>;
    getMetricsSummary(): RetryMetricsSummary;
    resetMetrics(): void;
    getMetrics(): RetryMetrics;
    getConfig(): RetryConfig;
    private sleep;
}
declare function createRetryManager(config?: Partial<RetryConfig>): RetryManager;

interface CacheStats {
    hits: number;
    misses: number;
    sets: number;
    evictions: number;
    size: number;
    maxSize: number;
    hitRate: number;
}
interface ResponseCacheConfig {
    maxSize?: number;
    defaultTtl?: number;
}
interface CacheSetOptions {
    model?: string;
    params?: Record<string, any>;
    ttl?: number;
}
interface CacheGetOptions {
    model?: string;
    params?: Record<string, any>;
}
declare class ResponseCache {
    private maxSize;
    private defaultTtl;
    private cache;
    private stats;
    constructor(config?: ResponseCacheConfig);
    generateKey(query: string, model?: string, params?: Record<string, any>): string;
    get(query: string, options?: CacheGetOptions): Record<string, any> | undefined;
    set(query: string, response: Record<string, any>, options?: CacheSetOptions): void;
    clear(): void;
    getStats(): CacheStats;
    resetStats(): void;
    getConfig(): ResponseCacheConfig;
    removeExpired(): number;
    has(query: string, options?: CacheGetOptions): boolean;
}
declare function createResponseCache(config?: ResponseCacheConfig): ResponseCache;

interface PreRouterConfig {
    enableCascade?: boolean;
    complexityDetector?: ComplexityDetector;
    cascadeComplexities?: QueryComplexity[];
    verbose?: boolean;
}
interface PreRouterStats {
    totalQueries: number;
    byComplexity: Record<string, number>;
    byStrategy: Record<string, number>;
    cascadeRate: string;
    directRate: string;
    forcedDirect: number;
    cascadeDisabledCount: number;
}
declare class PreRouter extends Router {
    private enableCascade;
    private detector;
    private cascadeComplexities;
    private verbose;
    private stats;
    constructor(config?: PreRouterConfig);
    route(query: string, context?: Record<string, any>): Promise<RoutingDecision>;
    getStats(): PreRouterStats;
    resetStats(): void;
    printStats(): void;
    private isValidComplexity;
}
declare function createPreRouter(config?: PreRouterConfig): PreRouter;

interface ToolFilterResult {
    models: ModelConfig[];
    filteredCount: number;
    hasCapableModels: boolean;
    reason: string;
}
interface ToolValidationResult {
    valid: boolean;
    errors: string[];
    warnings: string[];
}
interface ToolRouterStats {
    totalFilters: number;
    filterHits: number;
    noCapableModels: number;
    avgModelsBeforeFilter: number;
    avgModelsAfterFilter: number;
    toolCapableModels: number;
    totalModels: number;
    toolCapabilityRate: number;
}
interface ToolRouterConfig {
    models: ModelConfig[];
    verbose?: boolean;
}
interface FilterToolCapableModelsOptions {
    tools?: Tool[];
    availableModels: ModelConfig[];
}
interface SuggestModelsOptions {
    tools: Tool[];
    maxCost?: number;
}
declare class ToolRouter {
    private models;
    private verbose;
    private toolCapableModels;
    private stats;
    constructor(config: ToolRouterConfig);
    filterToolCapableModels(options: FilterToolCapableModelsOptions): ToolFilterResult;
    validateTools(tools: Tool[]): ToolValidationResult;
    suggestModelsForTools(options: SuggestModelsOptions): ModelConfig[];
    getStats(): ToolRouterStats;
    resetStats(): void;
    getToolCapableModels(): ModelConfig[];
}
declare function createToolRouter(config: ToolRouterConfig): ToolRouter;

type DetectionLayer = 'explicit' | 'structured' | 'heuristic' | 'fallback';
interface ToolCallIntent {
    shouldCallTool: boolean;
    confidence: number;
    layers: DetectionLayer[];
    reasons: string[];
    toolHints: string[];
    rawToolCalls?: ToolCall$1[];
}
type RiskTier = 'low' | 'medium' | 'high' | 'critical';
type ToolComplexityLevel = 'trivial' | 'simple' | 'moderate' | 'hard' | 'expert';
interface ToolComplexityAnalysis {
    complexityLevel: ToolComplexityLevel;
    score: number;
    signals?: Record<string, boolean>;
    reasoning?: string[];
}
interface ToolComplexityAnalyzerLike {
    analyzeToolCall(query: string, tools: Tool[], context?: Record<string, unknown>): ToolComplexityAnalysis;
}
type ToolRoutingStrategy = 'cascade' | 'direct' | 'skip';
interface ToolRoutingDecision {
    strategy: ToolRoutingStrategy;
    complexity: ToolComplexityAnalysis;
    risk: RiskTier;
    reasons: string[];
}
interface ToolCascadeContext {
    query: string;
    tools: Tool[];
    messages?: Message[];
    toolCalls?: ToolCall$1[];
}
interface ToolCascadeFeedback {
    attempt: number;
    issues: string[];
    warnings: string[];
    strategy: ToolRoutingStrategy;
}
type ToolCallGenerator = (context: ToolCascadeContext, feedback?: ToolCascadeFeedback) => Promise<ToolCall$1[]> | ToolCall$1[];
interface StructuralValidationResult {
    isValid: boolean;
    score: number;
    issues: string[];
}
interface SemanticValidationResult {
    isValid: boolean;
    score: number;
    issues: string[];
}
interface SafetyValidationResult {
    isValid: boolean;
    score: number;
    issues: string[];
    flaggedFields: string[];
}
interface ValidationResult {
    valid: boolean;
    score: number;
    errors: string[];
    warnings: string[];
    structural: StructuralValidationResult;
    semantic: SemanticValidationResult;
    safety: SafetyValidationResult;
}
interface ToolCascadeResult {
    accepted: boolean;
    attempts: number;
    intent: ToolCallIntent;
    decision: ToolRoutingDecision;
    validation: ValidationResult;
    toolCalls: ToolCall$1[];
}
interface ToolCascadeOptions {
    maxRetries?: number;
    allowUnsafe?: boolean;
    complexityAnalyzer?: ToolComplexityAnalyzerLike;
}

interface ToolCallDetectionInput {
    query?: string;
    toolCalls?: Record<string, unknown>[];
    tools?: Tool[];
}
declare class ToolCallDetector {
    detect(input: ToolCallDetectionInput): ToolCallIntent;
    private calculateConfidence;
}

declare class ToolCascadeRouter {
    private analyzer;
    constructor(analyzer?: ToolComplexityAnalyzerLike);
    route(context: ToolCascadeContext, intentScore: number): ToolRoutingDecision;
    calculateOverallRisk(tools: Tool[]): RiskTier;
    classifyRiskTier(tool: Tool): RiskTier;
}

declare class ToolCascadeValidator {
    private toolValidator;
    private router;
    constructor(options?: {
        toolValidator?: ToolValidator;
        router?: ToolCascadeRouter;
    });
    validate(toolCalls: ToolCall$1[], tools: Tool[], complexityLevel?: ToolComplexityLevel): ValidationResult;
    private validateStructural;
    private validateSemantic;
    private validateSafety;
}

declare class ToolCascade {
    private detector;
    private router;
    private validator;
    private maxRetries;
    private allowUnsafe;
    constructor(options?: ToolCascadeOptions);
    execute(context: ToolCascadeContext, generator: ToolCallGenerator): Promise<ToolCascadeResult>;
    private buildResult;
}

interface ModelRegistryEntry extends ModelConfig {
    aliases?: string[];
    domains?: string[];
    contextWindow?: number;
    supportsTools?: boolean;
    supportsStreaming?: boolean;
    supportsVision?: boolean;
    releaseDate?: string;
    deprecated?: string;
}
declare class ModelRegistry {
    private models;
    private aliases;
    constructor();
    private registerInternal;
    register(name: string, config: ModelRegistryEntry): void;
    get(name: string): ModelRegistryEntry;
    has(name: string): boolean;
    getOrUndefined(name: string): ModelRegistryEntry | undefined;
    listModels(): string[];
    listByProvider(provider: string): string[];
    listByDomain(domain: string): string[];
    listWithToolSupport(): string[];
    getCheapest(options?: {
        maxCost?: number;
        supportsTools?: boolean;
        supportsStreaming?: boolean;
        provider?: string;
    }): ModelRegistryEntry | undefined;
    resolve(nameOrConfig: string | ModelRegistryEntry): ModelRegistryEntry;
    static fromObject(models: Record<string, ModelRegistryEntry>): ModelRegistry;
    toObject(): Record<string, ModelRegistryEntry>;
}
declare const defaultModelRegistry: ModelRegistry;
declare function getModel(name: string): ModelRegistryEntry;
declare function hasModel(name: string): boolean;

declare const VERSION = "1.0.0";

export { type AgentConfig, type AlignmentAnalysis, AnthropicProvider, AuthenticationError, BUILTIN_DOMAIN_CONFIGS, BUILT_IN_STRATEGIES, type BatchConfig, type BatchItemResult, BatchProcessingError, BatchProcessor, type BatchResult, BatchStrategy, BudgetExceededError, CASCADE_QUALITY_CONFIG, type CacheGetOptions, type CacheSetOptions, type CacheStats, type CallbackData, CallbackEvent, type CallbackFunction, CallbackManager, type CallbackStats, CascadeAgent, type CascadeConfig, type CascadeExecutionResult, type CascadePlan, type CascadeResult, type CascadeStageConfig, type CascadeStep, type CascadeflowMetrics, ComplexityDetector, type ComplexityLevel, type ComplexityResult, type ConfidenceAnalysis, type ConfidenceEstimationOptions, ConfigurationError, type ConnectionTestResult, ContentModerator, type CostBreakdown, type CostCalculationFromTokensOptions, type CostCalculationOptions, CostCalculator, type CostSensitivity, DEFAULT_BATCH_CONFIG, DEFAULT_CASCADE_CONFIG, DEFAULT_DOMAIN_CONFIG, DEFAULT_QUALITY_CONFIG, DEFAULT_QUALITY_CONFIG$1 as DEFAULT_QUALITY_VALIDATOR_CONFIG, DEFAULT_RETRY_CONFIG, type DetectionLayer, Domain, type DomainCascadeStrategy, type DomainConfig, type DomainConfigMap, type DomainDetectionResult, type DomainKeywords, DomainRouter, type DomainRouterStats, type DomainValidationMethod, ErrorType, type FilterModelsOptions, type FilterToolCapableModelsOptions, GroqProvider, GuardrailViolation, type GuardrailsCheck, GuardrailsManager, type HallucinationAnalysis, type HarnessConfig, type HarnessInitOptions, type HarnessInitReport, type HarnessMode, type HarnessRecordOptions, HarnessRunContext, type HarnessRunOptions, type HarnessRunSummary, HarnessStopError, type HarnessTraceEntry, type HedgingAnalysis, HuggingFaceEndpointType, HuggingFaceProvider, LATENCY_PRESETS, type LatencyProfile, type RoutingStrategy$1 as LegacyRoutingStrategy, type LengthAnalysis, LiteLLMCostProvider, type Message, type MessageRole, type MetricDimensions, MetricsCollector, type MetricsSnapshot, type ModelConfig, type ModelPricing, ModelRegistry, type ModelRegistryEntry, type ModerationResult, OPTIMIZATION_PRESETS, OllamaProvider, OpenAIProvider, OpenRouterProvider, OpenTelemetryExporter, type OpenTelemetryExporterConfig, type OptimizationWeights, PRESETS, PRESET_ANTHROPIC_ONLY, PRESET_BEST_OVERALL, PRESET_FREE_LOCAL, PRESET_OPENAI_ONLY, PRESET_ULTRA_CHEAP, PRESET_ULTRA_FAST, PROVIDER_CONFIDENCE_CALIBRATION, type PerformanceMode, PiiDetector, type PiiMatch, PreRouter, type PreRouterConfig, type PreRouterStats, type PresetConfig, type PresetName, ProductionConfidenceEstimator, type Provider, type ProviderAdapter, type ProviderAdapterConfig, type ProviderCalibration, type ProviderCapabilities, type ProviderCost, type ProviderEndpoint, ProviderError, type ProviderInfo, type ProviderModelSpec, type ProviderRateLimitPolicy, ProviderRateLimiter, type ProviderRequest, type ProviderResponse, type ProviderRole, type Provider$1 as ProviderType, type QualityConfig, QualityConfigFactory, type QualityMode, type QualityResult, type QualityValidation, QualityValidationError, QualityValidator, type QualityConfig$1 as QualityValidatorConfig, type QueryComplexity, QueryResponseAlignmentScorer, RateLimitError$1 as RateLimitError, RateLimitError as RateLimitErrorV2, type RateLimitState, RateLimiter, ResponseAnalyzer, ResponseCache, type ResponseCacheConfig, type RetryConfig, RetryManager, type RetryMetrics, type RetryMetricsSummary, type RiskTier, Router, RouterChain, type RoutingDecision, RoutingDecisionHelper, RoutingStrategy, type RuleContext, type RuleDecision, type RuleDecisionLike, RuleEngine, type RuleEngineConfig, type RunOptions, type RunStreamingOptions, SUPPORTED_PROVIDERS, SemanticQualityChecker, type SemanticQualityResult, type SpecificityAnalysis, type StepResult, StepStatus, type StreamChunk, type StreamEvent, type StreamEventData, StreamEventType, type StreamEventsOptions, type StreamOptions, type SuggestModelsOptions, TIER_PRESETS, type TierAwareRouterConfig, type TierConfig, type TierConstraints, type TierLevel, TierRouter, type TierRouterConfig, type TierRouterStats, TimeoutError, type TimingBreakdown, TogetherProvider, type Tool, ToolCall, ToolCallDetector, ToolCallFormat, type ToolCallGenerator, type ToolCallIntent, type ToolCallOptions, ToolCascade, type ToolCascadeContext, type ToolCascadeFeedback, type ToolCascadeOptions, type ToolCascadeResult, ToolCascadeRouter, type ValidationResult as ToolCascadeValidationResult, ToolCascadeValidator, type ToolComplexityAnalysis, type ToolComplexityAnalyzerLike, type ToolComplexityLevel, ToolConfig, type ToolConfigOptions, ToolExecutionError, ToolExecutor, type ToolFilterResult, type ToolFunction, type ToolParameters, type ToolQualityScore, ToolResult, type ToolResultOptions, ToolRouter, type ToolRouterConfig, type ToolRouterStats, type ToolRoutingDecision, type ToolRoutingStrategy, type ToolValidationResult, ToolValidator, type UserProfile, UserProfileManager, VERCEL_AI_PROVIDER_NAMES, VERSION, VLLMProvider, type ValidationError, ValidationMethod, type ValidationResult$1 as ValidationResult, index as VercelAI, type VercelAIProviderId, VercelAIProviderRegistry, VercelAISDKProvider, WORKFLOW_PRESETS, type WorkflowProfile, anthropicAdapter, applyWorkflowProfile, azureAdapter, bedrockAdapter, buildCascadePlan, buildFallbackCascade, buildParameterSchema, calculateCascadeCost, calculateConfidenceFromLogprobs, calculateCost, cascadeflow, cascadeflowError, cohereAdapter, collectResult, collectStream, createCascadeStep, createDomainConfig, createDomainRouter, createDraftVerifierCascade, createExporterFromEnv, createLatencyProfile, createOptimizationWeights, createPreRouter, createPreset, createResponseCache, createRetryManager, createStreamEvent, createTierRouter, createTool, createToolRouter, createUserProfile, createWorkflowProfile, deepseekAdapter, defaultModelRegistry, deserializeProfile, domainValidationToMethod, estimateConfidenceFromContent, fireworksAdapter, formatToolQualityScore, getAvailableProviders, getBuiltinDomainConfig, getCodeStrategy, getCostBreakdown, getCurrentRun, getDailyBudget, getDataStrategy, getFallbackSteps, getGeneralStrategy, getHarnessConfig, getLatencyProfile, getMathStrategy, getMedicalStrategy, getModel, getModelCost, getOptimizationWeights, getProviderFormatType, getProviderInfo, getRequestsPerDay, getRequestsPerHour, getStepByName, getStepResult, getStrategyForDomain, getStructuredStrategy, getSuccessfulSteps, getVercelAiProviderNames, googleAdapter, groqAdapter, agent as harnessAgent, hasModel, inferJsonType, init, isAuthenticationError, isChunkEvent, isCompleteEvent, isConfigurationError, isErrorEvent, isHarnessInstrumented, isModelAllowedByWorkflow, isProviderError, isRateLimitError, iscascadeflowError, listAvailableStrategies, liteLLMAdapter, localAdapter, mistralAdapter, normalizeBatchConfig, openAIAdapter, openRouterAdapter, perplexityAdapter, providerRegistry, reset as resetHarness, resultToObject, run, serializeProfile, testConnection, testConnections, toAnthropicFormat, toOllamaFormat, toOpenAIFormat, toProviderFormat, togetherAdapter, tool, validateConfig, validateDomainConfig, validateModel, validateModelConfig, validateOptimizationWeights, validateProvider, validateSetup, validationMethodToDomain, vercelAIProviderRegistry, vertexAdapter, xaiAdapter };