dsh-openrouter-provider-advisor 0.1.0

package/lib/types/apply-provider.d.ts

@@ -0,0 +1,52 @@
+import type { OpenRouterEndpoint } from './types.js';
+export interface DshModelEntry {
+    id: string;
+    name?: string;
+    contextWindow?: number;
+    compat?: {
+        thinkingFormat?: string;
+        [key: string]: unknown;
+    };
+    reasoningEfforts?: Record<string, string | null> | false;
+    openrouterModel?: string;
+    [key: string]: unknown;
+}
+export interface ApplyProviderDependencies {
+    upsertPreset(modelId: string, tag: string): Promise<{
+        slug: string;
+    }>;
+    readModels(route: string): Promise<DshModelEntry[]>;
+    writeModels(route: string, models: DshModelEntry[]): Promise<void>;
+    selectModel(selection: {
+        sessionId: string;
+        provider: string;
+        model: string;
+        reasoningEffort?: string;
+    }): Promise<void>;
+    saveDefault(selection: {
+        provider: string;
+        model: string;
+        reasoningEffort?: string;
+    }): Promise<void>;
+}
+export interface ApplyProviderInput {
+    sessionId: string;
+    route: string;
+    sourceModel: string;
+    openrouterModel: string;
+    endpoint: OpenRouterEndpoint;
+    reasoningEffort?: string;
+}
+export declare class ProviderApplyError extends Error {
+    readonly stage: 'preset' | 'settings' | 'select-model' | 'default';
+    readonly partial: boolean;
+    constructor(message: string, stage: 'preset' | 'settings' | 'select-model' | 'default', partial: boolean, options?: ErrorOptions);
+}
+export declare function applyProvider(deps: ApplyProviderDependencies, input: ApplyProviderInput): Promise<{
+    ok: true;
+    provider: string;
+    model: string;
+    tag: string;
+    openrouterModel: string;
+}>;
+//# sourceMappingURL=apply-provider.d.ts.map

package/lib/types/client/i18n.d.ts

@@ -0,0 +1,24 @@
+export type SupportedLocale = 'zh-CN' | 'en-US';
+export type TranslationKey = 'panel.title' | 'panel.currentModelLoading' | 'panel.modelSelect' | 'panel.strategyGroup' | 'panel.refresh' | 'panel.close' | 'panel.loading' | 'panel.titleTrigger' | 'panel.unavailable' | 'panel.group.recommended' | 'panel.group.rest' | 'panel.column.provider' | 'panel.column.details' | 'panel.column.score' | 'panel.current' | 'panel.credentialMissing' | 'panel.switchHint' | 'panel.uptime' | 'panel.uptimeDelayHint' | 'panel.strategy.balanced' | 'panel.strategy.price' | 'panel.strategy.speed' | 'panel.strategy.context' | 'settings.title' | 'settings.summary' | 'settings.action.weights' | 'settings.action.priceBlend' | 'settings.action.reset' | 'settings.action.lock' | 'settings.action.unlock' | 'settings.expand' | 'settings.collapse' | 'settings.row.minContextTokens' | 'settings.row.recommendedCount' | 'settings.row.cacheTtlMs' | 'settings.row.weights.quantization' | 'settings.row.weights.speed' | 'settings.row.weights.price' | 'settings.row.weights.context' | 'settings.row.priceBlend.input' | 'settings.row.priceBlend.output' | 'settings.row.priceBlend.cache' | 'settings.row.uptimePenaltyThreshold' | 'settings.row.uptimePenaltyFactor' | 'settings.group.weights.title' | 'settings.group.weights.scope' | 'settings.group.priceBlend.title' | 'settings.group.priceBlend.scope' | 'settings.group.advanced.title' | 'settings.group.strategies.title' | 'settings.group.strategies.scope' | 'settings.dimension.quantization' | 'settings.dimension.speed' | 'settings.dimension.price' | 'settings.dimension.context' | 'settings.dimension.input' | 'settings.dimension.output' | 'settings.dimension.cache' | 'settings.connection.title' | 'settings.connection.loading' | 'settings.connection.configured' | 'settings.connection.missing' | 'settings.connection.error' | 'settings.connection.guide';
+export declare const zh: Record<TranslationKey, string>;
+export declare const en: Record<TranslationKey, string>;
+export declare const LOCALE_NS = "openrouterProviders";
+export interface LocaleServiceLike {
+    getSnapshot(): {
+        active: string;
+    };
+    subscribe(listener: () => void): () => void;
+}
+export declare function attachLocale(service: LocaleServiceLike | undefined): void;
+export declare function normalizeLocale(input?: string): SupportedLocale;
+export declare function getLocaleSnapshot(): SupportedLocale;
+export declare function createI18n(locale: string): {
+    locale: SupportedLocale;
+    t(key: TranslationKey, params?: Record<string, string | number>): string;
+};
+export declare function subscribeLocale(listener: () => void): () => void;
+export declare function useUiI18n(): {
+    locale: SupportedLocale;
+    t(key: TranslationKey, params?: Record<string, string | number>): string;
+};
+//# sourceMappingURL=i18n.d.ts.map

