@genesislcap/ai-assistant 14.444.1 → 14.445.1

package/src/config/define-stateful-agent.ts

@@ -5,6 +5,7 @@ import type {
   AgentLifecycleContext,
   ChatInputDuringExecutionMode,
   ManualSelectionConfig,
+  ProviderInput,
   SystemPromptContext,
   SystemPromptInput,
   ToolDefinitionsInput,
@@ -116,6 +117,16 @@ export interface StatefulAgentInit<S> {
    */
   toolHandlers?: (state: S) => ChatToolHandlers | Promise<ChatToolHandlers>;
 
+  /**
+   * Which registered AI provider this agent uses, by name. Either a static
+   * string or a function resolved each tool-loop iteration with the current
+   * `state` — pick the function form to vary provider per machine state
+   * (e.g. swap to a heavier model only for the planning step).
+   *
+   * Omit to use the registry's default provider. Unknown names hard-error.
+   */
+  provider?: string | ((ctx: StatefulAgentContext<S>) => string | Promise<string>);
+
   /**
    * Optional getter for the debug-log snapshot. Defaults to auto-snapshotting
    * any property on `state` that looks like a foundation-state-machine
@@ -246,6 +257,22 @@ export function defineStatefulAgent<S>(opts: StatefulAgentInit<S>): AgentConfig
       }
     : undefined;
 
+  // Function-form `provider` needs `state` injected the same way the other
+  // per-turn resolvers do; the static-string form is passed through unchanged
+  // and validated up-front by OrchestratingDriver.
+  const wrappedProvider: ProviderInput | undefined =
+    typeof opts.provider === 'function'
+      ? async (ctx: SystemPromptContext) => {
+          if (!state) {
+            throw new Error(`Stateful agent "${opts.name}" provider called before init`);
+          }
+          return (opts.provider as (ctx: StatefulAgentContext<S>) => string | Promise<string>)({
+            ...ctx,
+            state,
+          });
+        }
+      : opts.provider;
+
   const base = {
     name: opts.name,
     displayName: wrappedDisplayName,
@@ -255,6 +282,7 @@ export function defineStatefulAgent<S>(opts: StatefulAgentInit<S>): AgentConfig
     chatInputDuringExecution: opts.chatInputDuringExecution,
     toolDefinitions: wrappedTools,
     toolHandlers: wrappedHandlers,
+    provider: wrappedProvider,
 
     onActivate: async (ctx: AgentLifecycleContext) => {
       state = await opts.init(ctx);

package/src/config/validate-providers.test.ts

@@ -0,0 +1,148 @@
+import type { AIProvider, AIProviderRegistry } from '@genesislcap/foundation-ai';
+import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
+import type { AgentConfig } from './config';
+import { resolveChatProvider, validateStaticAgentProviders } from './validate-providers';
+
+const chatProvider = (): AIProvider => ({
+  chat: async () => ({ role: 'assistant', content: '' }),
+});
+
+const promptOnlyProvider = (): AIProvider => ({
+  prompt: async () => '',
+});
+
+/**
+ * Minimal in-test registry — implements only what the validation helpers
+ * touch (`get`, `names`). Avoids depending on foundation-ai's concrete
+ * registry impl, and keeps these tests Node-runnable.
+ */
+const makeRegistry = (providers: Record<string, AIProvider>): AIProviderRegistry => {
+  const map = new Map(Object.entries(providers));
+  return {
+    get: (name) => map.get(name),
+    default: () => map.values().next().value as AIProvider,
+    defaultName: () => map.keys().next().value as string,
+    names: () => [...map.keys()],
+    getStatus: async () => null,
+    listStatuses: async () => [],
+  };
+};
+
+const specialist = (overrides: Partial<AgentConfig> & { name: string }): AgentConfig =>
+  ({
+    name: overrides.name,
+    description: 'test specialist',
+    ...overrides,
+  }) as AgentConfig;
+
+// ---------------------------------------------------------------------------
+// resolveChatProvider
+// ---------------------------------------------------------------------------
+
+const resolve = createLogicSuite('resolveChatProvider');
+
+resolve('returns the provider when the name is registered and has chat()', () => {
+  const fast = chatProvider();
+  const registry = makeRegistry({ fast });
+  assert.is(resolveChatProvider(registry, 'fast', 'A'), fast);
+});
+
+resolve('throws on an unknown provider name with the agent name in the message', () => {
+  const registry = makeRegistry({ fast: chatProvider() });
+  assert.throws(
+    () => resolveChatProvider(registry, 'deep', 'A'),
+    /Agent "A" references unknown provider "deep"/,
+  );
+});
+
+resolve('throws including the registered names so the misconfiguration is debuggable', () => {
+  const registry = makeRegistry({
+    fast: chatProvider(),
+    deep: chatProvider(),
+    cheap: chatProvider(),
+  });
+  assert.throws(() => resolveChatProvider(registry, 'typo', 'A'), /Registered: fast, deep, cheap/);
+});
+
+resolve('throws when the resolved provider does not implement chat()', () => {
+  const registry = makeRegistry({ chrome: promptOnlyProvider() });
+  assert.throws(
+    () => resolveChatProvider(registry, 'chrome', 'A'),
+    /Agent "A" resolved to provider "chrome" which does not implement chat\(\)/,
+  );
+});
+
+resolve.run();
+
+// ---------------------------------------------------------------------------
+// validateStaticAgentProviders
+// ---------------------------------------------------------------------------
+
+const validate = createLogicSuite('validateStaticAgentProviders');
+
+validate('accepts agents with no `provider` field (back-compat path)', () => {
+  const registry = makeRegistry({ default: chatProvider() });
+  assert.not.throws(() => validateStaticAgentProviders([specialist({ name: 'A' })], registry));
+});
+
+validate('accepts agents that name a registered chat-capable provider', () => {
+  const registry = makeRegistry({ fast: chatProvider(), deep: chatProvider() });
+  assert.not.throws(() =>
+    validateStaticAgentProviders([specialist({ name: 'A', provider: 'deep' })], registry),
+  );
+});
+
+validate('throws when a top-level agent references an unknown provider', () => {
+  const registry = makeRegistry({ fast: chatProvider() });
+  assert.throws(
+    () => validateStaticAgentProviders([specialist({ name: 'A', provider: 'deep' })], registry),
+    /Agent "A" references unknown provider "deep"/,
+  );
+});
+
+validate('recurses into subAgents — bad provider on a sub-agent throws', () => {
+  const registry = makeRegistry({ fast: chatProvider() });
+  const sub = specialist({ name: 'Sub', provider: 'missing' });
+  assert.throws(
+    () => validateStaticAgentProviders([specialist({ name: 'A', subAgents: [sub] })], registry),
+    /Agent "Sub" references unknown provider "missing"/,
+  );
+});
+
+validate(
+  'recurses through multiple levels — bad provider on a deeply-nested sub-agent throws',
+  () => {
+    const registry = makeRegistry({ fast: chatProvider() });
+    const deepest = specialist({ name: 'Deepest', provider: 'missing' });
+    const middle = specialist({ name: 'Middle', subAgents: [deepest] });
+    assert.throws(
+      () =>
+        validateStaticAgentProviders([specialist({ name: 'Top', subAgents: [middle] })], registry),
+      /Agent "Deepest" references unknown provider "missing"/,
+    );
+  },
+);
+
+validate('defers function-form `provider` — it is not invoked at validation time', () => {
+  const registry = makeRegistry({ fast: chatProvider() });
+  const agent = specialist({
+    name: 'A',
+    // If validateStaticAgentProviders eagerly resolved this, it would throw
+    // here. The contract is that function-form is deferred to the driver's
+    // per-turn resolver.
+    provider: () => {
+      throw new Error('function-form provider should not be invoked at validation time');
+    },
+  });
+  assert.not.throws(() => validateStaticAgentProviders([agent], registry));
+});
+
+validate('shared sub-agent across two parents validates cleanly', () => {
+  const registry = makeRegistry({ fast: chatProvider() });
+  const shared = specialist({ name: 'Shared', provider: 'fast' });
+  const parentA = specialist({ name: 'ParentA', subAgents: [shared] });
+  const parentB = specialist({ name: 'ParentB', subAgents: [shared] });
+  assert.not.throws(() => validateStaticAgentProviders([parentA, parentB], registry));
+});
+
+validate.run();

package/src/config/validate-providers.ts

@@ -0,0 +1,58 @@
+import type { AIProvider, AIProviderRegistry } from '@genesislcap/foundation-ai';
+import type { AgentConfig } from './config';
+
+/**
+ * Resolve a provider name against the registry and assert it implements
+ * `chat()` — the capability the chat tool-loop depends on. Throws with a
+ * message naming the agent so misconfigured agents are easy to track down.
+ *
+ * Used by both the up-front static walk in `OrchestratingDriver` and by
+ * `ChatDriver`'s per-turn resolver for function-form `provider` values.
+ *
+ * @internal
+ */
+export function resolveChatProvider(
+  registry: AIProviderRegistry,
+  providerName: string,
+  agentName: string,
+): AIProvider {
+  const provider = registry.get(providerName);
+  if (!provider) {
+    const available = registry.names().join(', ') || '(none)';
+    throw new Error(
+      `Agent "${agentName}" references unknown provider "${providerName}". Registered: ${available}`,
+    );
+  }
+  if (!provider.chat) {
+    throw new Error(
+      `Agent "${agentName}" resolved to provider "${providerName}" which does not implement chat().`,
+    );
+  }
+  return provider;
+}
+
+/**
+ * Walk an agent tree (including nested `subAgents`) and validate every static
+ * `provider: string` against the registry. Function-form `provider` values are
+ * deferred — they validate on first resolution inside the driver.
+ *
+ * Throws on the first failure, with the same message shape produced by
+ * {@link resolveChatProvider}.
+ *
+ * @internal
+ */
+export function validateStaticAgentProviders(
+  agents: AgentConfig[],
+  registry: AIProviderRegistry,
+): void {
+  const visited = new Set<AgentConfig>();
+  const walk = (agent: AgentConfig): void => {
+    if (visited.has(agent)) return;
+    visited.add(agent);
+    if (typeof agent.provider === 'string') {
+      resolveChatProvider(registry, agent.provider, agent.name);
+    }
+    for (const sub of agent.subAgents ?? []) walk(sub);
+  };
+  for (const root of agents) walk(root);
+}

package/src/main/main.styles.ts

@@ -257,6 +257,58 @@ export const styles = css`
     font-family: var(--monospace-font, ui-monospace, monospace);
   }
 
+  .provider-list {
+    animation: settings-slide-in 0.2s ease-out;
+    padding: calc(var(--design-unit) * 1.5px) calc(var(--design-unit) * 3px);
+    border-bottom: 1px solid var(--neutral-stroke-rest);
+    background-color: var(--neutral-layer-2);
+    display: flex;
+    flex-direction: column;
+    gap: calc(var(--design-unit) * 1px);
+  }
+
+  .provider-list-label {
+    font-size: 0.85em;
+    font-weight: 600;
+    color: var(--neutral-foreground-rest);
+  }
+
+  .provider-list-row {
+    display: flex;
+    align-items: baseline;
+    gap: calc(var(--design-unit) * 1.5px);
+    font-size: 0.8em;
+    color: var(--neutral-foreground-hint, var(--neutral-foreground-rest));
+    opacity: 80%;
+  }
+
+  .provider-list-row.is-current {
+    opacity: 100%;
+    color: var(--neutral-foreground-rest);
+  }
+
+  .provider-list-name {
+    font-weight: 600;
+  }
+
+  .provider-list-model {
+    font-family: var(--monospace-font, ui-monospace, monospace);
+    flex: 1;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+
+  .provider-list-badge {
+    font-size: 0.7em;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    padding: 0 calc(var(--design-unit) * 0.75px);
+    border-radius: calc(var(--design-unit) * 0.5px);
+    background-color: var(--neutral-layer-3);
+    color: var(--neutral-foreground-rest);
+  }
+
   .splash-wrapper {
     position: absolute;
     inset: 0;

package/src/main/main.template.ts

@@ -15,7 +15,12 @@
  *   lines let the formatter inject whitespace between them.
  */
 
-import type { ChatAttachment, ChatMessage, ChatToolCall } from '@genesislcap/foundation-ai';
+import type {
+  AIProviderRegistryStatusEntry,
+  ChatAttachment,
+  ChatMessage,
+  ChatToolCall,
+} from '@genesislcap/foundation-ai';
 import { isChatToolCallUnknown } from '@genesislcap/foundation-ai';
 import { html, ref, repeat, when, ViewTemplate } from '@genesislcap/web-core';
 import type { FoundationAiAssistant } from './main';
@@ -500,7 +505,10 @@ ${(tc) => (tc.foldPath?.length ? `${tc.foldPath.join(' › ')} › ` : '')}<stro
       )}
       ${when(
         (x) =>
-          x.settingsOpen && x.chatConfig.ui?.showActiveModel !== false && x.activeModel != null,
+          x.settingsOpen &&
+          x.chatConfig.ui?.showActiveModel !== false &&
+          x.providerStatuses.length <= 1 &&
+          x.activeModel != null,
         html<FoundationAiAssistant>`
           <div class="session-stat" part="active-model">
             <span class="session-stat-label">Model</span>
@@ -508,6 +516,46 @@ ${(tc) => (tc.foldPath?.length ? `${tc.foldPath.join(' › ')} › ` : '')}<stro
           </div>
         `,
       )}
+      ${when(
+        (x) =>
+          x.settingsOpen &&
+          x.chatConfig.ui?.showActiveModel !== false &&
+          x.providerStatuses.length > 1,
+        html<FoundationAiAssistant>`
+          <div class="provider-list" part="provider-list">
+            <div class="provider-list-label">Providers</div>
+            ${repeat(
+              (x) => x.providerStatuses,
+              html<AIProviderRegistryStatusEntry, FoundationAiAssistant>`
+                <div
+                  class="provider-list-row ${(entry, c) =>
+                    entry.name === c.parent.activeProviderName ? 'is-current' : ''}"
+                  part="provider-list-row"
+                >
+                  <span class="provider-list-name">${(entry) => entry.name}</span>
+                  <span class="provider-list-model">${(entry) => entry.status?.model ?? '—'}</span>
+                  ${when(
+                    (entry) => entry.isDefault,
+                    html<AIProviderRegistryStatusEntry>`
+                      <span class="provider-list-badge" part="provider-list-default-badge">
+                        default
+                      </span>
+                    `,
+                  )}
+                  ${when(
+                    (entry, c) => entry.name === c.parent.activeProviderName,
+                    html<AIProviderRegistryStatusEntry>`
+                      <span class="provider-list-badge" part="provider-list-current-badge">
+                        current
+                      </span>
+                    `,
+                  )}
+                </div>
+              `,
+            )}
+          </div>
+        `,
+      )}
       ${when(
         (x) => x.settingsOpen && x.chatConfig.ui?.showSessionCost !== false && x.sessionCostUsd > 0,
         html<FoundationAiAssistant>`

package/src/main/main.ts

@@ -22,12 +22,13 @@
 // =============================================================================
 
 import type {
+  AIProviderRegistryStatusEntry,
   ChatAttachment,
   ChatConfig,
   ChatInputDuringExecutionMode,
   ChatMessage,
 } from '@genesislcap/foundation-ai';
-import { AIProvider } from '@genesislcap/foundation-ai';
+import { AIProviderRegistry } from '@genesislcap/foundation-ai';
 import { avoidTreeShaking } from '@genesislcap/foundation-utils';
 import {
   customElement,
@@ -59,6 +60,7 @@ import {
 import { ChatSuggestions } from '../suggestions/chat-suggestions';
 import { AnimatedPanelToggle } from '../utils/animated-panel-toggle';
 import { logger } from '../utils/logger';
+import { sumCosts } from '../utils/sum-costs';
 import { expandToolTree } from '../utils/tool-fold';
 import { styles } from './main.styles';
 import { FoundationAiAssistantTemplate } from './main.template';
@@ -107,9 +109,9 @@ avoidTreeShaking(
  *  - `toolHandlers` (functions),
  *  - `onActivate` / `onDeactivate` (lifecycle hooks, functions),
  *  - `getDebugSnapshot` (function),
- *  - function-form `systemPrompt` / `toolDefinitions` / `displayName` (downgraded
- *    to `undefined` in the snapshot — the live config on the driver is still
- *    the source of truth; the slice only stores a serializable projection).
+ *  - function-form `systemPrompt` / `toolDefinitions` / `displayName` / `provider`
+ *    (downgraded to `undefined` in the snapshot — the live config on the driver
+ *    is still the source of truth; the slice only stores a serializable projection).
  */
 function stripHandlers(agent: AgentConfig): Omit<AgentConfig, 'toolHandlers'> {
   const {
@@ -121,6 +123,7 @@ function stripHandlers(agent: AgentConfig): Omit<AgentConfig, 'toolHandlers'> {
     systemPrompt,
     toolDefinitions,
     displayName,
+    provider,
     ...rest
   } = agent;
   const stripped = {
@@ -128,6 +131,7 @@ function stripHandlers(agent: AgentConfig): Omit<AgentConfig, 'toolHandlers'> {
     systemPrompt: typeof systemPrompt === 'function' ? undefined : systemPrompt,
     toolDefinitions: typeof toolDefinitions === 'function' ? undefined : toolDefinitions,
     displayName: typeof displayName === 'function' ? undefined : displayName,
+    provider: typeof provider === 'function' ? undefined : provider,
   };
   return subAgents?.length
     ? { ...stripped, subAgents: subAgents.map(stripHandlers) as AgentConfig[] }
@@ -138,8 +142,11 @@ function stripHandlers(agent: AgentConfig): Omit<AgentConfig, 'toolHandlers'> {
  * Foundation AI Assistant component.
  *
  * @remarks
- * Inject an `AIProvider` through the DI container. Pass agent configuration via the `agents`
- * property. The component creates a `ChatDriver` (single agent) or `OrchestratingDriver`
+ * Register one or more AI providers via `registerAIProviders` from
+ * `@genesislcap/foundation-ai`; this element resolves the `AIProviderRegistry`
+ * through the DI container. Pass agent configuration via the `agents` property —
+ * each agent can override which registered provider it uses via `provider:`.
+ * The component creates a `ChatDriver` (single agent) or `OrchestratingDriver`
  * (multiple agents) to manage the conversation loop.
  *
  * Popout/collapse coordination uses `agenticActivityBus` topics `chat-popout` and `chat-popin` — not DOM `CustomEvent`s on this element.
@@ -156,7 +163,7 @@ function stripHandlers(agent: AgentConfig): Omit<AgentConfig, 'toolHandlers'> {
   styles,
 })
 export class FoundationAiAssistant extends GenesisElement {
-  @AIProvider aiProvider!: AIProvider;
+  @AIProviderRegistry providerRegistry!: AIProviderRegistry;
 
   @observable designSystemPrefix: string = 'rapid';
   @attr({ attribute: 'header-title' }) headerTitle: string = 'Genesis Assistant';
@@ -439,6 +446,22 @@ export class FoundationAiAssistant extends GenesisElement {
     this._sessionRef?.actions.aiAssistant.setActiveModel(value);
   }
 
+  /** Name of the AI provider used on the most recent turn. */
+  get activeProviderName(): string | undefined {
+    return this._sessionRef?.store.aiAssistant.activeProviderName;
+  }
+  set activeProviderName(value: string | undefined) {
+    this._sessionRef?.actions.aiAssistant.setActiveProviderName(value);
+  }
+
+  /** Per-provider status snapshot used by the settings panel. */
+  get providerStatuses(): AIProviderRegistryStatusEntry[] {
+    return this._sessionRef?.store.aiAssistant.providerStatuses ?? [];
+  }
+  set providerStatuses(value: AIProviderRegistryStatusEntry[]) {
+    this._sessionRef?.actions.aiAssistant.setProviderStatuses(value);
+  }
+
   // ---- Transient UI state (stays as @observable on the component) ----
 
   private _suggestionsGeneration = 0;
@@ -698,7 +721,7 @@ export class FoundationAiAssistant extends GenesisElement {
         // this via `agent-changed` once applyAgent fires on first sendMessage.
         this.activeAgent = agents[0];
       }
-      return new OrchestratingDriver(this.aiProvider, agents, {
+      return new OrchestratingDriver(this.providerRegistry, agents, {
         sessionKey: this.getStateKey() ?? '',
         maxHandoffs: agent.maxHandoffs,
         classifierHistoryLength: agent.classifierHistoryLength,
@@ -710,7 +733,7 @@ export class FoundationAiAssistant extends GenesisElement {
     }
 
     return new ChatDriver(
-      this.aiProvider,
+      this.providerRegistry,
       {},
       [],
       undefined,
@@ -763,6 +786,15 @@ export class FoundationAiAssistant extends GenesisElement {
       if (invocationId) {
         this._sessionRef?.actions.aiAssistant.removeInputOverride({ id: invocationId });
       }
+      // Sub-agents may have flipped the displayed provider while running;
+      // restore the parent agent's provider so the cog reflects the
+      // conversational driver again. Status (model / context-limit) is
+      // refreshed alongside so they don't disagree.
+      const restored = this.driver?.getActiveProviderName();
+      if (restored && restored !== this.activeProviderName) {
+        this.activeProviderName = restored;
+        void this.resolveContextLimit();
+      }
     };
     const onInteractionStart = (e: Event) => {
       const { interactionId, chatInputDuringExecution } = (e as CustomEvent).detail as {
@@ -781,11 +813,19 @@ export class FoundationAiAssistant extends GenesisElement {
         this._sessionRef?.actions.aiAssistant.removeInputOverride({ id: interactionId });
       }
     };
+    const onProviderChanged = (e: Event) => {
+      const { name } = (e as CustomEvent<{ name: string }>).detail;
+      this.activeProviderName = name;
+      // Status (model id / context limit) belongs to the active provider — refresh
+      // the displayed values so the header reflects the provider that just took over.
+      void this.resolveContextLimit();
+    };
     driver.addEventListener('sub-agent-history-updated', onSubAgentHistoryUpdated);
     driver.addEventListener('sub-agent-start', onSubAgentStart);
     driver.addEventListener('sub-agent-stop', onSubAgentStop);
     driver.addEventListener('interaction-start', onInteractionStart);
     driver.addEventListener('interaction-stop', onInteractionStop);
+    driver.addEventListener('provider-changed', onProviderChanged);
 
     const cleanups: (() => void)[] = [
       () => driver.removeEventListener('history-updated', onHistoryUpdated),
@@ -794,6 +834,7 @@ export class FoundationAiAssistant extends GenesisElement {
       () => driver.removeEventListener('sub-agent-stop', onSubAgentStop),
       () => driver.removeEventListener('interaction-start', onInteractionStart),
       () => driver.removeEventListener('interaction-stop', onInteractionStop),
+      () => driver.removeEventListener('provider-changed', onProviderChanged),
     ];
 
     if (driver instanceof OrchestratingDriver) {
@@ -935,6 +976,7 @@ export class FoundationAiAssistant extends GenesisElement {
     }
     this.fetchSuggestions();
     void this.resolveContextLimit();
+    void this.loadProviderStatuses();
     if (this.messagesEl) {
       this._scrollListener = () => {
         this._userScrolledAway =
@@ -983,7 +1025,13 @@ export class FoundationAiAssistant extends GenesisElement {
 
   private async resolveContextLimit(): Promise<void> {
     try {
-      const status = await this.aiProvider.getStatus?.();
+      // Resolve status for the currently active provider when a driver is up
+      // (so per-agent provider swaps update the displayed model/limit); fall
+      // back to the registry default at startup before any turn has run.
+      const activeName = this.driver?.getActiveProviderName();
+      const status = activeName
+        ? await this.providerRegistry.getStatus(activeName)
+        : await this.providerRegistry.getStatus();
       this.contextLimit = status?.contextLimit;
       this.activeModel = status?.model;
     } catch {
@@ -991,6 +1039,14 @@ export class FoundationAiAssistant extends GenesisElement {
     }
   }
 
+  private async loadProviderStatuses(): Promise<void> {
+    try {
+      this.providerStatuses = await this.providerRegistry.listStatuses();
+    } catch {
+      // Non-fatal — settings panel just won't list providers
+    }
+  }
+
   chatConfigChanged() {
     this.syncShowingSplash();
   }
@@ -1039,10 +1095,9 @@ export class FoundationAiAssistant extends GenesisElement {
     // Recompute aggregated session cost from per-message `cost` fields. Recomputing
     // (rather than incrementing on append) keeps the total correct under any
     // mutation of the message list — including future clear-chat / re-render flows.
-    let runningCost = 0;
-    for (const m of this.messages) {
-      if (m.cost != null) runningCost += m.cost;
-    }
+    // `sumCosts` recurses into `toolCall.subAgentTrace` so cost incurred by
+    // sub-agents (potentially on different providers) is included.
+    const runningCost = sumCosts(this.messages);
     if (runningCost !== this.sessionCostUsd) {
       this.sessionCostUsd = runningCost;
     }

package/src/state/ai-assistant-slice.ts

@@ -1,4 +1,8 @@
-import type { ChatInputDuringExecutionMode, ChatMessage } from '@genesislcap/foundation-ai';
+import type {
+  AIProviderRegistryStatusEntry,
+  ChatInputDuringExecutionMode,
+  ChatMessage,
+} from '@genesislcap/foundation-ai';
 import type { PayloadAction } from '@genesislcap/foundation-redux';
 import { createSlice } from '@genesislcap/foundation-redux';
 import type { AgentConfig } from '../config/config';
@@ -39,6 +43,17 @@ export interface AiAssistantSessionState {
   sessionCostUsd: number;
   /** Active model id (e.g. `claude-sonnet-4-6`), resolved on connect. */
   activeModel: string | undefined;
+  /**
+   * Name of the AI provider used on the most recent turn — drives "current"
+   * marker in the settings panel. `undefined` until the first turn runs.
+   */
+  activeProviderName: string | undefined;
+  /**
+   * Snapshot of every registered provider's status, in registration order.
+   * Populated on connect (or on settings-open if not yet loaded) and reused
+   * for the lifetime of the session — provider registration is static.
+   */
+  providerStatuses: AIProviderRegistryStatusEntry[];
   activeAgent: Omit<AgentConfig, 'toolHandlers'> | undefined;
   /**
    * Name of the agent the user has pinned via the picker. `null` means the
@@ -90,6 +105,8 @@ export const defaultSessionState: AiAssistantSessionState = {
   contextLimit: undefined,
   sessionCostUsd: 0,
   activeModel: undefined,
+  activeProviderName: undefined,
+  providerStatuses: [],
   activeAgent: undefined,
   pinnedAgentName: null,
   flowOwnerAgentName: null,
@@ -137,6 +154,12 @@ export const aiAssistantSlice = createSlice({
     setActiveModel(state, action: PayloadAction<string | undefined>) {
       state.activeModel = action.payload;
     },
+    setActiveProviderName(state, action: PayloadAction<string | undefined>) {
+      state.activeProviderName = action.payload;
+    },
+    setProviderStatuses(state, action: PayloadAction<AIProviderRegistryStatusEntry[]>) {
+      state.providerStatuses = action.payload;
+    },
     setActiveAgent(state, action: PayloadAction<Omit<AgentConfig, 'toolHandlers'> | undefined>) {
       state.activeAgent = action.payload;
     },