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

package/src/components/ChatThread/ChatThread.stories.tsx

@@ -2,259 +2,138 @@
 // Copyright 2025 DXOS.org
 //
 
-import '@dxos-theme';
-
 import { type Meta, type StoryObj } from '@storybook/react-vite';
-import { Effect, Layer } from 'effect';
-import React, { useEffect, useMemo } from 'react';
+import * as Effect from 'effect/Effect';
+import * as Fiber from 'effect/Fiber';
+import * as Layer from 'effect/Layer';
+import React, { useEffect, useMemo, useState } from 'react';
+
+import { withPluginManager } from '@dxos/app-framework/testing';
+import { createFeedServiceLayer } from '@dxos/client/echo';
+import { Database, Feed, Filter, Query } from '@dxos/echo';
+import { EffectEx } from '@dxos/effect';
+import { ClientPlugin, initializeIdentity } from '@dxos/plugin-client/testing';
+import { PreviewPlugin } from '@dxos/plugin-preview/testing';
+import { StorybookPlugin, corePlugins } from '@dxos/plugin-testing';
+import { random } from '@dxos/random';
+import { useQuery, useSpaces } from '@dxos/react-client/echo';
+import { EditorPreviewProvider } from '@dxos/react-ui-editor';
+import { Loading, withLayout, withTheme } from '@dxos/react-ui/testing';
+import { Message, Organization, Person } from '@dxos/types';
+
+import { createMessageGenerator } from '#testing';
+import { translations } from '#translations';
+
+import { ChatThread, type ChatThreadProps } from './ChatThread';
 
-import { Obj } from '@dxos/echo';
-import { ContextQueueService, DatabaseService } from '@dxos/functions';
-import { faker } from '@dxos/random';
-import { useQueue, useSpace } from '@dxos/react-client/echo';
-import { withClientProvider } from '@dxos/react-client/testing';
-import { type ContentBlock, DataType } from '@dxos/schema';
-import { ColumnContainer, render, withLayout, withTheme } from '@dxos/storybook-utils';
+random.seed(1);
 
-import { translations } from '../../translations';
+type MessageGenerator = Effect.Effect<void, never, Database.Service | Feed.ContextFeedService | Feed.FeedService>;
 
-import { renderObjectLink } from './ChatMessage';
-import { ChatThread, type ChatThreadProps } from './ChatThread';
+type DefaultStoryProps = { generator?: MessageGenerator[]; delay?: number; wait?: boolean } & ChatThreadProps;
 
