@dxos/plugin-assistant 0.8.4-main.dedc0f3 → 0.8.4-main.dfabb4ec29

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

@@ -2,37 +2,42 @@
 // Copyright 2025 DXOS.org
 //
 
-import '@dxos-theme';
-
 import { type Meta, type StoryObj } from '@storybook/react-vite';
-import { Effect, Fiber, Layer } from 'effect';
+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 { 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 { Popover } from '@dxos/react-ui';
-import { PreviewProvider, useRefPopover } from '@dxos/react-ui-editor';
-import { Card } from '@dxos/react-ui-stack';
-import { DataType } from '@dxos/schema';
-import { withLayout, withTheme } from '@dxos/storybook-utils';
+import { withPluginManager } from '@dxos/app-framework/testing';
+import { Database } from '@dxos/echo';
+import { runAndForwardErrors } from '@dxos/effect';
+import { ContextQueueService } from '@dxos/functions';
+import { ClientPlugin } from '@dxos/plugin-client/plugin';
+import { 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 { 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 { createMessageGenerator } from '../../testing';
-import { translations } from '../../translations';
+import { createMessageGenerator } from '#testing';
+import { translations } from '#translations';
 
-import { ChatThread, type ChatThreadController, type ChatThreadProps } from './ChatThread';
+import { ChatThread, type ChatThreadProps } from './ChatThread';
 
-faker.seed(1);
+random.seed(1);
 
-type MessageGenerator = Effect.Effect<void, never, DatabaseService | ContextQueueService>;
+type MessageGenerator = Effect.Effect<void, never, Database.Service | ContextQueueService>;
 
-type StoryProps = ChatThreadProps & { generator?: MessageGenerator[]; delay?: number };
+type DefaultStoryProps = { generator?: MessageGenerator[]; delay?: number; wait?: boolean } & ChatThreadProps;
 
-const DefaultStory = ({ generator = [], delay = 0, ...props }: StoryProps) => {
-  const space = useSpace();
-  const queueDxn = useMemo(() => space?.queues.create().dxn, [space]);
-  const queue = useQueue<DataType.Message>(queueDxn);
+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);
 
   // Generate messages.
   useEffect(() => {
@@ -48,83 +53,91 @@ const DefaultStory = ({ generator = [], delay = 0, ...props }: StoryProps) => {
             yield* Effect.sleep(delay);
           }
         }
-      }).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)))),
     );
 
     return () => {
-      void Effect.runPromise(Fiber.interrupt(fiber));
+      void runAndForwardErrors(Fiber.interrupt(fiber));
     };
-  }, [space, queue, generator]);
+  }, [space, queue, generator, delay]);
 
-  // Set context.
-  const [controller, setController] = useState<ChatThreadController | null>(null);
-  useEffect(() => {
-    // controller?.setContext({ timestamp: Date.now() });
-  }, [controller]);
+  if (wait && !done) {
+    return <Loading data={{ wait, done }} />;
+  }
 
-  // TODO(burdon): Elsewhere PreviewProvider is implemented via the plugin-preview.
   return (
-    <PreviewProvider
-      onLookup={async ({ label, ref }) => {
-        return { label, text: ref };
-      }}
-    >
-      <ChatThread {...props} messages={queue?.objects ?? []} ref={setController} />
-      <PreviewCard />
-    </PreviewProvider>
+    <EditorPreviewProvider onLookup={async ({ dxn, label }) => ({ label, text: dxn })}>
+      <ChatThread {...props} messages={messages} />
+    </EditorPreviewProvider>
   );
 };
 
