@pellux/goodvibes-sdk 0.18.13 → 0.18.15

package/dist/_internal/platform/runtime/provider-accounts/registry.js

@@ -0,0 +1,269 @@
+import { listBuiltinSubscriptionProviders } from '../../config/subscription-providers.js';
+import { resolveApiKeys } from '../../config/index.js';
+import { decodeJwtPayload } from '@pellux/goodvibes-sdk/platform/runtime/auth/oauth-core';
+function builtinWindowsForProvider(providerId) {
+    if (providerId === 'openai') {
+        return [
+            { label: '5-hour window', detail: 'Subscription-backed Codex access may be constrained by rolling 5-hour usage limits.' },
+            { label: '1-week window', detail: 'Subscription-backed Codex access may also be constrained by a rolling weekly limit.' },
+        ];
+    }
+    return [];
+}
+function classifyRoutes(input) {
+    const routes = [];
+    if (input.hasApiKey)
+        routes.push('api-key');
+    if (input.hasSubscription)
+        routes.push('subscription');
+    if (input.hasServiceOAuth)
+        routes.push('service-oauth');
+    if (routes.length === 0)
+        routes.push('unconfigured');
+    return routes;
+}
+function determineActiveRoute(routes) {
+    if (routes.includes('subscription'))
+        return 'subscription';
+    if (routes.includes('service-oauth'))
+        return 'service-oauth';
+    if (routes.includes('api-key'))
+        return 'api-key';
+    return 'unconfigured';
+}
+function determineSubscriptionFreshness(expiresAt) {
+    if (typeof expiresAt !== 'number' || !Number.isFinite(expiresAt))
+        return 'healthy';
+    if (expiresAt <= Date.now())
+        return 'expired';
+    if (expiresAt <= Date.now() + 24 * 60 * 60 * 1000)
+        return 'expiring';
+    return 'healthy';
+}
+export async function buildProviderAccountSnapshot(deps) {
+    const providerRegistry = deps.providerRegistry;
+    const allModels = providerRegistry.listModels();
+    const currentModel = providerRegistry.getCurrentModel?.();
+    const apiKeys = await resolveApiKeys(deps.secretsManager);
+    const subscriptions = deps.subscriptionManager;
+    const builtinSubscriptionProviders = new Set(listBuiltinSubscriptionProviders().map((entry) => entry.provider));
+    const serviceRegistry = deps.serviceRegistry;
+    const serviceConfigs = serviceRegistry.getAll();
+    const services = Object.values(serviceConfigs);
+    const serviceInspections = await Promise.all(Object.keys(serviceConfigs).map(async (name) => ({
+        name,
+        inspection: await serviceRegistry.inspect(name),
+    })));
+    const serviceOauthByProvider = new Map();
+    for (const { inspection } of serviceInspections) {
+        if (!inspection || inspection.config.authType !== 'oauth')
+            continue;
+        const providerId = inspection.config.providerId ?? inspection.config.name;
+        const existing = serviceOauthByProvider.get(providerId);
+        serviceOauthByProvider.set(providerId, {
+            configured: true,
+            usable: Boolean(existing?.usable || inspection.hasPrimaryCredential),
+        });
+    }
+    const providerIds = new Set([
+        ...allModels.map((model) => model.provider),
+        ...Object.keys(apiKeys),
+        ...subscriptions.list().map((entry) => entry.provider),
+        ...subscriptions.listPending().map((entry) => entry.provider),
+        ...services.map((service) => service.providerId ?? service.name),
+        ...builtinSubscriptionProviders,
+    ]);
+    const providers = await Promise.all([...providerIds]
+        .sort((a, b) => a.localeCompare(b))
+        .map(async (providerId) => {
+        const subscription = subscriptions.get(providerId);
+        const pending = subscriptions.getPending(providerId);
+        const jwtPayload = subscription ? decodeJwtPayload(subscription.accessToken) : null;
+        const serviceOauth = serviceOauthByProvider.get(providerId);
+        let runtimeMetadata;
+        try {
+            runtimeMetadata = await providerRegistry.describeRuntime(providerId) ?? undefined;
+        }
+        catch {
+            runtimeMetadata = undefined;
+        }
+        const subscriptionFreshness = subscription ? determineSubscriptionFreshness(subscription.expiresAt) : 'unconfigured';
+        const routes = classifyRoutes({
+            providerId,
+            hasApiKey: providerId in apiKeys,
+            hasSubscription: subscription != null,
+            hasServiceOAuth: Boolean(serviceOauth?.configured),
+        });
+        const usableRoutes = classifyRoutes({
+            providerId,
+            hasApiKey: providerId in apiKeys,
+            hasSubscription: subscription != null && subscriptionFreshness !== 'expired',
+            hasServiceOAuth: Boolean(serviceOauth?.usable),
+        });
+        const issues = [];
+        const notes = [];
+        const recommendedActions = [];
+        const routeRecords = [];
+        const preferredRoute = determineActiveRoute(routes);
+        const activeRoute = determineActiveRoute(usableRoutes);
+        let activeRouteReason = 'No usable auth route is configured for this provider.';
+        let authFreshness = 'unconfigured';
+        if (providerId in apiKeys) {
+            routeRecords.push({
+                route: 'api-key',
+                usable: true,
+                freshness: 'healthy',
+                detail: 'Ambient API key is available for direct provider access.',
+                issues: [],
+            });
+        }
+        if (subscription) {
+            const subscriptionIssues = [];
+            if (subscriptionFreshness === 'expired') {
+                subscriptionIssues.push('Stored subscription session is expired.');
+            }
+            else if (subscriptionFreshness === 'expiring') {
+                subscriptionIssues.push('Stored subscription session expires within 24 hours.');
+            }
+            routeRecords.push({
+                route: 'subscription',
+                usable: subscriptionFreshness !== 'expired',
+                freshness: pending ? 'pending' : subscriptionFreshness,
+                detail: subscription.overrideAmbientApiKeys
+                    ? 'Subscription route is configured to override ambient API-key resolution.'
+                    : 'Subscription route is configured, but ambient API keys remain active unless selected explicitly.',
+                issues: subscriptionIssues,
+            });
+        }
+        if (serviceOauth?.configured) {
+            const serviceOauthIssues = serviceOauth.usable
+                ? []
+                : ['Service OAuth path is configured but has no usable stored credential.'];
+            routeRecords.push({
+                route: 'service-oauth',
+                usable: serviceOauth.usable,
+                freshness: serviceOauth.usable ? 'healthy' : 'unconfigured',
+                detail: serviceOauth.usable
+                    ? 'Service OAuth credential is available for this provider.'
+                    : 'Service OAuth metadata exists, but the credential path is incomplete.',
+                issues: serviceOauthIssues,
+            });
+        }
+        if (routes.includes('subscription') && routes.includes('api-key')) {
+            issues.push('Provider has both subscription and API-key auth paths; routing must remain explicit.');
+            recommendedActions.push('Review provider routing before switching models or auth paths.');
+        }
+        if (subscriptionFreshness === 'expired') {
+            issues.push('Stored subscription session is expired and needs refresh.');
+            recommendedActions.push(`Refresh or replace the ${providerId} subscription session before relying on it.`);
+        }
+        else if (subscriptionFreshness === 'expiring') {
+            issues.push('Stored subscription session is nearing expiry.');
+            recommendedActions.push(`Renew or verify the ${providerId} subscription session soon to avoid route drift.`);
+        }
+        if (pending) {
+            issues.push('Provider has a pending OAuth login that has not been completed yet.');
+            recommendedActions.push(`Finish /subscription login ${providerId} finish <code> or clear the pending login.`);
+        }
+        if (serviceOauth?.configured && !serviceOauth.usable) {
+            issues.push('Service OAuth is configured but missing a usable credential.');
+            recommendedActions.push(`Repair service OAuth credentials for ${providerId} in /services or /settings.`);
+        }
+        if (!routes.includes('api-key') && !routes.includes('subscription') && !routes.includes('service-oauth')) {
+            recommendedActions.push(`Configure an API key or OAuth-backed route for ${providerId}.`);
+        }
+        else if (activeRoute === 'unconfigured') {
+            recommendedActions.push(`No currently usable auth path exists for ${providerId}; repair the preferred route.`);
+        }
+        if (preferredRoute !== 'unconfigured' && activeRoute !== preferredRoute && activeRoute !== 'unconfigured') {
+            issues.push(`Preferred ${preferredRoute} path is unavailable; current usable route is ${activeRoute}.`);
+            recommendedActions.push(`Review why ${providerId} fell back from ${preferredRoute} to ${activeRoute}.`);
+        }
+        if (jwtPayload && typeof jwtPayload['iss'] === 'string') {
+            notes.push(`issuer=${jwtPayload['iss']}`);
+        }
+        if (runtimeMetadata?.notes) {
+            notes.push(...runtimeMetadata.notes);
+        }
+        if (runtimeMetadata?.usage?.notes) {
+            notes.push(...runtimeMetadata.usage.notes);
+        }
+        if (runtimeMetadata?.policy?.notes) {
+            notes.push(...runtimeMetadata.policy.notes);
+        }
+        if (builtinSubscriptionProviders.has(providerId)) {
+            notes.push('Built-in subscription adapter available.');
+            if (!subscription && !pending) {
+                recommendedActions.push(`Start /subscription login ${providerId} start to enable the built-in subscription path.`);
+            }
+        }
+        for (const route of runtimeMetadata?.auth?.routes ?? []) {
+            if (!route.usable || !route.configured) {
+                for (const hint of route.repairHints ?? []) {
+                    recommendedActions.push(hint);
+                }
+            }
+        }
+        if (pending) {
+            authFreshness = 'pending';
+            activeRouteReason = 'OAuth login is pending completion.';
+        }
+        else if (activeRoute === 'subscription') {
+            authFreshness = subscriptionFreshness;
+            activeRouteReason = subscriptionFreshness === 'expiring'
+                ? 'Subscription route is active but nearing expiry.'
+                : 'Subscription route is the preferred usable path.';
+        }
+        else if (activeRoute === 'service-oauth') {
+            authFreshness = 'healthy';
+            activeRouteReason = preferredRoute === 'subscription'
+                ? 'Subscription route is unavailable, so service OAuth is the current usable path.'
+                : 'Service OAuth is the current usable route.';
+        }
+        else if (activeRoute === 'api-key') {
+            authFreshness = 'healthy';
+            activeRouteReason = preferredRoute === 'subscription'
+                ? 'Subscription route is unavailable, so ambient API-key access is the current usable path.'
+                : preferredRoute === 'service-oauth'
+                    ? 'Service OAuth is unavailable, so ambient API-key access is the current usable path.'
+                    : 'Ambient API-key access is the current usable route.';
+        }
+        const fallbackRoute = preferredRoute !== activeRoute && activeRoute !== 'unconfigured'
+            ? activeRoute
+            : undefined;
+        const fallbackRisk = fallbackRoute
+            ? `Provider is using ${fallbackRoute} because the preferred ${preferredRoute} path is not currently usable.`
+            : undefined;
+        if (!pending && routes.includes('subscription') && !subscription && builtinSubscriptionProviders.has(providerId)) {
+            authFreshness = 'unconfigured';
+        }
+        return Object.freeze({
+            providerId,
+            active: currentModel?.provider === providerId,
+            modelCount: allModels.filter((model) => model.provider === providerId).length,
+            configured: routes[0] !== 'unconfigured',
+            oauthReady: builtinSubscriptionProviders.has(providerId) || Boolean(serviceOauth?.configured),
+            pendingLogin: pending != null,
+            availableRoutes: routes,
+            preferredRoute,
+            activeRoute,
+            activeRouteReason,
+            authFreshness,
+            ...(fallbackRoute ? { fallbackRoute } : {}),
+            ...(fallbackRisk ? { fallbackRisk } : {}),
+            ...(subscription?.expiresAt ? { expiresAt: subscription.expiresAt } : {}),
+            ...(subscription?.tokenType ? { tokenType: subscription.tokenType } : {}),
+            notes,
+            usageWindows: builtinWindowsForProvider(providerId),
+            issues,
+            recommendedActions: [...new Set(recommendedActions)],
+            routeRecords,
+        });
+    }));
+    return Object.freeze({
+        capturedAt: Date.now(),
+        providers,
+        configuredCount: providers.filter((provider) => provider.configured).length,
+        issueCount: providers.reduce((sum, provider) => sum + provider.issues.length, 0),
+    });
+}

