@jsonstudio/llms 0.4.2

package/dist/router/virtual-router/classifier.js

@@ -0,0 +1,99 @@
+import { DEFAULT_ROUTE, ROUTE_PRIORITY } from './types.js';
+const DEFAULT_LONG_CONTEXT_THRESHOLD = 60000;
+export class RoutingClassifier {
+    config;
+    constructor(config) {
+        this.config = {
+            longContextThresholdTokens: config.longContextThresholdTokens ?? DEFAULT_LONG_CONTEXT_THRESHOLD,
+            thinkingKeywords: normalizeList(config.thinkingKeywords, ['think step', 'analysis', 'reasoning']),
+            backgroundKeywords: normalizeList(config.backgroundKeywords, ['background', 'context dump'])
+        };
+    }
+    classify(features) {
+        const evaluations = [
+            {
+                route: 'vision',
+                triggered: features.hasVisionTool && features.hasImageAttachment,
+                reason: 'vision:requires-tool+image'
+            },
+            {
+                route: 'websearch',
+                triggered: features.hasWebTool,
+                reason: 'websearch:web-tools-detected'
+            },
+            {
+                route: 'coding',
+                triggered: features.hasCodingTool,
+                reason: 'coding:coding-tools-detected'
+            },
+            {
+                route: 'tools',
+                triggered: features.hasTools || features.hasToolCallResponses,
+                reason: 'tools:tool-request-detected'
+            },
+            {
+                route: 'longcontext',
+                triggered: features.estimatedTokens >= (this.config.longContextThresholdTokens ?? DEFAULT_LONG_CONTEXT_THRESHOLD),
+                reason: 'longcontext:token-threshold'
+            },
+            {
+                route: 'thinking',
+                triggered: features.hasThinkingKeyword ||
+                    containsKeywords(features.userTextSample, this.config.thinkingKeywords ?? []),
+                reason: 'thinking:keywords'
+            },
+            {
+                route: 'background',
+                triggered: containsKeywords(features.userTextSample, this.config.backgroundKeywords ?? []),
+                reason: 'background:keywords'
+            }
+        ];
+        const triggeredEvaluations = evaluations.filter((evaluation) => evaluation.triggered);
+        const orderedRoutes = this.orderRoutes(triggeredEvaluations.map((entry) => entry.route));
+        const chosenRoute = orderedRoutes.length ? orderedRoutes[0] : DEFAULT_ROUTE;
+        const chosenReason = triggeredEvaluations.find((entry) => entry.route === chosenRoute)?.reason || 'fallback:default';
+        const candidates = this.ensureDefaultCandidate(orderedRoutes);
+        return this.buildResult(chosenRoute, chosenReason, evaluations, candidates);
+    }
+    buildResult(routeName, chosenReason, evaluations, candidates) {
+        const diagnostics = evaluations
+            .filter((evaluation) => evaluation.triggered)
+            .map((evaluation) => evaluation.reason);
+        const reasoningParts = [chosenReason, ...diagnostics.filter((reason) => reason !== chosenReason)];
+        return {
+            routeName,
+            confidence: 0.9,
+            reasoning: reasoningParts.join('|'),
+            fallback: routeName === DEFAULT_ROUTE,
+            candidates: candidates.length ? candidates : [DEFAULT_ROUTE]
+        };
+    }
+    ensureDefaultCandidate(routes) {
+        const deduped = routes.filter(Boolean);
+        if (!deduped.includes(DEFAULT_ROUTE)) {
+            deduped.push(DEFAULT_ROUTE);
+        }
+        return deduped;
+    }
+    orderRoutes(routes) {
+        const unique = Array.from(new Set(routes.filter(Boolean)));
+        return unique.sort((a, b) => this.routeWeight(a) - this.routeWeight(b));
+    }
+    routeWeight(route) {
+        const index = ROUTE_PRIORITY.indexOf(route);
+        return index >= 0 ? index : ROUTE_PRIORITY.length;
+    }
+}
+function normalizeList(source, fallback) {
+    if (!source || source.length === 0) {
+        return fallback;
+    }
+    return source.map((item) => item.toLowerCase());
+}
+function containsKeywords(text, keywords) {
+    if (!text || !keywords.length) {
+        return false;
+    }
+    const normalized = text.toLowerCase();
+    return keywords.some((keyword) => normalized.includes(keyword));
+}

package/dist/router/virtual-router/engine.d.ts

