@pellux/goodvibes-tui 0.18.4

package/src/runtime/transports/remote-events.ts

@@ -0,0 +1,16 @@
+export type {
+  DomainEventConnector,
+  DomainEvents as RemoteDomainEvents,
+  SerializedEventEnvelope as SerializedRuntimeEnvelope,
+  RemoteRuntimeEvents,
+  RuntimeEventConnectorOptions,
+} from '@pellux/goodvibes-sdk/transport-realtime';
+export {
+  buildEventSourceUrl,
+  buildWebSocketUrl,
+  createEventSourceConnector,
+  createRemoteDomainEvents,
+  createRemoteRuntimeEvents,
+  createWebSocketConnector,
+} from '@pellux/goodvibes-sdk/transport-realtime';
+export { createRemoteUiRuntimeEvents } from './ui-runtime-events.ts';

package/src/runtime/transports/shared.ts

@@ -0,0 +1,39 @@
+export type { DomainEventConnector, SerializedRuntimeEnvelope } from './remote-events.ts';
+export {
+  buildEventSourceUrl,
+  buildWebSocketUrl,
+  createEventSourceConnector,
+  createRemoteRuntimeEvents,
+  createRemoteUiRuntimeEvents,
+  createWebSocketConnector,
+} from './remote-events.ts';
+export type { TransportPaths } from '@pellux/goodvibes-sdk/platform/runtime/transports/transport-paths';
+export { buildUrl, createTransportPaths, normalizeBaseUrl } from '@pellux/goodvibes-sdk/platform/runtime/transports/transport-paths';
+export type { BackoffPolicy, ResolvedBackoffPolicy } from '@pellux/goodvibes-sdk/platform/runtime/transports/backoff';
+export { computeBackoffDelay, normalizeBackoffPolicy, sleepWithSignal } from '@pellux/goodvibes-sdk/platform/runtime/transports/backoff';
+export type { AuthTokenResolver, HeaderResolver, MaybePromise } from '@pellux/goodvibes-sdk/platform/runtime/transports/http-auth';
+export { mergeHeaders, resolveAuthToken, resolveHeaders } from '@pellux/goodvibes-sdk/platform/runtime/transports/http-auth';
+export type {
+  HttpJsonRequestOptions,
+  HttpRetryPolicy,
+  HttpJsonTransport,
+  HttpJsonTransportOptions,
+  JsonObject,
+  JsonValue,
+  ResolvedContractRequest,
+  TransportJsonError,
+} from '@pellux/goodvibes-sdk/platform/runtime/transports/http-json-transport';
+export {
+  createFetch,
+  createHttpJsonTransport,
+  createJsonInit,
+  createJsonRequestInit,
+  readJsonBody,
+  requestJson,
+} from '@pellux/goodvibes-sdk/platform/runtime/transports/http-json-transport';
+export type { ResolvedHttpRetryPolicy } from '@pellux/goodvibes-sdk/platform/runtime/transports/http-retry';
+export { DEFAULT_HTTP_RETRY_POLICY, getHttpRetryDelay, isRetryableHttpStatus, isRetryableNetworkError, normalizeHttpRetryPolicy, resolveHttpRetryPolicy } from '@pellux/goodvibes-sdk/platform/runtime/transports/http-retry';
+export type { ServerSentEventHandlers, ServerSentEventOptions } from '@pellux/goodvibes-sdk/platform/runtime/transports/sse-stream';
+export { isAbortError, openServerSentEventStream } from '@pellux/goodvibes-sdk/platform/runtime/transports/sse-stream';
+export type { StreamReconnectPolicy, ResolvedStreamReconnectPolicy } from '@pellux/goodvibes-sdk/platform/runtime/transports/stream-reconnect';
+export { DEFAULT_STREAM_RECONNECT_POLICY, getStreamReconnectDelay, normalizeStreamReconnectPolicy } from '@pellux/goodvibes-sdk/platform/runtime/transports/stream-reconnect';

package/src/runtime/transports/ui-runtime-events.ts

