@dxos/plugin-assistant 0.13.0 → 0.14.0

package/src/components/ChatPrompt/ChatOptions.tsx

@@ -2,11 +2,14 @@
 // Copyright 2025 DXOS.org
 //
 
+import { useAtomValue } from '@effect/atom-react/Hooks';
+import * as Atom from 'effect/reactivity/Atom';
 import React, { type JSX, useCallback, useMemo, useState } from 'react';
 
-import { Provider } from '@dxos/ai';
+import { Provider, SessionConfig } from '@dxos/ai';
 import * as Hooks from '@dxos/app-framework/Hooks';
 import { type AiContext } from '@dxos/assistant';
+import * as Agent from '@dxos/assistant/Agent';
 import type * as Chat from '@dxos/assistant/Chat';
 import * as McpServer from '@dxos/compute/McpServer';
 import { type Database, Filter, Obj, Ref, type Registry, Type, URI } from '@dxos/echo';
@@ -19,6 +22,7 @@ import { SearchList, useSearchListResults } from '@dxos/react-ui-search';
 import * as Button from '@dxos/react-ui/Button';
 import * as Field from '@dxos/react-ui/Field';
 import * as UiHooks from '@dxos/react-ui/Hooks';
+import * as Icon from '@dxos/react-ui/Icon';
 import * as Input from '@dxos/react-ui/Input';
 import * as Layout from '@dxos/react-ui/Layout';
 import * as Popover from '@dxos/react-ui/Popover';
