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

package/src/components/ChatPrompt/ChatReferences.tsx

@@ -2,52 +2,47 @@
 // Copyright 2025 DXOS.org
 //
 
-import React, { useCallback } from 'react';
+import React from 'react';
 
-import { type ContextBinder } from '@dxos/assistant';
-import { type Space } from '@dxos/client/echo';
-import { Filter, Obj, Ref } from '@dxos/echo';
-import { type ThemedClassName, useAsyncState, useTranslation } from '@dxos/react-ui';
-import { TagPicker, type TagPickerItemData, type TagPickerOptions } from '@dxos/react-ui-tag-picker';
+import { type AiContextBinder } from '@dxos/assistant';
+import { Obj } from '@dxos/echo';
+import { type Space } from '@dxos/react-client/echo';
+import { IconButton, type Label, type ThemedClassName, toLocalizedString, useTranslation } from '@dxos/react-ui';
 import { mx } from '@dxos/react-ui-theme';
-import { isNonNullable } from '@dxos/util';
 
+import { useContextObjects } from '../../hooks';
 import { meta } from '../../meta';
 
 export type ChatReferencesProps = ThemedClassName<{
+  context: AiContextBinder;
   space: Space;
-  context: ContextBinder;
-  onUpdate?: (ids: string[]) => void;
 }>;
 
