@dxos/plugin-assistant 0.8.4-main.406dc2a → 0.8.4-main.43cb759274

package/src/containers/AgentArticle/AgentArticle.tsx

@@ -0,0 +1,189 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { Atom, useAtomValue } from '@effect-atom/atom-react';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+import React, { forwardRef, useCallback, useMemo, useState } from 'react';
+
+import { Surface, useSpaceCallback } from '@dxos/app-framework/ui';
+import { AppSurface, useObjectMenuItems } from '@dxos/app-toolkit/ui';
+import { Agent } from '@dxos/assistant-toolkit';
+import { Database, Feed, Filter, Obj, Query, Ref } from '@dxos/echo';
+import { AtomObj, AtomRef } from '@dxos/echo-atom';
+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 { isNonNullable } from '@dxos/util';
+
+import { meta } from '#meta';
+
+type Tab = 'artifacts' | 'inputs';
+
+export type AgentArticleProps = AppSurface.ObjectArticleProps<Agent.Agent>;
+
+export const AgentArticle = ({ role, subject: agent }: AgentArticleProps) => {
+  const { t } = useTranslation(meta.id);
+  const [tab, setTab] = useState<Tab>('artifacts');
+  const [viewport, setViewport] = useState<HTMLElement | null>(null);
+
+  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 () => {
+    await resetHistory();
+  }, [resetHistory]);
+
+  const artifacts = useAtomValue(
+    useMemo(
+      () =>
+        AtomObj.make(agent).pipe((agent) =>
+          Atom.make((get) => {
+            return get(agent)
+              .artifacts.map((artifact) => get(AtomRef.make(artifact.data)))
+              .filter(isNonNullable);
+          }),
+        ),
+      [agent],
+    ),
+  );
+
+  const inputFeed = useAtomValue(
+    AtomObj.make(agent).pipe((_) =>
+      Atom.make((get) =>
+        Option.fromNullable(get(_).feed).pipe(Option.map(AtomRef.make), Option.map(get), Option.getOrUndefined),
+      ),
+    ),
+  );
+
+  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}>
+      <Panel.Toolbar asChild>
+        <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('inputs.label')} icon='ph--queue--regular' />
+          </Toolbar.ToggleGroup>
+          <Toolbar.Separator />
+          <Toolbar.IconButton
+            icon='ph--trash--regular'
+            label={t('reset-history.button')}
+            onCanPlay={handleResetHistory}
+          />
+        </Toolbar.Root>
+      </Panel.Toolbar>
+      <Panel.Content className='dx-container flex flex-col'>
+        {tab === 'artifacts' && (
+          <>
+            {artifacts.length === 0 && (
+              <Message.Root classNames='m-2' valence='info'>
+                <Message.Title>{t('project-empty-spec.message')}</Message.Title>
+                <Message.Content>{t('project-empty-spec.description')}</Message.Content>
+              </Message.Root>
+            )}
+
+            <Masonry.Root Tile={MasonryArtifactTile}>
+              <Masonry.Content padding thin centered>
+                <Masonry.Viewport items={artifacts} getId={(item: Obj.Unknown) => item.id} />
+              </Masonry.Content>
+            </Masonry.Root>
+          </>
+        )}
+
+        {tab === 'inputs' && (
+          <Mosaic.Container asChild withFocus autoScroll={viewport} classNames='dx-document'>
+            <ScrollArea.Root orientation='vertical' padding thin centered>
+              <ScrollArea.Viewport ref={setViewport}>
+                <Mosaic.VirtualStack
+                  Tile={StackTile}
+                  classNames='gap-2'
+                  draggable={false}
+                  estimateSize={() => 160}
+                  gap={8}
+                  getId={(item: Obj.Unknown) => item.id}
+                  getScrollElement={() => viewport}
+                  items={inputObjects}
+                />
+              </ScrollArea.Viewport>
+            </ScrollArea.Root>
+          </Mosaic.Container>
+        )}
+      </Panel.Content>
+    </Panel.Root>
+  );
+};
+
+const ArtifactTileCard = composable<HTMLDivElement, { data: Obj.Unknown }>(({ data, ...props }, forwardedRef) => {
+  const objectMenuItems = useObjectMenuItems(data);
+  const icon = Obj.getIcon(data)?.icon ?? 'ph--circle-dashed--regular';
+
+  return (
+    <Card.Root {...props} ref={forwardedRef} data-testid='board-item' fullWidth>
+      <Card.Header>
+        <Card.IconBlock>
+          <Card.Icon icon={icon} />
+        </Card.IconBlock>
+        <Card.Title>{Obj.getLabel(data, { fallback: 'typename' })}</Card.Title>
+        {/* TODO(wittjosiah): Reconcile with Card.Menu. */}
+        <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.Header>
+      <Card.Body>
+        <Surface.Surface
+          type={AppSurface.Card}
+          limit={1}
+          data={{ subject: data } satisfies AppSurface.ObjectCardData}
+        />
+      </Card.Body>
+    </Card.Root>
+  );
+});
+
+ArtifactTileCard.displayName = 'ArtifactTileCard';
+
+const MasonryArtifactTile = ({ data }: { data: Obj.Unknown; index: number }) => (
+  <Menu.Root>
+    <ArtifactTileCard data={data} />
+  </Menu.Root>
+);
+
+const StackTile = forwardRef<HTMLDivElement, MosaicTileProps<Obj.Unknown>>(
+  ({ data, location, debug, current }, forwardedRef) => (
+    <Menu.Root>
+      <Mosaic.Tile asChild id={data.id} data={data} location={location} debug={debug}>
+        <Focus.Item asChild current={current}>
+          <ArtifactTileCard ref={forwardedRef} data={data} />
+        </Focus.Item>
+      </Mosaic.Tile>
+    </Menu.Root>
+  ),
+);
+
+StackTile.displayName = 'StackTile';

