@pellux/goodvibes-tui 0.28.0 → 1.0.0

package/src/panels/provider-health-routes.ts

@@ -0,0 +1,203 @@
+// ---------------------------------------------------------------------------
+// provider-health-routes.ts
+//
+// Single-source auth-route posture for the provider console (WO-112 merge of
+// the retired accounts panel into provider-health). All route data flows from
+// ProviderRuntimeInspectionQuery.inspectAll() snapshots; this module only
+// normalizes descriptors (synthesizing them for providers that do not declare
+// routes) and derives the active/preferred route, freshness, issues, and
+// repair hints. It intentionally keeps the full descriptor list so the panel
+// can render per-route detail (absorbed from the accounts panel) instead of a
+// lossy summary record.
+// ---------------------------------------------------------------------------
+
+import type { ProviderAuthRouteDescriptor } from '@pellux/goodvibes-sdk/platform/providers';
+
+export type ProviderPanelAuthRoute = ProviderAuthRouteDescriptor['route'] | 'unconfigured';
+export type ProviderPanelAuthFreshness = NonNullable<ProviderAuthRouteDescriptor['freshness']> | 'unconfigured';
+
+/** Auth metadata shape carried by ProviderRuntimeInspectionQuery snapshots. */
+export interface ProviderRuntimeAuthMetadata {
+  readonly mode: 'api-key' | 'oauth' | 'anonymous' | 'none';
+  readonly configured: boolean;
+  readonly detail?: string;
+  readonly envVars?: readonly string[];
+  readonly routes?: readonly ProviderAuthRouteDescriptor[];
+}
+
+/** Minimal inspectAll() snapshot shape consumed by the provider console. */
+export interface ProviderRuntimeSnapshotLike {
+  readonly providerId: string;
+  readonly active: boolean;
+  readonly modelCount: number;
+  readonly runtime: {
+    readonly auth?: ProviderRuntimeAuthMetadata;
+  };
+}
+
+/** Derived per-provider account/auth posture for console rendering. */
+export interface ProviderAccountPosture {
+  readonly providerId: string;
+  readonly active: boolean;
+  readonly modelCount: number;
+  /** Normalized route descriptors (declared or synthesized). */
+  readonly routes: readonly ProviderAuthRouteDescriptor[];
+  readonly activeRoute: ProviderPanelAuthRoute;
+  readonly preferredRoute: ProviderPanelAuthRoute;
+  readonly activeRouteReason: string;
+  readonly authFreshness: ProviderPanelAuthFreshness;
+  /** True when any route is expiring (or already expired/pending). */
+  readonly expiringSoon: boolean;
+  readonly issues: readonly string[];
+  /** Repair hints sourced from ProviderAuthRouteDescriptor.repairHints. */
+  readonly repairHints: readonly string[];
+}
+
+const AUTH_ROUTE_PRIORITY: readonly ProviderPanelAuthRoute[] = [
+  'subscription-oauth',
+  'service-oauth',
+  'secret-ref',
+  'api-key',
+  'anonymous',
+  'none',
+  'unconfigured',
+] as const;
+
+export function routePriority(route: ProviderPanelAuthRoute): number {
+  const priority = AUTH_ROUTE_PRIORITY.indexOf(route);
+  return priority >= 0 ? priority : AUTH_ROUTE_PRIORITY.length;
+}
+
+/**
+ * Synthesize route descriptors for providers that only declare legacy auth
+ * metadata. Keeps the console on a single ProviderAuthRouteDescriptor shape.
+ */
+export function buildSyntheticAuthRoutes(
+  auth: ProviderRuntimeAuthMetadata | undefined,
+): readonly ProviderAuthRouteDescriptor[] {
+  if (!auth) return [];
+  switch (auth.mode) {
+    case 'none':
+      return [{
+        route: 'none',
+        label: 'No auth required',
+        configured: true,
+        usable: true,
+        freshness: 'healthy',
+        detail: auth.detail ?? 'Provider does not require interactive credentials.',
+      }];
+    case 'anonymous':
+      return [{
+        route: 'anonymous',
+        label: 'Anonymous / local access',
+        configured: auth.configured,
+        usable: auth.configured,
+        freshness: auth.configured ? 'healthy' : 'unconfigured',
+        detail: auth.detail ?? 'Provider can be used without stored credentials.',
+      }];
+    case 'api-key':
+      return [{
+        route: 'api-key',
+        label: 'Ambient API key',
+        configured: auth.configured,
+        usable: auth.configured,
+        freshness: auth.configured ? 'healthy' : 'unconfigured',
+        detail: auth.detail ?? 'Provider expects a configured API key.',
+        ...(auth.envVars?.length ? { envVars: auth.envVars } : {}),
+        ...(auth.envVars?.length
+          ? { repairHints: [`Set ${auth.envVars.join(' or ')} in the environment or secrets store.`] }
+          : {}),
+      }];
+    case 'oauth':
+      return [{
+        route: 'service-oauth',
+        label: 'OAuth session',
+        configured: auth.configured,
+        usable: auth.configured,
+        freshness: auth.configured ? 'healthy' : 'unconfigured',
+        detail: auth.detail ?? 'Provider expects an OAuth-backed credential.',
+        repairHints: ['Refresh or repair the provider OAuth session before relying on it.'],
+      }];
+    default:
+      return [];
+  }
+}
+
+export function isRouteUsable(route: ProviderAuthRouteDescriptor): boolean {
+  return route.usable ?? route.configured;
+}
+
+function pickRoute(
+  routes: readonly ProviderAuthRouteDescriptor[],
+): ProviderAuthRouteDescriptor | null {
+  if (routes.length === 0) return null;
+  return [...routes].sort((left, right) => routePriority(left.route) - routePriority(right.route))[0] ?? null;
+}
+
+/**
+ * Derive the console's account/auth posture for one inspectAll() snapshot.
+ * This is the only route-posture derivation in the TUI (the retired accounts
+ * panel's parallel snapshot model was deleted with WO-112).
+ */
+export function buildAccountPosture(snapshot: ProviderRuntimeSnapshotLike): ProviderAccountPosture {
+  const auth = snapshot.runtime.auth;
+  const routes = auth?.routes?.length ? auth.routes : buildSyntheticAuthRoutes(auth);
+  const configuredRoutes = routes.filter((route) => route.configured);
+  const usableRoutes = routes.filter(isRouteUsable);
+  const preferredRoute = pickRoute(configuredRoutes.length > 0 ? configuredRoutes : routes);
+  const activeRoute = pickRoute(usableRoutes.length > 0 ? usableRoutes : (preferredRoute ? [preferredRoute] : []));
+  const activeRouteId: ProviderPanelAuthRoute = activeRoute?.route ?? 'unconfigured';
+  const preferredRouteId: ProviderPanelAuthRoute = preferredRoute?.route ?? activeRouteId;
+  const authFreshness: ProviderPanelAuthFreshness =
+    activeRoute?.freshness ?? (activeRouteId === 'none' ? 'healthy' : 'unconfigured');
+
+  const issueSet = new Set<string>();
+  const hintSet = new Set<string>();
+
+  if (activeRouteId === 'unconfigured' && auth?.mode !== 'none') {
+    issueSet.add('Provider has no usable auth route configured.');
+  }
+
+  for (const route of routes) {
+    if (route.freshness === 'expired') {
+      issueSet.add(route.detail ?? `${route.label} is expired.`);
+    } else if (route.freshness === 'pending') {
+      issueSet.add(route.detail ?? `${route.label} is pending completion.`);
+    } else if (route.configured && !isRouteUsable(route)) {
+      issueSet.add(route.detail ?? `${route.label} is configured but not currently usable.`);
+    }
+    for (const hint of route.repairHints ?? []) {
+      if (hint.trim().length > 0) hintSet.add(hint);
+    }
+  }
+
+  if (usableRoutes.length > 1) {
+    issueSet.add('Multiple auth routes are simultaneously usable; verify route priority before switching providers.');
+  }
+  if (issueSet.size > 0 && hintSet.size === 0 && activeRouteId !== 'none') {
+    hintSet.add(`Review ${snapshot.providerId} provider credentials and routing metadata.`);
+  }
+
+  const expiringSoon = authFreshness === 'expiring'
+    || authFreshness === 'expired'
+    || authFreshness === 'pending'
+    || routes.some((route) => route.freshness === 'expiring' || route.freshness === 'expired' || route.freshness === 'pending');
+
+  return {
+    providerId: snapshot.providerId,
+    active: snapshot.active,
+    modelCount: snapshot.modelCount,
+    routes,
+    activeRoute: activeRouteId,
+    preferredRoute: preferredRouteId,
+    activeRouteReason: activeRoute?.detail
+      ?? auth?.detail
+      ?? (activeRouteId === 'none'
+        ? 'Provider does not require interactive credentials.'
+        : 'No usable auth route is configured for this provider.'),
+    authFreshness,
+    expiringSoon,
+    issues: [...issueSet],
+    repairHints: [...hintSet],
+  };
+}

