/**
 * Model-related type definitions for NeuroLink
 * Consolidates all model configuration, dynamic model, and provider model types
 */
import { z } from "zod";
import type { JsonValue } from "./common.js";
import { AIProviderName } from "../constants/enums.js";
import type { TaskType } from "./taskClassification.js";
/**
 * Model performance tier definition
 */
export type ModelTier = "fast" | "balanced" | "quality";
/**
 * Model configuration source type
 */
export type ConfigSource = "default" | "environment" | "file" | "dynamic";
/**
 * Model configuration for a specific provider
 */
export type ModelConfig = {
    /** Model identifier */
    id: string;
    /** Display name */
    name: string;
    /** Performance tier */
    tier: ModelTier;
    /** Cost per 1K tokens */
    cost: {
        input: number;
        output: number;
    };
    /** Model capabilities */
    capabilities: string[];
    /** Model-specific options */
    options?: Record<string, JsonValue>;
};
/**
 * Provider configuration for model management
 */
export type ProviderConfiguration = {
    /** Provider name */
    provider: string;
    /** Available models by tier */
    models: Record<ModelTier, string>;
    /** Default cost per token (fallback) */
    defaultCost: {
        input: number;
        output: number;
    };
    /** Required environment variables */
    requiredEnvVars: string[];
    /** Provider-specific performance metrics */
    performance: {
        speed: number;
        quality: number;
        cost: number;
    };
    /** Provider-specific model configurations */
    modelConfigs?: Record<string, ModelConfig>;
    /** Provider-specific model behavior configurations */
    modelBehavior?: {
        /** Models that have issues with maxTokens parameter */
        maxTokensIssues?: string[];
        /** Models that require special handling */
        specialHandling?: Record<string, JsonValue>;
        /** Models that support tool calling (Ollama-specific) */
        toolCapableModels?: string[];
    };
};
/**
 * Zod schema for model configuration validation
 */
export declare const ModelConfigSchema: z.ZodObject<{
    id: z.ZodString;
    displayName: z.ZodString;
    capabilities: z.ZodArray<z.ZodString>;
    deprecated: z.ZodBoolean;
    pricing: z.ZodObject<{
        input: z.ZodNumber;
        output: z.ZodNumber;
    }, z.core.$strip>;
    contextWindow: z.ZodNumber;
    releaseDate: z.ZodString;
}, z.core.$strip>;
/**
 * Zod schema for model registry validation
 */
export declare const ModelRegistrySchema: z.ZodObject<{
    version: z.ZodString;
    lastUpdated: z.ZodString;
    models: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
        id: z.ZodString;
        displayName: z.ZodString;
        capabilities: z.ZodArray<z.ZodString>;
        deprecated: z.ZodBoolean;
        pricing: z.ZodObject<{
            input: z.ZodNumber;
            output: z.ZodNumber;
        }, z.core.$strip>;
        contextWindow: z.ZodNumber;
        releaseDate: z.ZodString;
    }, z.core.$strip>>>;
    aliases: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    defaults: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
}, z.core.$strip>;
/**
 * Dynamic model configuration type
 */
export type DynamicModelConfig = z.infer<typeof ModelConfigSchema>;
/**
 * Dynamic model registry type
 */
export type ModelRegistry = z.infer<typeof ModelRegistrySchema>;
/**
 * Model capabilities interface
 */
export type ModelCapabilities = {
    vision: boolean;
    functionCalling: boolean;
    codeGeneration: boolean;
    reasoning: boolean;
    multimodal: boolean;
    streaming: boolean;
    jsonMode: boolean;
};
/**
 * Model pricing information
 */
export type ModelPricingInfo = {
    inputCostPer1K: number;
    outputCostPer1K: number;
    currency: string;
};
/**
 * Model performance characteristics
 */
export type ModelPerformance = {
    speed: "fast" | "medium" | "slow";
    quality: "high" | "medium" | "low";
    accuracy: "high" | "medium" | "low";
};
/**
 * Model limitations and constraints
 */
export type ModelLimits = {
    maxContextTokens: number;
    maxOutputTokens: number;
    maxRequestsPerMinute?: number;
    maxRequestsPerDay?: number;
};
/**
 * Use case suitability scores (1-10 scale)
 */
export type UseCaseSuitability = {
    coding: number;
    creative: number;
    analysis: number;
    conversation: number;
    reasoning: number;
    translation: number;
    summarization: number;
};
/**
 * Complete model information
 */
export type ModelInfo = {
    id: string;
    name: string;
    provider: AIProviderName;
    description: string;
    capabilities: ModelCapabilities;
    pricing: ModelPricingInfo;
    performance: ModelPerformance;
    limits: ModelLimits;
    useCases: UseCaseSuitability;
    aliases: string[];
    deprecated: boolean;
    isLocal: boolean;
    releaseDate?: string;
    category: "general" | "coding" | "creative" | "vision" | "reasoning";
};
/**
 * Model search filters
 */
export type ModelSearchFilters = {
    provider?: AIProviderName | AIProviderName[];
    capability?: keyof ModelCapabilities | (keyof ModelCapabilities)[];
    useCase?: keyof UseCaseSuitability;
    maxCost?: number;
    minContextSize?: number;
    maxContextSize?: number;
    performance?: ModelPerformance["speed"] | ModelPerformance["quality"];
    category?: ModelInfo["category"] | ModelInfo["category"][];
};
/**
 * Model search result with ranking
 */
export type ModelSearchResult = {
    model: ModelInfo;
    score: number;
    matchReasons: string[];
};
/**
 * Model recommendation context
 */
export type RecommendationContext = {
    useCase?: keyof UseCaseSuitability;
    maxCost?: number;
    minQuality?: "low" | "medium" | "high";
    requireCapabilities?: (keyof ModelCapabilities)[];
    excludeProviders?: AIProviderName[];
    contextSize?: number;
    preferLocal?: boolean;
};
/**
 * Model recommendation result
 */
export type ModelRecommendation = {
    model: ModelInfo;
    score: number;
    reasoning: string[];
    alternatives: ModelInfo[];
};
/**
 * Model comparison result
 */
export type ModelComparison = {
    models: ModelInfo[];
    comparison: {
        capabilities: Record<keyof ModelCapabilities, ModelInfo[]>;
        pricing: {
            cheapest: ModelInfo;
            mostExpensive: ModelInfo;
        };
        performance: Record<string, ModelInfo[]>;
        contextSize: {
            largest: ModelInfo;
            smallest: ModelInfo;
        };
    };
};
export type ModelRoute = {
    provider: string;
    model: string;
    reasoning: string;
    confidence: number;
};
export type ModelRoutingOptions = {
    /** Override the task classification */
    forceTaskType?: TaskType;
    /** Require specific performance characteristics */
    requireFast?: boolean;
    /** Require specific capability (reasoning, creativity, etc.) */
    requireCapability?: string;
    /** Fallback strategy if primary choice fails */
    fallbackStrategy?: "fast" | "reasoning" | "auto";
};
