@genesislcap/ai-assistant 14.444.1 → 14.445.0

package/src/components/orchestrating-driver/orchestrating-driver.ts

@@ -1,5 +1,5 @@
 import type {
-  AIProvider,
+  AIProviderRegistry,
   ChatAttachment,
   ChatDriverResult,
   ChatMessage,
@@ -12,6 +12,7 @@ import type {
   SystemPromptContext,
   SystemPromptInput,
 } from '../../config/config';
+import { validateStaticAgentProviders } from '../../config/validate-providers';
 import { transformHistoryForAgent } from '../../utils/history-transform';
 import { logger } from '../../utils/logger';
 import type { AiDriver, AllAgentSummary } from '../ai-driver/ai-driver';
@@ -110,7 +111,7 @@ export class OrchestratingDriver extends EventTarget implements AiDriver {
   activeAgent?: AgentConfig;
 
   constructor(
-    private readonly aiProvider: AIProvider,
+    private readonly providerRegistry: AIProviderRegistry,
     private readonly agents: AgentConfig[],
     options: {
       sessionKey?: string;
@@ -129,6 +130,11 @@ export class OrchestratingDriver extends EventTarget implements AiDriver {
       options.classifierHistoryLength ?? DEFAULT_CLASSIFIER_HISTORY_LENGTH;
     this.classifierRetries = options.classifierRetries ?? DEFAULT_CLASSIFIER_RETRIES;
 
+    // Static-name validation: walk every agent (and nested sub-agents). Any
+    // `provider: '<name>'` that isn't registered, or resolves to a provider
+    // without `chat()`, throws now rather than at first turn.
+    validateStaticAgentProviders(agents, providerRegistry);
+
     // Specialists drive the classifier. `excludeFromClassifier` agents are still
     // resolvable by name (so manual pinning works) but never auto-routed.
     this.specialists = agents.filter(isSpecialist).filter((a) => !a.excludeFromClassifier);
@@ -145,7 +151,7 @@ export class OrchestratingDriver extends EventTarget implements AiDriver {
       : undefined;
 
     this.chatDriver = new ChatDriver(
-      aiProvider,
+      providerRegistry,
       {},
       [],
       undefined,
@@ -180,6 +186,11 @@ export class OrchestratingDriver extends EventTarget implements AiDriver {
         new CustomEvent('interaction-stop', { detail: (e as CustomEvent).detail }),
       );
     });
+    this.chatDriver.addEventListener('provider-changed', (e: Event) => {
+      this.dispatchEvent(
+        new CustomEvent('provider-changed', { detail: (e as CustomEvent).detail }),
+      );
+    });
   }
 
   resolveInteraction(interactionId: string, result: unknown): void {
@@ -190,6 +201,11 @@ export class OrchestratingDriver extends EventTarget implements AiDriver {
     return this.chatDriver.isBusy();
   }
 
+  /** Currently active provider name from the underlying ChatDriver. */
+  getActiveProviderName(): string {
+    return this.chatDriver.getActiveProviderName();
+  }
+
   /**
    * Pins routing to a specific agent by name. While pinned, the classifier is
    * skipped and the continuation tool is hidden from the agent's tool list, so
@@ -530,8 +546,17 @@ export class OrchestratingDriver extends EventTarget implements AiDriver {
           systemPrompt: classifierPrompt,
           tools: [routingTool],
         };
+        // Classification is orchestrator-level, not bound to any single agent —
+        // always run against the registry default.
+        const classifierProvider = this.providerRegistry.default();
+        if (!classifierProvider.chat) {
+          logger.warn(
+            'OrchestratingDriver: default AI provider does not implement chat() — cannot classify.',
+          );
+          break;
+        }
         // oxlint-disable-next-line no-await-in-loop
-        const response = await this.aiProvider.chat!([], input, options);
+        const response = await classifierProvider.chat([], input, options);
         const tc = response.toolCalls?.[0];
         const index = tc?.name === 'select_agent' ? (tc.args.agent_index as number) : -1;
 

package/src/config/config.ts

@@ -75,6 +75,20 @@ export type ToolHandlersInput =
   | ChatToolHandlers
   | ((ctx: SystemPromptContext) => ChatToolHandlers | Promise<ChatToolHandlers>);
 
+/**
+ * Names which registered `AIProviderRegistry` entry an agent uses. Either
+ * a static string (resolved once at agent registration) or a function resolved
+ * each tool-loop iteration — pick the function form to vary the provider by
+ * current state (e.g. a stateful agent that switches providers between
+ * machine states).
+ *
+ * Unknown provider names hard-error: static names at agent registration time,
+ * function-resolved names on first resolution.
+ *
+ * @beta
+ */
+export type ProviderInput = string | ((ctx: SystemPromptContext) => string | Promise<string>);
+
 /**
  * Opts an agent in to manual selection from the assistant's agent picker.
  *
@@ -138,6 +152,24 @@ interface BaseAgentConfig {
    * See {@link ToolHandlersInput}.
    */
   toolHandlers?: ToolHandlersInput;
+  /**
+   * Which registered AI provider this agent uses, by name. Either a static
+   * string (resolved once at agent registration) or a function resolved each
+   * tool-loop iteration — pick the function form to vary the provider by
+   * current state (e.g. a stateful agent that switches providers between
+   * machine states).
+   *
+   * Omit to use the registry's default provider. Unknown names hard-error:
+   * static names at registration time, function-resolved names on first
+   * resolution.
+   *
+   * Known limitation: switching provider mid-conversation can blow the
+   * smaller provider's context window if history accumulated under a
+   * larger one. No automatic trimming is performed.
+   *
+   * @beta
+   */
+  provider?: ProviderInput;
   /**
    * Optional primer history prepended to every call (not visible to the user).
    * Used to establish agent identity and behavioural rules.

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,
@@ -138,8 +139,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 +160,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 +443,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 +718,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 +730,7 @@ export class FoundationAiAssistant extends GenesisElement {
     }
 
     return new ChatDriver(
-      this.aiProvider,
+      this.providerRegistry,
       {},
       [],
       undefined,
@@ -781,11 +801,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 +822,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 +964,7 @@ export class FoundationAiAssistant extends GenesisElement {
     }
     this.fetchSuggestions();
     void this.resolveContextLimit();
+    void this.loadProviderStatuses();
     if (this.messagesEl) {
       this._scrollListener = () => {
         this._userScrolledAway =
@@ -983,7 +1013,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 +1027,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();
   }