/**
 * Core Types for LLM SDK
 *
 * This module exports all core types, interfaces, and const objects
 * used throughout the SDK.
 */
export type { Result } from './types/result';
export { ok, err, isOk, isErr, unwrap, unwrapOr, map, mapErr, flatMap, fromPromise, tryCatch, all, } from './types/result';
export type { ModelName, TokenCount, ProviderID, PromptName, Milliseconds } from './types/branded';
export { modelName, tokenCount, providerID, promptName, milliseconds, isValidModelName, isValidTokenCount, } from './types/branded';
/**
 * Types of completions supported
 */
export declare const CompletionType: {
    readonly CHAT: "chat";
    readonly TEXT: "text";
};
export type CompletionType = (typeof CompletionType)[keyof typeof CompletionType];
/**
 * Supported LLM providers
 */
export declare const ProviderType: {
    readonly OPENAI: "openai";
    readonly FRIENDLI: "friendli";
    readonly NOVITA: "novita";
    readonly ANTHROPIC: "anthropic";
    readonly CUSTOM: "custom";
};
export type ProviderType = (typeof ProviderType)[keyof typeof ProviderType];
/**
 * Template engines for prompt rendering
 */
export declare const TemplateEngine: {
    readonly MUSTACHE: "mustache";
    readonly JINJA: "jinja";
    readonly NONE: "none";
};
export type TemplateEngine = (typeof TemplateEngine)[keyof typeof TemplateEngine];
/**
 * Truncation strategies for context management
 */
export declare const TruncationStrategy: {
    readonly RECENT_FIRST: "recent_first";
    readonly SLIDING_WINDOW: "sliding_window";
    readonly IMPORTANCE_BASED: "importance_based";
};
export type TruncationStrategy = (typeof TruncationStrategy)[keyof typeof TruncationStrategy];
/**
 * Message roles (OpenAI compatible)
 */
export declare const MessageRole: {
    readonly SYSTEM: "system";
    readonly USER: "user";
    readonly ASSISTANT: "assistant";
    readonly FUNCTION: "function";
    readonly TOOL: "tool";
};
export type MessageRole = (typeof MessageRole)[keyof typeof MessageRole];
/**
 * Retry configuration for requests
 */
export interface RetryOptions {
    /** Maximum number of retry attempts (default: 3) */
    maxRetries?: number;
    /** Initial delay in ms (default: 1000) */
    retryDelay?: number;
    /** Multiplier for exponential backoff (default: 2) */
    retryDelayMultiplier?: number;
    /** Maximum delay in ms (default: 30000) */
    maxRetryDelay?: number;
    /** HTTP status codes to retry (default: [408, 429, 500, 502, 503, 504]) */
    retryableStatusCodes?: number[];
    /** Callback on retry */
    onRetry?: (error: Error, attempt: number, delay: number) => void;
}
/**
 * Chat message structure
 */
export interface Message {
    /** Role of the message sender */
    role: MessageRole | string;
    /** Content of the message */
    content: string;
    /** Optional name for function/tool calls */
    name?: string;
    /** Flag for importance-based truncation */
    important?: boolean;
    /** Token count (if pre-computed) */
    tokenCount?: number;
    /** Function call details (for function calling) */
    functionCall?: {
        name: string;
        arguments: string;
    };
    /** Tool calls (for tool use) */
    toolCalls?: Array<{
        id: string;
        type: 'function';
        function: {
            name: string;
            arguments: string;
        };
    }>;
}
/**
 * Chat completion request (OpenAI compatible)
 */
export interface ChatCompletionRequest {
    /** Model identifier */
    model: string;
    /** Messages to send */
    messages: Message[];
    /** Sampling temperature (0-2) */
    temperature?: number;
    /** Maximum tokens to generate */
    max_tokens?: number;
    /** Nucleus sampling parameter */
    top_p?: number;
    /** Frequency penalty (-2 to 2) */
    frequency_penalty?: number;
    /** Presence penalty (-2 to 2) */
    presence_penalty?: number;
    /** Stop sequences */
    stop?: string | string[];
    /** Enable streaming */
    stream?: boolean;
    /** Number of completions to generate */
    n?: number;
    /** Logit bias for tokens */
    logit_bias?: Record<string, number>;
    /** End-user identifier */
    user?: string;
    /** Cancellation signal */
    signal?: AbortSignal;
    /** Retry configuration */
    retry?: RetryOptions;
    /** Response format (for JSON mode) */
    response_format?: {
        type: 'text' | 'json_object';
    };
    /** Seed for deterministic outputs */
    seed?: number;
}
/**
 * Generic LLM request payload
 * Use TExtra for provider-specific fields
 */
