llm-core/dist/index.d.ts

A unified TypeScript/JavaScript package providing a single interface for multiple LLM providers (OpenAI, Claude, Groq, Grok). Eliminate vendor lock-in with seamless provider switching, consistent responses, and built-in cost tracking.

type ProviderName = "openai" | "claude" | "groq" | "grok";
interface BaseProviderConfig {
    apiKey: string;
    baseURL?: string;
    timeout?: number;
    retries?: number;
    defaultModel?: string;
    [key: string]: unknown;
}
interface OpenAIConfig extends BaseProviderConfig {
    organization?: string;
    project?: string;
}
interface ClaudeConfig extends BaseProviderConfig {
    version?: string;
}
interface GroqConfig extends BaseProviderConfig {
}
interface GrokConfig extends BaseProviderConfig {
}
type ProviderConfig = OpenAIConfig | ClaudeConfig | GroqConfig | GrokConfig;
interface ProviderConfigMap {
    openai?: OpenAIConfig;
    claude?: ClaudeConfig;
    groq?: GroqConfig;
    grok?: GrokConfig;
}
type OpenAIModel = "gpt-4" | "gpt-4-turbo-preview" | "gpt-4-0125-preview" | "gpt-4o" | "gpt-4o-mini" | "gpt-3.5-turbo" | "gpt-3.5-turbo-16k";
type ClaudeModel = "claude-3-5-sonnet-20241022" | "claude-3-opus-20240229" | "claude-3-sonnet-20240229" | "claude-3-haiku-20240307";
type GroqModel = "llama-3.1-70b-versatile" | "llama-3.1-8b-instant" | "mixtral-8x7b-32768" | "gemma-7b-it" | "gemma2-9b-it";
type GrokModel = "grok-beta" | "grok-vision-beta";
type ModelName = OpenAIModel | ClaudeModel | GroqModel | GrokModel;
interface ProviderModels {
    openai: OpenAIModel[];
    claude: ClaudeModel[];
    groq: GroqModel[];
    grok: GrokModel[];
}
interface ProviderCapabilities {
    streaming: boolean;
    vision: boolean;
    tools: boolean;
    systemMessages: boolean;
    maxTokens: number;
    maxContextLength: number;
}
interface ProviderInfo {
    name: ProviderName;
    displayName: string;
    description: string;
    website: string;
    capabilities: ProviderCapabilities;
    models: ModelName[];
}
type ProviderStatus = "active" | "inactive" | "error" | "rate_limited";
interface ProviderHealth {
    status: ProviderStatus;
    latency?: number;
    lastCheck: Date;
    error?: string;
}

type MessageRole = "system" | "user" | "assistant" | "tool";
interface BaseMessage {
    role: MessageRole;
    content: string;
    name?: string;
    timestamp?: Date;
}
interface SystemMessage extends BaseMessage {
    role: "system";
}
interface UserMessage extends BaseMessage {
    role: "user";
    attachments?: MessageAttachment[];
}
interface AssistantMessage extends BaseMessage {
    role: "assistant";
    toolCalls?: ToolCall[];
    finishReason?: FinishReason;
}
interface ToolMessage extends BaseMessage {
    role: "tool";
    toolCallId: string;
}
type Message = SystemMessage | UserMessage | AssistantMessage | ToolMessage;
interface MessageAttachment {
    type: "image" | "file" | "audio" | "video";
    url?: string;
    data?: string;
    mimeType?: string;
    filename?: string;
    size?: number;
}
interface ToolCall {
    id: string;
    type: "function";
    function: {
        name: string;
        arguments: string;
    };
}
interface FunctionTool {
    type: "function";
    function: {
        name: string;
        description?: string;
        parameters: Record<string, unknown>;
    };
}
type Tool = FunctionTool;
type FinishReason = "stop" | "length" | "tool_calls" | "content_filter" | "error";
interface ConversationMetadata {
    id?: string;
    title?: string;
    createdAt?: Date;
    updatedAt?: Date;
    tags?: string[];
    customData?: Record<string, unknown>;
}
interface MessageContext {
    conversationId?: string;
    parentMessageId?: string;
    threadId?: string;
    metadata?: Record<string, unknown>;
}
type ContextualMessage = Message & {
    id?: string;
    context?: MessageContext;
};
interface Conversation {
    id: string;
    messages: ContextualMessage[];
    metadata?: ConversationMetadata;
    totalTokens?: number;
    cost?: number;
}
interface MessageValidation {
    isValid: boolean;
    errors: string[];
    warnings: string[];
}