package/dist/_internal/platform/runtime/provider-health/data-provider.d.ts

@@ -7,76 +7,5 @@
  * This class is a data provider only — it contains no rendering logic.
  * Subscribe to change notifications and call getSnapshot() to render.
  */
-import type { ProviderHealthDomainState } from '../store/domains/provider-health.js';
-import type { ModelDomainState } from '../store/domains/model.js';
-import type { ProviderHealthData } from './types.js';
-/**
- * ProviderHealthDataProvider produces enriched provider health data snapshots.
- *
- * Usage:
- * ```ts
- * const provider = new ProviderHealthDataProvider(healthState, modelState);
- * const unsub = provider.subscribe(() => {
- *   const data = provider.getSnapshot();
- *   // render data.entries, data.fallbackChain, etc.
- * });
- * // When state changes:
- * provider.updateHealthState(newHealthState);
- * provider.updateModelState(newModelState);
- * // Cleanup:
- * unsub();
- * provider.dispose();
- * ```
- */
-export declare class ProviderHealthDataProvider {
-    private _healthState;
-    private _modelState;
-    private _snapshot;
-    private readonly _subscribers;
-    /** Per-provider timeline buffers, keyed by providerId. */
-    private readonly _timelines;
-    constructor(healthState: ProviderHealthDomainState, modelState: ModelDomainState);
-    /**
-     * Return the current enriched provider health data snapshot.
-     * Updated synchronously when state changes via update methods.
-     */
-    getSnapshot(): ProviderHealthData;
-    /**
-     * Register a callback invoked whenever the snapshot changes.
-     * @returns An unsubscribe function.
-     */
-    subscribe(callback: () => void): () => void;
-    /**
-     * Update provider health state and rebuild the snapshot.
-     * Appends a new timeline point for each provider.
-     */
-    updateHealthState(healthState: ProviderHealthDomainState): void;
-    /**
-     * Update model domain state (e.g. active model or fallback chain change).
-     * Triggers a snapshot rebuild.
-     */
-    updateModelState(modelState: ModelDomainState): void;
-    /**
-     * Release all subscriber references.
-     * Does not clear internal state — getSnapshot() remains usable after disposal.
-     */
-    dispose(): void;
-    /**
-     * Seed timeline buffers from the initial health state.
-     * Appends one point per known provider to initialize the timeline.
-     */
-    private _seedTimelines;
-    /**
-     * Append a new timeline point for every provider in the updated state.
-     * Creates a new buffer for providers seen for the first time.
-     */
-    private _appendTimelinePoints;
-    /** Append a single timeline point to a buffer, capping at TIMELINE_MAX_POINTS. */
-    private _appendPoint;
-    /** Build a HealthTimeline from a buffer for a given provider. */
-    private _buildTimeline;
-    private _rebuild;
-    private _buildSnapshot;
-    private _notify;
-}
+export * from '../ui/provider-health/data-provider.js';
 //# sourceMappingURL=data-provider.d.ts.map

