@dxos/plugin-assistant 0.8.3 → 0.8.4-main.1f223c7

package/src/components/ChatThread/ChatThread.tsx

@@ -0,0 +1,93 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React, {
+  type CSSProperties,
+  forwardRef,
+  useCallback,
+  useEffect,
+  useImperativeHandle,
+  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 { keyToFallback } from '@dxos/util';
+
+import { type ChatEvent } from '../Chat';
+
+import { blockToMarkdown, componentRegistry } from './registry';
+import { MessageSyncer } from './sync';
+
+export type ChatThreadController = Pick<MarkdownStreamController, 'setContext' | 'scrollToBottom'>;
+
+export type ChatThreadProps = ThemedClassName<
+  {
+    identity?: Identity;
+    messages?: DataType.Message[];
+    error?: Error;
+    onEvent?: (event: ChatEvent) => void;
+  } & Pick<MarkdownStreamProps, 'cursor' | 'fadeIn'>
+>;
+
+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.
+    const [controller, setController] = useState<MarkdownStreamController | null>(null);
+    useImperativeHandle(forwardedRef, () => (controller ? controller : (null as any)), [controller]);
+
+    // Show error.
+    useEffect(() => {
+      controller?.scrollToBottom();
+    }, [controller, error]);
+
+    // Update document.
+    const syncer = useMemo(() => controller && new MessageSyncer(controller, blockToMarkdown), [controller]);
+    useEffect(() => {
+      syncer?.sync(messages);
+    }, [syncer, messages]);
+
+    // Event handler.
+    const handleEvent = useCallback<NonNullable<MarkdownStreamProps['onEvent']>>(
+      (ev) => {
+        switch (ev.type) {
+          case 'submit': {
+            ev.value &&
+              onEvent?.({
+                type: 'submit',
+                text: ev.value,
+              });
+            break;
+          }
+        }
+      },
+      [onEvent],
+    );
+
+    return (
+      <div
+        className={mx('flex bs-full is-full justify-center overflow-hidden', classNames)}
+        style={{ '--user-fill': `var(--dx-${userHue}Fill)` } as CSSProperties}
+      >
+        <MarkdownStream
+          ref={setController}
+          classNames='bs-full max-is-prose overflow-hidden'
+          registry={componentRegistry}
+          cursor={cursor}
+          fadeIn={fadeIn}
+          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.ref(dxn), [space, dxn.toString()]);
+
+  const title = 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/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './ChatThread';

package/src/components/ChatThread/reducers.ts

@@ -0,0 +1,151 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type ContentBlock, type DataType } from '@dxos/schema';
+
+type Reducer<R, I> = (acc: R, value: I, idx: number) => R;
+
+/**
+ * Reducer that collapses related message blocks into single messages.
+ * For example, combines tool request/response pairs into a single message.
+ *
+ * Typical order:
+ * - message 0
+ *  - text
+ * - message 1
+ *  - text
+ *  - toolCall
+ *  - summary
+ * - message 2
+ *  - toolResult
+ * - message 3
+ *  - text
+ *  - summary
+ *
+ * Coverts to:
+ * - message 0
+ *  - text
+ * - message 1
+ *  - text
+ * - message 2
+ *  - toolCall
+ *  - toolResult
+ *  - summary
+ * - message 3
+ *  - text
+ *  - summary
+ */
+export const reduceMessages: Reducer<
+  {
+    messages: DataType.Message[];
+    current?: DataType.Message;
+    toolBlock?: boolean;
+    assistantMessages?: DataType.Message[];
+  },
+  DataType.Message
+> = ({ messages, current, toolBlock, assistantMessages = [] }, message) => {
+  // Treat tool calls as assistant messages.
+  let assistant = message?.sender.role === 'assistant';
+  let i = 0;
+  for (const block of message.blocks) {
+    switch (block._tag) {
+      // TODO(burdon): Preserve call tool title.
+      case 'toolCall': {
+        assistant = true;
+        if (!toolBlock) {
+          current = {
+            ...message,
+            id: [message.id, i++].join('_'),
+            blocks: [block],
+          };
+          messages.push(current);
+          toolBlock = true;
+        } else {
+          current!.blocks.push(block);
+        }
+        break;
+      }
+
+      case 'toolResult': {
+        assistant = true;
+        if (toolBlock) {
+          current!.blocks.push(block);
+        }
+        break;
+      }
+
+      case 'summary': {
+        assistant = true;
+        if (toolBlock) {
+          current!.blocks.push(block);
+        } else {
+          const summary = reduceSummary([...assistantMessages, message]);
+          current!.blocks.push(summary);
+        }
+        break;
+      }
+
+      default: {
+        assistant = message.sender.role === 'assistant';
+        current = {
+          ...message,
+          id: [message.id, i++].join('_'),
+          blocks: [block],
+        };
+        messages.push(current);
+        toolBlock = false;
+        break;
+      }
+    }
+  }
+
+  return {
+    messages,
+    current,
+    toolBlock,
+    assistantMessages: assistant ? [...assistantMessages, message] : undefined,
+  };
+};
+
+/**
+ * Accumulate token counts from all summary blocks in pending messages.
+ */
+const reduceSummary = (messages: DataType.Message[]): ContentBlock.Summary => {
+  let start: number | undefined;
+  return messages.reduce<ContentBlock.Summary>(
+    (acc, msg) => {
+      const time = new Date(msg.created).getTime();
+      if (!start) {
+        start = time;
+      }
+      msg.blocks.forEach((block) => {
+        switch (block._tag) {
+          case 'toolCall': {
+            acc.toolCalls = (acc.toolCalls ?? 0) + 1;
+            break;
+          }
+          case 'summary': {
+            acc.model = block.model;
+            if (block.usage) {
+              acc.message = block.message;
+              acc.usage = {
+                inputTokens: (acc.usage?.inputTokens ?? 0) + (block.usage.inputTokens ?? 0),
+                outputTokens: (acc.usage?.outputTokens ?? 0) + (block.usage.outputTokens ?? 0),
+                totalTokens: (acc.usage?.totalTokens ?? 0) + (block.usage.totalTokens ?? 0),
+              };
+              acc.duration = time - (start ?? time);
+            }
+            break;
+          }
+        }
+      });
+
+      return acc;
+    },
+    {
+      _tag: 'summary',
+      duration: 0,
+    } satisfies ContentBlock.Summary,
+  );
+};