interface LLMCoreConfig {
    providers: ProviderConfigMap;
    defaultProvider?: ProviderName;
    globalSettings?: GlobalSettings;
    features?: FeatureConfig;
    logging?: LoggingConfig;
    analytics?: AnalyticsConfig;
    cache?: CacheConfig;
    rateLimiting?: RateLimitConfig;
}
interface GlobalSettings {
    timeout?: number;
    retries?: number;
    retryDelay?: number;
    maxConcurrentRequests?: number;
    userAgent?: string;
    defaultMaxTokens?: number;
    defaultTemperature?: number;
}
interface FeatureConfig {
    streaming?: boolean;
    tools?: boolean;
    vision?: boolean;
    costTracking?: boolean;
    analytics?: boolean;
    caching?: boolean;
    rateLimiting?: boolean;
    retries?: boolean;
}
interface LoggingConfig {
    enabled: boolean;
    level: LogLevel;
    format: LogFormat;
    destinations: LogDestination[];
    includeRequestData?: boolean;
    includeResponseData?: boolean;
    maskSensitiveData?: boolean;
    maxLogSize?: number;
    retention?: RetentionConfig;
}
type LogLevel = "error" | "warn" | "info" | "debug" | "trace";
type LogFormat = "json" | "text" | "structured";
interface LogDestination {
    type: "console" | "file" | "http" | "stream";
    config?: Record<string, unknown>;
}
interface RetentionConfig {
    maxFiles?: number;
    maxAge?: string;
    maxSize?: string;
}
interface AnalyticsConfig {
    enabled: boolean;
    endpoint?: string;
    apiKey?: string;
    trackUsage?: boolean;
    trackCosts?: boolean;
    trackLatency?: boolean;
    trackErrors?: boolean;
    batchSize?: number;
    flushInterval?: number;
}
interface CacheConfig {
    enabled: boolean;
    type: CacheType;
    ttl?: number;
    maxSize?: number;
    keyPrefix?: string;
    config?: Record<string, unknown>;
}
type CacheType = "memory" | "redis" | "file" | "custom";
interface RateLimitConfig {
    enabled: boolean;
    global?: RateLimitRule;
    perProvider?: Record<ProviderName, RateLimitRule>;
    perModel?: Record<string, RateLimitRule>;
    strategy: RateLimitStrategy;
}
interface RateLimitRule {
    requests: number;
    window: number;
    burst?: number;
    queue?: boolean;
}
type RateLimitStrategy = "fixed_window" | "sliding_window" | "token_bucket";
interface RuntimeConfig {
    defaultProvider?: ProviderName;
    globalSettings?: Partial<GlobalSettings>;
    features?: Partial<FeatureConfig>;
    logging?: Partial<LoggingConfig>;
}
interface ConfigValidation {
    isValid: boolean;
    errors: string[];
    warnings: string[];
    missingProviders: ProviderName[];
}
interface EnvConfig {
    OPENAI_API_KEY?: string;
    CLAUDE_API_KEY?: string;
    GROQ_API_KEY?: string;
    GROK_API_KEY?: string;
    LLMCORE_DEFAULT_PROVIDER?: ProviderName;
    LLMCORE_LOG_LEVEL?: LogLevel;
    LLMCORE_ENABLE_ANALYTICS?: string;
    LLMCORE_ENABLE_CACHING?: string;
}

interface ModelCapabilities {
    streaming: boolean;
    tools: boolean;
    vision: boolean;
    json: boolean;
    maxTemperature: number;
    maxTopP: number;
    contextLength: number;
    maxTokens: number;
    multimodal: boolean;
    reasoning: boolean;
}
declare class ModelCapabilityDetector {
    private static readonly CAPABILITIES;
    static getCapabilities(model: ModelName, provider: ProviderName): ModelCapabilities;
    static supportsFeature(model: ModelName, provider: ProviderName, feature: keyof ModelCapabilities): boolean;
    static findCompatibleModels(requiredFeatures: Array<keyof ModelCapabilities>, providers?: ProviderName[]): Array<{
        model: ModelName;
        provider: ProviderName;
        capabilities: ModelCapabilities;
    }>;
}

interface BaseResponse {
    id: string;
    provider: ProviderName;
    model: ModelName;
    created: number;
    usage?: UsageMetrics;
    cost?: CostMetrics;
    latency?: number;
    metadata?: ResponseMetadata;
}
interface ChatResponse extends BaseResponse {
    message: Message;
    finishReason: FinishReason;
    choices?: ChatChoice[];
}
interface ChatChoice {
    index: number;
    message: Message;
    finishReason: FinishReason;
    logprobs?: LogProbabilities;
}
interface StreamingChatResponse extends BaseResponse {
    delta: MessageDelta;
    finishReason?: FinishReason;
    isComplete: boolean;
}
interface MessageDelta {
    role?: string;
    content?: string;
    toolCalls?: ToolCallDelta[];
}
interface ToolCallDelta {
    index: number;
    id?: string;
    type?: string;
    function?: {
        name?: string;
        arguments?: string;
    };
}
interface LogProbabilities {
    tokens: string[];
    tokenLogprobs: number[];
    topLogprobs?: Record<string, number>[];
    textOffset?: number[];
}
interface UsageMetrics {
    promptTokens: number;
    completionTokens: number;
    totalTokens: number;
    requestDuration?: number;
    queueTime?: number;
    processingTime?: number;
}
interface CostMetrics {
    promptCost: number;
    completionCost: number;
    totalCost: number;
    currency: string;
    rateCard?: RateCard;
}
interface RateCard {
    promptTokenPrice: number;
    completionTokenPrice: number;
    currency: string;
    effectiveDate: string;
    source: string;
}
interface ResponseMetadata {
    requestId?: string;
    modelVersion?: string;
    region?: string;
    cacheHit?: boolean;
    processingNode?: string;
    retryCount?: number;
    warnings?: string[];
    systemFingerprint?: string;
}
interface ErrorResponse {
    error: {
        type: string;
        code: string;
        message: string;
        details?: Record<string, unknown>;
        retryable?: boolean;
        statusCode?: number;
    };
    provider: ProviderName;
    requestId?: string;
    timestamp: number;
}
interface HealthResponse {
    status: "healthy" | "degraded" | "down";
    provider: ProviderName;
    latency: number;
    timestamp: number;
    checks: HealthCheck[];
    version?: string;
}
interface HealthCheck {
    name: string;
    status: "pass" | "fail" | "warn";
    message?: string;
    duration?: number;
}
interface ModelsResponse {
    provider: ProviderName;
    models: ModelInfo[];
    timestamp: number;
}
interface ModelInfo {
    id: string;
    name: string;
    description?: string;
    contextLength: number;
    maxTokens: number;
    pricing?: ModelPricing;
    capabilities: ModelCapabilities;
    status: "active" | "deprecated" | "beta";
    version?: string;
}
interface ModelPricing {
    promptTokens: number;
    completionTokens: number;
    currency: string;
    unit: string;
}
interface BatchResponse<T = ChatResponse> {
    id: string;
    responses: (T | ErrorResponse)[];
    summary: BatchSummary;
    totalCost?: number;
    totalDuration?: number;
}
interface BatchSummary {
    total: number;
    successful: number;
    failed: number;
    retried: number;
    averageLatency: number;
    totalTokens: number;
}
interface StreamResponse<T> {
    stream: AsyncIterable<T>;
    controller: {
        abort(): void;
        signal: {
            aborted: boolean;
            addEventListener(type: string, listener: () => void): void;
            removeEventListener(type: string, listener: () => void): void;
        };
    };
    metadata: {
        requestId: string;
        provider: ProviderName;
        model: ModelName;
        startTime: number;
    };
}
interface ResponseValidation {
    isValid: boolean;
    errors: string[];
    warnings: string[];
    schema?: string;
}