package/lib/types/client/index.d.ts

@@ -0,0 +1,4 @@
+import type { ClientContext } from '@deepseek-ai/dsh-client-runtime/client';
+export declare const inject: string[];
+export declare function apply(ctx: ClientContext): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/client/linked-weights.d.ts

@@ -0,0 +1,3 @@
+export declare function rebalanceWeights<V extends Record<string, number>, K extends keyof V & string>(values: V, changedKey: K, requestedValue: number, lockedKeys: ReadonlySet<string>): V;
+export declare function percent(value: number): string;
+//# sourceMappingURL=linked-weights.d.ts.map

package/lib/types/client/provider-panel-store.d.ts

@@ -0,0 +1,42 @@
+import type { RecommendationResponse } from '../directory.js';
+import type { RankingStrategy } from '../config.js';
+export interface ProviderPanelSnapshot {
+    open: boolean;
+    status: 'idle' | 'loading' | 'ready' | 'applying' | 'error';
+    sessionId: string | null;
+    data: RecommendationResponse | null;
+    models: ConfiguredProviderModel[];
+    selected: {
+        provider: string;
+        model: string;
+        name?: string;
+    } | null;
+    strategy: RankingStrategy;
+    error: string | null;
+    credential: {
+        configured: boolean;
+        ref: string;
+        source: 'provider' | 'fallback';
+    } | null;
+}
+export interface ConfiguredProviderModel {
+    provider: string;
+    model: string;
+    name: string;
+    matchName: string;
+    current: boolean;
+}
+export interface ProviderPanelStore {
+    getSnapshot(): ProviderPanelSnapshot;
+    subscribe(listener: () => void): () => void;
+    toggle(sessionId: string): Promise<void>;
+    open(sessionId: string): Promise<void>;
+    close(): void;
+    refresh(sessionId: string): Promise<void>;
+    selectModel(sessionId: string, provider: string, model: string, name: string): Promise<void>;
+    setStrategy(sessionId: string, strategy: RankingStrategy): Promise<void>;
+    apply(sessionId: string, tag: string): Promise<void>;
+    dispose(): void;
+}
+export declare function createProviderPanelStore(fetchImpl?: typeof fetch): ProviderPanelStore;
+//# sourceMappingURL=provider-panel-store.d.ts.map

package/lib/types/client/provider-panel.d.ts

@@ -0,0 +1,47 @@
+import { type CSSProperties, type ReactNode } from 'react';
+import type { RecommendationResponse } from '../directory.js';
+import type { RankingStrategy } from '../config.js';
+import type { ProviderPanelStore } from './provider-panel-store.js';
+interface SessionListLike {
+    current?: string | undefined;
+    currentAddress?: unknown | undefined;
+}
+interface GlobalSlotProps {
+    useSessions<T>(selector: (state: SessionListLike) => T): T;
+}
+export interface ProviderRowView {
+    group: string;
+    tag: string;
+    providerName: string;
+    current: boolean;
+    detail: string;
+    score: number;
+    scoreLabel: string;
+}
+export declare const STRATEGY_OPTIONS: ReadonlyArray<{
+    id: RankingStrategy;
+    labelKey: 'panel.strategy.balanced' | 'panel.strategy.price' | 'panel.strategy.speed' | 'panel.strategy.context';
+}>;
+export declare function providerRows(data: RecommendationResponse, i18n?: {
+    locale: import("./i18n.js").SupportedLocale;
+    t(key: import("./i18n.js").TranslationKey, params?: Record<string, string | number>): string;
+}): ProviderRowView[];
+export declare function providerTableColumns(i18n?: {
+    locale: import("./i18n.js").SupportedLocale;
+    t(key: import("./i18n.js").TranslationKey, params?: Record<string, string | number>): string;
+}): [string, string, string];
+export declare function providerTriggerState(state: SessionListLike): {
+    sessionId: string | null;
+    disabled: boolean;
+};
+export declare function providerTriggerLayout(wide: boolean): CSSProperties;
+export declare function ProviderSidebarTrigger(props: GlobalSlotProps & {
+    wide: boolean;
+    store: ProviderPanelStore;
+}): ReactNode;
+export declare const providerGridColumns = "minmax(110px,1fr) minmax(0,2fr) minmax(54px,auto)";
+export declare function ProviderOverlay(props: GlobalSlotProps & {
+    store: ProviderPanelStore;
+}): ReactNode;
+export {};
+//# sourceMappingURL=provider-panel.d.ts.map