export interface LLMRequestPayload<TExtra extends Record<string, unknown> = Record<string, never>> {
    /** Model identifier */
    model: string;
    /** Messages for chat completion */
    messages?: Message[];
    /** Prompt for text completion */
    prompt?: string;
    /** Maximum tokens to generate */
    max_tokens?: number;
    /** Sampling temperature */
    temperature?: number;
    /** Nucleus sampling parameter */
    top_p?: number;
    /** Enable streaming */
    stream?: boolean;
    /** Stop sequences */
    stop?: string | string[];
    /** Provider-specific extra fields */
    extra?: TExtra;
}
/**
 * Choice in a completion response
 */
export interface CompletionChoice {
    /** Choice index */
    index: number;
    /** Message for chat completions */
    message?: Message;
    /** Text for text completions */
    text?: string;
    /** Reason for stopping */
    finish_reason: 'stop' | 'length' | 'content_filter' | 'tool_calls' | 'function_call' | string;
    /** Log probabilities (if requested) */
    logprobs?: unknown;
}
/**
 * Token usage information
 */
export interface TokenUsage {
    /** Tokens in the prompt */
    prompt_tokens: number;
    /** Tokens in the completion */
    completion_tokens: number;
    /** Total tokens used */
    total_tokens: number;
}
/**
 * LLM response payload
 */
export interface LLMResponsePayload {
    /** Unique response ID */
    id: string;
    /** Object type */
    object: string;
    /** Unix timestamp of creation */
    created: number;
    /** Model used */
    model: string;
    /** Completion choices */
    choices: CompletionChoice[];
    /** Token usage information */
    usage?: TokenUsage;
    /** System fingerprint (for caching) */
    system_fingerprint?: string;
}
/**
 * Provider configuration
 */
export interface ProviderConfig {
    /** API key for authentication */
    apiKey?: string;
    /** Base URL for API requests */
    baseUrl?: string;
    /** Additional headers */
    headers?: Record<string, string>;
    /** Request timeout in milliseconds */
    timeout?: number;
    /** Organization ID (for OpenAI) */
    organization?: string;
}
/**
 * LLM Provider interface
 */
export interface ILLMProvider {
    /** Provider identifier */
    readonly id: string;
    /** Generate a chat completion */
    generateChat(payload: LLMRequestPayload, config?: ProviderConfig): Promise<LLMResponsePayload>;
    /** Generate a text completion */
    generateText(payload: LLMRequestPayload, config?: ProviderConfig): Promise<LLMResponsePayload>;
    /** Check provider health (optional) */
    healthCheck?(): Promise<boolean>;
}
/**
 * Prompt template metadata
 */
export interface PromptMetadata {
    /** Unique prompt name */
    name: string;
    /** Description of the prompt */
    description?: string;
    /** Template engine to use */
    engine: TemplateEngine;
    /** Required variables */
    variables: string[];
    /** Version string */
    version?: string;
    /** Author name */
    author?: string;
    /** Tags for categorization */
    tags?: string[];
}
/**
 * Options for rendering prompts
 */
export interface RenderOptions {
    /** Throw on missing variables */
    strict?: boolean;
    /** Template partials/includes */
    partials?: Record<string, string>;
    /** Custom filters */
    filters?: Record<string, (value: unknown) => unknown>;
}
/**
 * Validation error details
 */
export interface ValidationErrorInfo {
    /** Field that failed validation */
    field: string;
    /** Error message */
    message: string;
    /** The invalid value */
    value?: unknown;
}
export type ValidationError = ValidationErrorInfo;
/**
 * Prompt manager interface
 */
export interface IPromptManager {
    loadTemplate(name: string): Promise<string>;
    render(templateName: string, variables: Record<string, unknown>): Promise<string>;
    renderWithOptions(templateName: string, variables: Record<string, unknown>, options?: RenderOptions): Promise<string>;
    getMetadata(templateName: string): Promise<PromptMetadata | undefined>;
    validateVariables(templateName: string, variables: Record<string, unknown>): ValidationErrorInfo[];
}
/**
 * Context configuration
 */
export interface ContextConfig {
    /** Maximum tokens for context */
    maxTokens?: number;
    /** Safety buffer tokens */
    bufferTokens?: number;
    /** Reserved tokens for completion */
    completionTokens?: number;
    /** Truncation strategy to use */
    truncationStrategy?: TruncationStrategy;
    /** Preserve system messages during truncation */
    preserveSystemMessages?: boolean;
    /** Sliding window configuration */
    slidingWindowConfig?: {
        /** Keep first N messages */
        keepFirstN?: number;
        /** Keep last M messages */
        keepLastM?: number;
    };
}
/**
 * Context metadata after processing
 */