interface BaseError {
    name: string;
    message: string;
    code: string;
    provider?: ProviderName;
    statusCode?: number;
    retryable?: boolean;
    timestamp: number;
    details?: Record<string, unknown>;
}
type ErrorType = "authentication" | "authorization" | "rate_limit" | "quota_exceeded" | "model_not_found" | "invalid_request" | "validation" | "network" | "timeout" | "server_error" | "service_unavailable" | "configuration" | "parsing" | "unknown";
interface LLMCoreError extends BaseError {
    type: ErrorType;
    requestId?: string;
    model?: string;
    context?: ErrorContext;
}
interface ErrorContext {
    requestData?: Record<string, unknown>;
    responseData?: Record<string, unknown>;
    stackTrace?: string;
    userAgent?: string;
    attemptNumber?: number;
    totalAttempts?: number;
}
interface AuthenticationError extends LLMCoreError {
    type: "authentication";
    code: "INVALID_API_KEY" | "MISSING_API_KEY" | "EXPIRED_API_KEY";
}
interface AuthorizationError extends LLMCoreError {
    type: "authorization";
    code: "INSUFFICIENT_PERMISSIONS" | "ACCESS_DENIED" | "RESOURCE_FORBIDDEN";
}
interface RateLimitError extends LLMCoreError {
    type: "rate_limit";
    code: "RATE_LIMIT_EXCEEDED" | "TOO_MANY_REQUESTS";
    retryAfter?: number;
    limit?: number;
    remaining?: number;
    resetTime?: number;
}
interface QuotaError extends LLMCoreError {
    type: "quota_exceeded";
    code: "QUOTA_EXCEEDED" | "USAGE_LIMIT_REACHED" | "BILLING_REQUIRED";
    quotaType?: "tokens" | "requests" | "cost";
    usage?: number;
    limit?: number;
}
interface ModelError extends LLMCoreError {
    type: "model_not_found";
    code: "MODEL_NOT_FOUND" | "MODEL_UNAVAILABLE" | "MODEL_DEPRECATED";
    availableModels?: string[];
}
interface ValidationError extends LLMCoreError {
    type: "validation";
    code: "INVALID_PARAMETER" | "MISSING_PARAMETER" | "PARAMETER_OUT_OF_RANGE";
    parameter?: string;
    expectedType?: string;
    actualValue?: unknown;
    constraints?: Record<string, unknown>;
}
interface NetworkError extends LLMCoreError {
    type: "network";
    code: "CONNECTION_FAILED" | "DNS_RESOLUTION_FAILED" | "SSL_ERROR";
    endpoint?: string;
    timeout?: number;
}
interface TimeoutError extends LLMCoreError {
    type: "timeout";
    code: "REQUEST_TIMEOUT" | "CONNECTION_TIMEOUT" | "READ_TIMEOUT";
    timeoutDuration?: number;
    elapsedTime?: number;
}
interface ServerError extends LLMCoreError {
    type: "server_error";
    code: "INTERNAL_SERVER_ERROR" | "BAD_GATEWAY" | "SERVICE_ERROR";
    serverMessage?: string;
}
interface ServiceUnavailableError extends LLMCoreError {
    type: "service_unavailable";
    code: "SERVICE_UNAVAILABLE" | "MAINTENANCE_MODE" | "OVERLOADED";
    retryAfter?: number;
    estimatedRecovery?: number;
}
interface ConfigurationError extends LLMCoreError {
    type: "configuration";
    code: "INVALID_CONFIG" | "MISSING_CONFIG" | "CONFIG_VALIDATION_FAILED";
    configPath?: string;
    expectedValue?: unknown;
}
interface ParsingError extends LLMCoreError {
    type: "parsing";
    code: "JSON_PARSE_ERROR" | "RESPONSE_PARSE_ERROR" | "INVALID_FORMAT";
    rawData?: string;
    expectedFormat?: string;
}
type SpecificError = AuthenticationError | AuthorizationError | RateLimitError | QuotaError | ModelError | ValidationError | NetworkError | TimeoutError | ServerError | ServiceUnavailableError | ConfigurationError | ParsingError;
type ErrorHandler = (error: LLMCoreError) => Promise<boolean> | boolean;
interface ErrorRecoveryStrategy {
    type: "retry" | "fallback" | "circuit_breaker" | "custom";
    maxAttempts?: number;
    delay?: number;
    backoffMultiplier?: number;
    fallbackProvider?: ProviderName;
    customHandler?: ErrorHandler;
}
interface ErrorClassification {
    severity: "low" | "medium" | "high" | "critical";
    category: "client" | "server" | "network" | "configuration";
    retryable: boolean;
    userActionRequired: boolean;
    suggestions: string[];
}
interface ErrorReporting {
    enabled: boolean;
    endpoint?: string;
    apiKey?: string;
    includeStackTrace?: boolean;
    includeSensitiveData?: boolean;
    batchSize?: number;
    flushInterval?: number;
    filters?: ErrorFilter[];
}
interface ErrorFilter {
    type: ErrorType;
    codes?: string[];
    providers?: ProviderName[];
    severity?: ErrorClassification["severity"];
    action: "include" | "exclude";
}
interface ErrorStats {
    total: number;
    byType: Record<ErrorType, number>;
    byProvider: Record<ProviderName, number>;
    byCode: Record<string, number>;
    recentErrors: LLMCoreError[];
    averageRecoveryTime: number;
}

