@revealui/ai 0.1.0

package/dist/llm/client.js

@@ -0,0 +1,497 @@
+/**
+ * Unified LLM Client
+ *
+ * Single interface for all LLM providers with fallback and rate limiting
+ */
+// =============================================================================
+// Log redaction
+// =============================================================================
+const SENSITIVE_KEYS = new Set([
+    'apiKey',
+    'api_key',
+    'authorization',
+    'Authorization',
+    'x-ai-api-key',
+    'X-AI-Api-Key',
+    'token',
+    'secret',
+    'password',
+    'encryptedKey',
+    'encrypted_key',
+]);
+/**
+ * Redact sensitive fields before passing an object to a logger.
+ * Replaces API keys, tokens, and authorization headers with `[REDACTED]`.
+ * Recurses into nested plain objects; leaves arrays and primitives as-is.
+ */
+export function redactSensitiveFields(obj) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (SENSITIVE_KEYS.has(key)) {
+            result[key] = '[REDACTED]';
+        }
+        else if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+            result[key] = redactSensitiveFields(value);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+import { decryptApiKey } from '@revealui/db/crypto';
+import { tenantProviderConfigs, userApiKeys } from '@revealui/db/schema';
+import { and, eq } from 'drizzle-orm';
+import { AnthropicProvider } from './providers/anthropic.js';
+import { GroqProvider } from './providers/groq.js';
+import { OllamaProvider } from './providers/ollama.js';
+import { OpenAIProvider } from './providers/openai.js';
+import { VultrProvider } from './providers/vultr.js';
+import { ResponseCache } from './response-cache.js';
+import { SemanticCache, } from './semantic-cache.js';
+import { estimateRequest as _estimateRequestTokens } from './token-counter.js';
+export class LLMClient {
+    provider;
+    fallbackProvider;
+    config;
+    rateLimitState;
+    responseCache;
+    semanticCache;
+    healthMonitor;
+    /** Tracks the last resolved API key so we only recreate the provider when it changes */
+    currentApiKey;
+    constructor(config) {
+        this.config = config;
+        this.currentApiKey = config.apiKey;
+        this.rateLimitState = {
+            requests: [],
+            dailyRequests: 0,
+            lastReset: Date.now(),
+        };
+        // Initialize response cache if enabled
+        if (config.enableResponseCache) {
+            this.responseCache = new ResponseCache(config.responseCacheOptions);
+        }
+        // Initialize semantic cache if enabled
+        if (config.enableSemanticCache) {
+            this.semanticCache = new SemanticCache(config.semanticCacheOptions);
+        }
+        // Wire health monitor if provided
+        this.healthMonitor = config.healthMonitor;
+        // Create primary provider
+        this.provider = this.createProvider(config.provider, {
+            apiKey: config.apiKey,
+            baseURL: config.baseURL,
+            model: config.model,
+            temperature: config.temperature,
+            maxTokens: config.maxTokens,
+        });
+        // Create fallback provider if specified
+        if (config.fallbackProvider) {
+            this.fallbackProvider = this.createProvider(config.fallbackProvider, {
+                apiKey: config.apiKey, // Note: In practice, you'd want separate API keys
+                baseURL: config.baseURL,
+                model: config.model,
+                temperature: config.temperature,
+                maxTokens: config.maxTokens,
+            });
+        }
+    }
+    createProvider(type, config) {
+        switch (type) {
+            case 'openai':
+                return new OpenAIProvider(config);
+            case 'anthropic':
+                return new AnthropicProvider({
+                    ...config,
+                    enableCacheByDefault: this.config.enableCacheByDefault,
+                });
+            case 'vultr':
+                return new VultrProvider(config);
+            case 'groq':
+                return new GroqProvider(config);
+            case 'ollama':
+                return new OllamaProvider(config);
+            default:
+                throw new Error(`Unknown provider type: ${String(type)}`);
+        }
+    }
+    /**
+     * Re-resolve the API key via apiKeyFn (if configured) and recreate the provider
+     * when the key has changed. No-op if apiKeyFn is not set.
+     */
+    async refreshProviderIfNeeded() {
+        if (!this.config.apiKeyFn)
+            return;
+        const newKey = await this.config.apiKeyFn();
+        if (newKey === this.currentApiKey)
+            return;
+        this.currentApiKey = newKey;
+        const providerConfig = {
+            apiKey: newKey,
+            baseURL: this.config.baseURL,
+            model: this.config.model,
+            temperature: this.config.temperature,
+            maxTokens: this.config.maxTokens,
+        };
+        this.provider = this.createProvider(this.config.provider, providerConfig);
+        if (this.config.fallbackProvider) {
+            this.fallbackProvider = this.createProvider(this.config.fallbackProvider, providerConfig);
+        }
+    }
+    checkRateLimit() {
+        const now = Date.now();
+        const { rateLimit } = this.config;
+        if (!rateLimit) {
+            return true;
+        }
+        // Reset daily counter if needed
+        if (now - this.rateLimitState.lastReset > 24 * 60 * 60 * 1000) {
+            this.rateLimitState.dailyRequests = 0;
+            this.rateLimitState.lastReset = now;
+        }
+        // Check per-minute limit
+        if (rateLimit.requestsPerMinute) {
+            const oneMinuteAgo = now - 60 * 1000;
+            this.rateLimitState.requests = this.rateLimitState.requests.filter((time) => time > oneMinuteAgo);
+            if (this.rateLimitState.requests.length >= rateLimit.requestsPerMinute) {
+                return false;
+            }
+        }
+        // Check daily limit
+        if (rateLimit.requestsPerDay) {
+            if (this.rateLimitState.dailyRequests >= rateLimit.requestsPerDay) {
+                return false;
+            }
+        }
+        return true;
+    }
+    recordRequest() {
+        const now = Date.now();
+        this.rateLimitState.requests.push(now);
+        this.rateLimitState.dailyRequests++;
+    }
+    async chat(messages, options) {
+        await this.refreshProviderIfNeeded();
+        // Check semantic cache first (if enabled)
+        // Semantic cache is more powerful - matches similar queries, not just exact matches
+        if (this.semanticCache) {
+            const query = this.semanticCache.extractQuery(messages);
+            const cached = await this.semanticCache.get(query);
+            if (cached) {
+                // Semantic cache hit - return immediately without API call
+                return {
+                    content: cached.response,
+                    role: 'assistant',
+                    finishReason: 'stop',
+                    usage: cached.usage
+                        ? {
+                            ...cached.usage,
+                            // Mark as cached for monitoring
+                            cacheReadTokens: cached.usage.totalTokens,
+                        }
+                        : undefined,
+                };
+            }
+        }
+        // Check response cache (if enabled and semantic cache didn't hit)
+        if (this.responseCache) {
+            const cacheKey = this.responseCache.getCacheKey(messages, {
+                temperature: options?.temperature,
+                maxTokens: options?.maxTokens,
+                tools: options?.tools,
+                model: this.config.model,
+            });
+            const cached = this.responseCache.get(cacheKey);
+            if (cached) {
+                // Cache hit - return immediately without API call
+                return {
+                    ...cached,
+                    usage: cached.usage
+                        ? {
+                            ...cached.usage,
+                            // Mark as cached for monitoring
+                            cacheReadTokens: cached.usage.totalTokens,
+                        }
+                        : undefined,
+                };
+            }
+            // Cache miss - proceed with API call
+        }
+        if (!this.checkRateLimit()) {
+            throw new Error('Rate limit exceeded');
+        }
+        const callStart = Date.now();
+        try {
+            this.recordRequest();
+            const response = await this.provider.chat(messages, options);
+            this.healthMonitor?.recordCall(this.config.provider, Date.now() - callStart);
+            // Store in semantic cache (if enabled)
+            if (this.semanticCache) {
+                const query = this.semanticCache.extractQuery(messages);
+                await this.semanticCache.set(query, response.content, response.usage);
+            }
+            // Store in response cache (if enabled)
+            if (this.responseCache) {
+                const cacheKey = this.responseCache.getCacheKey(messages, {
+                    temperature: options?.temperature,
+                    maxTokens: options?.maxTokens,
+                    tools: options?.tools,
+                    model: this.config.model,
+                });
+                this.responseCache.set(cacheKey, {
+                    content: response.content,
+                    role: response.role,
+                    finishReason: response.finishReason,
+                    toolCalls: response.toolCalls,
+                    timestamp: Date.now(),
+                    usage: response.usage,
+                });
+            }
+            return response;
+        }
+        catch (error) {
+            this.healthMonitor?.recordCall(this.config.provider, Date.now() - callStart, error instanceof Error ? error : new Error(String(error)));
+            // Try fallback if available
+            if (this.fallbackProvider && this.config.fallbackProvider) {
+                const fallbackStart = Date.now();
+                try {
+                    const fallbackResponse = await this.fallbackProvider.chat(messages, options);
+                    this.healthMonitor?.recordCall(this.config.fallbackProvider, Date.now() - fallbackStart);
+                    return fallbackResponse;
+                }
+                catch (fallbackError) {
+                    this.healthMonitor?.recordCall(this.config.fallbackProvider, Date.now() - fallbackStart, fallbackError instanceof Error ? fallbackError : new Error(String(fallbackError)));
+                    throw new Error(`Both primary and fallback providers failed: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+            throw error;
+        }
+    }
+    async embed(text, options) {
+        await this.refreshProviderIfNeeded();
+        if (!this.checkRateLimit()) {
+            throw new Error('Rate limit exceeded');
+        }
+        try {
+            this.recordRequest();
+            return await this.provider.embed(text, options);
+        }
+        catch (error) {
+            // Try fallback if available
+            if (this.fallbackProvider) {
+                try {
+                    return await this.fallbackProvider.embed(text, options);
+                }
+                catch {
+                    throw new Error(`Both primary and fallback providers failed: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+            throw error;
+        }
+    }
+    async *stream(messages, options) {
+        await this.refreshProviderIfNeeded();
+        // Note: Streaming is not cached (can't cache partial responses)
+        if (!this.checkRateLimit()) {
+            throw new Error('Rate limit exceeded');
+        }
+        try {
+            this.recordRequest();
+            yield* this.provider.stream(messages, options);
+        }
+        catch (error) {
+            // Try fallback if available
+            if (this.fallbackProvider) {
+                try {
+                    yield* this.fallbackProvider.stream(messages, options);
+                }
+                catch {
+                    throw new Error(`Both primary and fallback providers failed: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    /**
+     * Estimate token count and cost for a set of messages using the configured model.
+     * Uses a heuristic (~4 chars/token). Useful for pre-flight cost checks.
+     */
+    estimateRequest(messages) {
+        return _estimateRequestTokens(messages, this.config.model ?? '');
+    }
+    /**
+     * Get the provider health monitor if one was configured.
+     */
+    getHealthMonitor() {
+        return this.healthMonitor;
+    }
+    /**
+     * Get response cache statistics
+     *
+     * @returns Cache stats or undefined if caching is disabled
+     */
+    getResponseCacheStats() {
+        return this.responseCache?.getStats();
+    }
+    /**
+     * Clear response cache
+     */
+    clearResponseCache() {
+        this.responseCache?.clear();
+    }
+    /**
+     * Get semantic cache statistics
+     *
+     * @returns Semantic cache stats or undefined if caching is disabled
+     */
+    getSemanticCacheStats() {
+        return this.semanticCache?.getStats();
+    }
+    /**
+     * Clear semantic cache
+     */
+    clearSemanticCache() {
+        this.semanticCache?.resetStats();
+    }
+}
+/**
+ * Create an LLM client from environment variables.
+ *
+ * When LLM_PROVIDER is not set, auto-detects the provider by checking env vars
+ * in priority order: GROQ_API_KEY → OLLAMA_BASE_URL → ANTHROPIC_API_KEY.
+ *
+ * GROQ and Ollama are preferred — they are free-tier and BYOK-friendly.
+ * OpenAI is not in the auto-detection chain (no revenue yet — see LLM provider policy).
+ * To use OpenAI, set LLM_PROVIDER=openai explicitly.
+ *
+ * Provider defaults:
+ *   groq   → llama-3.3-70b-versatile
+ *   ollama → llama3.2:3b
+ */
+export function createLLMClientFromEnv() {
+    // Auto-detect provider when LLM_PROVIDER is not explicitly set
+    let provider;
+    if (process.env.LLM_PROVIDER) {
+        provider = process.env.LLM_PROVIDER;
+    }
+    else if (process.env.GROQ_API_KEY) {
+        provider = 'groq';
+    }
+    else if (process.env.OLLAMA_BASE_URL) {
+        provider = 'ollama';
+    }
+    else if (process.env.ANTHROPIC_API_KEY) {
+        provider = 'anthropic';
+    }
+    else {
+        // No provider configured — throw a clear error. OpenAI is intentionally excluded from
+        // auto-detection (no revenue yet). Set LLM_PROVIDER=openai explicitly if needed.
+        throw new Error('No LLM provider configured. Set one of: GROQ_API_KEY (recommended), ' +
+            'OLLAMA_BASE_URL (local), or ANTHROPIC_API_KEY. ' +
+            'Alternatively, set LLM_PROVIDER explicitly.');
+    }
+    let apiKey;
+    let baseURL;
+    let defaultModel;
+    if (provider === 'openai') {
+        apiKey = process.env.OPENAI_API_KEY;
+        baseURL = process.env.OPENAI_BASE_URL;
+    }
+    else if (provider === 'anthropic') {
+        apiKey = process.env.ANTHROPIC_API_KEY;
+        baseURL = process.env.ANTHROPIC_BASE_URL;
+    }
+    else if (provider === 'vultr') {
+        apiKey = process.env.VULTR_API_KEY;
+        baseURL = process.env.VULTR_BASE_URL;
+    }
+    else if (provider === 'huggingface') {
+        apiKey = process.env.HF_TOKEN;
+        baseURL = process.env.HF_MODEL_URL;
+    }
+    else if (provider === 'groq') {
+        apiKey = process.env.GROQ_API_KEY;
+        baseURL = process.env.GROQ_BASE_URL;
+        defaultModel = 'llama-3.3-70b-versatile';
+    }
+    else if (provider === 'ollama') {
+        apiKey = 'ollama'; // Ollama ignores the API key
+        baseURL = process.env.OLLAMA_BASE_URL;
+        defaultModel = 'llama3.2:3b';
+    }
+    if (!apiKey) {
+        throw new Error(`API key not found for provider "${provider}". Set the corresponding env var ` +
+            `(GROQ_API_KEY, OLLAMA_BASE_URL, ANTHROPIC_API_KEY, or OPENAI_API_KEY).`);
+    }
+    return new LLMClient({
+        provider,
+        apiKey,
+        baseURL,
+        model: process.env.LLM_MODEL ?? defaultModel,
+        temperature: process.env.LLM_TEMPERATURE ? parseFloat(process.env.LLM_TEMPERATURE) : undefined,
+        maxTokens: process.env.LLM_MAX_TOKENS ? parseInt(process.env.LLM_MAX_TOKENS, 10) : undefined,
+        enableCacheByDefault: process.env.LLM_ENABLE_CACHE === 'true' || process.env.ANTHROPIC_ENABLE_CACHE === 'true',
+        enableResponseCache: process.env.LLM_ENABLE_RESPONSE_CACHE === 'true' ||
+            process.env.RESPONSE_CACHE_ENABLED === 'true',
+        enableSemanticCache: process.env.LLM_ENABLE_SEMANTIC_CACHE === 'true' ||
+            process.env.SEMANTIC_CACHE_ENABLED === 'true',
+    });
+}
+/**
+ * Create an LLM client using a user's stored BYOK API key.
+ *
+ * Looks up the user's preferred provider from `tenant_provider_configs`
+ * (falling back to the first key in `user_api_keys`), decrypts the key
+ * with AES-256-GCM, and returns a configured LLMClient.
+ *
+ * Returns `null` if the user has no stored keys (callers should fall back
+ * to `createLLMClientFromEnv()` or return a 402/feature-unavailable error).
+ *
+ * @param userId - The user's ID from the `users` table
+ * @param db - A Drizzle NeonDB client instance
+ */
+export async function createLLMClientForUser(userId, db, auditStore) {
+    // Find the user's preferred provider config
+    const [preferredConfig] = await db
+        .select()
+        .from(tenantProviderConfigs)
+        .where(and(eq(tenantProviderConfigs.userId, userId), eq(tenantProviderConfigs.isDefault, true)))
+        .limit(1);
+    // Find the matching API key (preferred provider, or any available key)
+    const keyQuery = db
+        .select()
+        .from(userApiKeys)
+        .where(preferredConfig
+        ? and(eq(userApiKeys.userId, userId), eq(userApiKeys.provider, preferredConfig.provider))
+        : eq(userApiKeys.userId, userId))
+        .limit(1);
+    const [keyRow] = await keyQuery;
+    if (!keyRow)
+        return null;
+    const plaintext = decryptApiKey(keyRow.encryptedKey);
+    const provider = keyRow.provider;
+    const model = preferredConfig?.model ?? undefined;
+    // Fire-and-forget: record when this key was last used (best-effort, never blocks)
+    db.update(userApiKeys)
+        .set({ lastUsedAt: new Date() })
+        .where(eq(userApiKeys.id, keyRow.id))
+        .catch(() => undefined);
+    // Fire-and-forget: emit BYOK audit event if an audit store is wired up
+    if (auditStore) {
+        auditStore
+            .append({
+            id: crypto.randomUUID(),
+            timestamp: new Date(),
+            eventType: 'byok:key:accessed',
+            severity: 'info',
+            agentId: 'system',
+            payload: { userId, provider, keyId: keyRow.id },
+            policyViolations: [],
+        })
+            .catch(() => undefined);
+    }
+    return new LLMClient({ provider, apiKey: plaintext, model });
+}

package/dist/llm/key-validator.d.ts

@@ -0,0 +1,25 @@
+/**
+ * BYOK Provider Key Validator
+ *
+ * Validates API keys against their provider before storage.
+ * Uses the cheapest available endpoint for each provider — typically a
+ * models list (read-only, no token cost). Falls back gracefully when the
+ * provider is unreachable so that network failures don't block key storage.
+ */
+export type ProviderValidationResult = {
+    valid: true;
+} | {
+    valid: false;
+    error: string;
+};
+/**
+ * Validate an API key against the given provider.
+ *
+ * Unreachable providers return `{ valid: true }` with a warning comment so
+ * that network outages (especially for Ollama) never block key storage.
+ *
+ * @param provider - One of the allowed BYOK provider identifiers
+ * @param apiKey   - The plaintext key to probe
+ */
+export declare function validateProviderKey(provider: string, apiKey: string): Promise<ProviderValidationResult>;
+//# sourceMappingURL=key-validator.d.ts.map

package/dist/llm/key-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"key-validator.d.ts","sourceRoot":"","sources":["../../src/llm/key-validator.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,MAAM,wBAAwB,GAAG;IAAE,KAAK,EAAE,IAAI,CAAA;CAAE,GAAG;IAAE,KAAK,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAexF;;;;;;;;GAQG;AACH,wBAAsB,mBAAmB,CACvC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,wBAAwB,CAAC,CAuEnC"}

package/dist/llm/key-validator.js

@@ -0,0 +1,101 @@
+/**
+ * BYOK Provider Key Validator
+ *
+ * Validates API keys against their provider before storage.
+ * Uses the cheapest available endpoint for each provider — typically a
+ * models list (read-only, no token cost). Falls back gracefully when the
+ * provider is unreachable so that network failures don't block key storage.
+ */
+/** Timeout for validation probes (ms). Kept short to avoid blocking the request. */
+const VALIDATION_TIMEOUT_MS = 4_000;
+async function probeFetch(url, init) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), VALIDATION_TIMEOUT_MS);
+    try {
+        return await fetch(url, { ...init, signal: controller.signal });
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+/**
+ * Validate an API key against the given provider.
+ *
+ * Unreachable providers return `{ valid: true }` with a warning comment so
+ * that network outages (especially for Ollama) never block key storage.
+ *
+ * @param provider - One of the allowed BYOK provider identifiers
+ * @param apiKey   - The plaintext key to probe
+ */
+export async function validateProviderKey(provider, apiKey) {
+    try {
+        switch (provider) {
+            case 'groq': {
+                const res = await probeFetch('https://api.groq.com/openai/v1/models', {
+                    headers: { Authorization: `Bearer ${apiKey}` },
+                });
+                if (res.ok)
+                    return { valid: true };
+                if (res.status === 401)
+                    return { valid: false, error: 'Invalid Groq API key' };
+                // Any other non-OK status (429, 500 etc.) — treat as reachable but unknown
+                return { valid: false, error: `Groq validation failed: HTTP ${res.status}` };
+            }
+            case 'anthropic': {
+                // Anthropic has no free read endpoint. Validate by key format only.
+                // Valid Anthropic keys start with "sk-ant-api".
+                if (!apiKey.startsWith('sk-ant-api')) {
+                    return { valid: false, error: 'Anthropic API key must start with "sk-ant-api"' };
+                }
+                return { valid: true };
+            }
+            case 'openai': {
+                // Validate by format — keys start with "sk-"
+                // (Per LLM policy, OpenAI API calls are blocked until we have revenue.)
+                if (!apiKey.startsWith('sk-')) {
+                    return { valid: false, error: 'OpenAI API key must start with "sk-"' };
+                }
+                return { valid: true };
+            }
+            case 'huggingface': {
+                const res = await probeFetch('https://huggingface.co/api/whoami-v2', {
+                    headers: { Authorization: `Bearer ${apiKey}` },
+                });
+                if (res.ok)
+                    return { valid: true };
+                if (res.status === 401 || res.status === 403) {
+                    return { valid: false, error: 'Invalid HuggingFace token' };
+                }
+                return { valid: false, error: `HuggingFace validation failed: HTTP ${res.status}` };
+            }
+            case 'vultr': {
+                // Vultr Serverless Inference API (OpenAI-compatible)
+                const res = await probeFetch('https://api.vultrinference.com/v1/models', {
+                    headers: { Authorization: `Bearer ${apiKey}` },
+                });
+                if (res.ok)
+                    return { valid: true };
+                if (res.status === 401)
+                    return { valid: false, error: 'Invalid Vultr API key' };
+                return { valid: false, error: `Vultr validation failed: HTTP ${res.status}` };
+            }
+            case 'ollama': {
+                // Ollama is local — we cannot reliably probe it from the server.
+                // Accept the key as-is (Ollama doesn't use API keys anyway).
+                return { valid: true };
+            }
+            default:
+                // Unknown provider — skip validation
+                return { valid: true };
+        }
+    }
+    catch (err) {
+        // Network error (AbortError, DNS failure, etc.) — don't block storage
+        if (err instanceof Error && err.name === 'AbortError') {
+            // Timeout — provider unreachable, proceed with storage
+            return { valid: true };
+        }
+        // Other network errors (ECONNREFUSED, etc.) — proceed with storage
+        return { valid: true };
+    }
+}

package/dist/llm/provider-health.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Provider Health Monitor
+ *
+ * Sliding window of last 100 calls per provider.
+ * Tracks latency (p50) and error rate to rank fallback candidates.
+ *
+ * AnythingLLM lesson: no health checks → silent failures cascade.
+ */
+import type { LLMProviderType } from './client.js';
+export interface ProviderHealth {
+    provider: LLMProviderType;
+    /** healthy | degraded | unhealthy */
+    status: 'healthy' | 'degraded' | 'unhealthy';
+    latencyP50Ms: number;
+    errorRate: number;
+    sampleCount: number;
+}
+export declare class ProviderHealthMonitor {
+    private windows;
+    private getWindow;
+    /**
+     * Record a completed LLM API call.
+     */
+    recordCall(provider: LLMProviderType, latencyMs: number, error?: Error | null): void;
+    /**
+     * Get health metrics for a provider.
+     * Returns 'healthy' with 0 latency if no calls recorded yet.
+     */
+    getHealth(provider: LLMProviderType): ProviderHealth;
+    /**
+     * Pick the best provider from a set of candidates.
+     * Prefers healthy > degraded > unhealthy, then by p50 latency.
+     */
+    getBestProvider(candidates: LLMProviderType[]): LLMProviderType;
+    /**
+     * Reset health data for a provider (useful for testing).
+     */
+    reset(provider: LLMProviderType): void;
+}
+//# sourceMappingURL=provider-health.d.ts.map

package/dist/llm/provider-health.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-health.d.ts","sourceRoot":"","sources":["../../src/llm/provider-health.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAElD,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,eAAe,CAAA;IACzB,qCAAqC;IACrC,MAAM,EAAE,SAAS,GAAG,UAAU,GAAG,WAAW,CAAA;IAC5C,YAAY,EAAE,MAAM,CAAA;IACpB,SAAS,EAAE,MAAM,CAAA;IACjB,WAAW,EAAE,MAAM,CAAA;CACpB;AAqBD,qBAAa,qBAAqB;IAChC,OAAO,CAAC,OAAO,CAAgD;IAE/D,OAAO,CAAC,SAAS;IAQjB;;OAEG;IACH,UAAU,CAAC,QAAQ,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK,GAAG,IAAI,GAAG,IAAI;IAUpF;;;OAGG;IACH,SAAS,CAAC,QAAQ,EAAE,eAAe,GAAG,cAAc;IA4BpD;;;OAGG;IACH,eAAe,CAAC,UAAU,EAAE,eAAe,EAAE,GAAG,eAAe;IAkB/D;;OAEG;IACH,KAAK,CAAC,QAAQ,EAAE,eAAe,GAAG,IAAI;CAGvC"}