package/src/components/ChatThread/registry.tsx

@@ -0,0 +1,189 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React from 'react';
+
+import { log } from '@dxos/log';
+import {
+  PromptWidget,
+  ReferenceWidget,
+  SelectWidget,
+  SuggestionWidget,
+  SummaryWidget,
+  ToggleContainer,
+} from '@dxos/react-ui-components';
+import { type XmlWidgetProps, type XmlWidgetRegistry } from '@dxos/react-ui-editor';
+import { Json } from '@dxos/react-ui-syntax-highlighter';
+import { ContentBlock, type DataType } from '@dxos/schema';
+
+import { ToolBlock } from '../ToolBlock';
+
+import { type BlockRenderer, type MessageThreadContext } from './sync';
+
+const Fallback = ({ _tag, ...props }: XmlWidgetProps<MessageThreadContext>) => {
+  return (
+    <ToggleContainer.Root classNames='rounded-sm'>
+      <ToggleContainer.Header classNames='bg-groupSurface'>{_tag}</ToggleContainer.Header>
+      <ToggleContainer.Content classNames='bg-modalSurface'>
+        <Json classNames='!p-2 text-sm' data={props} />
+      </ToggleContainer.Content>
+    </ToggleContainer.Root>
+  );
+};
+
+const getTextChild = (children: any[]): string | null => {
+  const child = children?.[0];
+  return typeof child === 'string' ? child : null;
+};
+
+/**
+ * Custom XML tags registry.
+ */
+export const componentRegistry: XmlWidgetRegistry = {
+  //
+  // Widgets
+  //
+
+  ['prompt' as const]: {
+    block: true,
+    factory: (props) => {
+      const text = getTextChild(props.children);
+      return text ? new PromptWidget(text) : null;
+    },
+  },
+  ['reference' as const]: {
+    block: false,
+    factory: (props) => {
+      const text = getTextChild(props.children);
+      return text && props.ref ? new ReferenceWidget(text, props.ref) : null;
+    },
+  },
+  ['select' as const]: {
+    block: true,
+    factory: (props) => {
+      const options = props.children
+        ?.map((option: any) => option._tag === 'option' && getTextChild(option.children))
+        .filter(Boolean);
+      return options?.length ? new SelectWidget(options) : null;
+    },
+  },
+  ['suggestion' as const]: {
+    block: true,
+    factory: (props) => {
+      const text = getTextChild(props.children);
+      return text ? new SuggestionWidget(text) : null;
+    },
+  },
+  ['summary' as const]: {
+    block: true,
+    factory: (props) => {
+      const text = getTextChild(props.children);
+      return text ? new SummaryWidget(text) : null;
+    },
+  },
+
+  //
+  // React
+  //
+
+  ['toolCall' as const]: {
+    block: true,
+    Component: ToolBlock,
+  },
+  ['toolResult' as const]: {
+    block: true,
+    Component: Fallback,
+  },
+  ['toolkit' as const]: {
+    block: true,
+    Component: Fallback,
+  },
+
+  //
+  // Fallback
+  //
+
+  ['json' as const]: {
+    block: true,
+    Component: Fallback,
+  },
+};
+
+/**
+ * Convert block to markdown.
+ */
+export const blockToMarkdown: BlockRenderer = (
+  context: MessageThreadContext,
+  message: DataType.Message,
+  block: ContentBlock.Any,
+) => {
+  let str = _blockToMarkdown(context, message, block);
+  if (str && !block.pending) {
+    return (str += '\n');
+  }
+
+  return str;
+};
+
+const _blockToMarkdown = (context: MessageThreadContext, message: DataType.Message, block: ContentBlock.Any) => {
+  log('blockToMarkdown', { block: JSON.stringify(block) });
+  switch (block._tag) {
+    case 'text': {
+      if (message.sender.role === 'user') {
+        return `\n<prompt>${block.text}</prompt>\n`;
+      } else {
+        const text = block.text.trim();
+        if (text.length > 0) {
+          return text;
+        }
+      }
+      break;
+    }
+
+    case 'suggestion': {
+      if (block.pending) {
+        return;
+      }
+      return `<suggestion>${block.text}</suggestion>`;
+    }
+    case 'select': {
+      if (block.pending || block.options.length === 0) {
+        return;
+      }
+
+      return `<select>${block.options.map((option) => `<option>${option}</option>`).join('')}</select>`;
+    }
+
+    // TODO(burdon): Need label.
+    case 'reference': {
+      return `<reference ref="${block.reference.dxn.toString()}">Ref</reference>`;
+    }
+
+    // case 'toolkit': {
+    //   return `<toolkit />`;
+    // }
+
+    case 'toolCall': {
+      context.updateWidget(block.toolCallId, {
+        blocks: [block],
+      });
+      return `<toolCall id="${block.toolCallId}" />`;
+    }
+    case 'toolResult': {
+      context.updateWidget(block.toolCallId, ({ blocks = [] }: { blocks: ContentBlock.Any[] }) => ({
+        blocks: [...blocks, block],
+      }));
+      break;
+    }
+
+    case 'summary': {
+      return `<summary>${ContentBlock.createSummaryMessage(block)}</summary>`;
+    }
+
+    // TODO(burdon): Need stable ID.
+    default: {
+      return `<json id="${message.id}">\n${JSON.stringify(block)}\n</json>`;
+    }
+  }
+};