package/lib/types/client/settings-card.d.ts

@@ -0,0 +1,24 @@
+import { type ReactNode } from 'react';
+import { type Config } from '../config.js';
+export interface SettingsScopeLike {
+    getSnapshot(): {
+        status: string;
+        value?: Config;
+        writable: boolean;
+    };
+    subscribe(listener: () => void): () => void;
+    set(field: string, value: unknown): Promise<void>;
+}
+type ConfigField = keyof Config | `weights.${keyof Config['weights']}` | `priceBlend.${keyof Config['priceBlend']}`;
+export declare function setConfigField(scope: Pick<SettingsScopeLike, 'set'>, config: Config, field: ConfigField, value: number): Promise<void>;
+export declare function setConfigGroup(scope: Pick<SettingsScopeLike, 'set'>, group: 'weights' | 'priceBlend', value: Record<string, number>): Promise<void>;
+export declare function settingsDisclosureLabel(open: boolean, locale?: string): string;
+export declare function strategyWeightRows(locale?: string): Array<{
+    name: string;
+    values: string;
+}>;
+export declare function OpenRouterProvidersSettingsCard({ scope }: {
+    scope: SettingsScopeLike;
+}): ReactNode;
+export {};
+//# sourceMappingURL=settings-card.d.ts.map

package/lib/types/client/weight-group.d.ts

@@ -0,0 +1,22 @@
+import { type ReactNode } from 'react';
+import type { TranslationKey } from './i18n.js';
+export interface WeightItem<K extends string> {
+    key: K;
+    label: string;
+    color: string;
+}
+export interface WeightGroupProps<K extends string> {
+    title: string;
+    scope: string;
+    values: Record<K, number>;
+    defaults: Record<K, number>;
+    items: readonly WeightItem<K>[];
+    writable: boolean;
+    applyLabel: string;
+    resetLabel: string;
+    t(key: TranslationKey, params?: Record<string, string | number>): string;
+    onChange(values: Record<K, number>): void;
+    onApply(): void;
+}
+export declare function WeightGroup<K extends string>(props: WeightGroupProps<K>): ReactNode;
+//# sourceMappingURL=weight-group.d.ts.map

package/lib/types/config.d.ts

@@ -0,0 +1,24 @@
+export interface Config {
+    minContextTokens: number;
+    cacheTtlMs: number;
+    recommendedCount: number;
+    weights: {
+        quantization: number;
+        speed: number;
+        price: number;
+        context: number;
+    };
+    priceBlend: {
+        input: number;
+        output: number;
+        cache: number;
+    };
+    uptimePenaltyThreshold: number;
+    uptimePenaltyFactor: number;
+}
+export type RankingStrategy = 'balanced' | 'price' | 'speed' | 'context';
+export declare const STRATEGY_WEIGHTS: Readonly<Record<Exclude<RankingStrategy, 'balanced'>, Config['weights']>>;
+export declare const DEFAULT_CONFIG: Readonly<Config>;
+export declare function validateConfig(config: Config): void;
+export declare function configForStrategy(config: Config, strategy: RankingStrategy): Config;
+//# sourceMappingURL=config.d.ts.map

package/lib/types/controller.d.ts