interface BaseChatRequest {
    provider: ProviderName;
    model: ModelName;
    messages: Message[];
    stream?: boolean;
    temperature?: number;
    maxTokens?: number;
    topP?: number;
    frequencyPenalty?: number;
    presencePenalty?: number;
    stop?: string | string[];
    seed?: number;
    tools?: Tool[];
    toolChoice?: "auto" | "none" | "required" | {
        type: "function";
        function: {
            name: string;
        };
    };
    responseFormat?: ResponseFormat;
    user?: string;
    metadata?: Record<string, unknown>;
}
interface ResponseFormat {
    type: "text" | "json_object";
    schema?: Record<string, unknown>;
}
interface ChatRequest extends BaseChatRequest {
    providerOptions?: Record<string, unknown>;
}
interface OpenAIRequestOptions {
    organization?: string;
    project?: string;
    logprobs?: boolean;
    topLogprobs?: number;
    n?: number;
    suffix?: string;
    echo?: boolean;
    logitBias?: Record<string, number>;
}
interface ClaudeRequestOptions {
    version?: string;
    topK?: number;
    anthropicVersion?: string;
    anthropicBeta?: string[];
}
interface GroqRequestOptions {
    logprobs?: boolean;
    topLogprobs?: number;
    n?: number;
}
interface GrokRequestOptions {
    model_version?: string;
}
type ProviderOptions = OpenAIRequestOptions | ClaudeRequestOptions | GroqRequestOptions | GrokRequestOptions;
interface RequestValidation {
    isValid: boolean;
    errors: string[];
    warnings: string[];
    normalizedRequest?: ChatRequest;
}

interface ConfigValidationResult {
    isValid: boolean;
    errors: string[];
    warnings: string[];
    validProviders: ProviderName[];
    invalidProviders: ProviderName[];
}
declare class ConfigurationManager {
    private config;
    private validationCache;
    private static readonly DEFAULT_MODELS;
    private static readonly REQUIRED_FIELDS;
    constructor(config: LLMCoreConfig);
    validateConfig(): ConfigValidationResult;
    validateProviderConfig(provider: ProviderName, config: ProviderConfig): {
        isValid: boolean;
        errors: string[];
        warnings: string[];
    };
    getDefaultModel(provider: ProviderName): ModelName;
    getDefaultProvider(): ProviderName;
    getProviderConfig<T extends ProviderConfig>(provider: ProviderName): T;
    getRetryConfig(): {
        maxAttempts: number;
        backoffMultiplier: number;
        maxDelay: number;
    };
    getFallbackConfig(): {
        enabled: boolean;
        providers: never[];
    };
    getTimeout(): number;
    updateProviderConfig(provider: ProviderName, config: ProviderConfig): void;
    removeProviderConfig(provider: ProviderName): void;
    private normalizeConfig;
    private validateApiKey;
    private validateOpenAIConfig;
    private validateClaudeConfig;
    private validateGroqConfig;
    private validateGrokConfig;
    private isValidUrl;
    private createConfigError;
}