package/dist/_internal/platform/runtime/provider-health/data-provider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"data-provider.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/runtime/provider-health/data-provider.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,yBAAyB,EAAwB,MAAM,qCAAqC,CAAC;AAC3G,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAElE,OAAO,KAAK,EACV,kBAAkB,EAInB,MAAM,YAAY,CAAC;AAyBpB;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,0BAA0B;IACrC,OAAO,CAAC,YAAY,CAA4B;IAChD,OAAO,CAAC,WAAW,CAAmB;IACtC,OAAO,CAAC,SAAS,CAAqB;IACtC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAyB;IACtD,0DAA0D;IAC1D,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAqC;gBAEpD,WAAW,EAAE,yBAAyB,EAAE,UAAU,EAAE,gBAAgB;IAOhF;;;OAGG;IACI,WAAW,IAAI,kBAAkB;IAIxC;;;OAGG;IACI,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI;IAKlD;;;OAGG;IACI,iBAAiB,CAAC,WAAW,EAAE,yBAAyB,GAAG,IAAI;IAMtE;;;OAGG;IACI,gBAAgB,CAAC,UAAU,EAAE,gBAAgB,GAAG,IAAI;IAK3D;;;OAGG;IACI,OAAO,IAAI,IAAI;IAMtB;;;OAGG;IACH,OAAO,CAAC,cAAc;IAQtB;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAS7B,kFAAkF;IAClF,OAAO,CAAC,YAAY;IAmBpB,iEAAiE;IACjE,OAAO,CAAC,cAAc;IAUtB,OAAO,CAAC,QAAQ;IAKhB,OAAO,CAAC,cAAc;IAoDtB,OAAO,CAAC,OAAO;CAShB"}
+{"version":3,"file":"data-provider.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/runtime/provider-health/data-provider.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,cAAc,wCAAwC,CAAC"}