@@ -0,0 +1,107 @@
+import { type DshModelEntry } from './apply-provider.js';
+import { type Config, type RankingStrategy } from './config.js';
+import { type RecommendationResponse } from './directory.js';
+import type { OpenRouterEndpoint, OpenRouterModel } from './types.js';
+export interface SessionSelection {
+    provider: string;
+    model: string;
+    reasoningEffort?: string;
+}
+export interface ProviderProfile {
+    baseURL?: string;
+    apiKeyEnv?: string;
+    models?: DshModelEntry[];
+}
+export interface ProviderCredential {
+    configured: boolean;
+    ref: string;
+    source: 'provider' | 'fallback';
+    value?: string;
+}
+export type ResolvedProviderCredential = ProviderCredential & {
+    configured: true;
+    value: string;
+};
+export interface ControllerDependencies {
+    config(): Config;
+    credential(provider: string): Promise<ProviderCredential>;
+    sessionSelection(sessionId: string): Promise<SessionSelection>;
+    sessionDirectory(sessionId: string): Promise<{
+        current: SessionSelection;
+        groups: Array<{
+            id: string;
+            name: string;
+            models: Array<{
+                id: string;
+                name: string;
+            }>;
+        }>;
+    }>;
+    providerProfile(provider: string): ProviderProfile | undefined;
+    providerProfiles(): Record<string, ProviderProfile>;
+    listModels(credential: ResolvedProviderCredential): Promise<OpenRouterModel[]>;
+    getEndpoints(credential: ResolvedProviderCredential, modelId: string, refresh: boolean): Promise<OpenRouterEndpoint[]>;
+    upsertPreset(credential: ResolvedProviderCredential, modelId: string, tag: string): Promise<{
+        slug: string;
+    }>;
+    writeModels(route: string, models: DshModelEntry[]): Promise<void>;
+    selectModel(selection: {
+        sessionId: string;
+        provider: string;
+        model: string;
+        reasoningEffort?: string;
+    }): Promise<void>;
+    saveDefault(selection: {
+        provider: string;
+        model: string;
+        reasoningEffort?: string;
+    }): Promise<void>;
+}
+export declare class OpenRouterProviderController {
+    private readonly deps;
+    private readonly state;
+    constructor(deps: ControllerDependencies);
+    private key;
+    connection(): Promise<{
+        ok: true;
+        configured: boolean;
+        routes: Array<{
+            provider: string;
+            credentialRef: string;
+            configured: boolean;
+            source: 'provider' | 'fallback';
+        }>;
+    }>;
+    models(sessionId: string): Promise<{
+        ok: true;
+        credential: {
+            configured: boolean;
+            ref: string;
+            source: 'provider' | 'fallback';
+        };
+        current: {
+            provider: string;
+            model: string;
+        };
+        models: Array<{
+            provider: string;
+            model: string;
+            name: string;
+            matchName: string;
+            current: boolean;
+        }>;
+    }>;
+    recommend(sessionId: string, refresh?: boolean, override?: {
+        provider?: string;
+        model?: string;
+        name?: string;
+        strategy?: RankingStrategy;
+    }): Promise<RecommendationResponse>;
+    apply(sessionId: string, tag: string, override?: {
+        provider?: string;
+        model?: string;
+        name?: string;
+        strategy?: RankingStrategy;
+    }): Promise<unknown>;
+}
+//# sourceMappingURL=controller.d.ts.map

package/lib/types/directory.d.ts

@@ -0,0 +1,39 @@
+import type { Config } from './config.js';
+import { type ResolveInput } from './resolve-model.js';
+import type { OpenRouterEndpoint, OpenRouterModel, RankedProvider } from './types.js';
+export type DirectoryErrorCode = 'NOT_OPENROUTER' | 'MODEL_NOT_FOUND' | 'MODEL_AMBIGUOUS' | 'NO_ELIGIBLE_ENDPOINTS';
+export declare class ProviderDirectoryError extends Error {
+    readonly code: DirectoryErrorCode;
+    readonly details?: unknown | undefined;
+    constructor(message: string, code: DirectoryErrorCode, details?: unknown | undefined);
+}
+export interface DirectoryInput extends ResolveInput {
+    currentTag?: string;
+}
+export interface RecommendationResponse {
+    ok: true;
+    dsh: {
+        provider: string;
+        model: string;
+    };
+    openrouterModel: string;
+    currentTag?: string;
+    recommended: RankedProvider[];
+    rest: RankedProvider[];
+}
+export interface DirectoryDependencies {
+    config(): Config;
+    listModels(): Promise<OpenRouterModel[]>;
+    getEndpoints(modelId: string, options?: {
+        refresh?: boolean;
+    }): Promise<OpenRouterEndpoint[]>;
+}
+export declare class OpenRouterProviderDirectory {
+    private readonly deps;
+    constructor(deps: DirectoryDependencies);
+    recommend(input: DirectoryInput, options?: {
+        refresh?: boolean;
+    }): Promise<RecommendationResponse>;
+    refresh(input: DirectoryInput): Promise<RecommendationResponse>;
+}
+//# sourceMappingURL=directory.d.ts.map