@@ -0,0 +1,35 @@
+import type {
+  AgentEvent,
+  OpsEvent,
+  PlannerEvent,
+  ProviderEvent,
+  RuntimeEventDomain,
+  SessionEvent,
+  ToolEvent,
+  TurnEvent,
+  WorkflowEvent,
+} from '../events/index.ts';
+import type { UiEventFeed, UiRuntimeEvents } from '../ui-events.ts';
+import type { DomainEventConnector } from '@pellux/goodvibes-sdk/platform/runtime/transports/domain-events';
+import { createRemoteRuntimeEvents, type RemoteRuntimeEvents } from '@pellux/goodvibes-sdk/platform/runtime/transports/runtime-events-client';
+
+type RuntimeEventRecord = { readonly type: string };
+
+function asUiEvents(runtimeEvents: RemoteRuntimeEvents<RuntimeEventRecord>): UiRuntimeEvents {
+  return {
+    sessions: runtimeEvents.session as UiEventFeed<SessionEvent>,
+    turns: runtimeEvents.turn as UiEventFeed<TurnEvent>,
+    tools: runtimeEvents.tools as UiEventFeed<ToolEvent>,
+    providers: runtimeEvents.providers as UiEventFeed<ProviderEvent>,
+    agents: runtimeEvents.agents as UiEventFeed<AgentEvent>,
+    workflows: runtimeEvents.workflows as UiEventFeed<WorkflowEvent>,
+    planner: runtimeEvents.planner as UiEventFeed<PlannerEvent>,
+    ops: runtimeEvents.ops as UiEventFeed<OpsEvent>,
+  };
+}
+
+export function createRemoteUiRuntimeEvents(
+  connect: DomainEventConnector<RuntimeEventDomain, RuntimeEventRecord>,
+): UiRuntimeEvents {
+  return asUiEvents(createRemoteRuntimeEvents(connect));
+}

package/src/runtime/ui/index.ts

@@ -0,0 +1,39 @@
+/**
+ * Runtime UI data surface barrel.
+ *
+ * Exports enriched data providers and one-shot factory functions for
+ * the model picker and provider health surfaces.
+ *
+ * These modules produce structured data for renderers — no UI rendering
+ * logic lives here.
+ */
+
+// ── Model picker ──────────────────────────────────────────────────────────────
+export type {
+  CapabilityFlags,
+  ProviderLatencyStats,
+  ProviderHealthContext,
+  ModelPickerEntry,
+  ModelPickerGroup,
+  ModelPickerData,
+} from './model-picker/index.ts';
+export type { ProviderStatus as ModelPickerProviderStatus } from './model-picker/index.ts';
+export { ModelPickerDataProvider, createModelPickerData } from './model-picker/index.ts';
+export type { ModelPickerDataProviderOptions } from './model-picker/index.ts';
+
+// ── Provider health ───────────────────────────────────────────────────────────
+export type {
+  HealthTimelinePoint,
+  HealthTimeline,
+  ProviderHealthEntry,
+  FallbackChainNode,
+  FallbackChainData,
+  ProviderHealthData,
+  CompositeHealthStatus,
+} from './provider-health/index.ts';
+export type { ProviderStatus } from './provider-health/index.ts';
+export {
+  ProviderHealthDataProvider,
+  buildFallbackChainData,
+  createProviderHealthData,
+} from './provider-health/index.ts';

package/src/runtime/ui/model-picker/data-provider.ts