package/src/containers/AgentArticle/index.ts

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

package/src/containers/AgentProperties/AgentProperties.tsx

@@ -0,0 +1,43 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React, { useEffect } from 'react';
+
+import { useSpaceCallback } from '@dxos/app-framework/ui';
+import { type AppSurface } from '@dxos/app-toolkit/ui';
+import { Agent, SyncTriggers } from '@dxos/assistant-toolkit';
+import { Operation } from '@dxos/compute';
+import { Obj, Ref } from '@dxos/echo';
+import { log } from '@dxos/log';
+
+import { AgentProperties as AgentPropertiesComponent } from '#components';
+
+export type AgentPropertiesProps = AppSurface.ObjectPropertiesProps<Agent.Agent>;
+
+export const AgentProperties = ({ subject: agent }: AgentPropertiesProps) => {
+  const spaceId = Obj.getDatabase(agent)?.spaceId;
+
+  // TODO(burdon): Factor this out?
+  const syncTriggers = useSpaceCallback(
+    spaceId,
+    [] as const,
+    () => Operation.invoke(SyncTriggers, { agent: Ref.make(agent) }),
+    [agent],
+  );
+
+  // Sync triggers whenever the agent mutates (e.g., subscriptions change).
+  useEffect(() => {
+    if (!spaceId) {
+      return;
+    }
+
+    return Obj.subscribe(agent, () => {
+      queueMicrotask(() => {
+        syncTriggers().catch((err) => log.catch(err));
+      });
+    });
+  }, [spaceId, agent, syncTriggers]);
+
+  return <AgentPropertiesComponent agent={agent} />;
+};

package/src/containers/AgentProperties/index.ts

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

package/src/containers/BlueprintArticle/BlueprintArticle.tsx

@@ -0,0 +1,29 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React from 'react';
+
+import { type AppSurface } from '@dxos/app-toolkit/ui';
+import { type Blueprint } from '@dxos/compute';
+import { Panel, Toolbar } from '@dxos/react-ui';
+import { useAttention } from '@dxos/react-ui-attention';
+
+import { TemplateEditor } from '#components';
+
+export type BlueprintArticleProps = AppSurface.ObjectArticleProps<Blueprint.Blueprint>;
+
+export const BlueprintArticle = ({ role, attendableId, subject }: BlueprintArticleProps) => {
+  const { hasAttention } = useAttention(attendableId);
+
+  return (
+    <Panel.Root role={role} classNames='dx-document'>
+      <Panel.Toolbar asChild>
+        <Toolbar.Root disabled={!hasAttention} />
+      </Panel.Toolbar>
+      <Panel.Content asChild>
+        <TemplateEditor id={subject.id} source={subject.instructions.source} />
+      </Panel.Content>
+    </Panel.Root>
+  );
+};

package/src/containers/BlueprintArticle/index.ts

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

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