package/dist/_internal/platform/runtime/provider-health/data-provider.js

@@ -1,197 +1,10 @@
-import { buildFallbackChainData } from './fallback-visualizer.js';
 /**
- * Number of timeline points retained per provider.
- * Each point represents a snapshot at the time of a state update.
- */
-const TIMELINE_MAX_POINTS = 60;
-/** Status sort priority (lower = shown first in list). */
-const STATUS_ORDER = {
-    degraded: 0,
-    rate_limited: 1,
-    auth_error: 2,
-    unavailable: 3,
-    unknown: 4,
-    healthy: 5,
-};
-/**
- * ProviderHealthDataProvider produces enriched provider health data snapshots.
+ * ProviderHealthDataProvider — enriched provider health data surface.
+ *
+ * Combines ProviderHealthDomainState and ModelDomainState into a single,
+ * sorted ProviderHealthData snapshot for UI consumption.
  *
- * Usage:
- * ```ts
- * const provider = new ProviderHealthDataProvider(healthState, modelState);
- * const unsub = provider.subscribe(() => {
- *   const data = provider.getSnapshot();
- *   // render data.entries, data.fallbackChain, etc.
- * });
- * // When state changes:
- * provider.updateHealthState(newHealthState);
- * provider.updateModelState(newModelState);
- * // Cleanup:
- * unsub();
- * provider.dispose();
- * ```
+ * This class is a data provider only — it contains no rendering logic.
+ * Subscribe to change notifications and call getSnapshot() to render.
  */