@@ -0,0 +1,182 @@
+/**
+ * ModelPickerDataProvider — enriched model picker data surface.
+ *
+ * Combines ModelDefinition records from the provider registry with
+ * ProviderHealthDomainState and ModelDomainState to produce a single,
+ * sorted, health-enriched ModelPickerData snapshot for UI consumption.
+ *
+ * This class is a data provider only — it contains no rendering logic.
+ * Subscribe to change notifications and call getSnapshot() to render.
+ */
+import type { ModelDefinition } from '../../../providers/registry.ts';
+import type { ProviderRegistry } from '../../../providers/registry.ts';
+import type { BenchmarkStore } from '@pellux/goodvibes-sdk/platform/providers/model-benchmarks';
+import type { ProviderHealthDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/provider-health';
+import type { ModelDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/model';
+import { enrichModelEntries, groupEntriesByProvider } from './health-enrichment.ts';
+import type { ModelPickerData, ModelPickerEntry } from './types.ts';
+
+/** Options for constructing a ModelPickerDataProvider. */
+export interface ModelPickerDataProviderOptions {
+  /**
+   * Initial set of pinned model IDs.
+   * Call updatePinnedIds() to update at runtime.
+   */
+  readonly pinnedIds?: ReadonlySet<string>;
+  readonly benchmarkStore: Pick<BenchmarkStore, 'getBenchmarks'>;
+  readonly providerRegistry: Pick<ProviderRegistry, 'getSyntheticModelInfoFromCatalog' | 'getContextWindowForModel'>;
+}
+
+/**
+ * ModelPickerDataProvider produces enriched model picker data snapshots.
+ *
+ * Usage:
+ * ```ts
+ * const provider = new ModelPickerDataProvider(models, healthState, modelState);
+ * const unsub = provider.subscribe(() => {
+ *   const data = provider.getSnapshot();
+ *   // render data.entries or data.groups
+ * });
+ * // When health or model state changes:
+ * provider.updateHealthState(newHealthState);
+ * provider.updateModelState(newModelState);
+ * // Cleanup:
+ * unsub();
+ * provider.dispose();
+ * ```
+ */
+export class ModelPickerDataProvider {
+  private _models: readonly ModelDefinition[];
+  private _healthState: ProviderHealthDomainState;
+  private _modelState: ModelDomainState;
+  private _pinnedIds: ReadonlySet<string>;
+  private _snapshot: ModelPickerData;
+  private readonly benchmarkStore: Pick<BenchmarkStore, 'getBenchmarks'>;
+  private readonly providerRegistry: Pick<ProviderRegistry, 'getSyntheticModelInfoFromCatalog' | 'getContextWindowForModel'>;
+  private readonly _subscribers = new Set<() => void>();
+
+  constructor(
+    models: readonly ModelDefinition[],
+    healthState: ProviderHealthDomainState,
+    modelState: ModelDomainState,
+    options: ModelPickerDataProviderOptions,
+  ) {
+    this._models = models;
+    this._healthState = healthState;
+    this._modelState = modelState;
+    this._pinnedIds = options.pinnedIds ?? new Set();
+    this.benchmarkStore = options.benchmarkStore;
+    this.providerRegistry = options.providerRegistry;
+    this._snapshot = this._buildSnapshot();
+  }
+
+  /**
+   * Return the current enriched model picker data snapshot.
+   * This is updated synchronously when state changes via update methods.
+   */
+  public getSnapshot(): ModelPickerData {
+    return this._snapshot;
+  }
+
+  /**
+   * Register a callback invoked whenever the snapshot changes.
+   * @returns An unsubscribe function.
+   */
+  public subscribe(callback: () => void): () => void {
+    this._subscribers.add(callback);
+    return () => this._subscribers.delete(callback);
+  }
+
+  /**
+   * Update the model list (e.g. after registry reload).
+   * Triggers a snapshot rebuild and notifies subscribers.
+   */
+  public updateModels(models: readonly ModelDefinition[]): void {
+    this._models = models;
+    this._rebuild();
+  }
+
+  /**
+   * Update health state (e.g. on ProviderHealthDomainState change).
+   * Triggers a snapshot rebuild and notifies subscribers.
+   */
+  public updateHealthState(healthState: ProviderHealthDomainState): void {
+    this._healthState = healthState;
+    this._rebuild();
+  }
+
+  /**
+   * Update model domain state (e.g. on active model or fallback change).
+   * Triggers a snapshot rebuild and notifies subscribers.
+   */
+  public updateModelState(modelState: ModelDomainState): void {
+    this._modelState = modelState;
+    this._rebuild();
+  }
+
+  /**
+   * Update the pinned/favorites model ID set.
+   * Triggers a snapshot rebuild and notifies subscribers.
+   */
+  public updatePinnedIds(pinnedIds: ReadonlySet<string>): void {
+    this._pinnedIds = pinnedIds;
+    this._rebuild();
+  }
+
+  /**
+   * Release all subscriber references.
+   * Does not clear internal state — getSnapshot() remains usable after disposal.
+   */
+  public dispose(): void {
+    this._subscribers.clear();
+  }
+
+  // ── Private ────────────────────────────────────────────────────────────────
+
+  private _rebuild(): void {
+    this._snapshot = this._buildSnapshot();
+    this._notify();
+  }
+
+  private _buildSnapshot(): ModelPickerData {
+    const entries: readonly ModelPickerEntry[] = enrichModelEntries(
+      this._models,
+      this._healthState,
+      this._modelState,
+      this._pinnedIds,
+      this.benchmarkStore,
+      this.providerRegistry,
+    );
+
+    const groups = groupEntriesByProvider(entries);
+
+    const degradedProviderIds: string[] = [];
+    const unavailableProviderIds: string[] = [];
+    for (const [id, record] of this._healthState.providers) {
+      if (record.status === 'degraded' || record.status === 'rate_limited') {
+        degradedProviderIds.push(id);
+      } else if (record.status === 'unavailable' || record.status === 'auth_error') {
+        unavailableProviderIds.push(id);
+      }
+    }
+
+    return {
+      entries,
+      groups,
+      degradedProviderIds,
+      unavailableProviderIds,
+      activeModelId: this._modelState.activeModelId,
+      snapshotAt: Date.now(),
+    };
+  }
+
+  private _notify(): void {
+    for (const cb of this._subscribers) {
+      try {
+        cb();
+      } catch {
+        // Non-fatal: subscriber errors must not crash the provider
+      }
+    }
+  }
+}

package/src/runtime/ui/model-picker/health-enrichment.ts

@@ -0,0 +1,228 @@
+/**
+ * Health enrichment for model picker entries.
+ *
+ * Joins ModelDefinition records from the provider registry with health
+ * telemetry from ProviderHealthDomainState to produce enriched
+ * ModelPickerEntry objects ready for UI consumption.
+ */
+import type { ModelDefinition } from '../../../providers/registry.ts';
+import type { ProviderRegistry } from '../../../providers/registry.ts';
+import type { BenchmarkStore } from '@pellux/goodvibes-sdk/platform/providers/model-benchmarks';
+import type { ProviderHealthDomainState, ProviderHealthRecord } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/provider-health';
+import type { ModelDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/model';
+import { detectFamily, tierToCategoryFilter } from '../../../input/model-picker.ts';
+import { getQualityTier, getQualityTierFromScore, compositeScore } from '@pellux/goodvibes-sdk/platform/providers/model-benchmarks';
+import type {
+  ModelPickerEntry,
+  ModelPickerGroup,
+  ProviderHealthContext,
+  CapabilityFlags,
+  ProviderLatencyStats,
+} from './types.ts';
+
+/** Status sort priority (lower = shown first). */
+const STATUS_ORDER: Record<string, number> = {
+  healthy: 0,
+  unknown: 1,
+  degraded: 2,
+  rate_limited: 3,
+  auth_error: 4,
+  unavailable: 5,
+};
+
+/**
+ * Derive ProviderHealthContext from a ProviderHealthRecord.
+ * Returns a safe default when the record is absent (provider not yet observed).
+ */
+function buildHealthContext(record: ProviderHealthRecord | undefined): ProviderHealthContext {
+  if (!record) {
+    return {
+      status: 'unknown',
+      isConfigured: false,
+    };
+  }
+
+  let latency: ProviderLatencyStats | undefined;
+  if (record.stats.totalCalls > 0) {
+    latency = {
+      avgMs: record.stats.avgLatencyMs,
+      p95Ms: record.stats.maxLatencyMs,
+      minMs: record.stats.minLatencyMs,
+    };
+  }
+
+  return {
+    status: record.status,
+    latency,
+    cacheHitRate: record.cacheMetrics?.hitRate,
+    isConfigured: record.isConfigured,
+    rateLimitResetAt: record.rateLimitResetAt,
+  };
+}
+
+/**
+ * Derive CapabilityFlags from a ModelDefinition.
+ */
+function buildCapabilityFlags(model: ModelDefinition): CapabilityFlags {
+  return {
+    reasoning: model.capabilities?.reasoning ?? false,
+    caching: false, // caching capability is provider-level; enriched separately if needed
+    toolCalling: model.capabilities?.toolCalling ?? false,
+    multimodal: model.capabilities?.multimodal ?? false,
+    codeEditing: model.capabilities?.codeEditing ?? false,
+  };
+}
+
+/**
+ * Derive quality tier and benchmark score for a model.
+ * Handles synthetic models (catalog-backed composite scores) and standard models.
+ */
+function buildQualityInfo(
+  model: ModelDefinition,
+  benchmarkStore: Pick<BenchmarkStore, 'getBenchmarks'>,
+  providerRegistry: Pick<ProviderRegistry, 'getSyntheticModelInfoFromCatalog'>,
+): { qualityTier?: string; benchmarkScore?: number } {
+  if (model.provider === 'synthetic') {
+    const info = providerRegistry.getSyntheticModelInfoFromCatalog(model.id);
+    if (info?.bestCompositeScore != null) {
+      return {
+        qualityTier: getQualityTierFromScore(info.bestCompositeScore),
+        benchmarkScore: info.bestCompositeScore,
+      };
+    }
+    return {};
+  }
+
+  const benchmarks = benchmarkStore.getBenchmarks(model.id) ?? benchmarkStore.getBenchmarks(model.displayName);
+  if (!benchmarks) return {};
+
+  return {
+    qualityTier: getQualityTier(benchmarks.benchmarks),
+    benchmarkScore: compositeScore(benchmarks.benchmarks) ?? undefined,
+  };
+}
+
+/**
+ * Build the set of model IDs in the current fallback chain.
+ * Returns a Map from modelId to its position (0 = primary).
+ */
+function buildFallbackPositionMap(modelState: ModelDomainState): Map<string, number> {
+  const map = new Map<string, number>();
+  // Position 0 is always the primary active model
+  map.set(modelState.activeModelId, 0);
+  for (let i = 0; i < modelState.fallbackChain.length; i++) {
+    const entry = modelState.fallbackChain[i];
+    if (!map.has(entry.modelId)) {
+      map.set(entry.modelId, i + 1);
+    }
+  }
+  return map;
+}
+
+/**
+ * Enrich a flat list of ModelDefinitions with health and state data.
+ *
+ * @param models - All selectable models from the registry.
+ * @param healthState - Current provider health domain state.
+ * @param modelState - Current model domain state.
+ * @param pinnedIds - Set of pinned/favorited model IDs.
+ * @returns Sorted, enriched ModelPickerEntry array.
+ */
+export function enrichModelEntries(
+  models: readonly ModelDefinition[],
+  healthState: ProviderHealthDomainState,
+  modelState: ModelDomainState,
+  pinnedIds: ReadonlySet<string>,
+  benchmarkStore: Pick<BenchmarkStore, 'getBenchmarks'>,
+  providerRegistry: Pick<ProviderRegistry, 'getSyntheticModelInfoFromCatalog' | 'getContextWindowForModel'>,
+): ModelPickerEntry[] {
+  const fallbackPositions = buildFallbackPositionMap(modelState);
+
+  const entries: ModelPickerEntry[] = models.map((model) => {
+    const record = healthState.providers.get(model.provider);
+    const health = buildHealthContext(record);
+    const { qualityTier, benchmarkScore } = buildQualityInfo(model, benchmarkStore, providerRegistry);
+    const isProviderDegraded =
+      health.status === 'degraded' || health.status === 'rate_limited';
+    const isProviderUnavailable =
+      health.status === 'unavailable' || health.status === 'auth_error';
+
+    const fallbackPosition = fallbackPositions.get(model.id);
+
+    // Resolve effective context window and determine display source label.
+    const effectiveContextWindow = providerRegistry.getContextWindowForModel(model);
+    // Determine source: custom/local providers carry provenance on ModelDefinition;
+    // for catalog models, if getContextWindowForModel returned more than the
+    // static contextWindow it came from OpenRouter, else it's the registry value.
+    let contextWindowSource: ModelPickerEntry['contextWindowSource'];
+    if (model.contextWindowProvenance) {
+      contextWindowSource = model.contextWindowProvenance;
+    } else if (effectiveContextWindow !== model.contextWindow) {
+      contextWindowSource = 'openrouter';
+    } else {
+      contextWindowSource = 'registry';
+    }
+
+    return {
+      modelId: model.id,
+      providerId: model.provider,
+      displayName: model.displayName,
+      family: detectFamily(model),
+      pricingTier: tierToCategoryFilter(model.tier),
+      qualityTier,
+      benchmarkScore,
+      capabilities: buildCapabilityFlags(model),
+      health,
+      contextWindow: effectiveContextWindow,
+      contextWindowSource,
+      isPinned: pinnedIds.has(model.id),
+      isActive: model.id === modelState.activeModelId,
+      isProviderDegraded,
+      isProviderUnavailable,
+      isInFallbackChain: fallbackPosition !== undefined,
+      fallbackPosition,
+    };
+  });
+
+  // Sort: healthy providers first, then degraded, then unavailable.
+  // Within each status bucket: pinned first, then active, then by display name.
+  entries.sort((a, b) => {
+    const statusDiff =
+      (STATUS_ORDER[a.health.status] ?? 1) - (STATUS_ORDER[b.health.status] ?? 1);
+    if (statusDiff !== 0) return statusDiff;
+
+    // Pinned before unpinned
+    if (a.isPinned !== b.isPinned) return a.isPinned ? -1 : 1;
+    // Active before inactive
+    if (a.isActive !== b.isActive) return a.isActive ? -1 : 1;
+
+    return a.displayName.localeCompare(b.displayName);
+  });
+
+  return entries;
+}
+
+/**
+ * Group a sorted list of ModelPickerEntry records by their provider ID.
+ * Preserves the sort order of entries within each group.
+ *
+ * @param entries - Pre-sorted enriched entries.
+ * @returns Groups ordered by first appearance of each provider in entries.
+ */
+export function groupEntriesByProvider(entries: readonly ModelPickerEntry[]): ModelPickerGroup[] {
+  const groupMap = new Map<string, ModelPickerEntry[]>();
+  const groupOrder: string[] = [];
+
+  for (const entry of entries) {
+    if (!groupMap.has(entry.providerId)) {
+      groupMap.set(entry.providerId, []);
+      groupOrder.push(entry.providerId);
+    }
+    groupMap.get(entry.providerId)!.push(entry);
+  }
+
+  return groupOrder.map((providerId) => ({
+    label: providerId,
+    entries: groupMap.get(providerId)!,
+  }));
+}

package/src/runtime/ui/model-picker/index.ts

@@ -0,0 +1,59 @@
+/**
+ * Model picker UI data surface barrel.
+ *
+ * Re-exports all types and the ModelPickerDataProvider class.
+ * Also provides the createModelPickerData() factory for one-shot snapshots.
+ */
+export type {
+  CapabilityFlags,
+  ProviderLatencyStats,
+  ProviderHealthContext,
+  ModelPickerEntry,
+  ModelPickerGroup,
+  ModelPickerData,
+} from './types.ts';
+// ProviderStatus re-exported from types for convenience
+export type { ProviderStatus } from './types.ts';
+
+export { ModelPickerDataProvider } from './data-provider.ts';
+export type { ModelPickerDataProviderOptions } from './data-provider.ts';
+
+import type { ModelDefinition } from '../../../providers/registry.ts';
+import type { ProviderRegistry } from '../../../providers/registry.ts';
+import type { BenchmarkStore } from '@pellux/goodvibes-sdk/platform/providers/model-benchmarks';
+import type { ProviderHealthDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/provider-health';
+import type { ModelDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/model';
+import type { ModelPickerData } from './types.ts';
+import { ModelPickerDataProvider } from './data-provider.ts';
+
+/**
+ * Produce a one-shot ModelPickerData 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 ModelPickerDataProvider.
+ *
+ * @param models - All selectable models from the registry.
+ * @param healthState - Current provider health domain state.
+ * @param modelState - Current model domain state.
+ * @param pinnedIds - Set of pinned/favorited model IDs.
+ * @returns Immutable ModelPickerData snapshot.
+ */
+export function createModelPickerData(
+  models: readonly ModelDefinition[],
+  healthState: ProviderHealthDomainState,
+  modelState: ModelDomainState,
+  benchmarkStore: Pick<BenchmarkStore, 'getBenchmarks'>,
+  providerRegistry: Pick<ProviderRegistry, 'getSyntheticModelInfoFromCatalog' | 'getContextWindowForModel'>,
+  pinnedIds: ReadonlySet<string> = new Set(),
+): ModelPickerData {
+  // Delegate to the data provider for consistent derivation logic,
+  // then dispose immediately since no subscriptions are needed.
+  const dp = new ModelPickerDataProvider(models, healthState, modelState, {
+    pinnedIds,
+    benchmarkStore,
+    providerRegistry,
+  });
+  const snapshot = dp.getSnapshot();
+  dp.dispose();
+  return snapshot;
+}