@@ -0,0 +1,35 @@
+import { type RoutingDecision, type RoutingDiagnostics, type RouterMetadataInput, type VirtualRouterConfig, type TargetMetadata, type ProviderFailureEvent, type ProviderErrorEvent } from './types.js';
+import type { ProcessedRequest, StandardizedRequest } from '../../conversion/hub/types/standardized.js';
+export declare class VirtualRouterEngine {
+    private routing;
+    private readonly providerRegistry;
+    private readonly healthManager;
+    private loadBalancer;
+    private classifier;
+    private routeStats;
+    initialize(config: VirtualRouterConfig): void;
+    route(request: StandardizedRequest | ProcessedRequest, metadata: RouterMetadataInput): {
+        target: TargetMetadata;
+        decision: RoutingDecision;
+        diagnostics: RoutingDiagnostics;
+    };
+    handleProviderFailure(event: ProviderFailureEvent): void;
+    handleProviderError(event: ProviderErrorEvent): void;
+    getStatus(): {
+        routes: Record<string, {
+            providers: string[];
+            hits: number;
+            lastUsedProvider?: string;
+        }>;
+        health: import("./types.js").ProviderHealthState[];
+    };
+    private validateConfig;
+    private selectProvider;
+    private incrementRouteStat;
+    private mapProviderError;
+    private deriveReason;
+    private providerHealthConfig;
+    private buildRouteCandidates;
+    private sortByPriority;
+    private routeWeight;
+}

package/dist/router/virtual-router/engine.js

