@dxos/plugin-assistant 0.8.4-main.5ea62a8 → 0.8.4-main.66e292d

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

@@ -2,282 +2,147 @@
 // 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, { type CSSProperties, useEffect, useMemo, useState } from 'react';
 
-import { IntentPlugin } from '@dxos/app-framework';
-import { withPluginManager } from '@dxos/app-framework/testing';
-import { Obj } from '@dxos/echo';
 import { ContextQueueService, DatabaseService } from '@dxos/functions';
-import { ClientPlugin } from '@dxos/plugin-client';
-import { PreviewPlugin } from '@dxos/plugin-preview';
-import { StorybookLayoutPlugin } from '@dxos/plugin-storybook-layout';
-import { ThemePlugin } from '@dxos/plugin-theme';
 import { faker } from '@dxos/random';
 import { useQueue, useSpace } from '@dxos/react-client/echo';
-import { defaultTx } from '@dxos/react-ui-theme';
-import { type ContentBlock, DataType } from '@dxos/schema';
-import { ColumnContainer, render, withLayout } from '@dxos/storybook-utils';
-
+import { withClientProvider } from '@dxos/react-client/testing';
+import { Popover } from '@dxos/react-ui';
+import { withLayout, withTheme } from '@dxos/react-ui/testing';
+import { MarkdownStream } from '@dxos/react-ui-components';
+import { EditorPreviewProvider, useEditorPreview } from '@dxos/react-ui-editor';
+import { Card } from '@dxos/react-ui-stack';
+import { render } from '@dxos/storybook-utils';
+import { type Message, Organization, Person } from '@dxos/types';
+
+import { createMessageGenerator } from '../../testing';
 import { translations } from '../../translations';
 
-import { renderObjectLink } from './ChatMessage';
 import { ChatThread, type ChatThreadProps } from './ChatThread';
+import { componentRegistry } from './registry';
+import TEXT from './testing/thread.md?raw';
 
 faker.seed(1);
 
-const StoryContainer = ({ delay = 0, ...props }: ChatThreadProps & { delay?: number }) => {
+type MessageGenerator = Effect.Effect<void, never, DatabaseService | ContextQueueService>;
+
+type StoryProps = { generator?: MessageGenerator[]; delay?: number; wait?: boolean } & ChatThreadProps;
+
+const DefaultStory = ({ generator = [], delay = 0, wait, ...props }: StoryProps) => {
   const space = useSpace();
   const queueDxn = useMemo(() => space?.queues.create().dxn, [space]);
-  const queue = useQueue<DataType.Message>(queueDxn);
+  const queue = useQueue<Message.Message>(queueDxn);
+  const [done, setDone] = useState(false);
+
+  // Generate messages.
   useEffect(() => {
     if (!space || !queue) {
       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;
+        setDone(true);
       }).pipe(Effect.provide(Layer.mergeAll(DatabaseService.layer(space.db), ContextQueueService.layer(queue)))),
     );
-  }, [space, queue]);
 
-  if (!space) {
+    return () => {
+      void Effect.runPromise(Fiber.interrupt(fiber));
+    };
+  }, [space, queue, generator]);
+
+  if (wait && !done) {
     return null;
   }
 
   return (
-    <ChatThread {...props} space={space} messages={queue?.objects ?? []} onEvent={(event) => console.log(event)} />
+    <EditorPreviewProvider onLookup={async ({ label, ref }) => ({ label, text: ref })}>
+      <ChatThread {...props} messages={queue?.objects} />
+      <PreviewCard />
+    </EditorPreviewProvider>
   );
 };
 