@@ -0,0 +1,76 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import * as Effect from 'effect/Effect';
+import React from 'react';
+
+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 { 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],
+          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 chat', 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,108 @@
+//
+// 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 { type Space, 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 { getParentId } from '@dxos/react-ui-attention';
+
+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.ObjectArticleProps<ChatType.Chat | undefined>
+  | AppSurface.ObjectSectionProps<ChatType.Chat | undefined>
+) & {
+  space?: Space;
+  companionTo?: Obj.Unknown;
+} & Pick<ChatRootProps, 'onEvent'>;
+
+export const ChatArticle = forwardRef<HTMLDivElement, ChatArticleProps>((props, forwardedRef) => {
+  const { role, attendableId, subject: chat, space: spaceProp, companionTo, onEvent } = props;
+  const parentId = attendableId ? getParentId(attendableId) : undefined;
+  const space = spaceProp ?? getSpace(chat);
+  const settings = useAtomCapability(AssistantCapabilities.Settings);
+  const runtime = useChatServices({ id: space?.id });
+  const [online, setOnline] = useOnline();
+  const { preset, ...chatProps } = usePresets(online);
+  const registry = useRegistry();
+  const processor = useChatProcessor({
+    space,
+    chat,
+    preset,
+    runtime,
+    registry,
+    settings,
+  });
+
+  const atomRegistry = useCapability(Capabilities.AtomRegistry);
+  const stateAtom = useCapability(AssistantCapabilities.State);
+  const pendingSubmitted = useRef(false);
+  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 db={space?.db} chat={chat} feed={feedTarget} processor={processor} onEvent={onEvent}>
+      <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';

package/src/containers/ChatCompanion/ChatCompanion.tsx

@@ -0,0 +1,121 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Option from 'effect/Option';
+import React, { forwardRef, useCallback, useMemo } from 'react';
+
+import { useOperationInvoker } from '@dxos/app-framework/ui';
+import { BlueprintsAnnotation } from '@dxos/app-toolkit';
+import { type AppSurface } from '@dxos/app-toolkit/ui';
+import { Chat } from '@dxos/assistant-toolkit';
+import { getSpace } from '@dxos/client/echo';
+import { Blueprint } from '@dxos/compute';
+import { Entity, Filter, Obj, Ref, Type } from '@dxos/echo';
+import { SpaceOperation } from '@dxos/plugin-space';
+import { useQuery, useRegistry } from '@dxos/react-client/echo';
+import { useAsyncEffect } from '@dxos/react-ui';
+
+import { type ChatEvent } from '#components';
+import { useContextBinder } from '#hooks';
+import { AssistantOperation } from '#types';
+
+import ChatArticle from '../ChatArticle';
+
+export type ChatCompanionProps = AppSurface.ArticleProps<Chat.Chat, {}, Obj.Unknown>;
+
+export const ChatCompanion = forwardRef<HTMLDivElement, ChatCompanionProps>(
+  ({ role, subject: chat, companionTo, attendableId }, forwardedRef) => {
+    const { invokePromise } = useOperationInvoker();
+    const registry = useRegistry();
+    const space = getSpace(companionTo);
+    const feedTarget = chat?.feed.target;
+    const binder = useContextBinder(space, feedTarget);
+
+    // Persist chat on first submit.
+    const handleEvent = useCallback(
+      async (event: ChatEvent) => {
+        if (!space || !chat) {
+          return;
+        }
+
+        if (event.type === 'submit' && !Obj.getDatabase(chat)) {
+          await invokePromise(SpaceOperation.AddObject, {
+            object: chat,
+            target: space.db,
+            hidden: true,
+          });
+          await invokePromise(SpaceOperation.AddRelation, {
+            db: space.db,
+            schema: Chat.CompanionTo,
+            source: chat,
+            target: companionTo,
+          });
+          await invokePromise(AssistantOperation.SetCurrentChat, {
+            companionTo,
+            chat,
+          });
+        }
+      },
+      [chat, space, companionTo, invokePromise],
+    );
+
+    const blueprintKeys = useMemo(() => {
+      const schema = companionTo ? Obj.getType(companionTo) : undefined;
+      if (!schema) {
+        return [] as string[];
+      }
+      return Option.getOrElse(() => [] as string[])(BlueprintsAnnotation.get(Type.getSchema(schema)));
+    }, [companionTo]);
+    const existingBlueprints = useQuery(space?.db, Filter.type(Blueprint.Blueprint));
+    const pluginBlueprints = useMemo(
+      () =>
+        existingBlueprints.filter((blueprint) => {
+          const key = Obj.getMeta(blueprint).key;
+          return key !== undefined && blueprintKeys.includes(key);
+        }),
+      [existingBlueprints, blueprintKeys],
+    );
+
+    useAsyncEffect(async () => {
+      if (!binder?.isOpen) {
+        return;
+      }
+
+      // Bind annotated blueprints: use key URI for registry blueprints (no DB clone needed).
+      if (blueprintKeys.length > 0) {
+        const registryKeys = blueprintKeys.filter((key) => {
+          const candidate = registry.list().find((e) => Entity.getMeta(e)?.key === key);
+          return candidate != null && Obj.instanceOf(Blueprint.Blueprint, candidate);
+        });
+        // DB-forked blueprints (in space but not in registry).
+        const dbForks = pluginBlueprints.filter((bp) => !registryKeys.includes(Obj.getMeta(bp).key ?? ''));
+
+        if (registryKeys.length > 0) {
+          await binder.bind({ blueprints: registryKeys.map((key) => Ref.fromURI(Blueprint.registryURI(key))) });
+        }
+        if (dbForks.length > 0) {
+          await binder.bind({ blueprints: dbForks.map((blueprint) => Ref.make(blueprint)) });
+        }
+      }
+
+      if (Obj.instanceOf(Blueprint.Blueprint, companionTo)) {
+        await binder.bind({ blueprints: [Ref.make(companionTo)] });
+      } else {
+        await binder.bind({ objects: [Ref.make(companionTo)] });
+      }
+    }, [binder, companionTo, pluginBlueprints]);
+
+    return (
+      <ChatArticle
+        role={role ?? 'article'}
+        space={space}
+        subject={chat}
+        attendableId={attendableId}
+        companionTo={companionTo}
+        onEvent={handleEvent}
+        ref={forwardedRef}
+      />
+    );
+  },
+);

package/src/containers/ChatCompanion/index.ts

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

package/src/{components → containers/ChatDialog}/ChatDialog.tsx

@@ -4,31 +4,32 @@
 
 import React, { useCallback, useState } from 'react';
 
-import { Capabilities, useCapability } from '@dxos/app-framework';
-import { getSpace } from '@dxos/client/echo';
+import { useAtomCapability } from '@dxos/app-framework/ui';
+import { type Chat as ChatTypes } from '@dxos/assistant-toolkit';
+import { Obj } from '@dxos/echo';
+import { useRegistry } from '@dxos/react-client/echo';
 import { useTranslation } from '@dxos/react-ui';
 import { ChatDialog as NaturalChatDialog } from '@dxos/react-ui-chat';
 
-import { useBlueprintRegistry, useChatProcessor, useChatServices, useOnline, usePresets } from '../hooks';
-import { meta } from '../meta';
-import { type Assistant } from '../types';
-
-import { Chat, type ChatRootProps } from './Chat';
+import { Chat, type ChatRootProps } from '#components';
+import { useChatProcessor, useChatServices, useOnline, usePresets } from '#hooks';
+import { meta } from '#meta';
+import { type Assistant, AssistantCapabilities } from '#types';
 
 export type ChatDialogProps = {
-  chat?: Assistant.Chat;
+  chat?: ChatTypes.Chat;
 };
 
 export const ChatDialog = ({ chat }: ChatDialogProps) => {
   const { t } = useTranslation(meta.id);
 
-  const space = getSpace(chat);
-  const settings = useCapability(Capabilities.SettingsStore).getStore<Assistant.Settings>(meta.id)?.value;
-  const services = useChatServices({ space, chat });
+  const db = chat && Obj.getDatabase(chat);
+  const settings = useAtomCapability(AssistantCapabilities.Settings);
+  const runtime = useChatServices({ id: db?.spaceId });
   const [online, setOnline] = useOnline();
   const { preset, ...chatProps } = usePresets(online);
-  const blueprintRegistry = useBlueprintRegistry();
-  const processor = useChatProcessor({ chat, preset, services, blueprintRegistry, settings });
+  const registry = useRegistry();
+  const processor = useChatProcessor({ chat, preset, runtime, registry, settings });
 
   // TODO(burdon): Refocus when open.
   const [open, setOpen] = useState(true);
@@ -53,9 +54,9 @@ export const ChatDialog = ({ chat }: ChatDialogProps) => {
   return (
     <Chat.Root chat={chat} processor={processor} onEvent={handleEvent}>
       <NaturalChatDialog.Root open={open} expanded={expanded} onOpenChange={setOpen}>
-        <NaturalChatDialog.Header title={t('assistant dialog title')} />
+        <NaturalChatDialog.Header title={t('assistant-dialog.title')} />
         <NaturalChatDialog.Content>
-          <Chat.Thread />
+          <Chat.Thread viewType={(chat.view as Assistant.ChatView | undefined) ?? settings.chatView} />
         </NaturalChatDialog.Content>
         <NaturalChatDialog.Footer classNames='p-1.5'>
           <Chat.Prompt {...chatProps} preset={preset?.id} online={online} onOnlineChange={setOnline} expandable />
@@ -64,5 +65,3 @@ export const ChatDialog = ({ chat }: ChatDialogProps) => {
     </Chat.Root>
   );
 };
-
-export default ChatDialog;

package/src/containers/ChatDialog/index.ts

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