@@ -0,0 +1,260 @@
+import { ProviderHealthManager } from './health-manager.js';
+import { ProviderRegistry } from './provider-registry.js';
+import { RouteLoadBalancer } from './load-balancer.js';
+import { RoutingClassifier } from './classifier.js';
+import { buildRoutingFeatures } from './features.js';
+import { DEFAULT_ROUTE, ROUTE_PRIORITY, VirtualRouterError, VirtualRouterErrorCode } from './types.js';
+export class VirtualRouterEngine {
+    routing = {};
+    providerRegistry = new ProviderRegistry();
+    healthManager = new ProviderHealthManager();
+    loadBalancer = new RouteLoadBalancer();
+    classifier = new RoutingClassifier({});
+    routeStats = new Map();
+    initialize(config) {
+        this.validateConfig(config);
+        this.routing = config.routing;
+        this.providerRegistry.load(config.providers);
+        this.healthManager.configure(config.health);
+        this.healthManager.registerProviders(Object.keys(config.providers));
+        this.loadBalancer = new RouteLoadBalancer(config.loadBalancing);
+        this.classifier = new RoutingClassifier(config.classifier);
+        this.routeStats = new Map();
+        for (const routeName of Object.keys(this.routing)) {
+            this.routeStats.set(routeName, { hits: 0 });
+        }
+    }
+    route(request, metadata) {
+        const features = buildRoutingFeatures(request, metadata);
+        const classification = this.classifier.classify(features);
+        const routeName = classification.routeName || DEFAULT_ROUTE;
+        const selection = this.selectProvider(routeName, metadata, classification);
+        const target = this.providerRegistry.buildTarget(selection.providerKey);
+        this.healthManager.recordSuccess(selection.providerKey);
+        this.incrementRouteStat(selection.routeUsed, selection.providerKey);
+        const didFallback = selection.routeUsed !== routeName || classification.fallback;
+        return {
+            target,
+            decision: {
+                routeName: selection.routeUsed,
+                providerKey: selection.providerKey,
+                pool: selection.pool,
+                confidence: classification.confidence,
+                reasoning: classification.reasoning,
+                fallback: didFallback
+            },
+            diagnostics: {
+                routeName: selection.routeUsed,
+                providerKey: selection.providerKey,
+                pool: selection.pool,
+                reasoning: classification.reasoning,
+                fallback: didFallback,
+                confidence: classification.confidence
+            }
+        };
+    }
+    handleProviderFailure(event) {
+        if (!event || !event.providerKey) {
+            return;
+        }
+        if (event.affectsHealth === false) {
+            return;
+        }
+        if (event.fatal) {
+            this.healthManager.tripProvider(event.providerKey, event.reason, event.cooldownOverrideMs);
+        }
+        else {
+            this.healthManager.recordFailure(event.providerKey, event.reason);
+        }
+    }
+    handleProviderError(event) {
+        const derived = this.mapProviderError(event);
+        if (!derived) {
+            return;
+        }
+        this.handleProviderFailure(derived);
+    }
+    getStatus() {
+        const routes = {};
+        for (const [route, pool] of Object.entries(this.routing)) {
+            const stats = this.routeStats.get(route) ?? { hits: 0 };
+            routes[route] = {
+                providers: [...pool],
+                hits: stats.hits,
+                lastUsedProvider: stats.lastProvider
+            };
+        }
+        return {
+            routes,
+            health: this.healthManager.getSnapshot()
+        };
+    }
+    validateConfig(config) {
+        if (!config.routing || typeof config.routing !== 'object') {
+            throw new VirtualRouterError('routing configuration is required', VirtualRouterErrorCode.CONFIG_ERROR);
+        }
+        if (!config.providers || Object.keys(config.providers).length === 0) {
+            throw new VirtualRouterError('providers configuration is required', VirtualRouterErrorCode.CONFIG_ERROR);
+        }
+        const defaultPool = config.routing[DEFAULT_ROUTE];
+        if (!Array.isArray(defaultPool) || defaultPool.length === 0) {
+            throw new VirtualRouterError('default route must be configured with at least one provider', VirtualRouterErrorCode.CONFIG_ERROR);
+        }
+        const providerKeys = new Set(Object.keys(config.providers));
+        for (const [routeName, pool] of Object.entries(config.routing)) {
+            if (!Array.isArray(pool) || !pool.length) {
+                if (routeName === DEFAULT_ROUTE) {
+                    throw new VirtualRouterError('default route cannot be empty', VirtualRouterErrorCode.CONFIG_ERROR);
+                }
+                continue;
+            }
+            for (const providerKey of pool) {
+                if (!providerKeys.has(providerKey)) {
+                    throw new VirtualRouterError(`Route ${routeName} references unknown provider ${providerKey}`, VirtualRouterErrorCode.CONFIG_ERROR);
+                }
+            }
+        }
+    }
+    selectProvider(requestedRoute, metadata, classification) {
+        const candidates = this.buildRouteCandidates(requestedRoute, classification.candidates);
+        const stickyKey = metadata.requestId;
+        const attempted = [];
+        for (const routeName of candidates) {
+            const pool = this.routing[routeName];
+            if (!Array.isArray(pool) || pool.length === 0) {
+                attempted.push(routeName);
+                continue;
+            }
+            const providerKey = this.loadBalancer.select({
+                routeName,
+                candidates: pool,
+                stickyKey,
+                availabilityCheck: (key) => this.healthManager.isAvailable(key)
+            });
+            if (providerKey) {
+                return { providerKey, routeUsed: routeName, pool };
+            }
+            attempted.push(routeName);
+        }
+        throw new VirtualRouterError(`All providers unavailable for route ${requestedRoute}`, VirtualRouterErrorCode.PROVIDER_NOT_AVAILABLE, { routeName: requestedRoute, attempted });
+    }
+    incrementRouteStat(routeName, providerKey) {
+        if (!this.routeStats.has(routeName)) {
+            this.routeStats.set(routeName, { hits: 0, lastProvider: providerKey });
+            return;
+        }
+        const stats = this.routeStats.get(routeName);
+        stats.hits += 1;
+        stats.lastProvider = providerKey;
+    }
+    mapProviderError(event) {
+        if (!event || !event.runtime) {
+            return null;
+        }
+        const runtime = event.runtime;
+        const providerKey = runtime.providerKey ||
+            (runtime.target && typeof runtime.target === 'object' ? runtime.target.providerKey : undefined);
+        if (!providerKey) {
+            return null;
+        }
+        const routeName = runtime.routeName;
+        const statusCode = event.status;
+        const code = event.code?.toUpperCase() ?? 'ERR_UNKNOWN';
+        const stage = event.stage?.toLowerCase() ?? 'unknown';
+        const recoverable = event.recoverable === true;
+        let fatal = !recoverable;
+        let reason = this.deriveReason(code, stage, statusCode);
+        let cooldownOverrideMs;
+        if (statusCode === 429 || code.includes('429') || recoverable) {
+            fatal = false;
+            cooldownOverrideMs = Math.max(30_000, this.providerHealthConfig().cooldownMs);
+            reason = 'rate_limit';
+        }
+        else if (statusCode === 401 || statusCode === 403 || code.includes('AUTH')) {
+            fatal = true;
+            cooldownOverrideMs = Math.max(10 * 60_000, this.providerHealthConfig().fatalCooldownMs ?? 10 * 60_000);
+            reason = 'auth';
+        }
+        else if (statusCode && statusCode >= 500) {
+            fatal = true;
+            cooldownOverrideMs = Math.max(5 * 60_000, this.providerHealthConfig().fatalCooldownMs ?? 5 * 60_000);
+            reason = 'upstream_error';
+        }
+        else if (stage.includes('compat')) {
+            fatal = true;
+            cooldownOverrideMs = Math.max(10 * 60_000, this.providerHealthConfig().fatalCooldownMs ?? 10 * 60_000);
+            reason = 'compatibility';
+        }
+        return {
+            providerKey,
+            routeName,
+            reason,
+            fatal,
+            statusCode,
+            errorCode: code,
+            retryable: recoverable,
+            affectsHealth: true,
+            cooldownOverrideMs,
+            metadata: {
+                ...event.runtime,
+                stage,
+                eventCode: code,
+                originalMessage: event.message,
+                statusCode
+            }
+        };
+    }
+    deriveReason(code, stage, statusCode) {
+        if (code.includes('RATE') || code.includes('429'))
+            return 'rate_limit';
+        if (code.includes('AUTH') || statusCode === 401 || statusCode === 403)
+            return 'auth';
+        if (stage.includes('compat'))
+            return 'compatibility';
+        if (code.includes('SSE'))
+            return 'sse';
+        if (code.includes('TIMEOUT') || statusCode === 408 || statusCode === 504)
+            return 'timeout';
+        if (statusCode && statusCode >= 500)
+            return 'upstream_error';
+        if (statusCode && statusCode >= 400)
+            return 'client_error';
+        return 'unknown';
+    }
+    providerHealthConfig() {
+        return this.healthManager.getConfig();
+    }
+    buildRouteCandidates(requestedRoute, classificationCandidates) {
+        const normalized = requestedRoute || DEFAULT_ROUTE;
+        const baseList = classificationCandidates && classificationCandidates.length
+            ? classificationCandidates
+            : [normalized];
+        const ordered = this.sortByPriority(baseList);
+        const deduped = [];
+        for (const routeName of ordered) {
+            if (routeName && !deduped.includes(routeName)) {
+                deduped.push(routeName);
+            }
+        }
+        if (!deduped.includes(DEFAULT_ROUTE)) {
+            deduped.push(DEFAULT_ROUTE);
+        }
+        const filtered = deduped.filter((routeName) => {
+            const pool = this.routing[routeName];
+            return Array.isArray(pool) && pool.length > 0;
+        });
+        if (!filtered.includes(DEFAULT_ROUTE) &&
+            Array.isArray(this.routing[DEFAULT_ROUTE]) &&
+            this.routing[DEFAULT_ROUTE].length > 0) {
+            filtered.push(DEFAULT_ROUTE);
+        }
+        return filtered.length ? filtered : [DEFAULT_ROUTE];
+    }
+    sortByPriority(routeNames) {
+        return [...routeNames].sort((a, b) => this.routeWeight(a) - this.routeWeight(b));
+    }
+    routeWeight(routeName) {
+        const idx = ROUTE_PRIORITY.indexOf(routeName);
+        return idx >= 0 ? idx : ROUTE_PRIORITY.length;
+    }
+}

