@pellux/goodvibes-tui 0.18.13 → 0.18.17

package/src/renderer/settings-modal-helpers.ts

@@ -0,0 +1,122 @@
+/**
+ * Pure formatting, label, and color helpers for renderSettingsModal.
+ * Extracted from settings-modal.ts to keep the renderer under the 800-line
+ * architecture cap. No layout logic lives here.
+ */
+
+import type { SettingEntry, McpEntry, SubscriptionEntry } from '../input/settings-modal.ts';
+import { SETTINGS_CATEGORIES } from '../input/settings-modal.ts';
+
+export function formatValue(entry: SettingEntry): string {
+  const val = entry.currentValue;
+  if (val === null || val === undefined) return '(unset)';
+  if (typeof val === 'boolean') return val ? 'true' : 'false';
+  if (typeof val === 'string' && val === '') return '(empty)';
+  return String(val);
+}
+
+export function valueColor(entry: SettingEntry): string {
+  if (!entry.isDefault) return '#00ffcc'; // cyan-green = modified
+  return '244';                            // dim = default
+}
+
+export function flagStateColor(state: string, killed: boolean): string {
+  if (killed) return '#ef4444'; // red
+  if (state === 'enabled') return '#00ffcc'; // cyan-green
+  return '244'; // dim
+}
+
+export function mcpTrustColor(mode: McpEntry['trustMode']): string {
+  switch (mode) {
+    case 'allow-all':
+      return '#ef4444';
+    case 'ask-on-risk':
+      return '#eab308';
+    case 'constrained':
+      return '#00ffcc';
+    case 'blocked':
+      return '244';
+    default:
+      return '244';
+  }
+}
+
+export function subscriptionStateColor(state: SubscriptionEntry['state']): string {
+  switch (state) {
+    case 'active':
+      return '#00ffcc';
+    case 'pending':
+      return '#eab308';
+    case 'available':
+      return '#38bdf8';
+    default:
+      return '244';
+  }
+}
+
+export function inferSubscriptionRouteReason(entry: SubscriptionEntry): string | undefined {
+  if (entry.routeReason?.trim()) return entry.routeReason;
+  if (entry.state === 'active' && entry.oauthConfigured) {
+    return 'ambient key override enabled for this provider.';
+  }
+  if (entry.state === 'pending' && entry.oauthConfigured) {
+    return 'oauth configuration present; ambient key override will apply after activation.';
+  }
+  return undefined;
+}
+
+export const CATEGORY_LABELS: Record<(typeof SETTINGS_CATEGORIES)[number], string> = {
+  display: 'Display',
+  ui: 'UI',
+  provider: 'Provider',
+  subscriptions: 'Subscriptions',
+  behavior: 'Behavior',
+  storage: 'Storage',
+  permissions: 'Permissions',
+  mcp: 'MCP',
+  sandbox: 'Sandbox',
+  danger: 'Danger',
+  tools: 'Tools',
+  flags: 'Flags',
+};
+
+export const SETTING_LABELS: Partial<Record<string, string>> = {
+  'ui.systemMessages': 'System Message Target',
+  'ui.operationalMessages': 'Operational Message Target',
+  'ui.wrfcMessages': 'WRFC Message Target',
+  'ui.voiceEnabled': 'Voice Surface',
+  'behavior.autoCompactThreshold': 'Auto-Compact %',
+  'behavior.staleContextWarnings': 'Context Warnings',
+  'behavior.returnContextMode': 'Return Context',
+  'behavior.guidanceMode': 'Guidance Mode',
+  'storage.secretPolicy': 'Secret Policy',
+  'sandbox.vmBackend': 'Sandbox Backend',
+  'sandbox.qemuBinary': 'QEMU Binary',
+  'sandbox.qemuImagePath': 'QEMU Image',
+  'sandbox.qemuExecWrapper': 'QEMU Wrapper',
+  'tools.llmProvider': 'Tool LLM Provider',
+  'tools.llmModel': 'Tool LLM Model',
+  'tools.autoHeal': 'Auto-Heal',
+  'tools.defaultTokenBudget': 'Default Token Budget',
+  'tools.hooksFile': 'Hooks File',
+  'helper.enabled': 'Helper Enabled',
+  'helper.globalProvider': 'Helper Provider',
+  'helper.globalModel': 'Helper Model',
+};
+
+export function getSettingLabel(entry: SettingEntry): string {
+  return SETTING_LABELS[entry.setting.key] ?? entry.setting.key.replace(/^[^.]+\./, '');
+}
+
+export function describeUiRouting(value: string): string {
+  switch (value) {
+    case 'panel':
+      return 'render in panels only';
+    case 'conversation':
+      return 'render inline in conversation';
+    case 'both':
+      return 'render in both conversation and panels';
+    default:
+      return value;
+  }
+}