-export class ProviderHealthDataProvider {
-    _healthState;
-    _modelState;
-    _snapshot;
-    _subscribers = new Set();
-    /** Per-provider timeline buffers, keyed by providerId. */
-    _timelines = new Map();
-    constructor(healthState, modelState) {
-        this._healthState = healthState;
-        this._modelState = modelState;
-        this._seedTimelines(healthState);
-        this._snapshot = this._buildSnapshot();
-    }
-    /**
-     * Return the current enriched provider health data snapshot.
-     * Updated synchronously when state changes via update methods.
-     */
-    getSnapshot() {
-        return this._snapshot;
-    }
-    /**
-     * Register a callback invoked whenever the snapshot changes.
-     * @returns An unsubscribe function.
-     */
-    subscribe(callback) {
-        this._subscribers.add(callback);
-        return () => this._subscribers.delete(callback);
-    }
-    /**
-     * Update provider health state and rebuild the snapshot.
-     * Appends a new timeline point for each provider.
-     */
-    updateHealthState(healthState) {
-        this._healthState = healthState;
-        this._appendTimelinePoints(healthState);
-        this._rebuild();
-    }
-    /**
-     * Update model domain state (e.g. active model or fallback chain change).
-     * Triggers a snapshot rebuild.
-     */
-    updateModelState(modelState) {
-        this._modelState = modelState;
-        this._rebuild();
-    }
-    /**
-     * Release all subscriber references.
-     * Does not clear internal state — getSnapshot() remains usable after disposal.
-     */
-    dispose() {
-        this._subscribers.clear();
-    }
-    // ── Private ────────────────────────────────────────────────────────────────
-    /**
-     * Seed timeline buffers from the initial health state.
-     * Appends one point per known provider to initialize the timeline.
-     */
-    _seedTimelines(healthState) {
-        for (const [id, record] of healthState.providers) {
-            const buffer = { points: [] };
-            this._timelines.set(id, buffer);
-            this._appendPoint(buffer, record);
-        }
-    }
-    /**
-     * Append a new timeline point for every provider in the updated state.
-     * Creates a new buffer for providers seen for the first time.
-     */
-    _appendTimelinePoints(healthState) {
-        for (const [id, record] of healthState.providers) {
-            if (!this._timelines.has(id)) {
-                this._timelines.set(id, { points: [] });
-            }
-            this._appendPoint(this._timelines.get(id), record);
-        }
-    }
-    /** Append a single timeline point to a buffer, capping at TIMELINE_MAX_POINTS. */
-    _appendPoint(buffer, record) {
-        const total = record.stats.totalCalls;
-        const successRate = total > 0 ? record.stats.successCalls / total : 1;
-        const errorRate = total > 0 ? record.stats.errorCalls / total : 0;
-        buffer.points.push({
-            ts: Date.now(),
-            successRate,
-            avgLatencyMs: record.stats.avgLatencyMs,
-            errorRate,
-        });
-        if (buffer.points.length > TIMELINE_MAX_POINTS) {
-            // Array.shift() is O(n) but acceptable: TIMELINE_MAX_POINTS is capped at 60,
-            // so the cost is negligible and the simplicity outweighs a ring-buffer implementation.
-            buffer.points.shift();
-        }
-    }
-    /** Build a HealthTimeline from a buffer for a given provider. */
-    _buildTimeline(providerId) {
-        const buffer = this._timelines.get(providerId);
-        const points = buffer ? [...buffer.points] : [];
-        return {
-            providerId,
-            points,
-            length: points.length,
-        };
-    }
-    _rebuild() {
-        this._snapshot = this._buildSnapshot();
-        this._notify();
-    }
-    _buildSnapshot() {
-        const entries = [];
-        for (const [id, record] of this._healthState.providers) {
-            const total = record.stats.totalCalls;
-            const successRate = total > 0 ? record.stats.successCalls / total : 1;
-            const errorRate = total > 0 ? record.stats.errorCalls / total : 0;
-            entries.push({
-                providerId: id,
-                displayName: record.displayName,
-                status: record.status,
-                isActive: record.isActive,
-                isConfigured: record.isConfigured,
-                successRate,
-                errorRate,
-                p95LatencyMs: record.stats.maxLatencyMs,
-                avgLatencyMs: record.stats.avgLatencyMs,
-                totalCalls: total,
-                // cacheHitRate is populated only when cache-capability is wired to the provider record.
-                // Until then this will always be undefined — intentionally unsupported at this stage.
-                cacheHitRate: record.cacheMetrics?.hitRate,
-                cacheReadTokens: record.cacheMetrics?.cacheReadTokens,
-                cacheWriteTokens: record.cacheMetrics?.cacheWriteTokens,
-                lastSuccessAt: record.stats.lastSuccessAt,
-                lastErrorAt: record.stats.lastErrorAt,
-                lastErrorMessage: record.stats.lastErrorMessage,
-                lastCheckedAt: record.lastCheckedAt,
-                rateLimitResetAt: record.rateLimitResetAt,
-                timeline: this._buildTimeline(id),
-            });
-        }
-        // Sort: degraded/unavailable first (needs attention), then healthy, then unknown
-        entries.sort((a, b) => {
-            const diff = (STATUS_ORDER[a.status] ?? 4) - (STATUS_ORDER[b.status] ?? 4);
-            return diff !== 0 ? diff : a.displayName.localeCompare(b.displayName);
-        });
-        const fallbackChain = buildFallbackChainData(this._modelState, this._healthState);
-        return {
-            entries,
-            compositeStatus: this._healthState.compositeStatus,
-            degradedCount: this._healthState.degradedCount,
-            unavailableCount: this._healthState.unavailableCount,
-            fallbackChain,
-            warnings: this._healthState.warnings,
-            snapshotAt: Date.now(),
-        };
-    }
-    _notify() {
-        for (const cb of this._subscribers) {
-            try {
-                cb();
-            }
-            catch {
-                // Non-fatal: subscriber errors must not crash the provider
-            }
-        }
-    }
-}
+export * from '../ui/provider-health/data-provider.js';