@@ -41,7 +45,8 @@ import {
 import { meta } from '#meta';
 import { Assistant, AssistantCapabilities, AssistantPreset } from '#types';
 
-import { resolveProvider } from '../../processor/index.ts';
+import { resolveProvider } from '../../chat-model/index.ts';
+import { agentOptions } from '../../util/agent-options.ts';
 
 const styles = {
   panel: 'w-[calc(100dvw-.5rem)] sm:w-max max-w-document-width',
@@ -52,12 +57,23 @@ export type ChatOptionsProps = AssistantPreset.ChatPresetProps & {
   chat?: Chat.Chat;
   context?: AiContext.Binder;
   registry?: Registry.Registry;
+  /** Whether the conversation has begun; its agent is fixed from then on. */
+  started?: boolean;
 };
 
 /**
  * Manages the runtime context for the chat.
  */
-export const ChatOptions = ({ db, chat, context, registry, presets, preset, onPresetChange }: ChatOptionsProps) => {
+export const ChatOptions = ({
+  db,
+  chat,
+  context,
+  registry,
+  started,
+  presets,
+  preset,
+  onPresetChange,
+}: ChatOptionsProps) => {
   const { t } = UiHooks.useTranslation(meta.profile.key);
 
   return (
@@ -91,7 +107,15 @@ export const ChatOptions = ({ db, chat, context, registry, presets, preset, onPr
         </Popover.Trigger>
         <Popover.Content classNames={styles.panel}>
           {/* No Body: each tab's list and the tab bar share the popover's own padding. */}
-          <Tabs.Root orientation='horizontal' defaultValue='view' classNames='grid grid-rows-[1fr_40px] w-full'>
+          {/* A chat that has not begun opens on its agent, since that is the choice it is about to lose. */}
+          <Tabs.Root
+            orientation='horizontal'
+            defaultValue={started ? 'view' : 'agent'}
+            classNames='grid grid-rows-[1fr_40px] w-full'
+          >
+            <Tabs.Content tabIndex={-1} classNames='dx-focus-ring-inset overflow-hidden' value='agent'>
+              <AgentPanel chat={chat} started={started} />
+            </Tabs.Content>
             <Tabs.Content tabIndex={-1} classNames='dx-focus-ring-inset overflow-hidden' value='view'>
               <ViewPanel chat={chat} />
             </Tabs.Content>
@@ -108,6 +132,12 @@ export const ChatOptions = ({ db, chat, context, registry, presets, preset, onPr
               <EnvironmentPanel chat={chat} />
             </Tabs.Content>
             <Tabs.List classNames='p-1 gap-1 border-t border-separator'>
+              <Tabs.Trigger
+                value='agent'
+                icon='ph--robot--regular'
+                label={t('options.agent.title')}
+                data-testid='assistant.options.agent'
+              />
               <Tabs.Trigger value='view' icon='ph--eye--regular' label={t('chat-view.title')} />
               <Tabs.Trigger value='skills' icon='ph--student--regular' label={t('options.skills.title')} />
               <Tabs.Trigger value='mcp-servers' icon='ph--plugs-connected--regular' label={t('options.mcp.title')} />
@@ -126,6 +156,77 @@ export const ChatOptions = ({ db, chat, context, registry, presets, preset, onPr
           </Tabs.Root>
         </Popover.Content>
       </Popover.Root>
+
+      <AgentBadge chat={chat} />
+    </Layout.Flex>
+  );
+};
+
+/** The chat's agent and the picker's rows, live with each agent's availability. */
+const useChatAgent = (chat: Chat.Chat | undefined) => {
+  const agents = Hooks.useOptionalCapabilities(AssistantCapabilities.Agent);
+  const availabilityAtom = useMemo(() => Atom.make((get) => agents.map((agent) => get(agent.availability))), [agents]);
+  const availability = useAtomValue(availabilityAtom);
+  const [session] = useObject(chat, 'session');
+  const current = SessionConfig.harnessOf(session);
+  const options = useMemo(() => agentOptions({ agents, availability, current }), [agents, availability, current]);
+  return { current, options };
+};
+
+/**
+ * Which agent runs this chat. Picked before the first message only: an agent keeps its own session
+ * with the model, so one switched in mid-conversation would answer without the turns before it.
+ */
+const AgentPanel = ({ chat, started }: Pick<ChatOptionsProps, 'chat' | 'started'>) => {
+  const { t } = UiHooks.useTranslation(meta.profile.key);
+  const { current, options } = useChatAgent(chat);
+  const handleChange = useCallback(
+    (harness: string) => {
+      if (chat) {
+        Obj.update(chat, (chat) => {
+          chat.session = { ...chat.session, harness };
+        });
+      }
+    },
+    [chat],
+  );
+
+  return (
+    <Layout.Flex column classNames='dx-expand' data-testid='assistant.agents'>
+      <Listbox.Root value={current} onValueChange={handleChange} disabled={!chat || started} autoFocus items={options}>
+        <Listbox.Content gutter='none' aria-label={t('options.agent.title')}>
+          {options.map(({ value }) => (
+            <Listbox.Item
+              key={value}
+              id={value}
+              classNames='dx-focus-ring rounded-xs'
+              data-testid={`assistant.agents.${value}`}
+            />
+          ))}
+        </Listbox.Content>
+      </Listbox.Root>
+      {started && <p className='px-form-chrome py-1 text-xs text-fg-muted'>{t('agent-locked.message')}</p>}
+    </Layout.Flex>
+  );
+};
+
+/** Names the agent beside the options when it is not Composer's own, so a reader knows who answers. */
+const AgentBadge = ({ chat }: Pick<ChatOptionsProps, 'chat'>) => {
+  const { current, options } = useChatAgent(chat);
+  const agent = options.find(({ value }) => value === current);
+  if (!agent || agent.value === SessionConfig.COMPOSER_HARNESS) {
+    return null;
+  }
+
+  return (
+    <Layout.Flex
+      align='center'
+      gap='xs'
+      classNames='text-xs text-fg-muted whitespace-nowrap'
+      data-testid='assistant.agent'
+    >
+      <Icon.Icon icon={agent.icon} size='sm' />
+      <span>{agent.label}</span>
     </Layout.Flex>
   );
 };
@@ -152,7 +253,7 @@ const SkillsPanel = ({ registry, db, context }: Pick<ChatOptionsProps, 'registry
             const isActive = activeSkills.has(skillId);
             return (
               <SearchList.Item
-                classNames='flex items-center overflow-hidden'
+                classNames='overflow-hidden'
                 key={skillId}
                 value={skillId}
                 label={skill.name}
@@ -211,10 +312,17 @@ const EnvironmentPanel = ({ chat }: Pick<ChatOptionsProps, 'chat'>) => {
   // Offered only where an edge service is configured, which is the same condition that decides
   // whether `RemoteProcessManager` is the real manager or `layerNoop`: against the noop a spawn has
   // no `list` or `spawn`, so choosing `remote` would persist a flag the next prompt cannot honour.
-  const environments = client?.config.values.runtime?.services?.edge?.url
-    ? CHAT_ENVIRONMENTS
-    : CHAT_ENVIRONMENTS.filter((environment) => environment !== 'remote');
-  const value: ChatEnvironment = remote ? 'remote' : 'local';
+  // An agent's chat runs on EDGE (`Agent.chatLocation`) unless explicitly kept local: with EDGE configured local is
+  // no choice there, and without it local stays offered so the chat can be moved somewhere it can run.
+  const edgeConfigured = Boolean(client?.config.values.runtime?.services?.edge?.url);
+  const agentOnEdge = chat !== undefined && Agent.isAgentChat(chat) && chat.remote !== false;
+  const environments =
+    agentOnEdge && edgeConfigured
+      ? CHAT_ENVIRONMENTS.filter((environment) => environment === 'remote')
+      : agentOnEdge || edgeConfigured
+        ? CHAT_ENVIRONMENTS
+        : CHAT_ENVIRONMENTS.filter((environment) => environment !== 'remote');
+  const value: ChatEnvironment = remote || agentOnEdge ? 'remote' : 'local';
   const handleChange = useCallback((value: string) => setRemote(value === 'remote'), [setRemote]);
 
   return (
@@ -608,7 +716,7 @@ export const ObjectsPanel = ({ db, context }: Pick<ChatOptionsProps, 'db' | 'con
                 const styles = hue ? getStyles(hue) : undefined;
                 return (
                   <SearchList.Item
-                    classNames='flex items-center overflow-hidden'
+                    classNames='overflow-hidden'
                     key={object.id}
                     value={object.id}
                     icon={icon}

package/src/components/ChatPrompt/ChatPrompt.stories.tsx

@@ -24,7 +24,7 @@ import { useRegistry, useSpaces } from '@dxos/react-client/echo';
 import { Loading, withLayout, withTheme } from '@dxos/react-ui/testing';
 import { Message, Task } from '@dxos/types';
 
-import { useChatProcessor, useChatServices, usePresets } from '#hooks';
+import { useChatModel, useChatServices, usePresets } from '#hooks';
 import { AssistantPlugin } from '#plugin';
 import { translations } from '#translations';
 import { AssistantCapabilities } from '#types';
@@ -38,7 +38,7 @@ type StoryArgs = {
   /** Prompts already queued on the feed, as a submit-while-busy leaves them. */
   queued?: string[];
   /**
-   * Holds the processor `active` while leaving `streaming` false — a turn parked in a tool call.
+   * Holds the chat model `active` while leaving `streaming` false — a turn parked in a tool call.
    * This is the state the send/stop control has to get right, and no scripted model can hold it
    * still long enough to assert against.
    */
@@ -55,26 +55,26 @@ const DefaultStory = ({ tasksVisible: initialTasksVisible, running }: StoryArgs)
   const { preset, ...chatProps } = usePresets(settings, chat);
   const db = space?.db;
   const runtime = useChatServices({ id: db?.spaceId });
-  const processor = useChatProcessor({ db, chat, preset, runtime, registry, settings });
+  const chatModel = useChatModel({ db, chat, preset, runtime, registry, settings });
 
   // Drives the control's mode from the outside, so the assertion does not race a real turn. The
-  // processor reads its atoms from the ambient registry, which is what the story writes to.
-  // The same registry `useChatProcessor` hands the processor, so a write here is a write it sees.
+  // chat model reads its atoms from the ambient registry, which is what the story writes to.
+  // The same registry `useChatModel` hands the chat model, so a write here is a write it sees.
   const atomRegistry = useContext(RegistryContext);
   useEffect(() => {
-    if (running && processor) {
-      atomRegistry.set(processor.active, true);
+    if (running && chatModel) {
+      atomRegistry.set(chatModel.active, true);
     }
-  }, [running, processor, atomRegistry]);
+  }, [running, chatModel, atomRegistry]);
 
-  if (!chat || !db || !processor) {
+  if (!chat || !db || !chatModel) {
     return <Loading />;
   }
 
   return (
     <div className='flex justify-center p-4'>
       <div className='w-full max-w-document-width'>
-        <Chat.Root chat={chat} db={db} processor={processor}>
+        <Chat.Root chat={chat} db={db} chatModel={chatModel}>
           <Chat.Status classNames='px-3 rounded-sm bg-group-surface' />
           {/* `attendableId` is the graph node contributed actions are filed under; the story's chat
               has no node, so the row shows only its own controls unless a plugin renders one. The

package/src/components/ChatPrompt/ChatPrompt.tsx

@@ -8,10 +8,11 @@ import * as Option from 'effect/Option';
 import type * as Atom from 'effect/reactivity/Atom';
 import React, { useCallback, useEffect, useId, useMemo, useRef, useState } from 'react';
 
+import { type AiContext } from '@dxos/assistant';
 import type * as Chat from '@dxos/assistant/Chat';
 import { type Event } from '@dxos/async';
 import * as Project from '@dxos/compute/Project';
-import { type Database, Obj } from '@dxos/echo';
+import { type Database, Obj, type Registry } from '@dxos/echo';
 import { useObject } from '@dxos/echo-react';
 import {
   ChatEditor,
@@ -22,17 +23,17 @@ import {
 } from '@dxos/react-ui-chat';
 import type { ActionGraphProps } from '@dxos/react-ui-menu';
 import * as Hooks from '@dxos/react-ui/Hooks';
+import * as Layout from '@dxos/react-ui/Layout';
 import type * as Util from '@dxos/react-ui/Util';
 import { pendingText } from '@dxos/ui-editor';
-import { mx } from '@dxos/ui-theme';
 import { type Merge } from '@dxos/util';
 
 import { useChatKeymapExtensions } from '#hooks';
 import { meta } from '#meta';
 import { AssistantPreset } from '#types';
 
+import { type ChatModel, getChatModelState } from '../../chat-model/index.ts';
 import { TaskSlashCommands } from '../../commands/index.ts';
-import { type AiChatProcessor, getProcessorState } from '../../processor/index.ts';
 import { type ChatEvent } from '../Chat/index.ts';
 import { ChatActions, type ChatActionsProps } from './ChatActions.tsx';
 import { ChatMcpErrors } from './ChatMcpErrors.tsx';
@@ -50,8 +51,15 @@ export type ChatPromptProps = Merge<
     expandable?: boolean;
     db?: Database.Database;
     chat?: Chat.Chat;
-    /** Undefined while the processor is still opening: the prompt takes text but holds it until then. */
-    processor?: AiChatProcessor;
+    /** Undefined while the chat model is still opening: the prompt takes text but holds it until then. */
+    chatModel?: ChatModel;
+    /**
+     * Bindings for a draft with no chat model, whose caller handles the submit event: backs the context
+     * controls and lets the prompt send.
+     */
+    context?: AiContext.Binder;
+    /** Skill registry for the context controls when there is no chat model. */
+    registry?: Registry.Registry;
     event: Event<ChatEvent>;
     /** Whether the checklist beside the prompt is shown; the toggle renders only when provided. */
     tasksVisible?: boolean;
@@ -71,6 +79,8 @@ export type ChatPromptProps = Merge<
     queueSize?: number;
     /** The most prompts that may wait behind a running turn; past it the prompt takes no more until one is taken up. */
     maxQueue?: number;
+    /** Whether the conversation has begun, which fixes its agent. */
+    started?: boolean;
     /** Object the chat is attached to; its project instructions (if any) supply sentinel-command completion. */
     companionTo?: Obj.Unknown;
   }>,
@@ -82,7 +92,9 @@ export const ChatPrompt = ({
   outline,
   db,
   chat,
-  processor,
+  chatModel,
+  context: draftContext,
+  registry: draftRegistry,
   event,
   tasksVisible,
   attendableId,
@@ -96,13 +108,16 @@ export const ChatPrompt = ({
   presets,
   preset,
   companionTo,
+  started,
   onPresetChange,
 }: ChatPromptProps) => {
   const { t } = Hooks.useTranslation(meta.profile.key);
-  const processorState = getProcessorState(processor);
-  const error = useAtomValue(processorState.error).pipe(Option.getOrUndefined);
-  const streaming = useAtomValue(processorState.streaming);
-  const active = useAtomValue(processorState.active);
+  const chatModelState = getChatModelState(chatModel);
+  const error = useAtomValue(chatModelState.error).pipe(Option.getOrUndefined);
+  const streaming = useAtomValue(chatModelState.streaming);
+  const active = useAtomValue(chatModelState.active);
+  const context = chatModel?.context ?? draftContext;
+  const registry = chatModel?.registry ?? draftRegistry;
 
   const editorRef = useRef<ChatEditorController>(null);
   useEffect(() => {
@@ -157,7 +172,7 @@ export const ChatPrompt = ({
 
   // A full queue stops taking prompts: what is typed stays in the editor until the agent takes one up.
   const queueFull = active && queueSize >= maxQueue;
-  const canSend = hasText && processor != null && !queueFull;
+  const canSend = hasText && context != null && !queueFull;
 
   const extensions = useMemo(
     () => [keymapExtensions, pendingText(), commandsExtension, emptinessExtension],
@@ -165,17 +180,17 @@ export const ChatPrompt = ({
   );
 
   // Submits while a turn is running too: the agent's input queue is feed state, so the prompt is
-  // queued behind the running turn rather than dropped (`Chat.Root` sends it through the processor's
+  // queued behind the running turn rather than dropped (`Chat.Root` sends it through the chat model's
   // outbox, which queues it while the agent is busy).
   const handleSubmit = useCallback<NonNullable<ChatEditorProps['onSubmit']>>(
     (text) => {
-      if (!processor || queueFull) {
+      if (!context || queueFull) {
         return false;
       }
       event.emit({ type: 'submit', text });
       return true;
     },
-    [event, processor, queueFull],
+    [event, context, queueFull],
   );
 
   // Routed through `handleSubmit` so the button and the Enter keybinding share one submit path;
@@ -198,19 +213,20 @@ export const ChatPrompt = ({
   );
 
   return (
-    <div
+    <Layout.Flex
+      column
       data-testid='assistant.prompt'
       role='group'
-      className={mx(
-        'flex flex-col w-full dx-density-md',
+      classNames={[
+        'w-full dx-density-md',
         outline &&
           'dx-group-surface rounded-sm border border-separator-subtle transition transition-border [&:has(.cm-content:focus)]:border-separator',
         classNames,
-      )}
+      ]}
     >
-      {processor && <ChatMcpErrors processor={processor} />}
+      {chatModel && <ChatMcpErrors chatModel={chatModel} />}
 
-      <div className='flex p-2 gap-2'>
+      <Layout.Flex gap='sm' classNames='p-2'>
         <ChatStatusIndicator classNames='p-1' preset={preset} error={error} processing={streaming} />
         <ChatEditor
           ref={editorRef}
@@ -222,7 +238,7 @@ export const ChatPrompt = ({
           extensions={extensions}
           onSubmit={handleSubmit}
         />
-      </div>
+      </Layout.Flex>
 
       {db &&
         settings && (
@@ -243,20 +259,21 @@ export const ChatPrompt = ({
                 <ChatOptions
                   db={db}
                   chat={chat}
-                  registry={processor?.registry}
-                  context={processor?.context}
+                  registry={registry}
+                  context={context}
+                  started={started}
                   preset={preset}
                   presets={presets}
                   onPresetChange={onPresetChange}
                 />
-                <div className='flex h-6 grow overflow-x-auto scrollbar-none'>
-                  {processor && <ChatReferences db={db} context={processor.context} />}
-                </div>
+                <Layout.Flex classNames='h-6 grow overflow-x-auto scrollbar-none'>
+                  {context && <ChatReferences db={db} context={context} />}
+                </Layout.Flex>
               </>
             }
           />
         )}
-    </div>
+    </Layout.Flex>
   );
 };
 

package/src/components/ChatPrompt/ChatStatus.tsx

@@ -8,6 +8,7 @@ import { Alarm } from '@dxos/assistant';
 import { ChatStatus as NaturalChatStatus, formatElapsed } from '@dxos/react-ui-chat';
 import { Matrix } from '@dxos/react-ui-experimental';
 import * as Icon from '@dxos/react-ui/Icon';
+import * as Layout from '@dxos/react-ui/Layout';
 import type * as Util from '@dxos/react-ui/Util';
 import { type ContentBlock } from '@dxos/types';
 import { Unit } from '@dxos/util';
@@ -52,8 +53,8 @@ export type ChatStatusViewProps = ChatStreamStatusProps & {
  * - cumulative session total tokens across all `stats` content blocks
  */
 export const ChatStatus = ({ classNames, icon }: ChatStreamStatusProps) => {
-  // Read `messages` from the chat context (combines `useQuery(queue)` + the processor's
-  // pending atom) rather than `processor.messages` directly — the latter only contains
+  // Read `messages` from the chat context (combines `useQuery(queue)` + the chat model's
+  // pending atom) rather than `chatModel.messages` directly — the latter only contains
   // blocks streamed via the ephemeral `PartialBlock` channel, while finalized blocks
   // (including the per-turn `stats` block we read for token counts) are submitted to the
   // feed via `_submitMessage` and only show up through `useQuery`.
@@ -92,7 +93,7 @@ export const ChatStatus = ({ classNames, icon }: ChatStreamStatusProps) => {
 
 /**
  * The pill itself, given resolved values. Split from {@link ChatStatus} so each slot — elapsed,
- * tokens, the next alarm — can be mounted and asserted in a story without a live processor.
+ * tokens, the next alarm — can be mounted and asserted in a story without a live chat model.
  */
 export const ChatStatusView = ({
   classNames,
@@ -115,7 +116,7 @@ export const ChatStatusView = ({
         <NaturalChatStatus.Icon>
           <Matrix
             classNames='size-5'
-            dotClassNames='bg-primary-500'
+            dotClassNames='bg-primary-bg'
             dim={4}
             dotSize={3}
             count={10}
@@ -125,9 +126,9 @@ export const ChatStatusView = ({
         </NaturalChatStatus.Icon>
       )}
       {show && (
-        <div className='flex items-center'>
+        <Layout.Flex align='center'>
           {requestTiming && (
-            <NaturalChatStatus.Text classNames={isRunning && 'text-sky-500'}>
+            <NaturalChatStatus.Text classNames={isRunning && 'text-sky-text'}>
               <Elapsed timing={requestTiming} />
             </NaturalChatStatus.Text>
           )}
@@ -163,7 +164,7 @@ export const ChatStatusView = ({
               </NaturalChatStatus.Text>
             </>
           )}
-        </div>
+        </Layout.Flex>
       )}
     </NaturalChatStatus.Root>
   );

package/src/components/Toolbox/Toolbox.tsx

@@ -9,13 +9,13 @@ import type * as Skill from '@dxos/compute/Skill';
 import { type Database, Filter, type Ref } from '@dxos/echo';
 import { useQuery } from '@dxos/echo-react';
 import { log } from '@dxos/log';
+import * as Layout from '@dxos/react-ui/Layout';
 import * as ScrollArea from '@dxos/react-ui/ScrollArea';
 import * as Util from '@dxos/react-ui/Util';
-import { mx } from '@dxos/ui-theme';
 
 import { AssistantService } from '#types';
 
-import { type AiChatProcessor } from '../../processor/index.ts';
+import { type ChatModel } from '../../chat-model/index.ts';
 
 export type ToolboxProps = {
   services?: { service: AssistantService.ServiceType }[];
@@ -82,40 +82,39 @@ type SectionProps = {
 
 const Section = ({ title, items, striped }: SectionProps) => {
   const stripeClassNames = 'odd:bg-neutral-50 dark:odd:bg-neutral-800';
-  const gridClassNames = 'grid grid-cols-[8rem_1fr]';
-  const subGridClassNames = mx('col-span-full grid grid-cols-subgrid text-xs px-2', striped && stripeClassNames);
+  const subGridClassNames = ['text-xs px-2', striped && stripeClassNames];
 
   return (
     <div>
       <h1 className='px-2 text-sm'>{title}</h1>
-      <div className={gridClassNames}>
+      <Layout.Grid cols={['8rem', 'fill']}>
         {items.map(({ name, description, subitems }, i) => (
           <Fragment key={i}>
             {name && (
-              <div className={subGridClassNames}>
+              <Layout.Grid cols='subgrid' classNames={subGridClassNames}>
                 <div className='truncate text-accent-text'>{name}</div>
                 <div className='line-clamp-2'>{description}</div>
-              </div>
+              </Layout.Grid>
             )}
             {subitems?.map(({ name, description }, i) => (
-              <div key={i} className={mx(subGridClassNames, striped && stripeClassNames)}>
+              <Layout.Grid key={i} cols='subgrid' classNames={subGridClassNames}>
                 <div className='truncate'>{name}</div>
                 <div className='line-clamp-3 text-fg-subtle'>{description}</div>
-              </div>
+              </Layout.Grid>
             ))}
           </Fragment>
         ))}
-      </div>
+      </Layout.Grid>
     </div>
   );
 };
 
 export type ToolboxPanelProps = Util.ThemedClassName<{
   db?: Database.Database;
-  processor?: AiChatProcessor;
+  chatModel?: ChatModel;
 }>;
 
-export const ToolboxPanel = ({ classNames, db, processor }: ToolboxPanelProps) => {
+export const ToolboxPanel = ({ classNames, db, chatModel }: ToolboxPanelProps) => {
   // Registered services.
   const services = useQuery(db, Filter.type(AssistantService.ServiceType));
   const [serviceTools, setServiceTools] = useState<{ service: AssistantService.ServiceType }[]>([]);
@@ -136,7 +135,7 @@ export const ToolboxPanel = ({ classNames, db, processor }: ToolboxPanelProps) =
   return (
     <Toolbox
       classNames={classNames}
-      skills={processor?.context.getSkills()}
+      skills={chatModel?.context.getSkills()}
       services={serviceTools}
       functions={functions}
     />

package/src/containers/AssistantSettings/AssistantSettings.tsx

@@ -15,7 +15,7 @@ import * as UiHooks from '@dxos/react-ui/Hooks';
 import { meta } from '#meta';
 import { Assistant, AssistantCapabilities, Ollama } from '#types';
 
-import { presetsForProvider, resolveProvider } from '../../processor/index.ts';
+import { presetsForProvider, resolveProvider } from '../../chat-model/index.ts';
 import { OllamaModels } from './OllamaModels.tsx';
 
 export type AssistantSettingsProps = AppSurface.SettingsProps<Assistant.Settings>;

package/src/containers/ChatArticle/ChatArticle.stories.tsx

@@ -336,7 +336,7 @@ export const Send: Story = {
 /**
  * Submitting again without waiting for the running turn: the second prompt is QUEUED on the feed and
  * runs after the first, rather than being dropped (the composer used to ignore a submit while a turn
- * was active) or cancelling the turn in flight (`processor.request` interrupts, `enqueue` does not).
+ * was active) or cancelling the turn in flight (`chatModel.request` interrupts, `enqueue` does not).
  *
  * Deliberately no wait between the two submits — that is the whole case. Both replies landing is what
  * proves the second prompt survived; the agent-level ordering and mid-turn arrival are pinned

package/src/containers/ChatArticle/ChatArticle.tsx

@@ -12,6 +12,7 @@ import * as ToolkitHooks from '@dxos/app-toolkit/Hooks';
 import type * as Chat from '@dxos/assistant/Chat';
 import { Obj } from '@dxos/echo';
 import { useObject } from '@dxos/echo-react';
+import { useIdentity } from '@dxos/halo-react';
 import * as ClientOperation from '@dxos/plugin-client/ClientOperation';
 import { useRegistry } from '@dxos/react-client/echo';
 import { type ChatView } from '@dxos/react-ui-assistant';
@@ -21,7 +22,7 @@ import * as Panel from '@dxos/react-ui/Panel';
 import { Merge } from '@dxos/util';
 
 import { Chat as ChatComponent, type ChatRootProps } from '#components';
-import { useChatProcessor, useChatServices, usePlatform, usePresets, useSelectionContext } from '#hooks';
+import { useChatModel, useChatServices, usePlatform, usePresets, useSelectionContext } from '#hooks';
 import { AssistantCapabilities } from '#types';
 
 export type ChatArticleProps = Merge<
@@ -47,7 +48,16 @@ export const ChatArticle = forwardRef<HTMLDivElement, ChatArticleProps>(
     const runtime = useChatServices({ id: db?.spaceId });
 
     const { preset, ...chatProps } = usePresets(settings, chat);
-    const processor = useChatProcessor({ db, chat, preset, runtime, registry, settings });
+    // Every prompt carries the member's DID, so what they say is attributed to them rather than to a name.
+    const identity = useIdentity();
+    const sender = useMemo(
+      () =>
+        identity
+          ? { identityDid: identity.did, ...(identity.displayName ? { name: identity.displayName } : {}) }
+          : undefined,
+      [identity?.did, identity?.displayName],
+    );
+    const chatModel = useChatModel({ db, chat, preset, runtime, registry, settings, sender });
     const getContext = useSelectionContext(companionTo);
 
     // Subscribe to the view type via `useObject` so the thread re-renders when ChatOptions changes it;
@@ -85,7 +95,7 @@ export const ChatArticle = forwardRef<HTMLDivElement, ChatArticleProps>(
     }, [attendableId]);
 
     useEffect(() => {
-      if (!processor || !attendableId || pendingSubmitted.current) {
+      if (!chatModel || !attendableId || pendingSubmitted.current) {
         return;
       }
 
@@ -98,15 +108,15 @@ export const ChatArticle = forwardRef<HTMLDivElement, ChatArticleProps>(
           return { ...current, pendingPrompts: rest };
         });
 
-        void processor.request({ message: pendingPrompt });
+        void chatModel.request({ message: pendingPrompt });
       }
-    }, [processor, attendableId, atomRegistry, stateAtom]);
+    }, [chatModel, attendableId, atomRegistry, stateAtom]);
 
     return (
       <ChatComponent.Root
         chat={chat}
         db={db}
-        processor={processor}
+        chatModel={chatModel}
         debug={debug}
         getContext={getContext}
         onEvent={onEvent}