package/src/renderer/settings-modal.ts

@@ -17,116 +17,17 @@ import { SETTINGS_CATEGORIES } from '../input/settings-modal.ts';
 import { fitDisplay, truncateDisplay } from '../utils/terminal-width.ts';
 import { getOverlaySurfaceMetrics, getStableOverlayContentRows } from './overlay-viewport.ts';
 import { getVisibleWindow } from './surface-layout.ts';
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function formatValue(entry: SettingEntry): string {
-  const val = entry.currentValue;
-  if (val === null || val === undefined) return '(unset)';
-  if (typeof val === 'boolean') return val ? 'true' : 'false';
-  if (typeof val === 'string' && val === '') return '(empty)';
-  return String(val);
-}
-
-function valueColor(entry: SettingEntry): string {
-  if (!entry.isDefault) return '#00ffcc'; // cyan-green = modified
-  return '244';                            // dim = default
-}
-
-function flagStateColor(state: string, killed: boolean): string {
-  if (killed) return '#ef4444'; // red
-  if (state === 'enabled') return '#00ffcc'; // cyan-green
-  return '244'; // dim
-}
-
-function mcpTrustColor(mode: McpEntry['trustMode']): string {
-  switch (mode) {
-    case 'allow-all':
-      return '#ef4444';
-    case 'ask-on-risk':
-      return '#eab308';
-    case 'constrained':
-      return '#00ffcc';
-    case 'blocked':
-      return '244';
-    default:
-      return '244';
-  }
-}
-
-function subscriptionStateColor(state: SubscriptionEntry['state']): string {
-  switch (state) {
-    case 'active':
-      return '#00ffcc';
-    case 'pending':
-      return '#eab308';
-    case 'available':
-      return '#38bdf8';
-    default:
-      return '244';
-  }
-}
-
-function inferSubscriptionRouteReason(entry: SubscriptionEntry): string | undefined {
-  if (entry.routeReason?.trim()) return entry.routeReason;
-  if (entry.state === 'active' && entry.oauthConfigured) {
-    return 'ambient key override enabled for this provider.';
-  }
-  if (entry.state === 'pending' && entry.oauthConfigured) {
-    return 'oauth configuration present; ambient key override will apply after activation.';
-  }
-  return undefined;
-}
-
-const CATEGORY_LABELS: Record<(typeof SETTINGS_CATEGORIES)[number], string> = {
-  display: 'Display',
-  ui: 'UI',
-  provider: 'Provider',
-  subscriptions: 'Subscriptions',
-  behavior: 'Behavior',
-  storage: 'Storage',
-  permissions: 'Permissions',
-  mcp: 'MCP',
-  sandbox: 'Sandbox',
-  danger: 'Danger',
-  tools: 'Tools',
-  flags: 'Flags',
-};
-
-const SETTING_LABELS: Partial<Record<string, string>> = {
-  'ui.systemMessages': 'System Message Target',
-  'ui.operationalMessages': 'Operational Message Target',
-  'ui.wrfcMessages': 'WRFC Message Target',
-  'ui.voiceEnabled': 'Voice Surface',
-  'behavior.autoCompactThreshold': 'Auto-Compact %',
-  'behavior.staleContextWarnings': 'Context Warnings',
-  'behavior.returnContextMode': 'Return Context',
-  'behavior.guidanceMode': 'Guidance Mode',
-  'storage.secretPolicy': 'Secret Policy',
-  'sandbox.vmBackend': 'Sandbox Backend',
-  'sandbox.qemuBinary': 'QEMU Binary',
-  'sandbox.qemuImagePath': 'QEMU Image',
-  'sandbox.qemuExecWrapper': 'QEMU Wrapper',
-};
-
-function getSettingLabel(entry: SettingEntry): string {
-  return SETTING_LABELS[entry.setting.key] ?? entry.setting.key.replace(/^[^.]+\./, '');
-}
-
-function describeUiRouting(value: string): string {
-  switch (value) {
-    case 'panel':
-      return 'render in panels only';
-    case 'conversation':
-      return 'render inline in conversation';
-    case 'both':
-      return 'render in both conversation and panels';
-    default:
-      return value;
-  }
-}
+import {
+  formatValue,
+  valueColor,
+  flagStateColor,
+  mcpTrustColor,
+  subscriptionStateColor,
+  inferSubscriptionRouteReason,
+  CATEGORY_LABELS,
+  getSettingLabel,
+  describeUiRouting,
+} from './settings-modal-helpers.ts';
 
 // ---------------------------------------------------------------------------
 // Renderer