-// TODO(burdon): Factor out.
-// TODO(burdon): Provide renderer for preview extension.
-const PreviewCard = () => {
-  const { target } = useRefPopover('PreviewCard');
+const useQueueMessages = (queue?: Queue<Message.Message>) => {
+  const [messages, setMessages] = useState<Message.Message[]>([]);
 
-  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>
-  );
+  useEffect(() => {
+    if (!queue) {
+      setMessages([]);
+      return;
+    }
+
+    const update = () => setMessages([...queue.objects]);
+    update();
+    return queue.subscribe(update);
+  }, [queue]);
+
+  return messages;
 };
 
 const meta = {
-  title: 'plugins/plugin-assistant/ChatThread',
+  title: 'plugins/plugin-assistant/components/ChatThread',
   component: ChatThread,
   render: DefaultStory,
   decorators: [
-    withClientProvider({ createIdentity: true, createSpace: true, types: [DataType.Organization, DataType.Person] }),
-    withLayout({ fullscreen: true }),
-    withTheme,
+    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', // TODO(burdon): Replace withLayout.
+    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: Story = {
   args: {
     generator: createMessageGenerator(),
+    wait: true,
   },
 };
 
 export const Delayed: Story = {
   args: {
     generator: createMessageGenerator(),
-    delay: 3_000,
-    fadeIn: true,
-    cursor: false,
+    delay: 500,
+    options: {
+      autoScroll: true,
+      typewriter: true,
+      cursor: true,
+    },
   },
 };

package/src/components/ChatThread/ChatThread.tsx

@@ -2,49 +2,66 @@
 // Copyright 2025 DXOS.org
 //
 
-import React, {
-  type CSSProperties,
-  forwardRef,
-  useCallback,
-  useEffect,
-  useImperativeHandle,
-  useMemo,
-  useState,
-} 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 { 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 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 { type Assistant } from '../../types';
 import { type ChatEvent } from '../Chat';
-
-import { blockToMarkdown, componentRegistry } from './registry';
+import { componentRegistry, createBlockRenderer } from './registry';
 import { MessageSyncer } from './sync';
 
-export type ChatThreadController = Pick<MarkdownStreamController, 'setContext' | 'scrollToBottom'>;
+const defaultOptions: MarkdownStreamProps['options'] = {
+  autoScroll: true,
+  cursor: false,
+  fader: false,
+  typewriter: true,
+};
 
 export type ChatThreadProps = ThemedClassName<
   {
     identity?: Identity;
-    messages?: DataType.Message[];
+    messages?: Message.Message[];
     error?: Error;
+    viewType?: Assistant.ChatView;
     onEvent?: (event: ChatEvent) => void;
-  } & Pick<MarkdownStreamProps, 'cursor' | 'fadeIn'>
+  } & Pick<MarkdownStreamProps, 'options' | 'debug' | 'extensions' | 'footer'>
 >;
 
-export const ChatThread = forwardRef<ChatThreadController | null, ChatThreadProps>(
-  ({ classNames, identity, messages = [], error, cursor = false, fadeIn = true, onEvent }, forwardedRef) => {
-    const userHue = useMemo(() => {
-      return identity?.profile?.data?.hue || keyToFallback(identity?.identityKey ?? PublicKey.random()).hue;
-    }, [identity]);
-
-    // Expose controller.
+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);
-    useImperativeHandle(forwardedRef, () => (controller ? controller : (null as any)), [controller]);
+    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(() => {
@@ -52,21 +69,24 @@ export const ChatThread = forwardRef<ChatThreadController | null, ChatThreadProp
     }, [controller, error]);
 
     // Update document.
-    const syncer = useMemo(() => controller && new MessageSyncer(controller, blockToMarkdown), [controller]);
+    const renderer = useMemo(() => createBlockRenderer(viewType), [viewType]);
+    const syncer = useMemo(() => controller && new MessageSyncer(controller, renderer), [controller, renderer]);
     useEffect(() => {
-      syncer?.sync(messages);
-    }, [syncer, messages]);
+      if (!syncer) {
+        return;
+      }
+
+      if (syncer.update(messages)) {
+        controller?.scrollToBottom('instant');
+      }
+    }, [controller, syncer, messages]);
 
-    // Event handler.
+    // Event adapter.
     const handleEvent = useCallback<NonNullable<MarkdownStreamProps['onEvent']>>(
-      (ev) => {
-        switch (ev.type) {
+      ({ type, value }) => {
+        switch (type) {
           case 'submit': {
-            ev.value &&
-              onEvent?.({
-                type: 'submit',
-                text: ev.value,
-              });
+            value && onEvent?.({ type, text: value });
             break;
           }
         }
@@ -75,17 +95,17 @@ export const ChatThread = forwardRef<ChatThreadController | null, ChatThreadProp
     );
 
     return (
-      <div
-        className={mx('flex bs-full is-full justify-center overflow-hidden', classNames)}
-        style={{ '--user-fill': `var(--dx-${userHue}Fill)` } as CSSProperties}
-      >
+      <div data-hue={userHue} className='contents'>
         <MarkdownStream
-          ref={setController}
-          classNames='bs-full max-is-prose overflow-hidden'
+          key={viewType}
+          classNames={classNames}
           registry={componentRegistry}
-          cursor={cursor}
-          fadeIn={fadeIn}
+          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

@@ -5,7 +5,7 @@
 import React, { useMemo } from 'react';
 
 import { type Space } from '@dxos/client/echo';
-import { Obj } from '@dxos/echo';
+import { Entity } from '@dxos/echo';
 import { type DXN } from '@dxos/keys';
 import { DxAnchor } from '@dxos/lit-ui/react';
 
@@ -15,11 +15,11 @@ export type ObjectLinkProps = {
 };
 
 export const ObjectLink = ({ space, dxn }: ObjectLinkProps) => {
-  const ref = useMemo(() => space.db.ref(dxn), [space, dxn.toString()]);
+  const ref = useMemo(() => space.db.makeRef(dxn), [space, dxn.toString()]);
 
-  const title = Obj.getLabel(ref.target) ?? ref.target?.id ?? ref.dxn.toString();
+  const title = (ref.target && Entity.getLabel(ref.target)) ?? ref.target?.id ?? ref.dxn.toString();
   return (
-    <DxAnchor rootclassname='dx-tag--anchor' refid={dxn.toString()}>
+    <DxAnchor rootclassname='dx-tag--anchor' dxn={dxn.toString()}>
       {title}
     </DxAnchor>
   );