package/lib/types/host-adapter.d.ts

@@ -0,0 +1,64 @@
+import type { Config } from './config.js';
+import { OpenRouterProviderController, type SessionSelection } from './controller.js';
+interface RpcResult<T> {
+    result: {
+        ok: true;
+        value: T;
+    } | {
+        ok: false;
+        error: {
+            code: string;
+            message: string;
+        };
+    };
+}
+export interface HostContextLike {
+    credentials: {
+        resolve(ref: unknown): Promise<{
+            value: string;
+        } | undefined>;
+    };
+    settings: {
+        get(ns: unknown): unknown;
+        mutate(ns: unknown, ops: Array<{
+            op: 'set';
+            path: string[];
+            value: unknown;
+        }>): Promise<void>;
+    };
+    apiProxy: {
+        sessions: {
+            models(input: {
+                payload: {
+                    sessionId: string;
+                };
+            }): Promise<RpcResult<{
+                current: SessionSelection;
+                groups?: Array<{
+                    id: string;
+                    name: string;
+                    models: Array<{
+                        id: string;
+                        name: string;
+                    }>;
+                }>;
+            }>>;
+            selectModel(input: {
+                payload: {
+                    sessionId: string;
+                    provider: string;
+                    model: string;
+                    reasoningEffort?: string;
+                };
+            }): Promise<RpcResult<{
+                selected: SessionSelection;
+            }>>;
+        };
+    };
+    agentDefaultModel: {
+        saveSelection(selection: Omit<SessionSelection, never>): Promise<void>;
+    };
+}
+export declare function createHostController(ctx: HostContextLike, config: () => Config, credentialRef: (name: string) => unknown): OpenRouterProviderController;
+export {};
+//# sourceMappingURL=host-adapter.d.ts.map

package/lib/types/host-routes.d.ts