package/dist/_internal/platform/runtime/provider-health/fallback-visualizer.d.ts

@@ -5,18 +5,5 @@
  * provider health records into a structured FallbackChainData snapshot
  * suitable for UI rendering.
  */
-import type { ModelDomainState } from '../store/domains/model.js';
-import type { ProviderHealthDomainState } from '../store/domains/provider-health.js';
-import type { FallbackChainData } from './types.js';
-/**
- * Build a FallbackChainData snapshot from the current model and health state.
- *
- * The primary model is always node 0. Each entry in ModelDomainState.fallbackChain
- * becomes a subsequent node. Health status is enriched from the provider health domain.
- *
- * @param modelState - Current model domain state.
- * @param healthState - Current provider health domain state.
- * @returns Immutable FallbackChainData for visualization.
- */
-export declare function buildFallbackChainData(modelState: ModelDomainState, healthState: ProviderHealthDomainState): FallbackChainData;
+export * from '../ui/provider-health/fallback-visualizer.js';
 //# sourceMappingURL=fallback-visualizer.d.ts.map

package/dist/_internal/platform/runtime/provider-health/fallback-visualizer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fallback-visualizer.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/runtime/provider-health/fallback-visualizer.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAClE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,qCAAqC,CAAC;AACrF,OAAO,KAAK,EAAE,iBAAiB,EAAqB,MAAM,YAAY,CAAC;AAEvE;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,gBAAgB,EAC5B,WAAW,EAAE,yBAAyB,GACrC,iBAAiB,CA4CnB"}
+{"version":3,"file":"fallback-visualizer.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/runtime/provider-health/fallback-visualizer.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,cAAc,8CAA8C,CAAC"}