-export const ChatReferences = ({ classNames, space, context, onUpdate }: ChatReferencesProps) => {
-  const { t: _t } = useTranslation(meta.id);
-
-  const [items] = useAsyncState<TagPickerItemData[]>(async () => {
-    const objects = await Ref.Array.loadAll(context.objects.value ?? []);
-    return objects.filter(isNonNullable).map((obj) => ({ id: obj.id, label: Obj.getLabel(obj) ?? obj.id }));
-  }, [context]);
-
-  const handleSearch = useCallback<NonNullable<TagPickerOptions['onSearch']>>(
-    (text, ids) => {
-      // TODO(burdon): Filter by Item tag (e.g., exclude "contacts") and Query by object label.
-      // TODO(burdon): Change to Filter.text().
-      const objects = space.db.query(Filter.everything()).runSync();
-      return objects
-        .map(({ object }) => ({ id: object.id, label: Obj.getLabel(object) ?? '' }))
-        .filter(({ id, label }) => !ids.includes(id) && label.toLocaleLowerCase().includes(text.toLocaleLowerCase()));
-    },
-    [space],
-  );
+export const ChatReferences = ({ classNames, context, space }: ChatReferencesProps) => {
+  const { t } = useTranslation(meta.id);
+  const { objects, onUpdateObject } = useContextObjects({ space, context });
 
   return (
-    <TagPicker
-      classNames={mx('h-[1.75rem] text-sm', classNames)}
-      mode='multi-select'
-      // placeholder={t('context objects placeholder')}
-      items={items}
-      onSearch={handleSearch}
-      onUpdate={onUpdate}
-    />
+    <ul className={mx('flex', classNames)}>
+      {objects.map((obj) => {
+        const dxn = Obj.getDXN(obj);
+        const typename = Obj.getTypename(obj);
+        const label: Label = Obj.getLabel(obj) ?? (typename ? ['object name placeholder', { ns: typename }] : obj.id);
+        return (
+          <li key={dxn.toString()} className='dx-tag plb-0 pis-2 flex items-center' data-hue='neutral'>
+            {toLocalizedString(label, t)}
+            <IconButton
+              icon='ph--x--bold'
+              iconOnly
+              variant='ghost'
+              label={t('remove object in context label')}
+              classNames='p-0 hover:bg-transparent'
+              size={3}
+              onClick={() => onUpdateObject?.(dxn, false)}
+            />
+          </li>
+        );
+      })}
+    </ul>
   );
 };

package/src/components/ChatPrompt/ChatStatusIndicator.tsx

@@ -4,36 +4,39 @@
 
 import React, { useEffect, useState } from 'react';
 
-import { Icon, Tooltip, useTimeout } from '@dxos/react-ui';
-import { Spinner } from '@dxos/react-ui-sfx';
-import { errorText } from '@dxos/react-ui-theme';
+import { type ThemedClassName, Tooltip, useTimeout } from '@dxos/react-ui';
+import { Spinner, type SpinnerProps } from '@dxos/react-ui-sfx';
+import { mx } from '@dxos/react-ui-theme';
 
-export type ChatStatusIndicatorProps = {
-  preset?: string;
-  error?: Error;
-  processing?: boolean;
-};
+const period = 3_000;
+
+export type ChatStatusIndicatorProps = ThemedClassName<
+  {
+    preset?: string;
+    processing?: boolean;
+    error?: Error;
+  } & Pick<SpinnerProps, 'size' | 'onClick'>
+>;
 
-export const ChatStatusIndicator = ({ preset, error, processing }: ChatStatusIndicatorProps) => {
+export const ChatStatusIndicator = ({ classNames, preset, processing, error, ...props }: ChatStatusIndicatorProps) => {
   const [init, setInit] = useState(false);
-  useEffect(() => {
-    setInit(false);
-  }, [preset]);
+  useEffect(() => setInit(false), [preset]);
   useTimeout(
     async () => {
       setInit(true);
     },
-    1_500,
+    period / 2,
     [preset],
   );
 
-  if (error) {
-    return (
-      <Tooltip.Trigger content={error.message} delayDuration={0}>
-        <Icon icon='ph--warning-circle--regular' classNames={errorText} size={5} />
-      </Tooltip.Trigger>
-    );
-  }
-
-  return <Spinner state={!init ? 'flash' : processing ? 'spin' : 'pulse'} />;
+  return (
+    <div role='none' className={mx('relative flex', classNames)}>
+      <Spinner duration={period} state={!init ? 'flash' : error ? 'error' : processing ? 'spin' : 'pulse'} {...props} />
+      {error && (
+        <Tooltip.Trigger asChild content={error.message}>
+          <div className='absolute inset-0' />
+        </Tooltip.Trigger>
+      )}
+    </div>
+  );
 };

package/src/components/ChatPrompt/index.ts

@@ -3,7 +3,7 @@
 //
 
 export * from './ChatActions';
-export * from './ChatOptionsMenu';
+export * from './ChatOptions';
 export * from './ChatPresets';
 export * from './ChatReferences';
 export * from './ChatStatusIndicator';

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

@@ -2,142 +2,147 @@
 // Copyright 2025 DXOS.org
 //
 
-import '@dxos-theme';
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+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 { type StoryObj, type Meta } from '@storybook/react-vite';
-import React, { useEffect, useState } from 'react';
-
-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 { DataType, type ContentBlock } from '@dxos/schema';
-import { ColumnContainer, withLayout, withTheme } from '@dxos/storybook-utils';
-
-import { ChatThread } from './ChatThread';
+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 { ChatThread, type ChatThreadProps } from './ChatThread';
+import { componentRegistry } from './registry';
+import TEXT from './testing/thread.md?raw';
+
 faker.seed(1);
 
-const createMessage = (role: DataType.ActorRole, blocks: ContentBlock.Any[]): DataType.Message => {
-  return Obj.make(DataType.Message, {
-    created: new Date().toISOString(),
-    sender: { role },
-    blocks,
-  });
+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<Message.Message>(queueDxn);
+  const [done, setDone] = useState(false);
+
+  // Generate messages.
+  useEffect(() => {
+    if (!space || !queue) {
+      return;
+    }
+
+    const fiber = Effect.runFork(
+      Effect.gen(function* () {
+        for (const step of generator) {
+          yield* step;
+          if (delay) {
+            yield* Effect.sleep(delay);
+          }
+        }
+        setDone(true);
+      }).pipe(Effect.provide(Layer.mergeAll(DatabaseService.layer(space.db), ContextQueueService.layer(queue)))),
+    );
+
+    return () => {
+      void Effect.runPromise(Fiber.interrupt(fiber));
+    };
+  }, [space, queue, generator]);
+
+  if (wait && !done) {
+    return null;
+  }
+
+  return (
+    <EditorPreviewProvider onLookup={async ({ label, ref }) => ({ label, text: ref })}>
+      <ChatThread {...props} messages={queue?.objects} />
+      <PreviewCard />
+    </EditorPreviewProvider>
+  );
 };
 
-const TEST_MESSAGES: DataType.Message[] = [
-  createMessage('user', [
-    {
-      _tag: 'text',
-      text: faker.lorem.sentence(5),
-    } satisfies ContentBlock.Text,
-  ]),
-
-  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: 'text',
-      text: Array.from({ length: faker.number.int({ min: 2, max: 5 }) })
-        .map(() => faker.lorem.paragraphs())
-        .join('\n\n'),
-    },
-    {
-      _tag: 'toolCall',
-      toolCallId: '1234',
-      name: 'search',
-      input: {},
-    } satisfies ContentBlock.ToolCall,
-  ]),
-
-  createMessage('user', [
-    {
-      _tag: 'toolResult',
-      toolCallId: '1234',
-      name: 'search',
-      result: 'This is a tool result.',
-    } satisfies ContentBlock.ToolResult,
-  ]),
-
-  createMessage('assistant', [
-    {
-      _tag: 'toolCall',
-      toolCallId: '4567',
-      name: 'create',
-      input: {},
-    } satisfies ContentBlock.ToolCall,
-  ]),
-
-  createMessage('user', [
-    {
-      _tag: 'toolResult',
-      toolCallId: '4567',
-      name: 'create',
-      result: 'This is a tool result.',
-    } satisfies ContentBlock.ToolResult,
-  ]),
-
-  createMessage('assistant', [
-    {
-      _tag: 'text',
-      text: faker.lorem.paragraphs(1),
-    } satisfies ContentBlock.Text,
-  ]),
-
-  createMessage('assistant', [
-    {
-      _tag: 'json',
-      disposition: 'suggest',
-      data: JSON.stringify({ text: 'Search...' }),
-    },
-    {
-      _tag: 'json',
-      disposition: 'suggest',
-      data: JSON.stringify({ text: faker.lorem.paragraphs(1) }),
-    } satisfies ContentBlock.Json,
-  ]),
-];
+const PreviewCard = () => {
+  const { target } = useEditorPreview('PreviewCard');
+
+  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,
-  decorators: [withClientProvider({ createIdentity: true }), withTheme, withLayout({ Container: ColumnContainer })],
+  render: render(DefaultStory),
+  decorators: [
+    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 = {
+export const Default: Story = {
   args: {
-    messages: TEST_MESSAGES,
+    generator: createMessageGenerator(),
+    wait: true,
   },
-} satisfies Story;
-
-export const Incremental = {
-  render: () => {
-    const [messages, setMessages] = useState<DataType.Message[]>([]);
-    useEffect(() => {
-      let i = 0;
-      const interval = setInterval(() => {
-        setMessages((messages) => [...messages, TEST_MESSAGES[i++]]);
-        if (i >= TEST_MESSAGES.length) {
-          clearInterval(interval);
-        }
-      }, 2_000);
-
-      return () => clearInterval(interval);
-    }, []);
+};
 
-    return <ChatThread messages={messages} collapse />;
+export const Delayed: Story = {
+  args: {
+    generator: createMessageGenerator(),
+    delay: 1_000,
+    fadeIn: true,
+    cursor: false,
   },
-} satisfies Story;
+};
+
+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,56 +2,86 @@
 // Copyright 2025 DXOS.org
 //
 
-import React, { type CSSProperties, forwardRef, useMemo } from 'react';
+import React, { type CSSProperties, forwardRef, useCallback, useEffect, useMemo } 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 { 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 { ChatMessage, type ChatMessageProps } from './ChatMessage';
-import { messageReducer } from './reducer';
+import { type ChatEvent } from '../Chat';
+
+import { blockToMarkdown, componentRegistry } from './registry';
+import { MessageSyncer } from './sync';
 
 export type ChatThreadProps = ThemedClassName<
   {
     identity?: Identity;
-    messages?: DataType.Message[];
-    collapse?: boolean;
-  } & Pick<ChatMessageProps, 'debug' | 'space' | 'processor' | 'tools' | 'onEvent'>
+    messages?: Message.Message[];
+    error?: Error;
+    onEvent?: (event: ChatEvent) => void;
+  } & Pick<MarkdownStreamProps, 'cursor' | 'fadeIn' | 'debug'>
 >;
 
-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 ?? [] };
+// 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(() => {
+      controller?.scrollToBottom();
+    }, [controller, error]);
+
+    // Update document.
+    const syncer = useMemo(() => controller && new MessageSyncer(controller, blockToMarkdown), [controller]);
+    useEffect(() => {
+      const reset = syncer?.append(messages, true);
+      if (reset) {
+        controller?.scrollToBottom('instant');
       }
-    }, [messages, collapse]);
+    }, [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(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'
+        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

@@ -0,0 +1,26 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React, { useMemo } from 'react';
+
+import { type Space } from '@dxos/client/echo';
+import { Obj } from '@dxos/echo';
+import { type DXN } from '@dxos/keys';
+import { DxAnchor } from '@dxos/lit-ui/react';
+
+export type ObjectLinkProps = {
+  space: Space;
+  dxn: DXN;
+};
+
+export const ObjectLink = ({ space, dxn }: ObjectLinkProps) => {
+  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>
+  );
+};