@@ -0,0 +1,21 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { RankingStrategy } from './config.js';
+import type { RecommendationResponse } from './directory.js';
+export interface ProviderHostController {
+    connection(): Promise<unknown>;
+    models(sessionId: string): Promise<unknown>;
+    recommend(sessionId: string, refresh?: boolean, override?: {
+        provider?: string;
+        model?: string;
+        name?: string;
+        strategy?: RankingStrategy;
+    }): Promise<RecommendationResponse>;
+    apply(sessionId: string, tag: string, override?: {
+        provider?: string;
+        model?: string;
+        name?: string;
+        strategy?: RankingStrategy;
+    }): Promise<unknown>;
+}
+export declare function createProviderRoute(controller: ProviderHostController): (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+//# sourceMappingURL=host-routes.d.ts.map

package/lib/types/index.d.ts

@@ -0,0 +1,10 @@
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+import { type Config as ProviderConfig } from './config.js';
+export declare const name = "openrouter-providers";
+export declare const inject: string[];
+export declare const NS: import("@deepseek-ai/dsh-settings").SettingsNamespace;
+export declare const Config: z<ProviderConfig>;
+export declare function apply(ctx: Context, initial?: ProviderConfig): void;
+export { OpenRouterProviderDirectory } from './directory.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/types/openrouter.d.ts

@@ -0,0 +1,34 @@
+import type { OpenRouterEndpoint, OpenRouterModel } from './types.js';
+export declare class OpenRouterError extends Error {
+    readonly status: number;
+    readonly body?: unknown | undefined;
+    constructor(message: string, status: number, body?: unknown | undefined);
+}
+export interface OpenRouterClientOptions {
+    apiKey: string;
+    fetch?: typeof globalThis.fetch;
+    cacheTtlMs?: number;
+    now?: () => number;
+    baseURL?: string;
+}
+export declare class OpenRouterClient {
+    private readonly options;
+    private readonly fetchImpl;
+    private readonly cache;
+    private modelCatalogCache;
+    private readonly ttl;
+    private readonly now;
+    private readonly baseURL;
+    constructor(options: OpenRouterClientOptions);
+    private request;
+    listModels(): Promise<OpenRouterModel[]>;
+    getEndpoints(modelId: string, options?: {
+        refresh?: boolean;
+    }): Promise<OpenRouterEndpoint[]>;
+    clearEndpoints(modelId: string): void;
+    upsertPreset(modelId: string, tag: string): Promise<{
+        slug: string;
+        response: unknown;
+    }>;
+}
+//# sourceMappingURL=openrouter.d.ts.map

package/lib/types/resolve-model.d.ts

@@ -0,0 +1,23 @@
+import type { OpenRouterModel } from './types.js';
+export interface ResolveInput {
+    provider: string;
+    model: string;
+    name?: string;
+    baseURL?: string;
+    presetModel?: string;
+}
+export type ResolveResult = {
+    kind: 'matched';
+    model: OpenRouterModel;
+} | {
+    kind: 'ambiguous';
+    candidates: OpenRouterModel[];
+} | {
+    kind: 'not-found';
+    normalized: string;
+} | {
+    kind: 'not-openrouter';
+};
+export declare function normalizeModelName(value: string): string;
+export declare function resolveOpenRouterModel(input: ResolveInput, catalog: readonly OpenRouterModel[]): ResolveResult;
+//# sourceMappingURL=resolve-model.d.ts.map

package/lib/types/score.d.ts

@@ -0,0 +1,5 @@
+import type { Config } from './config.js';
+import type { OpenRouterEndpoint, RankedProviders } from './types.js';
+export declare function uptimeMultiplier(uptime: number | null, config: Config): number;
+export declare function rankEndpoints(endpoints: readonly OpenRouterEndpoint[], config: Config, currentTag?: string): RankedProviders;
+//# sourceMappingURL=score.d.ts.map

package/lib/types/tools.d.ts

@@ -0,0 +1,17 @@
+import type { ProviderHostController } from './host-routes.js';
+type DefineTool = (definition: Record<string, unknown>) => unknown;
+type PreToolDecision = {
+    kind: 'allow';
+} | {
+    kind: 'deny';
+    reason: string;
+} | {
+    kind: 'ask';
+    reason?: string;
+};
+export declare function providerToolApproval(exec: {
+    name: string;
+}, next: () => Promise<PreToolDecision>): Promise<PreToolDecision>;
+export declare function createProviderTools(defineTool: DefineTool, controller: Pick<ProviderHostController, 'recommend' | 'apply'>): unknown[];
+export {};
+//# sourceMappingURL=tools.d.ts.map

package/lib/types/types.d.ts

@@ -0,0 +1,53 @@
+export interface OpenRouterModel {
+    id: string;
+    name: string;
+}
+export interface OpenRouterEndpoint {
+    provider_name: string;
+    tag: string;
+    quantization?: string | null;
+    context_length: number;
+    status: number;
+    throughput_last_30m?: {
+        p50?: number | null;
+    } | null;
+    latency_last_30m?: {
+        p50?: number | null;
+    } | null;
+    pricing: {
+        prompt?: string | number | null;
+        completion?: string | number | null;
+        input_cache_read?: string | number | null;
+    };
+    uptime_last_30m?: number | null;
+}
+export interface ProviderScore {
+    quantization: number;
+    speed: number;
+    price: number;
+    context: number;
+}
+export interface RankedProvider {
+    rank: number;
+    score: number;
+    providerName: string;
+    tag: string;
+    quantization: string;
+    tps: number;
+    latency: number | null;
+    price: {
+        input: number;
+        output: number;
+        cache: number;
+    };
+    contextLength: number;
+    uptime: number | null;
+    current: boolean;
+    reasons: string[];
+    dimensions: ProviderScore;
+}
+export interface RankedProviders {
+    recommended: RankedProvider[];
+    rest: RankedProvider[];
+}
+//# sourceMappingURL=types.d.ts.map