interface RouterOptions {
    enableFallback?: boolean;
    fallbackProviders?: ProviderName[];
    retryAttempts?: number;
    retryDelay?: number;
    circuitBreaker?: {
        enabled?: boolean;
        failureThreshold?: number;
        resetTimeout?: number;
    };
}
interface ProviderMetrics {
    requests: number;
    failures: number;
    successRate: number;
    averageLatency: number;
    lastFailure?: Date;
    isCircuitOpen: boolean;
}
declare class ProviderRouter {
    private providers;
    private metrics;
    private configManager;
    private options;
    private healthCheckInterval;
    constructor(configManager: ConfigurationManager, options?: RouterOptions);
    initialize(): Promise<void>;
    chat(request: ChatRequest): Promise<ChatResponse>;
    chatStream(request: ChatRequest): Promise<StreamResponse<StreamingChatResponse>>;
    getMetrics(): Map<ProviderName, ProviderMetrics>;
    getAvailableProviders(): ProviderName[];
    isProviderAvailable(provider: ProviderName): boolean;
    resetCircuitBreaker(provider: ProviderName): void;
    destroy(): Promise<void>;
    private selectProvider;
    private getProviderForModel;
    private createProvider;
    private executeWithRetry;
    private executeWithFallback;
    private isRetryableError;
    private mapProviderError;
    private initializeMetrics;
    private recordSuccess;
    private recordFailure;
    private shouldOpenCircuitBreaker;
    private shouldResetCircuitBreaker;
    private sleep;
    private createRouterError;
}

interface LLMCoreOptions extends RouterOptions {
    autoInitialize?: boolean;
    healthCheckInterval?: number;
    enableMetrics?: boolean;
    logLevel?: "debug" | "info" | "warn" | "error" | "none";
}
interface LLMCoreStatus {
    isInitialized: boolean;
    availableProviders: ProviderName[];
    defaultProvider: ProviderName | null;
    metrics: Map<ProviderName, ProviderMetrics>;
    lastHealthCheck?: Date;
}
declare class LLMCore {
    private configManager;
    private router;
    private options;
    private isInitialized;
    private healthCheckTimer;
    constructor(config: LLMCoreConfig, options?: LLMCoreOptions);
    initialize(): Promise<void>;
    chat(messages: Message[], options?: Partial<ChatRequest>): Promise<ChatResponse>;
    chatStream(messages: Message[], options?: Partial<ChatRequest>): Promise<StreamResponse<StreamingChatResponse>>;
    getModels(provider?: ProviderName): Promise<ModelsResponse[]>;
    estimateCost(messages: Message[], options?: Partial<ChatRequest>): Promise<number>;
    getStatus(): LLMCoreStatus;
    updateProviderConfig(provider: ProviderName, config: any): void;
    removeProviderConfig(provider: ProviderName): void;
    resetCircuitBreaker(provider: ProviderName): void;
    runHealthChecks(): Promise<void>;
    shutdown(): Promise<void>;
    complete(prompt: string, options?: Partial<ChatRequest>): Promise<string>;
    ask(question: string, systemPrompt?: string, options?: Partial<ChatRequest>): Promise<string>;
    private ensureInitialized;
    private getDefaultProvider;
    private getDefaultModel;
    private startHealthChecks;
    private enhanceError;
    private log;
}

interface BaseProvider {
    readonly name: string;
    readonly displayName: string;
    chat(request: ChatRequest): Promise<ChatResponse>;
    chatStream(request: ChatRequest): Promise<StreamResponse<StreamingChatResponse>>;
    isConfigured(): boolean;
    validateConfig(): Promise<boolean>;
    getHealth(): Promise<ProviderHealth>;
    getModels(): Promise<ModelsResponse>;
    estimateCost(request: ChatRequest): Promise<number>;
    validateRequest(request: ChatRequest): Promise<boolean>;
}
declare abstract class AbstractProvider implements BaseProvider {
    protected config: BaseProviderConfig;
    constructor(config: BaseProviderConfig);
    abstract readonly name: string;
    abstract readonly displayName: string;
    abstract chat(request: ChatRequest): Promise<ChatResponse>;
    abstract chatStream(request: ChatRequest): Promise<StreamResponse<StreamingChatResponse>>;
    abstract getModels(): Promise<ModelsResponse>;
    isConfigured(): boolean;
    validateConfig(): Promise<boolean>;
    getHealth(): Promise<ProviderHealth>;
    estimateCost(request: ChatRequest): Promise<number>;
    validateRequest(request: ChatRequest): Promise<boolean>;
    protected estimateTokens(text: string): number;
    protected createError(type: string, code: string, message: string, statusCode?: number | undefined, details?: Record<string, unknown> | undefined): LLMCoreError;
    protected handleError(error: unknown): never;
}

declare class OpenAIProvider extends AbstractProvider {
    readonly name = "openai";
    readonly displayName = "OpenAI";
    private client;
    private static readonly MODEL_PRICING;
    private static readonly SUPPORTED_MODELS;
    constructor(config: OpenAIConfig);
    chat(request: ChatRequest): Promise<ChatResponse>;
    chatStream(request: ChatRequest): Promise<StreamResponse<StreamingChatResponse>>;
    getModels(): Promise<ModelsResponse>;
    estimateCost(request: ChatRequest): Promise<number>;
    private convertRequest;
    private convertMessage;
    private convertResponse;
    private createStreamingResponse;
    private convertFinishReason;
    private calculateCost;
    private getModelContextLength;
    private getModelMaxTokens;
    private handleAxiosError;
}