-const createMessage = (role: DataType.ActorRole, blocks: ContentBlock.Any[]): DataType.Message => {
-  return Obj.make(DataType.Message, {
-    created: new Date().toISOString(),
-    sender: { role },
-    blocks,
-  });
-};
+const PreviewCard = () => {
+  const { target } = useEditorPreview('PreviewCard');
 
-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: 'suggestion',
-            text: 'Search...',
-          },
-          {
-            _tag: 'suggestion',
-            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, true),
-              }) 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: JSON.stringify({}),
-          },
-        ]),
-        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: JSON.stringify({}),
-          },
-        ]),
-        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),
-          },
-        ]),
-      ]),
-    );
-  }),
-];
+  return (
+    <Popover.Portal>
+      <Popover.Content onOpenAutoFocus={(event) => event.preventDefault()}>
+        <Popover.Viewport>
+          <Card.SurfaceRoot role='card--popover'>
+            <Card.Heading>{target?.label}</Card.Heading>
+            {target && <Card.Text classNames='truncate line-clamp-3'>{target.text}</Card.Text>}
+          </Card.SurfaceRoot>
+        </Popover.Viewport>
+        <Popover.Arrow />
+      </Popover.Content>
+    </Popover.Portal>
+  );
+};
 
 const meta = {
   title: 'plugins/plugin-assistant/ChatThread',
   component: ChatThread,
-  render: render(StoryContainer),
+  render: render(DefaultStory),
   decorators: [
-    withPluginManager({
-      plugins: [
-        ClientPlugin({
-          onClientInitialized: async ({ client }) => {
-            await client.halo.createIdentity();
-          },
-          types: [DataType.Organization, DataType.Person],
-        }),
-        ThemePlugin({ tx: defaultTx }),
-        StorybookLayoutPlugin(),
-        IntentPlugin(),
-        PreviewPlugin(),
-      ],
-    }),
-    withLayout({
-      Container: ColumnContainer,
-      classNames: 'is-[40rem]',
+    withTheme,
+    withLayout({ container: 'column' }),
+    withClientProvider({
+      createIdentity: true,
+      createSpace: true,
+      types: [Organization.Organization, Person.Person],
     }),
   ],
   parameters: {
+    layout: 'fullscreen',
     translations,
   },
-} satisfies Meta<typeof ChatThread>;
+} satisfies Meta<StoryProps>;
 
 export default meta;
 
-type Story = StoryObj<typeof meta>;
+type Story = StoryObj<StoryProps>;
 
-export const Default: Story = {};
+export const Default: Story = {
+  args: {
+    generator: createMessageGenerator(),
+    wait: true,
+  },
+};
 
 export const Delayed: Story = {
   args: {
-    delay: 2_000,
+    generator: createMessageGenerator(),
+    delay: 1_000,
+    fadeIn: true,
+    cursor: false,
   },
 };
 
-export const Sanity = () => {
-  return (
-    <div className='grid grow place-items-center'>
-      <div className='p-8 border border-separator rounded'>DXOS</div>
+export const Raw: Story = {
+  render: () => (
+    <div className='contents' style={{ '--user-fill': 'var(--dx-amberFill)' } as CSSProperties}>
+      <MarkdownStream content={TEXT} />
     </div>
-  );
+  ),
+};
+
+export const Static: Story = {
+  render: () => (
+    <div className='contents' style={{ '--user-fill': 'var(--dx-amberFill)' } as CSSProperties}>
+      <MarkdownStream content={TEXT} registry={componentRegistry} />
+    </div>
+  ),
 };

package/src/components/ChatThread/ChatThread.tsx

@@ -2,78 +2,86 @@
 // Copyright 2025 DXOS.org
 //
 
-import React, { type CSSProperties, Fragment, forwardRef, useEffect, useMemo } from 'react';
+import React, { type CSSProperties, forwardRef, useCallback, useEffect, useMemo } from 'react';
 
-import { invariant } from '@dxos/invariant';
 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 { type ThemedClassName, useForwardedRef } from '@dxos/react-ui';
+import { MarkdownStream, type MarkdownStreamController, type MarkdownStreamProps } from '@dxos/react-ui-components';
 import { mx } from '@dxos/react-ui-theme';
-import { type DataType } from '@dxos/schema';
+import { type Message } from '@dxos/types';
 import { keyToFallback } from '@dxos/util';
 
-import { ChatError, ChatMessage, type ChatMessageProps, styles } from './ChatMessage';
-import { reduceMessages } from './reducers';
+import { type ChatEvent } from '../Chat';
+
+import { blockToMarkdown, componentRegistry } from './registry';
+import { MessageSyncer } from './sync';
 
 export type ChatThreadProps = ThemedClassName<
   {
     identity?: Identity;
-    messages?: DataType.Message[];
+    messages?: Message.Message[];
     error?: Error;
-  } & Pick<ChatMessageProps, 'debug' | 'space' | 'toolProvider' | 'onEvent'>
+    onEvent?: (event: ChatEvent) => void;
+  } & Pick<MarkdownStreamProps, 'cursor' | 'fadeIn' | 'debug'>
 >;
 
-export const ChatThread = forwardRef<ScrollController, ChatThreadProps>(
-  ({ classNames, identity, messages = [], error, debug, onEvent, ...props }, forwardedRef) => {
-    const userHue = useMemo(() => {
-      return identity?.profile?.data?.hue || keyToFallback(identity?.identityKey ?? PublicKey.random()).hue;
-    }, [identity]);
+// TODO(burdon): Memo thread position.
+export const ChatThread = forwardRef<MarkdownStreamController, ChatThreadProps>(
+  (
+    { classNames, identity, messages = [], error, cursor = false, fadeIn = true, debug = false, onEvent },
+    forwardedRef,
+  ) => {
+    const controllerRef = useForwardedRef(forwardedRef);
+    const controller = controllerRef.current;
+
+    const userHue = useMemo(
+      () => identity?.profile?.data?.hue || keyToFallback(identity?.identityKey ?? PublicKey.random()).hue,
+      [identity],
+    );
 
     // Show error.
     useEffect(() => {
-      onEvent?.({ type: 'scroll-to-bottom' });
-    }, [error]);
+      controller?.scrollToBottom();
+    }, [controller, error]);
 
-    // Reduce messages to collapse related blocks.
-    const reducedMessages = useMemo(() => {
-      if (!debug) {
-        return messages.reduce(reduceMessages, { messages: [] }).messages;
-      } else {
-        return messages;
+    // Update document.
+    const syncer = useMemo(() => controller && new MessageSyncer(controller, blockToMarkdown), [controller]);
+    useEffect(() => {
+      const reset = syncer?.append(messages, true);
+      if (reset) {
+        controller?.scrollToBottom('instant');
       }
-    }, [messages, debug]);
+    }, [syncer, messages]);
 
-    const getDelta = (idx: number) => {
-      invariant(idx > 0);
-      const prev = new Date(reducedMessages[idx - 1].created).getTime();
-      const current = new Date(reducedMessages[idx].created).getTime();
-      return current - prev;
-    };
+    // Event adapter.
+    const handleEvent = useCallback<NonNullable<MarkdownStreamProps['onEvent']>>(
+      ({ type, value }) => {
+        switch (type) {
+          case 'submit': {
+            value && onEvent?.({ type, text: value });
+            break;
+          }
+        }
+      },
+      [onEvent],
+    );
 
     return (
-      <ScrollContainer.Root pin fade ref={forwardedRef} classNames={classNames}>
-        <ScrollContainer.Content
-          classNames='relative flex flex-col gap-2 pbs-2 pbe-2'
-          style={{ '--user-fill': `var(--dx-${userHue}Fill)` } as CSSProperties}
-        >
-          {reducedMessages.map((message, idx) => (
-            <Fragment key={message.id}>
-              {debug && (
-                <div className={mx('flex justify-end text-subdued', styles.margin)}>
-                  <pre className='text-xs'>
-                    {JSON.stringify({ created: message.created, delta: idx > 0 ? getDelta(idx) : undefined })}
-                  </pre>
-                </div>
-              )}
-              <ChatMessage message={message} debug={debug} onEvent={onEvent} {...props} />
-            </Fragment>
-          ))}
-
-          {error && <ChatError error={error} onEvent={onEvent} />}
-        </ScrollContainer.Content>
-        <ScrollContainer.ScrollDownButton />
-      </ScrollContainer.Root>
+      <div
+        role='none'
+        className={mx('flex bs-full is-full justify-center overflow-hidden', classNames)}
+        style={{ '--user-fill': `var(--dx-${userHue}Fill)` } as CSSProperties}
+      >
+        <MarkdownStream
+          ref={controllerRef}
+          registry={componentRegistry}
+          cursor={cursor}
+          fadeIn={fadeIn}
+          debug={debug}
+          onEvent={handleEvent}
+        />
+      </div>
     );
   },
 );

package/src/components/ChatThread/Link.tsx

@@ -2,14 +2,12 @@
 // 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 { Obj } from '@dxos/echo';
 import { type DXN } from '@dxos/keys';
-import { DxRefTag } from '@dxos/lit-ui/react';
-
-import { useResolvedRef } from '../../hooks';
+import { DxAnchor } from '@dxos/lit-ui/react';
 
 export type ObjectLinkProps = {
   space: Space;
@@ -17,7 +15,12 @@ export type ObjectLinkProps = {
 };
 
 export const ObjectLink = ({ space, dxn }: ObjectLinkProps) => {
-  const object = useResolvedRef(space, Ref.fromDXN(dxn));
-  const title = Obj.getLabel(object) ?? object?.id ?? dxn.toString();
-  return <DxRefTag refid={dxn.toString()}>{title}</DxRefTag>;
+  const ref = useMemo(() => space.db.makeRef(dxn), [space, dxn.toString()]);
+
+  const title = (ref.target && Obj.getLabel(ref.target)) ?? ref.target?.id ?? ref.dxn.toString();
+  return (
+    <DxAnchor rootclassname='dx-tag--anchor' refid={dxn.toString()}>
+      {title}
+    </DxAnchor>
+  );
 };

package/src/components/ChatThread/reducers.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type ContentBlock, type DataType } from '@dxos/schema';
+import { type ContentBlock, type Message } from '@dxos/types';
 
 type Reducer<R, I> = (acc: R, value: I, idx: number) => R;
 
@@ -38,12 +38,12 @@ type Reducer<R, I> = (acc: R, value: I, idx: number) => R;
  */
 export const reduceMessages: Reducer<
   {
-    messages: DataType.Message[];
-    current?: DataType.Message;
+    messages: Message.Message[];
+    current?: Message.Message;
     toolBlock?: boolean;
-    assistantMessages?: DataType.Message[];
+    assistantMessages?: Message.Message[];
   },
-  DataType.Message
+  Message.Message
 > = ({ messages, current, toolBlock, assistantMessages = [] }, message) => {
   // Treat tool calls as assistant messages.
   let assistant = message?.sender.role === 'assistant';
@@ -111,7 +111,7 @@ export const reduceMessages: Reducer<
 /**
  * Accumulate token counts from all summary blocks in pending messages.
  */
-const reduceSummary = (messages: DataType.Message[]): ContentBlock.Summary => {
+const reduceSummary = (messages: Message.Message[]): ContentBlock.Summary => {
   let start: number | undefined;
   return messages.reduce<ContentBlock.Summary>(
     (acc, msg) => {