@dxos/plugin-assistant 0.8.4-main.fcfe5033a5 → 0.8.4-staging.60fe92afc8

package/src/containers/AgentArticle/AgentArticle.stories.tsx

@@ -8,32 +8,40 @@ import React from 'react';
 
 import { withPluginManager } from '@dxos/app-framework/testing';
 import { Plan, Agent } from '@dxos/assistant-toolkit';
-import { Obj, Ref } from '@dxos/echo';
-import { AutomationPlugin } from '@dxos/plugin-automation';
-import { ClientPlugin } from '@dxos/plugin-client';
+import { Filter, Obj, Ref } from '@dxos/echo';
+import { AutomationPlugin } from '@dxos/plugin-automation/testing';
+import { ClientPlugin } from '@dxos/plugin-client/testing';
 import { initializeIdentity } from '@dxos/plugin-client/testing';
-import { PreviewPlugin } from '@dxos/plugin-preview';
-import { corePlugins, StorybookPlugin } from '@dxos/plugin-testing';
+import { PreviewPlugin } from '@dxos/plugin-preview/testing';
+import { StorybookPlugin, corePlugins } from '@dxos/plugin-testing';
 import { random } from '@dxos/random';
-import { Filter, useQuery, useSpaces } from '@dxos/react-client/echo';
+import { useQuery, useSpaces } from '@dxos/react-client/echo';
 import { Loading, withTheme } from '@dxos/react-ui/testing';
 import { Text } from '@dxos/schema';
 import { createObjectFactory, TypeSpec } from '@dxos/schema/testing';
 import { Message, Organization, Person } from '@dxos/types';
 
 import { createMessage } from '#testing';
+import { translations } from '#translations';
 
 import { AssistantPlugin } from '../../AssistantPlugin';
-import { translations } from '../../translations';
 import { AgentArticle } from './AgentArticle';
 
 random.seed(1);
 
 type DefaultStoryProps = {
-  spec?: TypeSpec[];
   inputs?: boolean;
 };
 
