/**
 * Chat Engine
 *
 * High-level coordinator for LLM chat interactions.
 * Handles the complete flow from user request to response.
 */
import { Message, LLMResponsePayload, ContextConfig, StreamDelta, StreamingOptions } from './types';
import { ModelRegistry } from './registry/model-registry';
import { ProviderRegistry } from './registry/provider-registry';
import { ContextManager } from './context/manager';
import { PromptService } from './prompt/service';
/**
 * Store for conversation messages
 */
export interface MessageStore {
    /**
     * Get messages for a conversation
     */
    getMessages(conversationId: string, limit?: number): Promise<Message[]>;
    /**
     * Save a message to a conversation
     */
    saveMessage(conversationId: string, message: Message): Promise<void>;
    /**
     * Clear conversation history
     */
    clearMessages?(conversationId: string): Promise<void>;
}
/**
 * Store for long-term memories (optional)
 */
export interface MemoryStore {
    /**
     * Get relevant memories for a query
     */
    getRelevant(query: string, limit?: number): Promise<Memory[]>;
}
/**
 * A memory entry
 */
export interface Memory {
    content: string;
    relevance?: number;
}
/**
 * Generation settings that can override model defaults
 */
export interface GenerationSettings {
    temperature?: number;
    top_p?: number;
    max_tokens?: number;
    frequency_penalty?: number;
    presence_penalty?: number;
    stop?: string[];
}
/**
 * Chat request
 */
export interface ChatRequest {
    /** Conversation identifier */
    conversationId: string;
    /** User message content */
    content: string;
    /** Model to use (optional if default set) */
    model?: string;
    /** Override generation settings */
    settings?: GenerationSettings;
    /** System prompt override */
    systemPrompt?: string;
    /** Template name to use */
    templateName?: string;
    /** Template variables */
    templateVariables?: Record<string, unknown>;
    /** Abort signal for cancellation */
    signal?: AbortSignal;
}
/**
 * Chat response
 */
export interface ChatResponse {
    /** Response content */
    content: string;
    /** Model used */
    model: string;
    /** Token usage */
    usage?: {
        prompt_tokens: number;
        completion_tokens: number;
        total_tokens: number;
    };
    /** Finish reason */
    finishReason?: string;
    /** Full raw response */
    raw: LLMResponsePayload;
}
/**
 * Engine configuration
 */
export interface ChatEngineConfig {
    /** Model registry */
    models: ModelRegistry;
    /** Provider registry */
    providers: ProviderRegistry;
    /** Context manager */
    context: ContextManager;
    /** Message store */
    messages: MessageStore;
    /** Prompt service (optional) */
    prompts?: PromptService;
    /** Memory store (optional) */
    memories?: MemoryStore;
    /** Default model */
    defaultModel?: string;
    /** Default system prompt */
    defaultSystemPrompt?: string;
    /** Default context config */
    defaultContextConfig?: ContextConfig;
}
/**
 * Chat Engine
 *
 * Coordinates the complete chat flow:
 * 1. Resolve model and provider
 * 2. Fetch conversation history
 * 3. Apply template (if specified)
 * 4. Manage context window
 * 5. Inject memories (if available)
 * 6. Send request to provider
 * 7. Process and save response
 */
export declare class ChatEngine {
    private readonly models;
    private readonly providers;
    private readonly context;
    private readonly messages;
    private readonly prompts?;
    private readonly memories?;
    private readonly defaultModel?;
    private readonly defaultSystemPrompt;
    private readonly defaultContextConfig;
    private readonly logger;
    constructor(config: ChatEngineConfig);
    /**
     * Send a chat message and get a response
     */
    chat(request: ChatRequest): Promise<ChatResponse>;
    /**
     * Stream a chat response
     */
    stream(request: ChatRequest): AsyncGenerator<StreamDelta, ChatResponse, unknown>;
    /**
     * Stream with callbacks
     */
    streamWithCallbacks(request: ChatRequest, options: StreamingOptions): Promise<ChatResponse>;
    private buildMessages;
    private mergeSettings;
    private getProviderUrl;
}
//# sourceMappingURL=engine.d.ts.map