declare class ClaudeProvider extends AbstractProvider {
    readonly name = "claude";
    readonly displayName = "Claude (Anthropic)";
    private client;
    private static readonly MODEL_PRICING;
    private static readonly SUPPORTED_MODELS;
    constructor(config: ClaudeConfig);
    chat(request: ChatRequest): Promise<ChatResponse>;
    chatStream(request: ChatRequest): Promise<StreamResponse<StreamingChatResponse>>;
    getModels(): Promise<ModelsResponse>;
    estimateCost(request: ChatRequest): Promise<number>;
    private convertRequest;
    private convertMessages;
    private convertResponse;
    private createStreamingResponse;
    private convertFinishReason;
    private calculateCost;
    private getModelContextLength;
    private getModelMaxTokens;
    private handleAxiosError;
}

declare class GroqProvider extends AbstractProvider {
    readonly name = "groq";
    readonly displayName = "Groq";
    private client;
    private static readonly MODEL_PRICING;
    private static readonly SUPPORTED_MODELS;
    constructor(config: GroqConfig);
    chat(request: ChatRequest): Promise<ChatResponse>;
    chatStream(request: ChatRequest): Promise<StreamResponse<StreamingChatResponse>>;
    getModels(): Promise<ModelsResponse>;
    estimateCost(request: ChatRequest): Promise<number>;
    private convertRequest;
    private convertMessage;
    private convertResponse;
    private createStreamingResponse;
    private convertFinishReason;
    private calculateCost;
    private getModelContextLength;
    private getModelMaxTokens;
    private handleAxiosError;
}

declare class GrokProvider extends AbstractProvider {
    readonly name = "grok";
    readonly displayName = "Grok (xAI)";
    private client;
    private static readonly MODEL_PRICING;
    private static readonly SUPPORTED_MODELS;
    constructor(config: GrokConfig);
    chat(request: ChatRequest): Promise<ChatResponse>;
    chatStream(request: ChatRequest): Promise<StreamResponse<StreamingChatResponse>>;
    getModels(): Promise<ModelsResponse>;
    estimateCost(request: ChatRequest): Promise<number>;
    private convertRequest;
    private convertMessage;
    private convertResponse;
    private createStreamingResponse;
    private convertFinishReason;
    private calculateCost;
    private getModelContextLength;
    private getModelMaxTokens;
    private handleAxiosError;
}

interface EnhancedResponseMetadata extends ResponseMetadata {
    raw?: unknown;
    processingTime?: number;
    requestTimestamp: number;
    responseTimestamp: number;
    providerMetadata?: Record<string, unknown>;
    cost?: {
        inputCost: number;
        outputCost: number;
        totalCost: number;
        currency: string;
    };
    capabilities?: {
        streaming: boolean;
        tools: boolean;
        vision: boolean;
        multimodal: boolean;
    };
    quality?: {
        confidence?: number;
        relevance?: number;
        completeness?: number;
    };
}
interface StandardizedResponse extends Omit<ChatResponse, "metadata"> {
    metadata: EnhancedResponseMetadata;
}
interface StandardizedStreamResponse extends Omit<StreamingChatResponse, "metadata"> {
    metadata: EnhancedResponseMetadata & {
        chunkIndex: number;
        totalChunks?: number;
        streamStartTime: number;
        latency?: number;
        bufferSize?: number;
    };
}
declare class ResponseStandardizer {
    static standardize(response: ChatResponse, options?: {
        includeRaw?: boolean;
        calculateCost?: boolean;
        startTime?: number;
        providerMetadata?: Record<string, unknown>;
    }): StandardizedResponse;
    static standardizeStream(chunk: StreamingChatResponse, chunkIndex: number, streamStartTime: number): StandardizedStreamResponse;
    static normalizeResponse(response: any, provider: ProviderName): ChatResponse;
    static standardizeUsage(usage: Record<string, number | undefined>, provider: ProviderName): UsageMetrics;
    static standardizeError(error: Error & {
        response?: {
            status?: number;
            data?: unknown;
        };
    }, provider: ProviderName): LLMCoreError;
    private static calculateResponseCost;
    private static detectCapabilities;
    private static assessQuality;
    private static normalizeOpenAIResponse;
    private static normalizeClaudeResponse;
    private static normalizeGroqResponse;
    private static normalizeGrokResponse;
    private static standardizeOpenAIError;
    private static standardizeClaudeError;
    private static standardizeGroqError;
    private static standardizeGrokError;
    private static getModelPricing;
    private static hasVisionContent;
    private static hasMultimodalContent;
}

