@dxos/plugin-assistant 0.8.4-main.f5c0578 → 0.8.4-main.fcc0d83b33

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

@@ -2,274 +2,142 @@
 // 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 { IntentPlugin } from '@dxos/app-framework';
 import { withPluginManager } from '@dxos/app-framework/testing';
-import { Obj } from '@dxos/echo';
-import { ContextQueueService, DatabaseService } from '@dxos/functions';
+import { ContextQueueService } from '@dxos/compute';
+import { Database } from '@dxos/echo';
+import { runAndForwardErrors } from '@dxos/effect';
 import { ClientPlugin } from '@dxos/plugin-client';
+import { initializeIdentity } from '@dxos/plugin-client/testing';
 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 { StorybookPlugin, corePlugins } from '@dxos/plugin-testing';
+import { random } from '@dxos/random';
+import { type Queue, 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 { translations } from '../../translations';
+import { createMessageGenerator } from '#testing';
+import { translations } from '#translations';
 
-import { renderObjectLink } from './ChatMessage';
 import { ChatThread, type ChatThreadProps } from './ChatThread';
 
-faker.seed(1);
+random.seed(1);
+
+type MessageGenerator = Effect.Effect<void, never, Database.Service | ContextQueueService>;
+
+type DefaultStoryProps = { generator?: MessageGenerator[]; delay?: number; wait?: boolean } & ChatThreadProps;
+
+const DefaultStory = ({ generator = [], delay = 0, wait, ...props }: DefaultStoryProps) => {
+  const [space] = useSpaces();
+  const queue = useMemo<Queue<Message.Message> | undefined>(() => space?.queues.create(), [space]);
+  const messages = useQueueMessages(queue);
+  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) {
       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), ContextQueueService.layer(queue)))),
     );
-  }, [space, queue]);
 
-  if (!space) {
-    return null;
+    return () => {
+      void runAndForwardErrors(Fiber.interrupt(fiber));
+    };
+  }, [space, queue, 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, 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',
-          },
-        ]),
-      ]),
-    );
-  }),
+const useQueueMessages = (queue?: Queue<Message.Message>) => {
+  const [messages, setMessages] = useState<Message.Message[]>([]);
 
-  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.',
-          },
-        ]),
-      ]),
-    );
-  }),
+  useEffect(() => {
+    if (!queue) {
+      setMessages([]);
+      return;
+    }
 
-  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'),
-          },
-        ]),
-      ]),
-    );
-  }),
+    const update = () => setMessages([...queue.objects]);
+    update();
+    return queue.subscribe(update);
+  }, [queue]);
 
-  Effect.gen(function* () {
-    const { queue } = yield* ContextQueueService;
-    yield* Effect.promise(() =>
-      queue.append([
-        createMessage('assistant', [
-          {
-            _tag: 'text',
-            text: faker.lorem.paragraphs(2),
-          },
-        ]),
-      ]),
-    );
-  }),
-];
+  return messages;
+};
 
 const meta = {
-  title: 'plugins/plugin-assistant/ChatThread',
+  title: 'plugins/plugin-assistant/components/ChatThread',
   component: ChatThread,
-  render: render(StoryContainer),
+  render: DefaultStory,
   decorators: [
+    withTheme(),
+    withLayout({ layout: 'column' }),
     withPluginManager({
       plugins: [
+        ...corePlugins(),
+        StorybookPlugin({}),
+        PreviewPlugin(),
         ClientPlugin({
-          onClientInitialized: async ({ client }) => {
-            await client.halo.createIdentity();
-          },
-          types: [DataType.Organization, DataType.Person],
+          types: [Organization.Organization, Person.Person],
+          onClientInitialized: ({ client }) =>
+            Effect.gen(function* () {
+              yield* initializeIdentity(client);
+            }),
         }),
-        ThemePlugin({ tx: defaultTx }),
-        StorybookLayoutPlugin(),
-        IntentPlugin(),
-        PreviewPlugin(),
       ],
     }),
-    withLayout({
-      Container: ColumnContainer,
-      classNames: 'is-[40rem]',
-    }),
   ],
   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,112 @@
 // Copyright 2025 DXOS.org
 //
 
-import React, { type CSSProperties, forwardRef, useMemo } from 'react';
+import React, { forwardRef, useCallback, useEffect, useMemo, 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],
+    );
+
+    // Show error.
+    useEffect(() => {
+      controller?.scrollToBottom();
+    }, [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');
       }
-    }, [messages, collapse]);
+    }, [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 role='none' 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,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 { Entity } 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 && Entity.getLabel(ref.target)) ?? ref.target?.id ?? ref.dxn.toString();
+  return (
+    <DxAnchor rootclassname='dx-tag--anchor' dxn={dxn.toString()}>
+      {title}
+    </DxAnchor>
+  );
 };