export interface ContextMetadata {
    /** Total tokens used */
    totalTokens: number;
    /** Tokens from messages */
    messageTokens: number;
    /** Tokens from template */
    templateTokens: number;
    /** Buffer tokens reserved */
    bufferTokens: number;
    /** Available tokens remaining */
    availableTokens: number;
    /** Whether truncation occurred */
    truncated: boolean;
    /** Number of messages truncated */
    truncatedCount?: number;
    /** Strategy used for truncation */
    strategy?: TruncationStrategy;
    /** Processing timestamp */
    timestamp: number;
}
/**
 * Result of message truncation
 */
export interface TruncationResult {
    /** Truncated messages */
    messages: Message[];
    /** Truncation metadata */
    metadata: ContextMetadata;
}
/**
 * Context manager interface
 */
export interface IContextManager {
    truncateMessages(messages: Message[], maxTokens: number): Promise<Message[]>;
    truncateMessagesWithMetadata(messages: Message[], config: ContextConfig): Promise<TruncationResult>;
    countTokens(text: string): Promise<number>;
    countMessagesTokens(messages: Message[]): Promise<number>;
    estimateTemplateTokens(template: string, variables: Record<string, unknown>): Promise<number>;
    calculateAvailableTokens(config: ContextConfig): number;
}
/**
 * Middleware function type
 */
export type Middleware<T> = (context: T, next: () => Promise<void>) => Promise<void>;
/**
 * Hook context for middleware
 */
export interface HookContext {
    /** Provider ID */
    provider: string;
    /** Request payload */
    payload: LLMRequestPayload;
    /** Response (after completion) */
    response?: LLMResponsePayload;
    /** Error (if occurred) */
    error?: Error;
    /** Request start time */
    startTime?: number;
    /** Request ID for tracing */
    requestId?: string;
    /** Custom metadata */
    metadata?: Record<string, unknown>;
}
/**
 * Model configuration
 */
export interface ModelConfig {
    /** Model name/identifier */
    modelName: string;
    /** Provider type */
    providerType: ProviderType;
    /** Provider configuration */
    providerConfig: ProviderConfig;
    /** Model field to inject (for Friendli-style) */
    modelField?: string;
    /** Base URL override */
    baseUrl?: string;
    /** Context window size */
    contextWindow?: number;
    /** Default max completion tokens */
    maxCompletionTokens?: number;
    /** Tokens added per message */
    messageOverhead?: number;
    /** Tokens added per request */
    requestOverhead?: number;
    /** Tokenizer name to use */
    tokenizerName?: string;
    /** Default request settings (merged with request payload) */
    defaultSettings?: {
        /** Default temperature (0-2) */
        temperature?: number;
        /** Default top_p (0-1) */
        top_p?: number;
        /** Default frequency penalty (-2 to 2) */
        frequency_penalty?: number;
        /** Default presence penalty (-2 to 2) */
        presence_penalty?: number;
        /** Default stop sequences */
        stop?: string[];
        /** Default timeout in ms */
        timeout?: number;
        /** Any other model-specific settings */
        [key: string]: unknown;
    };
}
/**
 * Model registry interface
 */
export interface IModelRegistry {
    registerModel(config: ModelConfig): void;
    getModelConfig(modelName: string): ModelConfig | undefined;
    listModels(): string[];
    hasModel?(modelName: string): boolean;
    unregisterModel?(modelName: string): boolean;
}
/**
 * Streaming delta (chunk of streamed response)
 */
export interface StreamDelta {
    /** Choice index */
    index: number;
    /** Content delta */
    delta: {
        role?: MessageRole;
        content?: string;
        functionCall?: {
            name?: string;
            arguments?: string;
        };
        toolCalls?: Array<{
            index: number;
            id?: string;
            type?: 'function';
            function?: {
                name?: string;
                arguments?: string;
            };
        }>;
    };
    /** Finish reason (on last chunk) */
    finish_reason?: string;
}
/**
 * Streaming options
 */
export interface StreamingOptions {
    /** Callback for each token */
    onToken?: (token: string) => void;
    /** Callback for each delta */
    onDelta?: (delta: StreamDelta) => void;
    /** Callback on completion */
    onComplete?: (response: LLMResponsePayload) => void;
    /** Callback on error */
    onError?: (error: Error) => void;
}
/**
 * Log levels
 */
export declare const LogLevel: {
    readonly DEBUG: 0;
    readonly INFO: 1;
    readonly WARN: 2;
    readonly ERROR: 3;
    readonly SILENT: 4;
};
export type LogLevel = (typeof LogLevel)[keyof typeof LogLevel];
/**
 * Logger interface for dependency injection
 */
export interface ILogger {
    debug(message: string, meta?: Record<string, unknown>): void;
    info(message: string, meta?: Record<string, unknown>): void;
    warn(message: string, meta?: Record<string, unknown>): void;
    error(message: string, meta?: Record<string, unknown>): void;
    child(name: string): ILogger;
}
//# sourceMappingURL=types.d.ts.map