package/src/panels/provider-health-tracker.ts

@@ -1,8 +1,23 @@
 // ProviderStatus is the shared SDK type — imported from the runtime barrel
 // to eliminate the duplicate local definition that diverged from the SDK shape.
-import type { ProviderStatus } from '@/runtime/index.ts';
+import type {
+  ProviderHealthDomainState,
+  ProviderHealthRecord,
+  ProviderStatus,
+} from '@/runtime/index.ts';
+import { calcSessionCost } from '../export/cost-utils.ts';
+
 export type { ProviderStatus };
 
+/** Token/cost usage delta carried by one LLM_RESPONSE_RECEIVED event. */
+export interface ProviderUsageDelta {
+  readonly model?: string;
+  readonly inputTokens?: number;
+  readonly outputTokens?: number;
+  readonly cacheReadTokens?: number;
+  readonly cacheWriteTokens?: number;
+}
+
 export interface ProviderHealth {
   name: string;
   status: ProviderStatus;
@@ -11,16 +26,55 @@ export interface ProviderHealth {
   lastSuccessAt?: number;
   lastErrorAt?: number;
   rateLimitExpiresAt: number;
+  /** Most recent model id seen for this provider (from LLM responses). */
+  lastModelId?: string;
+  /** Session request counter (successes + errors). */
+  requests: number;
+  /** Session error counter. */
+  errors: number;
+  /** Session token counters (absorbed from the retired provider-stats panel). */
+  inputTokens: number;
+  outputTokens: number;
+  cacheReadTokens: number;
+  cacheWriteTokens: number;
+  totalTokens: number;
+  /** Session USD cost accumulated per call via calcSessionCost. */
+  totalCostUsd: number;
+  /** Ring buffer of recent request latencies in ms (most-recent last). */
+  latencies: number[];
+}
+
+/** Per-provider identity/config metadata used to build SDK domain state. */
+export interface ProviderHealthMeta {
+  readonly providerId: string;
+  readonly displayName?: string;
+  readonly isActive: boolean;
+  readonly isConfigured: boolean;
+}
+
+const LATENCY_RING_SIZE = 20;
+
+function avg(values: readonly number[]): number {
+  if (values.length === 0) return 0;
+  return values.reduce((sum, value) => sum + value, 0) / values.length;
 }
 
 /**
  * Tracks provider request posture from shell-facing turn and provider events.
  * The panel owns event subscriptions and feeds those events into this tracker.
+ *
+ * WO-112: the tracker also accumulates the session metrics the retired
+ * provider-stats panel used to duplicate (latency ring, request/error/token
+ * counters, per-call cost) and can project its records into the SDK
+ * ProviderHealthDomainState shape so the orphaned ProviderHealthDataProvider
+ * (60-point timelines, success/error rates, cache metrics) is the single
+ * derivation engine for the provider console.
  */
 export class ProviderHealthTracker {
   private records = new Map<string, ProviderHealth>();
   private streamStartMs: number | null = null;
   private turnStartMs: number | null = null;
+  private revision = 0;
 
   private static readonly DEFAULT_COOLDOWN_MS = 60_000;
 
@@ -32,7 +86,7 @@ export class ProviderHealthTracker {
     this.streamStartMs = Date.now();
   }
 
-  onLlmResponse(providerName: string): void {
+  onLlmResponse(providerName: string, usage?: ProviderUsageDelta): void {
     const now = Date.now();
     const latencyMs =
       this.streamStartMs !== null
@@ -42,10 +96,15 @@ export class ProviderHealthTracker {
           : undefined;
     this.streamStartMs = null;
 
-    this.recordSuccess(providerName, latencyMs);
+    this.recordSuccess(providerName, latencyMs, usage);
   }
 
-  onTurnError(error: string, providerName = 'unknown'): void {
+  /**
+   * Record a turn error against a concrete provider. The panel resolves the
+   * active provider (in-flight request, model domain, config, last response)
+   * before calling this — the tracker never invents an 'unknown' row.
+   */
+  onTurnError(error: string, providerName: string): void {
     this.streamStartMs = null;
     this.turnStartMs = null;
     const isRateLimit = this.isRateLimitMessage(error);
@@ -73,22 +132,149 @@ export class ProviderHealthTracker {
     return this.records.get(name);
   }
 
+  /**
+   * Project tracked records into the SDK ProviderHealthDomainState shape so
+   * ProviderHealthDataProvider can derive timelines, rates, and sort order.
+   * Providers present in `meta` but never seen by the tracker are emitted as
+   * zero-stat 'unknown' records; tracked providers missing from `meta` are
+   * kept so attribution/table rows never silently disappear.
+   */
+  buildHealthDomainState(meta: readonly ProviderHealthMeta[]): ProviderHealthDomainState {
+    const providers = new Map<string, ProviderHealthRecord>();
+    const metaById = new Map(meta.map((entry) => [entry.providerId, entry] as const));
+    const ids = new Set<string>([...metaById.keys(), ...this.records.keys()]);
+
+    let degradedCount = 0;
+    let unavailableCount = 0;
+    let healthySeen = 0;
+
+    for (const id of ids) {
+      const record = this.records.get(id);
+      const entry = metaById.get(id);
+      const latencies = record?.latencies ?? [];
+      const requests = record?.requests ?? 0;
+      const errors = record?.errors ?? 0;
+      const status: ProviderStatus = record?.status ?? 'unknown';
+
+      if (status === 'degraded' || status === 'rate_limited' || status === 'auth_error') degradedCount++;
+      if (status === 'unavailable') unavailableCount++;
+      if (status === 'healthy') healthySeen++;
+
+      const cacheRead = record?.cacheReadTokens ?? 0;
+      const cacheWrite = record?.cacheWriteTokens ?? 0;
+      const promptTokens = record?.inputTokens ?? 0;
+
+      providers.set(id, {
+        providerId: id,
+        displayName: entry?.displayName ?? id,
+        status,
+        isActive: entry?.isActive ?? false,
+        isConfigured: entry?.isConfigured ?? true,
+        stats: {
+          totalCalls: requests,
+          successCalls: Math.max(0, requests - errors),
+          errorCalls: errors,
+          avgLatencyMs: Math.round(avg(latencies)),
+          minLatencyMs: latencies.length > 0 ? Math.min(...latencies) : 0,
+          maxLatencyMs: latencies.length > 0 ? Math.max(...latencies) : 0,
+          lastSuccessAt: record?.lastSuccessAt,
+          lastErrorAt: record?.lastErrorAt,
+          lastErrorMessage: record?.lastErrorMessage,
+        },
+        ...(cacheRead + cacheWrite > 0
+          ? {
+            cacheMetrics: {
+              cacheReadTokens: cacheRead,
+              cacheWriteTokens: cacheWrite,
+              hitRate: promptTokens + cacheRead > 0 ? cacheRead / (promptTokens + cacheRead) : 0,
+            },
+          }
+          : {}),
+        lastCheckedAt: Date.now(),
+        ...(record && record.rateLimitExpiresAt > Date.now()
+          ? { rateLimitResetAt: record.rateLimitExpiresAt }
+          : {}),
+      });
+    }
+
+    const compositeStatus = unavailableCount > 0
+      ? 'critical'
+      : degradedCount > 0
+        ? 'degraded'
+        : healthySeen > 0 && healthySeen === ids.size
+          ? 'healthy'
+          : ids.size === 0
+            ? 'unknown'
+            : healthySeen > 0
+              ? 'healthy'
+              : 'unknown';
+
+    this.revision += 1;
+    return {
+      revision: this.revision,
+      lastUpdatedAt: Date.now(),
+      source: 'provider-health-panel',
+      providers,
+      compositeStatus,
+      degradedCount,
+      unavailableCount,
+      warnings: [],
+    };
+  }
+
   private ensureRecord(name: string): ProviderHealth {
     let record = this.records.get(name);
     if (!record) {
-      record = { name, status: 'unknown', rateLimitExpiresAt: 0 };
+      record = {
+        name,
+        status: 'unknown',
+        rateLimitExpiresAt: 0,
+        requests: 0,
+        errors: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0,
+        totalTokens: 0,
+        totalCostUsd: 0,
+        latencies: [],
+      };
       this.records.set(name, record);
     }
     return record;
   }
 
-  private recordSuccess(name: string, latencyMs?: number): void {
+  private applyUsage(record: ProviderHealth, usage: ProviderUsageDelta | undefined): void {
+    if (!usage) return;
+    const input = usage.inputTokens ?? 0;
+    const output = usage.outputTokens ?? 0;
+    const cacheRead = usage.cacheReadTokens ?? 0;
+    const cacheWrite = usage.cacheWriteTokens ?? 0;
+    record.inputTokens += input;
+    record.outputTokens += output;
+    record.cacheReadTokens += cacheRead;
+    record.cacheWriteTokens += cacheWrite;
+    record.totalTokens += input + output + cacheRead + cacheWrite;
+    if (usage.model) record.lastModelId = usage.model;
+    const model = usage.model ?? record.lastModelId;
+    if (model) {
+      record.totalCostUsd += calcSessionCost(input, output, cacheRead, cacheWrite, model);
+    }
+  }
+
+  private recordSuccess(name: string, latencyMs: number | undefined, usage?: ProviderUsageDelta): void {
     const record = this.ensureRecord(name);
     record.status = 'healthy';
     record.lastSuccessAt = Date.now();
     record.lastErrorMessage = undefined;
+    record.requests += 1;
+    this.applyUsage(record, usage);
     if (latencyMs !== undefined) {
       record.lastLatencyMs = latencyMs;
+      if (latencyMs > 0) {
+        record.latencies.push(latencyMs);
+        if (record.latencies.length > LATENCY_RING_SIZE) record.latencies.shift();
+      }
     }
     if (record.rateLimitExpiresAt > 0 && record.rateLimitExpiresAt <= Date.now()) {
       record.rateLimitExpiresAt = 0;
@@ -99,6 +285,8 @@ export class ProviderHealthTracker {
     const record = this.ensureRecord(name);
     record.lastErrorAt = Date.now();
     record.lastErrorMessage = message.slice(0, 120);
+    record.requests += 1;
+    record.errors += 1;
     if (isRateLimit) {
       record.status = 'rate_limited';
       record.rateLimitExpiresAt = Date.now() + ProviderHealthTracker.DEFAULT_COOLDOWN_MS;