-faker.seed(1);
+const DefaultStory = ({ generator = [], delay = 0, wait, ...props }: DefaultStoryProps) => {
+  const [space] = useSpaces();
+  const feed = useMemo<Feed.Feed | undefined>(
+    () => (space ? space.db.add(Feed.make({ name: 'chat' })) : undefined),
+    [space],
+  );
+  const messages = useQuery(
+    space?.db,
+    feed ? Query.select(Filter.type(Message.Message)).from(feed) : Query.select(Filter.nothing()),
+  );
+  const [done, setDone] = useState(false);
 
-const StoryContainer = ({ delay = 0, ...props }: ChatThreadProps & { delay?: number }) => {
-  const space = useSpace();
-  const queueDxn = useMemo(() => space?.queues.create().dxn, [space]);
-  const queue = useQueue<DataType.Message>(queueDxn);
+  // Generate messages.
   useEffect(() => {
-    if (!space || !queue) {
+    if (!space || !feed) {
       return;
     }
 
-    void Effect.runPromise(
+    const fiber = Effect.runFork(
       Effect.gen(function* () {
-        for (const step of MESSAGES) {
+        for (const step of generator) {
           yield* step;
-          yield* Effect.sleep(delay);
+          if (delay) {
+            yield* Effect.sleep(delay);
+          }
         }
 
-        return queue;
-      }).pipe(Effect.provide(Layer.mergeAll(DatabaseService.layer(space.db), ContextQueueService.layer(queue)))),
+        setDone(true);
+      }).pipe(
+        Effect.provide(
+          Layer.mergeAll(
+            Database.layer(space.db),
+            Feed.ContextFeedService.layer(feed),
+            createFeedServiceLayer(space.queues),
+          ),
+        ),
+      ),
     );
-  }, [space, queue]);
 
-  if (!space) {
-    return null;
+    return () => {
+      void EffectEx.runAndForwardErrors(Fiber.interrupt(fiber));
+    };
+  }, [space, feed, generator, delay]);
+
+  if (wait && !done) {
+    return <Loading data={{ wait, done }} />;
   }
 
   return (
-    <ChatThread {...props} space={space} messages={queue?.objects ?? []} onEvent={(event) => console.log(event)} />
+    <EditorPreviewProvider onLookup={async ({ dxn, label }) => ({ label, text: dxn })}>
+      <ChatThread {...props} messages={messages} />
+    </EditorPreviewProvider>
   );
 };
 
-const createMessage = (role: DataType.ActorRole, blocks: ContentBlock.Any[]): DataType.Message => {
-  return Obj.make(DataType.Message, {
-    created: new Date().toISOString(),
-    sender: { role },
-    blocks,
-  });
-};
-
-const MESSAGES: Effect.Effect<void, never, DatabaseService | ContextQueueService>[] = [
-  Effect.gen(function* () {
-    const { queue } = yield* ContextQueueService;
-    yield* Effect.promise(() =>
-      queue.append([
-        createMessage('user', [
-          {
-            _tag: 'text',
-            text: faker.lorem.sentence(5),
-          },
-        ]),
-      ]),
-    );
-  }),
-
-  Effect.gen(function* () {
-    const { queue } = yield* ContextQueueService;
-    yield* Effect.promise(() =>
-      queue.append([
-        createMessage('assistant', [
-          {
-            _tag: 'suggest',
-            text: 'Search...',
-          },
-          {
-            _tag: 'suggest',
-            text: faker.lorem.paragraphs(1),
-          },
-        ]),
-        createMessage('assistant', [
-          {
-            _tag: 'text',
-            text: 'Select an option:',
-          },
-          {
-            _tag: 'select',
-            options: ['Option 1', 'Option 2', 'Option 3'],
-          },
-        ]),
-      ]),
-    );
-  }),
-
-  Effect.gen(function* () {
-    const { queue } = yield* ContextQueueService;
-    const { db } = yield* DatabaseService;
-    const obj1 = db.add(Obj.make(DataType.Organization, { name: 'DXOS' }));
-    const obj2 = db.add(Obj.make(DataType.Person, { fullName: 'Alice' }));
-    const obj3 = db.add(Obj.make(DataType.Person, { fullName: 'Bob' }));
-    const obj4 = db.add(Obj.make(DataType.Person, { fullName: 'Charlie' }));
-    yield* Effect.promise(() =>
-      queue.append([
-        createMessage('assistant', [
-          // Inline tag.
-          {
-            _tag: 'text',
-            text: [faker.lorem.paragraph(), renderObjectLink(obj1), faker.lorem.paragraph()].join(' '),
-          },
-          // Inline cards.
-          ...[obj2, obj3, obj4].map(
-            (obj) =>
-              ({
-                _tag: 'text',
-                text: renderObjectLink(obj),
-              }) satisfies ContentBlock.Text,
-          ),
-        ]),
-      ]),
-    );
-  }),
-
-  Effect.gen(function* () {
-    const { queue } = yield* ContextQueueService;
-    yield* Effect.promise(() =>
-      queue.append([
-        createMessage('assistant', [
-          {
-            _tag: 'text',
-            text: faker.lorem.paragraphs(1),
-          },
-          {
-            _tag: 'toolkit',
-          },
-        ]),
-      ]),
-    );
-  }),
-
-  Effect.gen(function* () {
-    const { queue } = yield* ContextQueueService;
-    yield* Effect.promise(() =>
-      queue.append([
-        createMessage('assistant', [
-          {
-            _tag: 'text',
-            disposition: 'cot',
-            text: Array.from({ length: faker.number.int({ min: 3, max: 5 }) })
-              .map((_, idx) => `${idx + 1}. ${faker.lorem.paragraph()}`)
-              .join('\n'),
-          },
-          {
-            _tag: 'toolCall',
-            toolCallId: '1234',
-            name: 'search',
-            input: {},
-          },
-        ]),
-        createMessage('user', [
-          {
-            _tag: 'toolResult',
-            toolCallId: '1234',
-            name: 'search',
-            result: 'This is a tool result.',
-          },
-        ]),
-      ]),
-    );
-  }),
-
-  Effect.gen(function* () {
-    const { queue } = yield* ContextQueueService;
-    yield* Effect.promise(() =>
-      queue.append([
-        createMessage('assistant', [
-          {
-            _tag: 'toolCall',
-            toolCallId: '4567',
-            name: 'create',
-            input: {},
-          },
-        ]),
-        createMessage('user', [
-          {
-            _tag: 'toolResult',
-            toolCallId: '4567',
-            name: 'create',
-            result: 'This is a tool result.',
-          },
-        ]),
-        createMessage('assistant', [
-          {
-            _tag: 'text',
-            text: Array.from({ length: faker.number.int({ min: 2, max: 3 }) })
-              .map(() => faker.lorem.paragraphs())
-              .join('\n\n'),
-          },
-        ]),
-      ]),
-    );
-  }),
-
-  Effect.gen(function* () {
-    const { queue } = yield* ContextQueueService;
-    yield* Effect.promise(() =>
-      queue.append([
-        createMessage('assistant', [
-          {
-            _tag: 'text',
-            text: faker.lorem.paragraphs(2),
-          },
-        ]),
-      ]),
-    );
-  }),
-];
-
 const meta = {
-  title: 'plugins/plugin-assistant/ChatThread',
+  title: 'plugins/plugin-assistant/components/ChatThread',
   component: ChatThread,
-  render: render(StoryContainer),
+  render: DefaultStory,
   decorators: [
-    withClientProvider({
-      createIdentity: true,
-      types: [DataType.Organization, DataType.Person],
-    }),
-    withTheme,
-    withLayout({
-      Container: ColumnContainer,
-      classNames: 'is-[40rem]',
+    withTheme(),
+    withLayout({ layout: 'column' }),
+    withPluginManager({
+      plugins: [
+        ...corePlugins(),
+        StorybookPlugin({}),
+        PreviewPlugin(),
+        ClientPlugin({
+          types: [Organization.Organization, Person.Person],
+          onClientInitialized: ({ client }) =>
+            Effect.gen(function* () {
+              yield* initializeIdentity(client);
+            }),
+        }),
+      ],
     }),
   ],
   parameters: {
+    layout: 'fullscreen',
     translations,
   },
-} satisfies Meta<typeof ChatThread>;
+} satisfies Meta<DefaultStoryProps>;
 
 export default meta;
 
-type Story = StoryObj<typeof meta>;
+type Story = StoryObj<DefaultStoryProps>;
 
-export const Default = {} satisfies Story;
+export const Default: Story = {
+  args: {
+    generator: createMessageGenerator(),
+    wait: true,
+  },
+};
 
-export const Delayed = {
+export const Delayed: Story = {
   args: {
-    delay: 2_000,
+    generator: createMessageGenerator(),
+    delay: 500,
+    options: {
+      autoScroll: true,
+      typewriter: true,
+      cursor: true,
+    },
   },
-} satisfies Story;
+};

package/src/components/ChatThread/ChatThread.tsx

@@ -2,56 +2,121 @@
 // Copyright 2025 DXOS.org
 //
 
-import React, { type CSSProperties, forwardRef, useMemo } from 'react';
+import React, { forwardRef, useCallback, useEffect, useMemo, useRef, useState } from 'react';
 
 import { PublicKey } from '@dxos/keys';
 import { type Identity } from '@dxos/react-client/halo';
-import { type ThemedClassName } from '@dxos/react-ui';
-import { ScrollContainer, type ScrollController } from '@dxos/react-ui-components';
-import { mx } from '@dxos/react-ui-theme';
-import { type DataType } from '@dxos/schema';
+import { type ThemedClassName, setRef } from '@dxos/react-ui';
+import { MarkdownStream, type MarkdownStreamController, type MarkdownStreamProps } from '@dxos/react-ui-markdown';
+import { type Message } from '@dxos/types';
 import { keyToFallback } from '@dxos/util';
 
-import { ChatMessage, type ChatMessageProps } from './ChatMessage';
-import { messageReducer } from './reducer';
+import { type Assistant } from '../../types';
+import { type ChatEvent } from '../Chat';
+import { componentRegistry, createBlockRenderer } from './registry';
+import { MessageSyncer } from './sync';
+
+const defaultOptions: MarkdownStreamProps['options'] = {
+  autoScroll: true,
+  cursor: false,
+  fader: false,
+  typewriter: true,
+};
 
 export type ChatThreadProps = ThemedClassName<
   {
     identity?: Identity;
-    messages?: DataType.Message[];
-    collapse?: boolean;
-  } & Pick<ChatMessageProps, 'debug' | 'space' | 'tools' | 'onEvent'>
+    messages?: Message.Message[];
+    error?: Error;
+    viewType?: Assistant.ChatView;
+    onEvent?: (event: ChatEvent) => void;
+  } & Pick<MarkdownStreamProps, 'options' | 'debug' | 'extensions' | 'footer'>
 >;
 
-export const ChatThread = forwardRef<ScrollController, ChatThreadProps>(
-  ({ classNames, identity, messages, collapse = true, ...props }, forwardedRef) => {
-    const userHue = useMemo(() => {
-      return identity?.profile?.data?.hue || keyToFallback(identity?.identityKey ?? PublicKey.random()).hue;
-    }, [identity]);
-
-    // TODO(dmaretskyi): This needs to be a separate type: `id` is not a valid ObjectId, this needs to accommodate messageId for deletion.
-    const { messages: filteredMessages = [] } = useMemo(() => {
-      if (collapse) {
-        return (messages ?? []).reduce<{ messages: DataType.Message[]; current?: DataType.Message }>(messageReducer, {
-          messages: [],
-        });
-      } else {
-        return { messages: messages ?? [] };
+export const ChatThread = forwardRef<MarkdownStreamController | null, ChatThreadProps>(
+  (
+    {
+      classNames,
+      identity,
+      messages = [],
+      error,
+      options = defaultOptions,
+      footer,
+      debug = false,
+      extensions,
+      viewType,
+      onEvent,
+    },
+    forwardedRef,
+  ) => {
+    const [controller, setController] = useState<MarkdownStreamController | null>(null);
+    const handleMarkdownStreamRef = useCallback(
+      (instance: MarkdownStreamController | null) => {
+        setController(instance);
+        setRef(forwardedRef, instance);
+      },
+      [forwardedRef],
+    );
+
+    const userHue = useMemo(
+      () => identity?.profile?.data?.hue || keyToFallback(identity?.identityKey ?? PublicKey.random()).hue,
+      [identity],
+    );
+
+    // Jump to the bottom instantly when the thread first mounts (e.g. opening the companion);
+    // smooth-scroll only on subsequent error changes.
+    const initializedRef = useRef(false);
+    useEffect(() => {
+      if (!controller) {
+        // MarkdownStream is keyed by viewType; switching views replaces the controller. Reset so
+        // the first scroll for the new controller is instant rather than animated.
+        initializedRef.current = false;
+        return;
       }
-    }, [messages, collapse]);
+      controller.scrollToBottom(initializedRef.current ? 'smooth' : 'instant');
+      initializedRef.current = true;
+    }, [controller, error]);
+
+    // Update document.
+    const renderer = useMemo(() => createBlockRenderer(viewType), [viewType]);
+    const syncer = useMemo(() => controller && new MessageSyncer(controller, renderer), [controller, renderer]);
+    useEffect(() => {
+      if (!syncer) {
+        return;
+      }
+
+      if (syncer.update(messages)) {
+        controller?.scrollToBottom('instant');
+      }
+    }, [controller, syncer, messages]);
+
+    // Event adapter.
+    const handleEvent = useCallback<NonNullable<MarkdownStreamProps['onEvent']>>(
+      ({ type, value }) => {
+        switch (type) {
+          case 'submit': {
+            value && onEvent?.({ type, text: value });
+            break;
+          }
+        }
+      },
+      [onEvent],
+    );
 
     return (
-      <ScrollContainer ref={forwardedRef} classNames={classNames} fade>
-        <div
-          role='none'
-          className={mx('flex flex-col gap-2', filteredMessages.length > 0 && 'pbs-4 pbe-4')}
-          style={{ '--user-fill': `var(--dx-${userHue}Fill)` } as CSSProperties}
-        >
-          {filteredMessages.map((message) => (
-            <ChatMessage key={message.id} message={message} {...props} />
-          ))}
-        </div>
-      </ScrollContainer>
+      <div data-hue={userHue} className='contents'>
+        <MarkdownStream
+          key={viewType}
+          classNames={classNames}
+          registry={componentRegistry}
+          options={options}
+          debug={debug}
+          extensions={extensions}
+          footer={footer}
+          onEvent={handleEvent}
+          ref={handleMarkdownStreamRef}
+        />
+      </div>
     );
   },
 );

package/src/components/ChatThread/DEBUG.md

@@ -0,0 +1,41 @@
+# Dataflow from AI to Codemirror
+
+AiSession (packages/core/assistant/src/conversation/session.ts)
+│
+│ emits ephemeral Trace events containing
+│ PartialBlock { messageId, role, block: ContentBlock.Any }
+│ via AgentService.Session.subscribeEphemeral(): Stream<Trace.Message>
+▼
+AiChatProcessor (packages/plugins/plugin-assistant/src/processor/processor.ts)
+│
+│ Stream.runForEach → if Trace.isOfType(PartialBlock) →
+│ #handleEphemeralMessage(event.data)
+│ → upserts Message.Message into #streaming atom
+│ → finalizes into #messages atom on complete block
+▼
+Chat.tsx (packages/plugins/plugin-assistant/src/components/Chat/Chat.tsx)
+│
+│ reads processor.messages + processor.streaming atoms,
+│ passes flat Message[] down to ChatThread
+▼
+ChatThread.tsx (packages/plugins/plugin-assistant/src/components/ChatThread/ChatThread.tsx)
+│
+│ MessageSyncer (sync.ts) compares current messages
+│ to last rendered set:
+│ - new finalized chunk → controller.append(delta)
+│ - changed earlier message → controller.setContent(full)
+│ blockToMarkdown serializes ContentBlocks → markdown,
+│ embedding tool calls as XML widget tags
+│ (e.g. <tool-call name="...">...</tool-call>)
+▼
+MarkdownStreamController.append / setContent
+▼
+MarkdownStream (packages/ui/react-ui-markdown/src/MarkdownStream/MarkdownStream.tsx)
+│
+│ CodeMirror editor with:
+│ - extendedMarkdown (parseMixed → xmlLanguage on HTMLBlock/Paragraph)
+│ - xmlTags (registry → React/native widget portals)
+│ - wire extension (buffers appended text, drips at typewriter rate,
+│ treats XML atomic ranges as indivisible units)
+▼
+Rendered DOM (markdown + portaled widgets for tool calls / reasoning / etc.)

package/src/components/ChatThread/Link.tsx

@@ -2,38 +2,25 @@
 // Copyright 2025 DXOS.org
 //
 
-import React from 'react';
+import React, { useMemo } from 'react';
 
 import { type Space } from '@dxos/client/echo';
-import { Obj, Ref } from '@dxos/echo';
-import { type DXN } from '@dxos/keys';
-import { mx } from '@dxos/react-ui-theme';
-
-import { useResolvedRef } from '../../hooks';
+import { Entity } from '@dxos/echo';
+import { type URI } from '@dxos/keys';
+import { DxAnchor } from '@dxos/lit-ui/react';
 
 export type ObjectLinkProps = {
   space: Space;
-  dxn: DXN;
+  dxn: URI.URI;
 };
 
-// TODO(burdon): Factor out.
 export const ObjectLink = ({ space, dxn }: ObjectLinkProps) => {
-  const object = useResolvedRef(space, Ref.fromDXN(dxn));
-  const title = Obj.getLabel(object) ?? object?.id ?? dxn.toString();
+  const ref = useMemo(() => space.db.makeRef(dxn), [space, dxn]);
 
+  const title = (ref.target && Entity.getLabel(ref.target)) ?? ref.target?.id ?? ref.uri;
   return (
-    <a
-      // href={dxn.toString()}
-      title={title}
-      className={mx(
-        // TODO(burdon): Use style for tags.
-        'inline-flex items-center max-w-[16rem] px-1.5 overflow-hidden',
-        'border border-separator rounded whitespace-nowrap text-ellipsis text-primary-500 hover:text-primary-500 hover:border-primary-500 cursor-pointer',
-      )}
-      target='_blank'
-      rel='noopener noreferrer'
-    >
-      <span className='truncate'>{title}</span>
-    </a>
+    <DxAnchor rootclassname='dx-tag--anchor' dxn={dxn}>
+      {title}
+    </DxAnchor>
   );
 };