package/src/components/ChatThread/sync.test.ts

@@ -0,0 +1,81 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { EditorView } from '@codemirror/view';
+import { describe, it } from '@effect/vitest';
+import { Effect } from 'effect';
+
+import { type ContentBlock } from '@dxos/schema';
+
+import { createMessage } from '../../testing';
+
+import { blockToMarkdown } from './registry';
+import { MessageSyncer, type TextModel } from './sync';
+
+class TestDocument implements TextModel {
+  private readonly _view = new EditorView({ extensions: [] });
+
+  get content() {
+    return this._view.state.doc.toString();
+  }
+
+  async reset(text: string) {
+    this._view.dispatch({ changes: { from: 0, to: this._view.state.doc.length, insert: text } });
+  }
+
+  async append(text: string) {
+    this._view.dispatch({ changes: { from: this._view.state.doc.length, insert: text } });
+  }
+
+  updateWidget(_id: string, _value: any) {}
+}
+
+describe('reducers', () => {
+  it.effect(
+    'basic sync',
+    Effect.fn(function* ({ expect }) {
+      const doc = new TestDocument();
+      const syncer = new MessageSyncer(doc, blockToMarkdown);
+
+      const messages = [
+        createMessage('user', [{ _tag: 'text', text: 'Hello' }]),
+        createMessage('assistant', [{ _tag: 'text', text: 'Hi there!' }]),
+      ];
+
+      syncer.sync(messages);
+      expect(doc.content).toEqual(['\n<prompt>Hello</prompt>\n', 'Hi there!', ''].join('\n'));
+
+      messages[1].blocks.push({ _tag: 'text', text: 'How can I help?' });
+      syncer.sync(messages);
+      expect(doc.content).toEqual(['\n<prompt>Hello</prompt>\n', 'Hi there!', 'How can I help?', ''].join('\n'));
+    }),
+  );
+
+  it.effect(
+    'sync with partial updates',
+    Effect.fn(function* ({ expect }) {
+      const doc = new TestDocument();
+      const syncer = new MessageSyncer(doc, blockToMarkdown);
+
+      const messages = [
+        createMessage('user', [{ _tag: 'text', text: 'Hello' }]),
+        createMessage('assistant', [{ _tag: 'text', text: 'Hi there!', pending: true }]),
+      ];
+
+      syncer.sync(messages);
+      expect(doc.content).toEqual(['\n<prompt>Hello</prompt>\n', 'Hi there!'].join('\n'));
+
+      const block = messages[1].blocks[0] as ContentBlock.Text;
+      block.text = 'Hi there! How are you?';
+      block.pending = false;
+      syncer.sync(messages);
+
+      messages[1].blocks.push({ _tag: 'text', text: 'How can I help?' });
+      syncer.sync(messages);
+      expect(doc.content).toEqual(
+        ['\n<prompt>Hello</prompt>\n', 'Hi there! How are you?', 'How can I help?', ''].join('\n'),
+      );
+    }),
+  );
+});