@@ -161,6 +62,7 @@ export function renderSettingsModal(
   const isSubscriptionsTab = SETTINGS_CATEGORIES[modal.categoryIndex] === 'subscriptions';
   const isFlagsTab = SETTINGS_CATEGORIES[modal.categoryIndex] === 'flags';
   const isUiTab = SETTINGS_CATEGORIES[modal.categoryIndex] === 'ui';
+  const isToolsTab = SETTINGS_CATEGORIES[modal.categoryIndex] === 'tools';
   let persistentHelpers: import('./modal-factory.ts').ModalHelperRow[] | undefined;
   sections.push({
     type: 'text',
@@ -174,7 +76,9 @@ export function renderSettingsModal(
             ? 'Control shell presentation, including where operational and WRFC updates render across conversation and panels.'
           : isFlagsTab
             ? 'Feature flags control staged or experimental behavior. Some changes may require restart.'
-            : 'Browse and adjust operator-facing runtime settings by category.',
+            : isToolsTab
+              ? 'Configure tool LLM routing and helper model. Provider and model fields are optional — empty means use the active provider.'
+              : 'Browse and adjust operator-facing runtime settings by category.',
     style: { fg: '246', dim: true },
   });
 
@@ -529,6 +433,138 @@ export function renderSettingsModal(
     );
   }
 
+  // ── Tools tab ─────────────────────────────────────────────────
+  if (isToolsTab) {
+    const toolsItems = modal.currentItems; // includes helper.* entries routed into tools group
+
+    if (toolsItems.length === 0) {
+      sections.push({
+        type: 'text',
+        content: '(no tool or helper settings available)',
+        style: { fg: '240', dim: true },
+      });
+    } else {
+      const labelW = Math.floor(contentW * 0.38);
+      const valW = Math.floor(contentW * 0.30);
+      const srcW = Math.max(0, contentW - labelW - valW - 4);
+
+      sections.push({
+        type: 'text',
+        content: `${fitDisplay('Setting', labelW)}  ${fitDisplay('Value', valW)}  Source`,
+        style: { fg: '240', dim: true },
+      });
+      sections.push({ type: 'separator' });
+
+      const window = getVisibleWindow(toolsItems.length, modal.selectedIndex, maxVisibleRows);
+      const visibleItems = toolsItems.slice(window.start, window.end);
+
+      // Render each entry as an individual text row so section headers can interleave.
+      // Section headers are emitted when the key prefix changes (tools.* vs helper.*).
+      let lastGroupPrefix = '';
+      for (let i = 0; i < visibleItems.length; i++) {
+        const entry = visibleItems[i]!;
+        const isSelected = window.start + i === modal.selectedIndex;
+        const isEditing = isSelected && modal.editingMode;
+        const prefix = entry.setting.key.split('.')[0]!;
+
+        // Emit a section header when the group prefix changes
+        if (prefix !== lastGroupPrefix) {
+          lastGroupPrefix = prefix;
+          const sectionLabel = prefix === 'helper' ? '── Helper Model ──' : '── Tool LLM ──';
+          sections.push({
+            type: 'text',
+            content: fitDisplay(sectionLabel, contentW),
+            style: { fg: '243', dim: true },
+          });
+        }
+
+        const label = getSettingLabel(entry);
+        const labelStr = fitDisplay(label, labelW);
+
+        let valueStr: string;
+        if (entry.setting.type === 'boolean') {
+          const boolVal = Boolean(entry.currentValue);
+          valueStr = isEditing ? `${modal.editBuffer}\u2588` : (boolVal ? '[on]' : '[off]');
+        } else if (isEditing) {
+          valueStr = `${modal.editBuffer}\u2588`;
+        } else {
+          valueStr = formatValue(entry);
+        }
+
+        const valStr = fitDisplay(valueStr, valW);
+        const sourceText = entry.effectiveSource ?? 'default';
+        const srcStr = fitDisplay(sourceText, srcW);
+        const rowLabel = `${labelStr}  ${valStr}  ${srcStr}`;
+
+        // Render as a single-item list so the ModalFactory applies selection highlight
+        sections.push({
+          type: 'list',
+          items: [{
+            label: rowLabel,
+            selected: isSelected,
+            style: isSelected ? undefined : { fg: valueColor(entry) },
+          }],
+        });
+      }
+
+      if (toolsItems.length > maxVisibleRows) {
+        sections.push({
+          type: 'text',
+          content: `[${window.start + 1}-${window.end} of ${toolsItems.length}]`,
+          style: { fg: '244', dim: true },
+        });
+      }
+
+      // Description of selected entry
+      const selected = modal.getSelected();
+      if (selected) {
+        sections.push({ type: 'separator' });
+        sections.push({
+          type: 'text',
+          content: truncateDisplay(selected.setting.description, contentW),
+          style: { fg: '246', dim: true },
+        });
+        if (selected.setting.type === 'boolean') {
+          sections.push({
+            type: 'text',
+            content: truncateDisplay(`Currently ${Boolean(selected.currentValue) ? 'enabled' : 'disabled'}. Press Enter or Space to toggle.`, contentW),
+            style: { fg: '#38bdf8', dim: true },
+          });
+        } else {
+          const emptyNote = selected.currentValue === '' || selected.currentValue === null || selected.currentValue === undefined
+            ? ' (empty = use active provider default)'
+            : '';
+          sections.push({
+            type: 'text',
+            content: truncateDisplay(`Current: ${formatValue(selected)}${emptyNote}`, contentW),
+            style: { fg: '#38bdf8', dim: true },
+          });
+        }
+      }
+    }
+
+    const hints = modal.editingMode
+      ? ['[Enter] Confirm', '[Esc] Cancel']
+      : ['[Tab] Category', '[\u2191\u2193] Navigate', '[Enter] Toggle / Edit', '[Esc] Close'];
+
+    return ModalFactory.createModal(
+      {
+        title: 'Settings',
+        width: boxW,
+        margin: boxMargin,
+        targetContentRows,
+        tabs: SETTINGS_CATEGORIES.map((category, index) => ({
+          label: CATEGORY_LABELS[category],
+          active: index === modal.categoryIndex,
+        })),
+        sections,
+        hints,
+        helpers: persistentHelpers,
+      },
+      width,
+    );
+  }
+
   // ── Settings list ────────────────────────────────────────────
   const items = modal.currentItems;
 

package/src/runtime/bootstrap-command-context.ts

@@ -82,7 +82,7 @@ export type CreateBootstrapCommandContextOptions = {
   providerApi?: ProviderApi;
   subscriptionManager?: import('@pellux/goodvibes-sdk/platform/config/subscriptions').SubscriptionManager;
   secretsManager?: import('../config/secrets.ts').SecretsManager;
-  serviceRegistry?: import('../config/service-registry.ts').ServiceRegistry;
+  serviceRegistry?: import('@pellux/goodvibes-sdk/platform/config/service-registry').ServiceRegistry;
   localUserAuthManager?: import('@pellux/goodvibes-sdk/platform/security/user-auth').UserAuthManager;
   tokenAuditor?: import('@pellux/goodvibes-sdk/platform/security/token-audit').ApiTokenAuditor;
   replayEngine?: import('@pellux/goodvibes-sdk/platform/core/deterministic-replay').DeterministicReplayEngine;

package/src/runtime/bootstrap-command-parts.ts

@@ -92,7 +92,7 @@ export interface BootstrapCommandSectionOptions {
   readonly benchmarkStore?: import('@pellux/goodvibes-sdk/platform/providers/model-benchmarks').BenchmarkStore;
   readonly subscriptionManager?: import('@pellux/goodvibes-sdk/platform/config/subscriptions').SubscriptionManager;
   readonly secretsManager?: import('../config/secrets.ts').SecretsManager;
-  readonly serviceRegistry?: import('../config/service-registry.ts').ServiceRegistry;
+  readonly serviceRegistry?: import('@pellux/goodvibes-sdk/platform/config/service-registry').ServiceRegistry;
   readonly localUserAuthManager?: import('@pellux/goodvibes-sdk/platform/security/user-auth').UserAuthManager;
   readonly tokenAuditor?: import('@pellux/goodvibes-sdk/platform/security/token-audit').ApiTokenAuditor;
   readonly replayEngine?: import('@pellux/goodvibes-sdk/platform/core/deterministic-replay').DeterministicReplayEngine;
@@ -182,25 +182,41 @@ export function createBootstrapCommandActions(
     clearScreen: () => unwiredShellAction('clearScreen'),
     activatePlan,
     requestPermission: (request) => requestPermission(request),
-    completeModelSelection: ({ model, effort, contextCap }) => {
+    completeModelSelection: ({ model, effort, contextCap, target }) => {
       if (!model) return;
       const def = model;
       const key = def.registryKey ?? `${def.provider}:${def.id}`;
+      const resolvedTarget = target ?? 'main';
       try {
-        if (contextCap != null && contextCap > 0) {
-          providerRegistry.setModelContextCap(key, contextCap);
+        if (resolvedTarget === 'helper') {
+          // Write to helper config keys and enable the helper
+          configManager.set('helper.globalProvider', def.provider);
+          configManager.set('helper.globalModel', key);
+          configManager.set('helper.enabled', true);
+          conversation.log(`Helper model set to: ${def.displayName} (${def.provider})`, { fg: '135' });
+        } else if (resolvedTarget === 'tool') {
+          // Write to tool LLM config keys and enable the tool LLM
+          configManager.set('tools.llmProvider', def.provider);
+          configManager.set('tools.llmModel', key);
+          configManager.setDynamic('tools.llmEnabled' as never, true);
+          conversation.log(`Tool LLM set to: ${def.displayName} (${def.provider})`, { fg: '135' });
+        } else {
+          // Default: main provider/model
+          if (contextCap != null && contextCap > 0) {
+            providerRegistry.setModelContextCap(key, contextCap);
+          }
+          providerRegistry.setCurrentModel(key);
+          runtime.model = key;
+          runtime.provider = def.provider;
+          runtime.reasoningEffort = effort as 'instant' | 'low' | 'medium' | 'high';
+          configManager.set('provider.model', key);
+          configManager.set('provider.provider', def.provider);
+          configManager.set('provider.reasoningEffort', effort as 'instant' | 'low' | 'medium' | 'high');
+          const ctxNote = contextCap != null && contextCap > 0
+            ? `, context cap: ${contextCap.toLocaleString()}`
+            : '';
+          conversation.log(`Switched to model: ${def.displayName} (${def.provider}), effort: ${effort}${ctxNote}`, { fg: '135' });
         }
-        providerRegistry.setCurrentModel(key);
-        runtime.model = key;
-        runtime.provider = def.provider;
-        runtime.reasoningEffort = effort as 'instant' | 'low' | 'medium' | 'high';
-        configManager.set('provider.model', key);
-        configManager.set('provider.provider', def.provider);
-        configManager.set('provider.reasoningEffort', effort as 'instant' | 'low' | 'medium' | 'high');
-        const ctxNote = contextCap != null && contextCap > 0
-          ? `, context cap: ${contextCap.toLocaleString()}`
-          : '';
-        conversation.log(`Switched to model: ${def.displayName} (${def.provider}), effort: ${effort}${ctxNote}`, { fg: '135' });
       } catch (e) {
         conversation.log(`Error switching model: ${summarizeError(e)}`, { fg: '#ef4444' });
       }

package/src/runtime/bootstrap.ts

@@ -35,6 +35,7 @@ import {
 import { startBackgroundProviderRegistration } from '@pellux/goodvibes-sdk/platform/runtime/bootstrap-background';
 import { restoreSavedModel } from '@pellux/goodvibes-sdk/platform/runtime/bootstrap-helpers';
 import { startExternalServices, type ExternalServicesHandle } from '@pellux/goodvibes-sdk/platform/runtime/bootstrap-services';
+import { getOrCreateCompanionToken } from '@pellux/goodvibes-sdk/platform/pairing/companion-token';
 import type { UiRuntimeServices } from './ui-services.ts';
 import { createDeferredStartupCoordinator } from '@pellux/goodvibes-sdk/platform/runtime/deferred-startup';
 import { initializeBootstrapCore } from './bootstrap-core.ts';
@@ -320,11 +321,15 @@ export async function bootstrapRuntime(
   deferredStartup.schedule({
     label: 'external-services',
     run: async () => {
+      // Register the persistent companion-pairing token as the daemon's shared
+      // bearer, so tokens scanned from the /qrcode panel's QR actually
+      // authenticate against the embedded daemon this surface starts.
+      const companionTokenRecord = getOrCreateCompanionToken('tui');
       externalServicesPromise = startExternalServices(
         configManager,
         runtimeBus,
         hookDispatcher,
-        {},
+        { sharedDaemonToken: companionTokenRecord.token },
         services,
       );
       externalServices = await externalServicesPromise;

package/src/runtime/diagnostics/panels/index.ts

@@ -3,13 +3,13 @@
  *
  * Import from this module to access the individual diagnostic panel providers.
  */
-export { ToolCallsPanel } from './tool-calls.ts';
-export { AgentsPanel } from './agents.ts';
-export { TasksPanel } from './tasks.ts';
-export { EventsPanel } from './events.ts';
+export { ToolCallsPanel } from '@pellux/goodvibes-sdk/platform/runtime/diagnostics/panels/tool-calls';
+export { AgentsPanel } from '@pellux/goodvibes-sdk/platform/runtime/diagnostics/panels/agents';
+export { TasksPanel } from '@pellux/goodvibes-sdk/platform/runtime/diagnostics/panels/tasks';
+export { EventsPanel } from '@pellux/goodvibes-sdk/platform/runtime/diagnostics/panels/events';
 export { StateInspectorPanel } from '@pellux/goodvibes-sdk/platform/runtime/diagnostics/panels/state-inspector';
 export type { InspectableDomain } from '@pellux/goodvibes-sdk/platform/runtime/diagnostics/panels/state-inspector';
-export { HealthPanel } from './health.ts';
+export { HealthPanel } from '@pellux/goodvibes-sdk/platform/runtime/diagnostics/panels/health';
 export { DivergencePanel } from '@pellux/goodvibes-sdk/platform/runtime/diagnostics/panels/divergence';
 export { ReplayPanel } from '@pellux/goodvibes-sdk/platform/runtime/diagnostics/panels/replay';
 export { PolicyPanel } from './policy.ts';

package/src/runtime/services.ts

@@ -1,7 +1,7 @@
 import { join } from 'node:path';
 import { ConfigManager } from '@pellux/goodvibes-sdk/platform/config/manager';
 import { SecretsManager } from '../config/secrets.ts';
-import { ServiceRegistry } from '../config/service-registry.ts';
+import { ServiceRegistry } from '@pellux/goodvibes-sdk/platform/config/service-registry';
 import { SubscriptionManager } from '@pellux/goodvibes-sdk/platform/config/subscriptions';
 import { AutomationDeliveryManager, AutomationManager, AutomationRouteStore } from '@pellux/goodvibes-sdk/platform/automation/index';
 import { ChannelPluginRegistry, ChannelPolicyManager, RouteBindingManager, SurfaceRegistry } from '@pellux/goodvibes-sdk/platform/channels/index';

package/src/runtime/store/domains/domain-read-matrix.ts

@@ -1,7 +1,5 @@
 export const DOMAINS = [
-  'conversation',
   'panels',
-  'permissions',
   'ui-perf',
 ] as const;
 

package/src/runtime/ui-events.ts

@@ -1,46 +1 @@
-import type {
-  AgentEvent,
-  AnyRuntimeEvent,
-  OpsEvent,
-  PlannerEvent,
-  ProviderEvent,
-  RuntimeEventBus,
-  RuntimeEventEnvelope,
-  SessionEvent,
-  ToolEvent,
-  TurnEvent,
-  WorkflowEvent,
-} from '@pellux/goodvibes-sdk/platform/runtime/events/index';
-import { createRuntimeEventFeed, type RuntimeEventFeed } from '@pellux/goodvibes-sdk/platform/runtime/event-feeds';
-
-export type UiEventFeed<TEvent extends AnyRuntimeEvent> = RuntimeEventFeed<TEvent>;
-
-export interface UiRuntimeEvents {
-  readonly sessions: UiEventFeed<SessionEvent>;
-  readonly turns: UiEventFeed<TurnEvent>;
-  readonly tools: UiEventFeed<ToolEvent>;
-  readonly providers: UiEventFeed<ProviderEvent>;
-  readonly agents: UiEventFeed<AgentEvent>;
-  readonly workflows: UiEventFeed<WorkflowEvent>;
-  readonly planner: UiEventFeed<PlannerEvent>;
-  readonly ops: UiEventFeed<OpsEvent>;
-}
-
-function createUiEventFeed<TEvent extends AnyRuntimeEvent>(runtimeBus: RuntimeEventBus): UiEventFeed<TEvent> {
-  return createRuntimeEventFeed<TEvent>((type, listener) => (
-    runtimeBus.on(type as TEvent['type'], listener as (envelope: RuntimeEventEnvelope<TEvent['type'], TEvent>) => void)
-  ));
-}
-
-export function createUiRuntimeEvents(runtimeBus: RuntimeEventBus): UiRuntimeEvents {
-  return {
-    sessions: createUiEventFeed<SessionEvent>(runtimeBus),
-    turns: createUiEventFeed<TurnEvent>(runtimeBus),
-    tools: createUiEventFeed<ToolEvent>(runtimeBus),
-    providers: createUiEventFeed<ProviderEvent>(runtimeBus),
-    agents: createUiEventFeed<AgentEvent>(runtimeBus),
-    workflows: createUiEventFeed<WorkflowEvent>(runtimeBus),
-    planner: createUiEventFeed<PlannerEvent>(runtimeBus),
-    ops: createUiEventFeed<OpsEvent>(runtimeBus),
-  };
-}
+export * from '@pellux/goodvibes-sdk/platform/runtime/ui-events';

package/src/runtime/ui-read-model-helpers.ts

@@ -1,32 +1 @@
-import type { RuntimeServices } from './services.ts';
-import type { UiReadModel } from '@pellux/goodvibes-sdk/platform/runtime/ui-read-models-base';
-
-export function combineSubscriptions(...teardowns: Array<() => void>): () => void {
-  return () => {
-    for (const teardown of teardowns) {
-      teardown();
-    }
-  };
-}
-
-export function createStoreBackedReadModel<TSnapshot>(
-  runtimeServices: RuntimeServices,
-  getSnapshot: () => TSnapshot,
-): UiReadModel<TSnapshot> {
-  return {
-    getSnapshot,
-    subscribe(listener) {
-      return runtimeServices.runtimeStore.subscribe(listener);
-    },
-  };
-}
-
-export function listProviderIds(runtimeServices: RuntimeServices): readonly string[] {
-  const providerIds = new Set<string>(
-    runtimeServices.providerRegistry.listProviders().map((provider) => provider.name),
-  );
-  for (const model of runtimeServices.providerRegistry.listModels()) {
-    providerIds.add(model.provider);
-  }
-  return [...providerIds].sort();
-}
+export * from '@pellux/goodvibes-sdk/platform/runtime/ui-read-model-helpers';