package/dist/_internal/platform/runtime/provider-health/fallback-visualizer.js

@@ -1,48 +1,8 @@
 /**
- * Build a FallbackChainData snapshot from the current model and health state.
+ * Fallback chain visualization data builder.
  *
- * The primary model is always node 0. Each entry in ModelDomainState.fallbackChain
- * becomes a subsequent node. Health status is enriched from the provider health domain.
- *
- * @param modelState - Current model domain state.
- * @param healthState - Current provider health domain state.
- * @returns Immutable FallbackChainData for visualization.
+ * Converts the raw fallback chain from ModelDomainState and current
+ * provider health records into a structured FallbackChainData snapshot
+ * suitable for UI rendering.
  */
-export function buildFallbackChainData(modelState, healthState) {
-    const nodes = [];
-    // Node 0 — primary (active model)
-    const primaryRecord = healthState.providers.get(modelState.activeProviderId);
-    nodes.push({
-        providerId: modelState.activeProviderId,
-        modelId: modelState.activeModelId,
-        displayName: modelState.displayName,
-        position: 0,
-        isCurrent: modelState.activeFallbackIndex === -1,
-        providerStatus: primaryRecord?.status ?? 'unknown',
-        reason: undefined,
-    });
-    // Nodes 1..N — fallback chain entries
-    for (let i = 0; i < modelState.fallbackChain.length; i++) {
-        const entry = modelState.fallbackChain[i];
-        const record = healthState.providers.get(entry.providerId);
-        nodes.push({
-            providerId: entry.providerId,
-            modelId: entry.modelId,
-            displayName: entry.displayName,
-            position: i + 1,
-            isCurrent: modelState.activeFallbackIndex === i,
-            providerStatus: record?.status ?? 'unknown',
-            reason: entry.reason,
-        });
-    }
-    const hasUnhealthyNode = nodes.some((n) => n.providerStatus === 'degraded' ||
-        n.providerStatus === 'rate_limited' ||
-        n.providerStatus === 'unavailable' ||
-        n.providerStatus === 'auth_error');
-    return {
-        nodes,
-        activeIndex: modelState.activeFallbackIndex,
-        falloverCount: modelState.falloverCount,
-        hasUnhealthyNode,
-    };
-}
+export * from '../ui/provider-health/fallback-visualizer.js';