+// Hoisted out of `args` because Storybook's CSF arg traversal walks every value
+// and tries to mutate `.id` on each entry — which throws on ECHO `Type.Type`
+// entities (Type.makeObject returns an immutable proxy). Keeping the spec here
+// dodges the traversal entirely.
+const defaultSpec: TypeSpec[] = [
+  { type: Organization.Organization, count: 10 },
+  { type: Person.Person, count: 10 },
+];
+
 const DefaultStory = (_: DefaultStoryProps) => {
   const [space] = useSpaces();
   const [agent] = useQuery(space?.db, Filter.type(Agent.Agent));
@@ -49,7 +57,7 @@ const meta = {
   render: DefaultStory,
   decorators: [
     withTheme(),
-    withPluginManager<DefaultStoryProps>(({ args: { spec = [], inputs } }) => ({
+    withPluginManager<DefaultStoryProps>(({ args: { inputs } }) => ({
       plugins: [
         ...corePlugins(),
         ClientPlugin({
@@ -61,7 +69,7 @@ const meta = {
               yield* Effect.promise(() => space.waitUntilReady());
 
               const factory = createObjectFactory(space.db, random as any);
-              const artifacts = yield* Effect.promise(() => factory(spec));
+              const artifacts = yield* Effect.promise(() => factory(defaultSpec));
 
               const inputQueue = space.queues.create();
               if (inputs) {
@@ -84,7 +92,7 @@ const meta = {
                     name: Obj.getLabel(obj) ?? 'Artifact',
                     data: Ref.make(obj),
                   })),
-                  queue: Ref.fromDXN(inputQueue.dxn),
+                  feed: Ref.fromURI(inputQueue.uri),
                   subscriptions: [],
                 }),
               );
@@ -110,10 +118,6 @@ type Story = StoryObj<typeof meta>;
 export const Default: Story = {
   args: {
     inputs: true,
-    spec: [
-      { type: Organization.Organization, count: 10 },
-      { type: Person.Person, count: 10 },
-    ],
   },
 };
 

package/src/containers/AgentArticle/AgentArticle.tsx

@@ -4,23 +4,19 @@
 
 import { Atom, useAtomValue } from '@effect-atom/atom-react';
 import * as Effect from 'effect/Effect';
-import * as Function from 'effect/Function';
 import * as Option from 'effect/Option';
 import React, { forwardRef, useCallback, useMemo, useState } from 'react';
 
-import { Surface, useCapabilities } from '@dxos/app-framework/ui';
+import { Surface, useSpaceCallback } from '@dxos/app-framework/ui';
 import { AppSurface, useObjectMenuItems } from '@dxos/app-toolkit/ui';
 import { Agent } from '@dxos/assistant-toolkit';
-import { Annotation, Filter, Obj, Query, Ref } from '@dxos/echo';
-import { AtomObj, AtomRef } from '@dxos/echo-atom';
-import { QueueService } from '@dxos/functions';
-import { AutomationCapabilities } from '@dxos/plugin-automation/types';
+import { Database, Feed, Filter, Obj, Query, Ref } from '@dxos/echo';
 import { useQuery } from '@dxos/react-client/echo';
 import { Card, Message, Panel, ScrollArea, Toolbar, useTranslation } from '@dxos/react-ui';
+import { composable } from '@dxos/react-ui';
 import { Masonry } from '@dxos/react-ui-masonry';
 import { Menu } from '@dxos/react-ui-menu';
 import { Focus, Mosaic, type MosaicTileProps } from '@dxos/react-ui-mosaic';
-import { composable } from '@dxos/ui-theme';
 import { isNonNullable } from '@dxos/util';
 
 import { meta } from '#meta';
@@ -34,39 +30,33 @@ export const AgentArticle = ({ role, subject: agent }: AgentArticleProps) => {
   const [tab, setTab] = useState<Tab>('artifacts');
   const [viewport, setViewport] = useState<HTMLElement | null>(null);
 
-  const [computeRuntime] = useCapabilities(AutomationCapabilities.ComputeRuntime);
-  // TODO(burdon): Clear input queue also.
+  const spaceId = Obj.getDatabase(agent)?.spaceId;
+  // TODO(burdon): Clear input feed also.
+  const resetHistory = useSpaceCallback(
+    spaceId,
+    [Feed.FeedService, Database.Service] as const,
+    Effect.fnUntraced(function* () {
+      yield* Agent.resetChatHistory(agent);
+      if (!agent.feed) {
+        const feed = yield* Database.add(Feed.make());
+        Obj.update(agent, (agent) => {
+          agent.feed = Ref.make(feed);
+        });
+      }
+    }),
+    [agent],
+  );
   const handleResetHistory = useCallback(async () => {
-    if (!computeRuntime) {
-      return;
-    }
-
-    const space = Obj.getDatabase(agent);
-    if (!space) {
-      return;
-    }
-
-    const runtime = computeRuntime.getRuntime(space.spaceId);
-    await runtime.runPromise(Agent.resetChatHistory(agent));
-    if (!agent.queue) {
-      await runtime.runPromise(
-        Effect.gen(function* () {
-          const queue = yield* QueueService.createQueue();
-          Obj.change(agent, (agent) => {
-            agent.queue = Ref.fromDXN(queue.dxn);
-          });
-        }),
-      );
-    }
-  }, [agent, computeRuntime]);
+    await resetHistory();
+  }, [resetHistory]);
 
   const artifacts = useAtomValue(
     useMemo(
       () =>
-        AtomObj.make(agent).pipe((agent) =>
+        Obj.atom(agent).pipe((agent) =>
           Atom.make((get) => {
             return get(agent)
-              .artifacts.map((artifact) => get(AtomRef.make(artifact.data)))
+              .artifacts.map((artifact) => get(artifact.data.atom))
               .filter(isNonNullable);
           }),
         ),
@@ -74,15 +64,23 @@ export const AgentArticle = ({ role, subject: agent }: AgentArticleProps) => {
     ),
   );
 
-  const inputQueue = useAtomValue(
-    AtomObj.make(agent).pipe((_) =>
+  const inputFeed = useAtomValue(
+    Obj.atom(agent).pipe((_) =>
       Atom.make((get) =>
-        Option.fromNullable(get(_).queue).pipe(Option.map(AtomRef.make), Option.map(get), Option.getOrUndefined),
+        Option.fromNullable(get(_).feed).pipe(
+          Option.map((ref) => ref.atom),
+          Option.map(get),
+          Option.getOrUndefined,
+        ),
       ),
     ),
   );
 
-  const inputObjects = useQuery(inputQueue, Query.select(Filter.everything()));
+  const db = Obj.getDatabase(agent);
+  const inputObjects = useQuery(
+    db,
+    inputFeed ? Query.select(Filter.everything()).from(inputFeed) : Query.select(Filter.nothing()),
+  );
 
   return (
     <Panel.Root role={role}>
@@ -90,7 +88,7 @@ export const AgentArticle = ({ role, subject: agent }: AgentArticleProps) => {
         <Toolbar.Root>
           <Toolbar.ToggleGroup type='single' value={tab} onValueChange={(value) => value && setTab(value as Tab)}>
             <Toolbar.ToggleGroupIconItem value='artifacts' label={t('artifacts.label')} icon='ph--cube--regular' />
-            <Toolbar.ToggleGroupIconItem value='inputs' label={t('input-queue.label')} icon='ph--queue--regular' />
+            <Toolbar.ToggleGroupIconItem value='inputs' label={t('inputs.label')} icon='ph--queue--regular' />
           </Toolbar.ToggleGroup>
           <Toolbar.Separator />
           <Toolbar.IconButton
@@ -111,7 +109,9 @@ export const AgentArticle = ({ role, subject: agent }: AgentArticleProps) => {
             )}
 
             <Masonry.Root Tile={MasonryArtifactTile}>
-              <Masonry.Content items={artifacts} getId={(item: Obj.Unknown) => item.id} padding thin centered />
+              <Masonry.Content padding thin centered>
+                <Masonry.Viewport items={artifacts} getId={(item: Obj.Unknown) => item.id} />
+              </Masonry.Content>
             </Masonry.Root>
           </>
         )}
@@ -141,36 +141,30 @@ export const AgentArticle = ({ role, subject: agent }: AgentArticleProps) => {
 
 const ArtifactTileCard = composable<HTMLDivElement, { data: Obj.Unknown }>(({ data, ...props }, forwardedRef) => {
   const objectMenuItems = useObjectMenuItems(data);
-  const icon = Function.pipe(
-    Obj.getSchema(data),
-    Option.fromNullable,
-    Option.flatMap(Annotation.IconAnnotation.get),
-    Option.map(({ icon }) => icon),
-    Option.getOrElse(() => 'ph--placeholder--regular'),
-  );
+  const icon = Obj.getIcon(data)?.icon ?? 'ph--circle-dashed--regular';
 
   return (
     <Card.Root {...props} ref={forwardedRef} data-testid='board-item' fullWidth>
-      <Card.Toolbar>
-        <Card.IconBlock padding>
+      <Card.Header>
+        <Card.IconBlock>
           <Card.Icon icon={icon} />
         </Card.IconBlock>
-        <Card.Title>{Obj.getLabel(data)}</Card.Title>
+        <Card.Title>{Obj.getLabel(data, { fallback: 'typename' })}</Card.Title>
         {/* TODO(wittjosiah): Reconcile with Card.Menu. */}
-        <Card.IconBlock padding>
+        <Card.IconBlock>
           <Menu.Trigger asChild disabled={!objectMenuItems?.length}>
             <Toolbar.IconButton iconOnly variant='ghost' icon='ph--dots-three-vertical--regular' label='Actions' />
           </Menu.Trigger>
           <Menu.Content items={objectMenuItems} />
         </Card.IconBlock>
-      </Card.Toolbar>
-      <Card.Content>
+      </Card.Header>
+      <Card.Body>
         <Surface.Surface
           type={AppSurface.Card}
           limit={1}
           data={{ subject: data } satisfies AppSurface.ObjectCardData}
         />
-      </Card.Content>
+      </Card.Body>
     </Card.Root>
   );
 });

package/src/containers/AgentProperties/AgentProperties.tsx

@@ -2,157 +2,42 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Atom } from '@effect-atom/atom';
-import { useAtomValue } from '@effect-atom/atom-react';
-import * as Option from 'effect/Option';
-import React, { useCallback, useEffect, useMemo } from 'react';
+import React, { useEffect } from 'react';
 
-import { useCapability } from '@dxos/app-framework/ui';
+import { useSpaceCallback } from '@dxos/app-framework/ui';
 import { type AppSurface } from '@dxos/app-toolkit/ui';
-import { Agent, SyncTriggers } from '@dxos/assistant-toolkit';
-import { DXN, Obj, Ref } from '@dxos/echo';
-import { AtomObj, AtomRef } from '@dxos/echo-atom';
-import { createDocAccessor } from '@dxos/echo-db';
+import { Agent, AgentWizardOperations } from '@dxos/assistant-toolkit';
+import { Operation } from '@dxos/compute';
+import { Obj, Ref } from '@dxos/echo';
 import { log } from '@dxos/log';
-import { Operation } from '@dxos/operation';
-import { AutomationCapabilities } from '@dxos/plugin-automation/types';
-import { Filter, useQuery } from '@dxos/react-client/echo';
-import { Input, useTranslation } from '@dxos/react-ui';
-import { Editor } from '@dxos/react-ui-editor';
-import { FeedAnnotation } from '@dxos/schema';
-import {
-  createBasicExtensions,
-  createDataExtensions,
-  createMarkdownExtensions,
-  createThemeExtensions,
-  decorateMarkdown,
-} from '@dxos/ui-editor';
 
-import { meta } from '#meta';
+import { AgentProperties as AgentPropertiesComponent } from '#components';
 
 export type AgentPropertiesProps = AppSurface.ObjectPropertiesProps<Agent.Agent>;
 
 export const AgentProperties = ({ subject: agent }: AgentPropertiesProps) => {
-  const { t } = useTranslation(meta.id);
-  const db = Obj.getDatabase(agent);
+  const spaceId = Obj.getDatabase(agent)?.spaceId;
 
-  // TODO(burdon): Factor out (separate component from container)?
-  const computeRuntime = useCapability(AutomationCapabilities.ComputeRuntime);
+  // TODO(burdon): Factor this out?
+  const syncTriggers = useSpaceCallback(
+    spaceId,
+    [] as const,
+    () => Operation.invoke(AgentWizardOperations.SyncTriggers, { agent: Ref.make(agent) }),
+    [agent],
+  );
+
+  // Sync triggers whenever the agent mutates (e.g., subscriptions change).
   useEffect(() => {
-    if (!db) {
+    if (!spaceId) {
       return;
     }
 
     return Obj.subscribe(agent, () => {
       queueMicrotask(() => {
-        const runtime = computeRuntime.getRuntime(db.spaceId);
-        runtime
-          .runPromise(
-            Operation.invoke(SyncTriggers, {
-              agent: Ref.make(agent),
-            }),
-          )
-          .catch((err) => log.catch(err));
+        syncTriggers().catch((err) => log.catch(err));
       });
     });
-  }, [db, agent, computeRuntime]);
+  }, [spaceId, agent, syncTriggers]);
 
-  // Build a filter matching objects of any schema annotated as a feed.
-  const feedFilter = useMemo(() => {
-    if (!db) {
-      return Filter.nothing();
-    }
-
-    const schemas = db.schemaRegistry.query({ location: ['database', 'runtime'] }).runSync();
-    const feedSchemas = schemas.filter((schema) => {
-      const annotation = FeedAnnotation.get(schema);
-      return Option.isSome(annotation) && annotation.value === true;
-    });
-
-    return feedSchemas.length === 0 ? Filter.nothing() : Filter.or(...feedSchemas.map((schema) => Filter.type(schema)));
-  }, [db]);
-
-  const subscribedObjects = useQuery(db, feedFilter);
-
-  // Query all existing subscriptions (e.g., mail, calendar, etc.)
-  const existingSubscriptions = useAtomValue(
-    useMemo(
-      () =>
-        AtomObj.make(agent).pipe((_) =>
-          Atom.make((get) => {
-            const agentObj = get(_);
-            const selectedSubscriptions: Obj.Unknown[] = subscribedObjects.filter((object) =>
-              agentObj.subscriptions.some((subscription) => DXN.equals(subscription.dxn, Obj.getDXN(object))),
-            );
-
-            return selectedSubscriptions;
-          }),
-        ),
-      [agent, subscribedObjects],
-    ),
-  );
-
-  // Create/remove agent subscription.
-  const handleSubscriptionChange = useCallback(
-    (object: Obj.Unknown, checked: boolean) => {
-      Obj.change(agent, (agent) => {
-        if (checked) {
-          agent.subscriptions.push(Ref.fromDXN(Obj.getDXN(object)));
-        } else {
-          agent.subscriptions = agent.subscriptions.filter(
-            (subscription) => !DXN.equals(subscription.dxn, Obj.getDXN(object)),
-          );
-        }
-      });
-    },
-    [agent],
-  );
-
-  const instructions = useAtomValue(AtomRef.make(agent.instructions));
-  const extension = useMemo(
-    () =>
-      instructions && [
-        createBasicExtensions({ placeholder: t('instructions.placeholder') }),
-        createThemeExtensions({ syntaxHighlighting: true }),
-        createDataExtensions({ id: agent.id, text: createDocAccessor(instructions, ['content']) }),
-        createMarkdownExtensions(),
-        decorateMarkdown(),
-      ],
-    [instructions, agent.id, t],
-  );
-
-  return (
-    <div role='none' className='dx-expander flex flex-col'>
-      {subscribedObjects.length > 0 && (
-        <>
-          <Input.Root>
-            <Input.Label classNames='mt-form-gap'>{t('subscriptions.label')}</Input.Label>
-          </Input.Root>
-
-          {subscribedObjects.map((object) => (
-            <Input.Root key={object.id}>
-              <div className='flex items-center gap-2'>
-                <Input.Checkbox
-                  checked={existingSubscriptions.includes(object)}
-                  onCheckedChange={(checked) => {
-                    handleSubscriptionChange(object, checked === true);
-                  }}
-                />
-                <Input.Label>{Obj.getLabel(object) ?? object.id}</Input.Label>
-              </div>
-            </Input.Root>
-          ))}
-        </>
-      )}
-
-      <Input.Root>
-        <Input.Label classNames='mt-form-gap'>{t('instructions.label')}</Input.Label>
-        {instructions && (
-          <Editor.Root>
-            <Editor.View classNames='border border-subdued-separator rounded-xs p-1 px-2' extensions={extension} />
-          </Editor.Root>
-        )}
-      </Input.Root>
-    </div>
-  );
+  return <AgentPropertiesComponent agent={agent} />;
 };

package/src/containers/BlueprintArticle/BlueprintArticle.tsx

@@ -5,7 +5,7 @@
 import React from 'react';
 
 import { type AppSurface } from '@dxos/app-toolkit/ui';
-import { type Blueprint } from '@dxos/blueprints';
+import { type Blueprint } from '@dxos/compute';
 import { Panel, Toolbar } from '@dxos/react-ui';
 import { useAttention } from '@dxos/react-ui-attention';
 
@@ -22,7 +22,7 @@ export const BlueprintArticle = ({ role, attendableId, subject }: BlueprintArtic
         <Toolbar.Root disabled={!hasAttention} />
       </Panel.Toolbar>
       <Panel.Content asChild>
-        <TemplateEditor id={subject.id} template={subject.instructions} />
+        <TemplateEditor id={subject.id} source={subject.instructions.source} />
       </Panel.Content>
     </Panel.Root>
   );

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

@@ -0,0 +1,78 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import * as Effect from 'effect/Effect';
+import React from 'react';
+
+import { SERVICES_CONFIG } from '@dxos/ai/testing';
+import { withPluginManager } from '@dxos/app-framework/testing';
+import { AppActivationEvents } from '@dxos/app-toolkit';
+import { Chat } from '@dxos/assistant-toolkit';
+import { capabilities } from '@dxos/assistant-toolkit/testing';
+import { Feed, Filter, Ref } from '@dxos/echo';
+import { AutomationPlugin } from '@dxos/plugin-automation/testing';
+import { initializeIdentity, ClientPlugin } from '@dxos/plugin-client/testing';
+import { PreviewPlugin } from '@dxos/plugin-preview/testing';
+import { StorybookPlugin, corePlugins } from '@dxos/plugin-testing';
+import { Config } from '@dxos/react-client';
+import { useQuery, useSpaces } from '@dxos/react-client/echo';
+import { Loading, withTheme } from '@dxos/react-ui/testing';
+
+import { translations } from '#translations';
+
+import { AssistantPlugin } from '../../AssistantPlugin';
+import { ChatArticle } from './ChatArticle';
+
+const DefaultStory = () => {
+  const [space] = useSpaces();
+  const [chat] = useQuery(space?.db, Filter.type(Chat.Chat));
+  if (!chat) {
+    return <Loading />;
+  }
+
+  return <ChatArticle role='article' subject={chat} attendableId='story' />;
+};
+
+const meta = {
+  title: 'plugins/plugin-assistant/containers/ChatArticle',
+  render: DefaultStory,
+  decorators: [
+    withTheme(),
+    withPluginManager({
+      setupEvents: [AppActivationEvents.SetupSettings],
+      plugins: [
+        ...corePlugins(),
+        ClientPlugin({
+          types: [Chat.Chat, Feed.Feed],
+          config: new Config({ runtime: { services: SERVICES_CONFIG.REMOTE } }),
+          onClientInitialized: ({ client }) =>
+            Effect.gen(function* () {
+              yield* initializeIdentity(client);
+              const [space] = client.spaces.get();
+              yield* Effect.promise(() => space.waitUntilReady());
+              const feed = space.db.add(Feed.make());
+              space.db.add(Chat.make({ name: 'Test', feed: Ref.make(feed) }));
+              yield* Effect.promise(() => space.db.flush({ indexes: true }));
+            }),
+        }),
+        AutomationPlugin(),
+        AssistantPlugin(),
+        PreviewPlugin(),
+        StorybookPlugin({}),
+      ],
+      capabilities,
+    }),
+  ],
+  parameters: {
+    layout: 'fullscreen',
+    translations,
+  },
+} satisfies Meta<typeof DefaultStory>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {};

package/src/containers/ChatArticle/ChatArticle.tsx

@@ -0,0 +1,112 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React, { forwardRef, useEffect, useRef } from 'react';
+
+import { Capabilities } from '@dxos/app-framework';
+import { useAtomCapability, useCapability } from '@dxos/app-framework/ui';
+import { type AppSurface } from '@dxos/app-toolkit/ui';
+import { getSpace } from '@dxos/client/echo';
+import { type Obj } from '@dxos/echo';
+import { useRegistry } from '@dxos/react-client/echo';
+import { Panel } from '@dxos/react-ui';
+
+import { Chat as ChatComponent, type ChatRootProps } from '#components';
+import { useChatProcessor, useChatServices, useOnline, usePresets } from '#hooks';
+import { type Assistant, AssistantCapabilities, type ChatType } from '#types';
+
+export type ChatArticleProps = AppSurface.ObjectSectionProps<ChatType.Chat> & {
+  companionTo?: Obj.Unknown;
+} & Pick<ChatRootProps, 'onEvent' | 'onSubmit'>;
+
+export const ChatArticle = forwardRef<HTMLDivElement, ChatArticleProps>(
+  ({ role, attendableId, subject: chat, companionTo, onEvent, onSubmit }, forwardedRef) => {
+    const registry = useRegistry();
+    const settings = useAtomCapability(AssistantCapabilities.Settings);
+    const atomRegistry = useCapability(Capabilities.AtomRegistry);
+    const stateAtom = useCapability(AssistantCapabilities.State);
+    // Transient (pre-submit) chats have no database; fall back to the companion's space.
+    const space = getSpace(chat) ?? getSpace(companionTo);
+    const runtime = useChatServices({ id: space?.id });
+
+    const [online, setOnline] = useOnline();
+    const { preset, ...chatProps } = usePresets(online);
+    const processor = useChatProcessor({ space, chat, preset, runtime, registry, settings });
+    const pendingSubmitted = useRef(false);
+
+    // Reset the one-shot guard when the target conversation changes, so a pending prompt for a new
+    // `attendableId` is still auto-submitted within the same mount.
+    useEffect(() => {
+      pendingSubmitted.current = false;
+    }, [attendableId]);
+
+    useEffect(() => {
+      if (!processor || !attendableId || pendingSubmitted.current) {
+        return;
+      }
+
+      const state = atomRegistry.get(stateAtom);
+      const pendingPrompt = state.pendingPrompts[attendableId];
+      if (pendingPrompt) {
+        pendingSubmitted.current = true;
+        atomRegistry.update(stateAtom, (current) => {
+          const { [attendableId]: _, ...rest } = current.pendingPrompts;
+          return { ...current, pendingPrompts: rest };
+        });
+
+        void processor.request({ message: pendingPrompt });
+      }
+    }, [processor, attendableId, atomRegistry, stateAtom]);
+
+    const feedTarget = chat?.feed.target;
+    const view = (chat?.view as Assistant.ChatView | undefined) ?? settings.chatView;
+
+    if (!processor) {
+      return null;
+    }
+
+    return (
+      <ChatComponent.Root
+        chat={chat}
+        feed={feedTarget}
+        db={space?.db}
+        processor={processor}
+        onEvent={onEvent}
+        onSubmit={onSubmit}
+      >
+        <Panel.Root role={role} ref={forwardedRef}>
+          <Panel.Toolbar className='bg-toolbar-surface'>
+            <ChatComponent.Toolbar classNames='dx-document' attendableId={attendableId} companionTo={companionTo} />
+          </Panel.Toolbar>
+          <Panel.Content>
+            <ChatComponent.Content>
+              <div className='dx-container relative'>
+                <ChatComponent.Thread viewType={view} />
+                {view !== 'summary' && (
+                  <div className='absolute bottom-2 left-0 right-0'>
+                    <div className='dx-document px-4'>
+                      <ChatComponent.Status classNames='px-3 rounded-sm bg-group-surface' />
+                    </div>
+                  </div>
+                )}
+              </div>
+              <div className='dx-document px-4 pb-4'>
+                <div className='flex flex-col items-center py-2 overflow-hidden'>
+                  <ChatComponent.TaskList classNames='max-h-[120px] border border-separator rounded-sm text-description' />
+                </div>
+                <ChatComponent.Prompt
+                  {...chatProps}
+                  outline
+                  preset={preset?.id}
+                  online={online}
+                  onOnlineChange={setOnline}
+                />
+              </div>
+            </ChatComponent.Content>
+          </Panel.Content>
+        </Panel.Root>
+      </ChatComponent.Root>
+    );
+  },
+);

package/src/containers/ChatArticle/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export { ChatArticle as default } from './ChatArticle';