package/src/components/ChatThread/sync.ts

@@ -0,0 +1,113 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { log } from '@dxos/log';
+import { type MarkdownStreamController } from '@dxos/react-ui-components';
+import { type XmlWidgetStateManager } from '@dxos/react-ui-editor';
+import { type ContentBlock, type DataType } from '@dxos/schema';
+
+/**
+ * Update document.
+ */
+export type TextModel = Pick<MarkdownStreamController, 'reset' | 'append' | 'updateWidget'>;
+
+/**
+ * Thread context passed to renderer.
+ */
+export class MessageThreadContext implements Pick<MarkdownStreamController, 'updateWidget'> {
+  constructor(private readonly _widgetState?: XmlWidgetStateManager) {}
+
+  updateWidget<T>(id: string, value: T) {
+    this._widgetState?.updateWidget(id, value);
+  }
+}
+
+/**
+ * Renders a block to markdown.
+ */
+export type BlockRenderer = (
+  context: MessageThreadContext,
+  message: DataType.Message,
+  block: ContentBlock.Any,
+) => string | undefined;
+
+/**
+ * Syncs messages with the editor.
+ */
+export class MessageSyncer {
+  private _initialMessageId?: string;
+  private _currentMessageIndex = 0;
+  private _currentBlockIndex = 0;
+  private _currentBlockContent?: string;
+
+  private readonly _context: MessageThreadContext;
+
+  constructor(
+    private readonly _model: TextModel,
+    private readonly _blockRenderer: BlockRenderer,
+  ) {
+    this._context = new MessageThreadContext(this._model);
+  }
+
+  get context() {
+    return this._context;
+  }
+
+  reset() {
+    log('reset');
+    this._initialMessageId = undefined;
+    this._currentMessageIndex = 0;
+    this._currentBlockIndex = 0;
+    this._currentBlockContent = undefined;
+    void this._model.reset('');
+  }
+
+  sync(messages: DataType.Message[]) {
+    log('sync', {
+      messages: messages.map((m) => m.blocks.length),
+      currentMessageIndex: this._currentMessageIndex,
+      currentBlockIndex: this._currentBlockIndex,
+      currentBlockContent: this._currentBlockContent,
+    });
+    if (this._initialMessageId !== messages[0]?.id) {
+      this.reset();
+      this._initialMessageId = messages[0]?.id;
+    }
+
+    let i = this._currentMessageIndex;
+    for (const message of messages.slice(this._currentMessageIndex)) {
+      if (i > this._currentMessageIndex) {
+        this._currentBlockIndex = 0;
+      }
+
+      this._currentMessageIndex = i;
+      let j = this._currentBlockIndex;
+      for (const block of message.blocks.slice(this._currentBlockIndex)) {
+        this._currentBlockIndex = j;
+        const currentBlockContent = this._blockRenderer(this._context, message, block);
+        if (currentBlockContent) {
+          let content: string = '';
+          if (this._currentBlockContent && currentBlockContent.startsWith(this._currentBlockContent)) {
+            content = currentBlockContent.slice(this._currentBlockContent.length);
+          } else {
+            content = currentBlockContent;
+          }
+
+          void this._model.append(content);
+          this._currentBlockContent = currentBlockContent;
+          log('append', { message: i, block: j, content });
+        }
+
+        if (block.pending) {
+          return;
+        } else {
+          this._currentBlockContent = undefined;
+          this._currentBlockIndex++;
+        }
+        j++;
+      }
+      i++;
+    }
+  }
+}