/**
 * Runner HTTP Client
 * Communicates with the llama.cpp runner process via HTTP
 */
import type { HealthResponse } from '../types/index.js';
export interface RunnerCompletionRequest {
    prompt: string;
    images?: string[];
    grammar?: string;
    cachePrompt?: boolean;
    shift?: boolean;
    truncate?: boolean;
    temperature?: number;
    topK?: number;
    topP?: number;
    minP?: number;
    typicalP?: number;
    repeatPenalty?: number;
    repeatLastN?: number;
    presencePenalty?: number;
    frequencyPenalty?: number;
    seed?: number;
    stop?: string[];
    nPredict?: number;
    nKeep?: number;
    logprobs?: boolean;
    topLogprobs?: number;
    stream?: boolean;
}
export interface RunnerCompletionResponse {
    content: string;
    stop: boolean;
    stopReason?: 'stop' | 'length' | 'eos';
    promptEvalCount?: number;
    promptEvalDuration?: number;
    evalCount?: number;
    evalDuration?: number;
    completionProbabilities?: TokenProbability[];
}
export interface TokenProbability {
    content: string;
    probs: Array<{
        tok_str: string;
        prob: number;
    }>;
}
export interface LoadRequest {
    operation: 'fit' | 'alloc' | 'commit' | 'close';
    loraPath?: string[];
    parallel?: number;
    batchSize?: number;
    flashAttention?: boolean;
    kvSize?: number;
    kvCacheType?: string;
    numThreads?: number;
    gpuLayers?: GPULayers[];
    multiUserCache?: boolean;
    projectorPath?: string;
    mainGpu?: number;
    useMmap?: boolean;
}
export interface GPULayers {
    deviceId: string;
    layers: number[];
}
export interface LoadResponse {
    success: boolean;
    memory?: BackendMemory;
}
export interface BackendMemory {
    inputWeights: number;
    cpu: DeviceMemory;
    gpus: DeviceMemory[];
}
export interface DeviceMemory {
    name: string;
    deviceId?: string;
    weights: number[];
    cache: number[];
    graph: number;
}
export interface EmbeddingRequest {
    content: string;
}
export interface EmbeddingResponse {
    embedding: number[];
    promptEvalCount: number;
}
export interface RunnerClientOptions {
    host: string;
    port: number;
    timeout?: number;
}
export declare class RunnerClient {
    private baseUrl;
    private timeout;
    constructor(options: RunnerClientOptions);
    get url(): string;
    /**
     * Check runner health status
     */
    health(): Promise<HealthResponse>;
    /**
     * Wait until the runner is responding
     */
    waitUntilLaunched(timeoutMs?: number): Promise<void>;
    /**
     * Wait until the runner is ready (model loaded)
     */
    waitUntilReady(timeoutMs?: number, onProgress?: (progress: number) => void): Promise<void>;
    /**
     * Load a model
     */
    load(request: LoadRequest): Promise<LoadResponse>;
    private operationToNumber;
    /**
     * Run completion (streaming)
     */
    completion(request: RunnerCompletionRequest): AsyncGenerator<RunnerCompletionResponse, void, unknown>;
    private mapDoneReason;
    /**
     * Get embeddings
     */
    embedding(content: string): Promise<EmbeddingResponse>;
    /**
     * Close the connection (for cleanup)
     */
    close(): Promise<void>;
}
//# sourceMappingURL=client.d.ts.map