interface StreamOptions {
    maxReconnectAttempts?: number;
    reconnectDelay?: number;
    reconnectBackoffMultiplier?: number;
    maxReconnectDelay?: number;
    bufferSize?: number;
    bufferTimeout?: number;
    ignoreErrors?: boolean;
    errorCallback?: (error: LLMCoreError) => void;
    debug?: boolean;
    onChunk?: (chunk: StreamingChatResponse, index: number) => void;
}
interface StreamMetrics {
    startTime: number;
    endTime?: number;
    totalChunks: number;
    totalBytes: number;
    avgChunkSize: number;
    reconnectAttempts: number;
    errors: number;
    latencies: number[];
}
declare class StreamManager {
    private options;
    private metrics;
    private abortController?;
    private isActive;
    constructor(options?: StreamOptions);
    createStream<T extends StreamingChatResponse>(request: ChatRequest, provider: ProviderName, streamFunction: (req: ChatRequest, signal?: AbortSignal) => Promise<StreamResponse<T>>): AsyncGenerator<T, void, unknown>;
    createBufferedStream<T extends StreamingChatResponse>(request: ChatRequest, provider: ProviderName, streamFunction: (req: ChatRequest, signal?: AbortSignal) => Promise<StreamResponse<T>>): AsyncGenerator<T[], void, unknown>;
    abort(): void;
    getMetrics(): StreamMetrics;
    resetMetrics(): void;
    private updateMetrics;
    private handleChunkError;
    private shouldReconnect;
    private delay;
    private debug;
}
declare class StreamUtils {
    static combineStreams<T>(...streams: AsyncIterable<T>[]): AsyncGenerator<T, void, unknown>;
    static transformStream<T, U>(stream: AsyncIterable<T>, transformer: (chunk: T, index: number) => U | Promise<U>): AsyncGenerator<U, void, unknown>;
    static filterStream<T>(stream: AsyncIterable<T>, predicate: (chunk: T, index: number) => boolean | Promise<boolean>): AsyncGenerator<T, void, unknown>;
    static takeStream<T>(stream: AsyncIterable<T>, count: number): AsyncGenerator<T, void, unknown>;
    static collectStream<T>(stream: AsyncIterable<T>): Promise<T[]>;
    static streamToString(stream: AsyncIterable<StreamingChatResponse>): Promise<string>;
    static monitorStream<T extends StreamingChatResponse>(stream: AsyncIterable<T>, onMetrics?: (metrics: {
        chunksReceived: number;
        totalTime: number;
        avgLatency: number;
    }) => void): AsyncIterable<T>;
}

interface TokenCount {
    tokens: number;
    characters: number;
    words: number;
    estimatedCost?: number;
}
interface TokenCountOptions {
    includeSystemMessage?: boolean;
    includeToolDescriptions?: boolean;
    model?: ModelName;
    provider?: ProviderName;
}
declare class TokenCounter {
    private static readonly TOKEN_RATIOS;
    private static readonly MODEL_ADJUSTMENTS;
    static countMessageTokens(message: Message, options?: TokenCountOptions): TokenCount;
    static countConversationTokens(messages: Message[], options?: TokenCountOptions): TokenCount;
    static countToolTokens(tools: any[], options?: TokenCountOptions): TokenCount;
    static estimateCost(tokenCount: number, model: ModelName, type?: "input" | "output"): number;
    static wouldExceedLimit(messages: Message[], model: ModelName, maxTokens?: number, options?: TokenCountOptions): {
        wouldExceed: boolean;
        currentTokens: number;
        limitTokens: number;
        overflow: number;
    };
    static truncateToLimit(messages: Message[], model: ModelName, maxTokens?: number, options?: TokenCountOptions): {
        truncatedMessages: Message[];
        removedMessages: Message[];
        finalTokenCount: number;
    };
    private static estimateTokens;
    private static countWords;
    private static getMessageOverhead;
    private static getConversationOverhead;
    private static getToolOverhead;
    private static getModelTokenLimit;
    private static getModelPricing;
}
declare class TokenAnalyzer {
    static analyzeConversation(messages: Message[], options?: TokenCountOptions): {
        totalTokens: number;
        byRole: Record<string, number>;
        byMessage: Array<{
            index: number;
            role: string;
            tokens: number;
            percentage: number;
        }>;
        efficiency: number;
    };
    static getRecommendations(messages: Message[], _model: ModelName, targetTokens: number, options?: TokenCountOptions): {
        currentTokens: number;
        targetTokens: number;
        recommendations: string[];
        canOptimize: boolean;
    };
}

interface CostBreakdown {
    inputCost: number;
    outputCost: number;
    totalCost: number;
    currency: string;
    breakdown: {
        inputTokens: number;
        outputTokens: number;
        inputRate: number;
        outputRate: number;
        unit: string;
    };
}
interface CostEstimate {
    estimated: CostBreakdown;
    confidence: "high" | "medium" | "low";
    factors: string[];
    lastUpdated: string;
}
interface BillingPeriod {
    period: "hourly" | "daily" | "weekly" | "monthly";
    costs: CostBreakdown[];
    totalCost: number;
    averageCost: number;
    peakCost: number;
    requestCount: number;
}
declare class CostCalculator {
    private static readonly PRICING_DATA;
    private static readonly VOLUME_DISCOUNTS;
    static calculateCost(usage: UsageMetrics, model: ModelName, provider: ProviderName): CostBreakdown;
    static estimateCost(messages: any[], model: ModelName, provider: ProviderName, expectedOutputTokens?: number): CostEstimate;
    static calculateWithDiscount(usage: UsageMetrics, model: ModelName, provider: ProviderName, monthlyTokenUsage?: number): CostBreakdown & {
        originalCost: number;
        discount: number;
        discountPercentage: number;
    };
    static compareCosts(usage: UsageMetrics, model: ModelName, providers: ProviderName[]): Array<{
        provider: ProviderName;
        cost: CostBreakdown;
        ranking: number;
        savings?: number | undefined;
    }>;
    static calculateMonthlyEstimate(dailyUsage: UsageMetrics[], model: ModelName, provider: ProviderName): BillingPeriod;
    static getEfficiencyMetrics(usage: UsageMetrics, model: ModelName, provider: ProviderName): {
        costPerToken: number;
        costPerWord: number;
        costPerCharacter: number;
        efficiency: "high" | "medium" | "low";
    };
    static checkBudget(usage: UsageMetrics, model: ModelName, provider: ProviderName, budget: {
        limit: number;
        period: "daily" | "weekly" | "monthly";
        currentSpend: number;
    }): {
        cost: CostBreakdown;
        willExceed: boolean;
        remainingBudget: number;
        percentageUsed: number;
        daysUntilReset?: number;
    };
    private static getPricing;
    private static calculateVolumeDiscount;
}
declare class CostOptimizer {
    static getOptimizationSuggestions(usage: UsageMetrics, model: ModelName, provider: ProviderName): Array<{
        strategy: string;
        potentialSavings: number;
        difficulty: "easy" | "medium" | "hard";
        description: string;
    }>;
    private static findCheaperModels;
    private static getKnownModels;
}