package/dist/router/virtual-router/error-center.d.ts

@@ -0,0 +1,10 @@
+import type { ProviderErrorEvent } from './types.js';
+type ProviderErrorListener = (event: ProviderErrorEvent) => void;
+export declare class ProviderErrorCenter {
+    private readonly listeners;
+    subscribe(listener: ProviderErrorListener): () => void;
+    emit(event: ProviderErrorEvent): ProviderErrorEvent;
+    private normalize;
+}
+export declare const providerErrorCenter: ProviderErrorCenter;
+export {};

package/dist/router/virtual-router/error-center.js

@@ -0,0 +1,39 @@
+export class ProviderErrorCenter {
+    listeners = new Set();
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    emit(event) {
+        const enriched = this.normalize(event);
+        for (const listener of this.listeners) {
+            try {
+                listener(enriched);
+            }
+            catch {
+                // Listener failures should not break propagation
+            }
+        }
+        return enriched;
+    }
+    normalize(event) {
+        const timestamp = typeof event.timestamp === 'number' ? event.timestamp : Date.now();
+        const code = event.code?.toString() || 'ERR_UNKNOWN';
+        const message = event.message || code;
+        const stage = event.stage || 'unknown';
+        const runtime = event.runtime || {};
+        return {
+            code,
+            message,
+            stage,
+            status: event.status,
+            recoverable: event.recoverable,
+            runtime,
+            timestamp,
+            details: event.details
+        };
+    }
+}
+export const providerErrorCenter = new ProviderErrorCenter();