package/dist/_internal/platform/runtime/provider-health/index.d.ts

@@ -1,24 +1,2 @@
-/**
- * Provider health UI data surface barrel.
- *
- * Re-exports all types and the ProviderHealthDataProvider class.
- * Also provides the createProviderHealthData() factory for one-shot snapshots.
- */
-export type { ProviderStatus, CompositeHealthStatus, HealthTimelinePoint, HealthTimeline, ProviderHealthEntry, FallbackChainNode, FallbackChainData, ProviderHealthData, } from './types.js';
-export { ProviderHealthDataProvider } from './data-provider.js';
-export { buildFallbackChainData } from './fallback-visualizer.js';
-import type { ProviderHealthDomainState } from '../store/domains/provider-health.js';
-import type { ModelDomainState } from '../store/domains/model.js';
-import type { ProviderHealthData } from './types.js';
-/**
- * Produce a one-shot ProviderHealthData snapshot without creating a long-lived provider.
- *
- * Use this when you need a single render pass and do not require change subscriptions.
- * For reactive/subscription-based UIs, prefer ProviderHealthDataProvider.
- *
- * @param healthState - Current provider health domain state.
- * @param modelState - Current model domain state.
- * @returns Immutable ProviderHealthData snapshot.
- */
-export declare function createProviderHealthData(healthState: ProviderHealthDomainState, modelState: ModelDomainState): ProviderHealthData;
+export * from '../ui/provider-health/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/_internal/platform/runtime/provider-health/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/runtime/provider-health/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,YAAY,EACV,cAAc,EACd,qBAAqB,EACrB,mBAAmB,EACnB,cAAc,EACd,mBAAmB,EACnB,iBAAiB,EACjB,iBAAiB,EACjB,kBAAkB,GACnB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,0BAA0B,EAAE,MAAM,oBAAoB,CAAC;AAChE,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAElE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,qCAAqC,CAAC;AACrF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAElE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAErD;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CACtC,WAAW,EAAE,yBAAyB,EACtC,UAAU,EAAE,gBAAgB,GAC3B,kBAAkB,CAOpB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/runtime/provider-health/index.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAC"}