interface AnalyticsEvent {
    timestamp: number;
    provider: ProviderName;
    model: ModelName;
    usage: UsageMetrics;
    cost?: number;
    latency?: number;
    success: boolean;
    errorType?: string;
}
declare class AnalyticsTracker {
    private events;
    private maxEvents;
    trackEvent(event: AnalyticsEvent): void;
    getUsageStats(timeframe?: "hour" | "day" | "week" | "month"): {
        totalRequests: number;
        totalTokens: number;
        totalCost: number;
        averageLatency: number;
        successRate: number;
        topProviders: Array<{
            provider: ProviderName;
            count: number;
        }>;
        topModels: Array<{
            model: ModelName;
            count: number;
        }>;
    };
}

interface RateLimit {
    requests: number;
    tokens: number;
    windowMs: number;
    burstAllowance?: number;
}
interface RateLimitStatus {
    remaining: number;
    resetTime: number;
    retryAfter?: number | undefined;
}
declare class RateLimiter {
    private requestCounts;
    private tokenCounts;
    private static readonly DEFAULT_LIMITS;
    checkLimit(provider: ProviderName, requestTokens?: number, customLimits?: Partial<RateLimit>): {
        allowed: boolean;
        requestsRemaining: number;
        tokensRemaining: number;
        retryAfter?: number | undefined;
    };
    waitForLimit(provider: ProviderName, requestTokens?: number, maxWaitMs?: number): Promise<boolean>;
}

export { AbstractProvider, type AnalyticsConfig, type AnalyticsEvent, AnalyticsTracker, type AssistantMessage, type AuthenticationError, type AuthorizationError, type BaseChatRequest, type BaseError, type BaseMessage, type BaseProvider, type BaseProviderConfig, type BaseResponse, type BatchResponse, type BatchSummary, type BillingPeriod, type CacheConfig, type CacheType, type ChatChoice, type ChatRequest, type ChatResponse, type ClaudeConfig, type ClaudeModel, ClaudeProvider, type ClaudeRequestOptions, type ConfigValidation, type ConfigValidationResult, type ConfigurationError, ConfigurationManager, type ContextualMessage, type Conversation, type ConversationMetadata, type CostBreakdown, CostCalculator, type CostEstimate, type CostMetrics, CostOptimizer, type EnhancedResponseMetadata, type EnvConfig, type ErrorClassification, type ErrorContext, type ErrorFilter, type ErrorHandler, type ErrorRecoveryStrategy, type ErrorReporting, type ErrorResponse, type ErrorStats, type ErrorType, type FeatureConfig, type FinishReason, type FunctionTool, type GlobalSettings, type GrokConfig, type GrokModel, GrokProvider, type GrokRequestOptions, type GroqConfig, type GroqModel, GroqProvider, type GroqRequestOptions, type HealthCheck, type HealthResponse, LLMCore, type LLMCoreConfig, type LLMCoreError, type LLMCoreOptions, type LLMCoreStatus, type LogDestination, type LogFormat, type LogLevel, type LogProbabilities, type LoggingConfig, type Message, type MessageAttachment, type MessageContext, type MessageDelta, type MessageRole, type MessageValidation, type ModelCapabilities, ModelCapabilityDetector, type ModelError, type ModelInfo, type ModelName, type ModelPricing, type ModelsResponse, type NetworkError, type OpenAIConfig, type OpenAIModel, OpenAIProvider, type OpenAIRequestOptions, type ParsingError, type ProviderCapabilities, type ProviderConfig, type ProviderConfigMap, type ProviderHealth, type ProviderInfo, type ProviderMetrics, type ProviderModels, type ProviderName, type ProviderOptions, ProviderRouter, type ProviderStatus, type QuotaError, type RateCard, type RateLimit, type RateLimitConfig, type RateLimitError, type RateLimitRule, type RateLimitStatus, type RateLimitStrategy, RateLimiter, type RequestValidation, type ResponseFormat, type ResponseMetadata, ResponseStandardizer, type ResponseValidation, type RetentionConfig, type RouterOptions, type RuntimeConfig, type ServerError, type ServiceUnavailableError, type SpecificError, type StandardizedResponse, type StandardizedStreamResponse, StreamManager, type StreamMetrics, type StreamOptions, type StreamResponse, StreamUtils, type StreamingChatResponse, type SystemMessage, type TimeoutError, TokenAnalyzer, type TokenCount, type TokenCountOptions, TokenCounter, type Tool, type ToolCall, type ToolCallDelta, type ToolMessage, type UsageMetrics, type UserMessage, type ValidationError, LLMCore as default };