package/dist/router/virtual-router/features.d.ts

@@ -0,0 +1,3 @@
+import type { ProcessedRequest, StandardizedRequest } from '../../conversion/hub/types/standardized.js';
+import type { RouterMetadataInput, RoutingFeatures } from './types.js';
+export declare function buildRoutingFeatures(request: StandardizedRequest | ProcessedRequest, metadata: RouterMetadataInput): RoutingFeatures;

package/dist/router/virtual-router/features.js

@@ -0,0 +1,162 @@
+const THINKING_KEYWORDS = ['let me think', 'chain of thought', 'cot', 'reason step', 'deliberate'];
+const WEB_TOOL_KEYWORDS = ['websearch', 'web_search', 'web-search', 'webfetch', 'web_fetch', 'web_request', 'search_web', 'internet_search'];
+export function buildRoutingFeatures(request, metadata) {
+    const latestUserMessage = getLatestUserMessage(request.messages);
+    const assistantMessages = request.messages.filter((msg) => msg.role === 'assistant');
+    const latestUserText = latestUserMessage ? extractMessageText(latestUserMessage) : '';
+    const normalizedUserText = latestUserText.toLowerCase();
+    const hasTools = Array.isArray(request.tools) && request.tools.length > 0;
+    const hasToolCallResponses = assistantMessages.some((msg) => Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0);
+    const estimatedTokens = estimateTokens(latestUserText, latestUserText ? 1 : 0);
+    const hasThinking = detectKeyword(normalizedUserText, THINKING_KEYWORDS);
+    const hasVisionTool = detectVisionTool(request);
+    const hasImageAttachment = hasVisionTool && detectImageAttachment(latestUserMessage);
+    const hasCodingTool = detectCodingTool(request);
+    const hasWebTool = detectWebTool(request);
+    const hasThinkingKeyword = hasThinking || detectExtendedThinkingKeyword(normalizedUserText);
+    return {
+        requestId: metadata.requestId,
+        model: request.model,
+        totalMessages: latestUserText ? 1 : 0,
+        userTextSample: latestUserText.slice(0, 2000),
+        toolCount: request.tools?.length ?? 0,
+        hasTools,
+        hasToolCallResponses,
+        hasVisionTool,
+        hasImageAttachment,
+        hasWebTool,
+        hasCodingTool,
+        hasThinkingKeyword,
+        estimatedTokens,
+        metadata: {
+            ...metadata
+        }
+    };
+}
+function getLatestUserMessage(messages) {
+    for (let idx = messages.length - 1; idx >= 0; idx -= 1) {
+        if (messages[idx]?.role === 'user') {
+            return messages[idx];
+        }
+    }
+    return undefined;
+}
+function extractMessageText(message) {
+    if (typeof message.content === 'string' && message.content.trim()) {
+        return message.content;
+    }
+    return '';
+}
+function detectKeyword(text, keywords) {
+    if (!text)
+        return false;
+    return keywords.some((keyword) => text.includes(keyword.toLowerCase()));
+}
+function detectImageAttachment(message) {
+    if (!message)
+        return false;
+    if (!message.metadata || typeof message.metadata !== 'object') {
+        return false;
+    }
+    const meta = message.metadata;
+    const attachments = (meta.attachments ?? null);
+    if (Array.isArray(attachments)) {
+        return attachments.some((attachment) => {
+            const candidate = attachment;
+            const typeValue = typeof candidate.type === 'string' ? candidate.type.toLowerCase() : '';
+            const urlValue = typeof candidate.url === 'string'
+                ? candidate.url
+                : typeof candidate.src === 'string'
+                    ? candidate.src
+                    : typeof candidate.image_url === 'string'
+                        ? candidate.image_url
+                        : typeof candidate.image_url?.url === 'string'
+                            ? candidate.image_url.url
+                            : '';
+            return typeValue.includes('image') && urlValue.trim().length > 0;
+        });
+    }
+    if (typeof meta.attachmentType === 'string' && meta.attachmentType.toLowerCase().includes('image')) {
+        const urlCandidate = typeof meta.attachmentUrl === 'string' ? meta.attachmentUrl : '';
+        return urlCandidate.trim().length > 0;
+    }
+    return false;
+}
+function detectVisionTool(request) {
+    if (!Array.isArray(request.tools)) {
+        return false;
+    }
+    return request.tools.some((tool) => {
+        const functionName = extractToolName(tool);
+        const description = extractToolDescription(tool);
+        return /vision|image|picture|photo/i.test(functionName) || /vision|image|picture|photo/i.test(description || '');
+    });
+}
+function detectCodingTool(request) {
+    if (!Array.isArray(request.tools)) {
+        return false;
+    }
+    return request.tools.some((tool) => {
+        const functionName = extractToolName(tool);
+        const description = extractToolDescription(tool);
+        const chineseDesc = description;
+        return (/write_file|apply_patch|modify_file|edit_file|create_file|shell|terminal|bash|run_shell/i.test(functionName) ||
+            /write file|apply patch|modify file|edit file|create file|shell|terminal|bash|run shell/i.test(description || '') ||
+            /创建文件|修改文件|写入文件|执行shell|执行终端/.test(chineseDesc || ''));
+    });
+}
+function detectWebTool(request) {
+    if (!Array.isArray(request.tools)) {
+        return false;
+    }
+    return request.tools.some((tool) => {
+        const functionName = extractToolName(tool);
+        const description = extractToolDescription(tool);
+        const normalizedName = functionName.toLowerCase();
+        const normalizedDesc = (description || '').toLowerCase();
+        return (WEB_TOOL_KEYWORDS.some((keyword) => normalizedName.includes(keyword)) ||
+            WEB_TOOL_KEYWORDS.some((keyword) => normalizedDesc.includes(keyword)));
+    });
+}
+function detectExtendedThinkingKeyword(text) {
+    if (!text) {
+        return false;
+    }
+    const keywords = ['仔细分析', '思考', '超级思考', '深度思考', 'careful analysis', 'deep thinking', 'deliberate'];
+    return keywords.some((keyword) => text.includes(keyword));
+}
+function estimateTokens(text, messageCount) {
+    if (!text) {
+        return Math.max(32, messageCount * 16);
+    }
+    const rough = Math.ceil(text.length / 4);
+    return Math.max(rough, messageCount * 32);
+}
+function extractToolName(tool) {
+    if (!tool || typeof tool !== 'object') {
+        return '';
+    }
+    const candidate = tool;
+    const fromFunction = candidate.function;
+    if (fromFunction && typeof fromFunction.name === 'string' && fromFunction.name.trim()) {
+        return fromFunction.name;
+    }
+    if (typeof candidate.name === 'string' && candidate.name.trim()) {
+        return candidate.name;
+    }
+    return '';
+}
+function extractToolDescription(tool) {
+    if (!tool || typeof tool !== 'object') {
+        return '';
+    }
+    const candidate = tool;
+    const fromFunction = candidate.function;
+    if (fromFunction && typeof fromFunction.description === 'string' && fromFunction.description.trim()) {
+        return fromFunction.description;
+    }
+    if (typeof candidate.description === 'string' && candidate.description.trim()) {
+        return candidate.description;
+    }
+    return '';
+}

package/dist/router/virtual-router/health-manager.d.ts

@@ -0,0 +1,18 @@
+import type { ProviderHealthConfig, ProviderHealthState } from './types.js';
+interface ProviderInternalState extends ProviderHealthState {
+    lastFailureAt?: number;
+}
+export declare class ProviderHealthManager {
+    private readonly states;
+    private config;
+    configure(config?: ProviderHealthConfig): void;
+    registerProviders(providerKeys: string[]): void;
+    recordFailure(providerKey: string, reason?: string): ProviderInternalState;
+    recordSuccess(providerKey: string): ProviderInternalState;
+    tripProvider(providerKey: string, reason?: string, cooldownOverrideMs?: number): ProviderInternalState;
+    isAvailable(providerKey: string): boolean;
+    getSnapshot(): ProviderHealthState[];
+    getConfig(): Required<ProviderHealthConfig>;
+    private getState;
+}
+export {};