@dxos/plugin-assistant 0.8.3 → 0.8.4-main.1068cf700f

package/src/components/ChatThread/registry.tsx

@@ -0,0 +1,174 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React from 'react';
+
+import { log } from '@dxos/log';
+import { ToggleContainer } from '@dxos/react-ui-components';
+import {
+  PromptWidget,
+  ReferenceWidget,
+  SelectWidget,
+  SuggestionWidget,
+  SummaryWidget,
+} from '@dxos/react-ui-components';
+import { Json } from '@dxos/react-ui-syntax-highlighter';
+import { ContentBlock, type Message } from '@dxos/types';
+import { type XmlWidgetProps, type XmlWidgetRegistry, getXmlTextChild } from '@dxos/ui-editor';
+
+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>
+  );
+};
+
+/**
+ * Custom XML tags registry.
+ */
+export const componentRegistry: XmlWidgetRegistry = {
+  //
+  // Widgets
+  //
+
+  ['prompt' as const]: {
+    block: true,
+    factory: ({ children }) => {
+      const text = getXmlTextChild(children);
+      return text ? new PromptWidget(text) : null;
+    },
+  },
+  ['reference' as const]: {
+    block: false,
+    factory: ({ children, ref }) => {
+      const text = getXmlTextChild(children);
+      return text && ref ? new ReferenceWidget(text, ref) : null;
+    },
+  },
+  ['select' as const]: {
+    block: true,
+    factory: ({ children }) => {
+      const options = children
+        ?.map((option: any) => option._tag === 'option' && getXmlTextChild(option.children))
+        .filter(Boolean);
+      return options?.length ? new SelectWidget(options) : null;
+    },
+  },
+  ['suggestion' as const]: {
+    block: true,
+    factory: ({ children }) => {
+      const text = getXmlTextChild(children);
+      return text ? new SuggestionWidget(text) : null;
+    },
+  },
+  ['summary' as const]: {
+    block: true,
+    factory: ({ children }) => {
+      const text = getXmlTextChild(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: Message.Message,
+  block: ContentBlock.Any,
+) => {
+  let str = blockToMarkdownImpl(context, message, block);
+  if (str && !block.pending) {
+    return (str += '\n');
+  }
+
+  return str;
+};
+
+const blockToMarkdownImpl = (context: MessageThreadContext, message: Message.Message, block: ContentBlock.Any) => {
+  log('blockToMarkdown', { block: JSON.stringify(block) });
+  switch (block._tag) {
+    case 'text': {
+      if (message.sender.role === 'user') {
+        return `<prompt>${block.text}</prompt>`;
+      } else {
+        const text = block.text.trim();
+        if (text.length > 0) {
+          return text;
+        }
+      }
+      break;
+    }
+    case 'reference': {
+      const dxn = block.reference.dxn;
+      return `<reference ref="${dxn.toString()}">${context.getObjectLabel(dxn)}</reference>`;
+    }
+    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>`;
+    }
+    case 'toolCall': {
+      context.updateWidget<{ blocks: ContentBlock.Any[] }>(block.toolCallId, {
+        blocks: [block],
+      });
+      return `<toolCall id="${block.toolCallId}" />`;
+    }
+    case 'toolResult': {
+      context.updateWidget<{ blocks: ContentBlock.Any[] }>(block.toolCallId, ({ blocks = [] }) => ({
+        blocks: [...blocks, block],
+      }));
+      break;
+    }
+    case 'summary': {
+      return `<summary>${ContentBlock.createSummaryMessage(block)}</summary>`;
+    }
+    default: {
+      // TODO(burdon): Needs stable ID.
+      return `<json id="${message.id}">\n${JSON.stringify(block)}\n</json>`;
+    }
+  }
+};

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

@@ -0,0 +1,97 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { EditorView } from '@codemirror/view';
+import { describe, it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+
+import { Obj } from '@dxos/echo';
+import { type Mutable } from '@dxos/echo/internal';
+import { type ContentBlock } from '@dxos/types';
+
+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 view() {
+    return this._view;
+  }
+
+  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.append(messages);
+      expect(doc.content).toEqual(['<prompt>Hello</prompt>', 'Hi there!', ''].join('\n'));
+
+      Obj.change(messages[1], (m) => {
+        m.blocks.push({ _tag: 'text', text: 'How can I help?' });
+      });
+      syncer.append(messages);
+      expect(doc.content).toEqual(['<prompt>Hello</prompt>', '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.append(messages);
+      expect(doc.content).toEqual(['<prompt>Hello</prompt>', 'Hi there!'].join('\n'));
+
+      Obj.change(messages[1], (m) => {
+        const block = m.blocks[0] as Mutable<ContentBlock.Text>;
+        block.text = 'Hi there! How are you?';
+        block.pending = false;
+      });
+      syncer.append(messages);
+
+      Obj.change(messages[1], (m) => {
+        m.blocks.push({ _tag: 'text', text: 'How can I help?' });
+      });
+      syncer.append(messages);
+      expect(doc.content).toEqual(
+        ['<prompt>Hello</prompt>', 'Hi there! How are you?', 'How can I help?', ''].join('\n'),
+      );
+    }),
+  );
+});

package/src/components/ChatThread/sync.ts

@@ -0,0 +1,154 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type DXN } from '@dxos/echo';
+import { log } from '@dxos/log';
+import { type MarkdownStreamController } from '@dxos/react-ui-components';
+import { type ContentBlock, type Message } from '@dxos/types';
+import { type StateDispatch, type XmlWidgetStateManager } from '@dxos/ui-editor';
+
+/**
+ * Update document.
+ */
+export type TextModel = Pick<MarkdownStreamController, 'view' | '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: StateDispatch<T>) {
+    this._widgetState?.updateWidget(id, value);
+  }
+
+  // TODO(burdon): Resolve from hypergraph.
+  getObjectLabel(_id: DXN) {
+    return 'Object';
+  }
+}
+
+/**
+ * Renders a block to markdown.
+ */
+export type BlockRenderer = (
+  context: MessageThreadContext,
+  message: Message.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('');
+  }
+
+  /**
+   * Syncs messages with the editor.
+   */
+  append(messages: Message.Message[], flush = false): boolean {
+    // Check if new set of messages.
+    if (this._initialMessageId !== messages[0]?.id) {
+      this.reset();
+      this._initialMessageId = messages[0]?.id;
+    }
+
+    if (flush && this._model.view?.state.doc.length === 0) {
+      const buffer: string[] = [];
+      this.process(messages, (content) => {
+        buffer.push(content);
+      });
+
+      const content = buffer.join('');
+      this._model.view?.dispatch({
+        changes: [
+          {
+            from: 0,
+            to: this._model.view?.state.doc.length ?? 0,
+            insert: content,
+          },
+        ],
+        selection: { anchor: content.length },
+      });
+
+      return true;
+    } else {
+      this.process(messages, (content) => {
+        void this._model.append(content);
+      });
+
+      return false;
+    }
+  }
+
+  private process(messages: Message.Message[], append: (content: string) => void) {
+    log('sync', {
+      doc: this._model.view?.state.doc.length,
+      messages: messages.map((message) => message.blocks.length),
+      currentMessageIndex: this._currentMessageIndex,
+      currentBlockIndex: this._currentBlockIndex,
+      currentBlockContent: this._currentBlockContent,
+    });
+
+    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;
+          }
+
+          log('append', { message: i, block: j, content });
+          this._currentBlockContent = currentBlockContent;
+          append(content);
+        }
+
+        if (block.pending) {
+          return;
+        } else {
+          this._currentBlockContent = undefined;
+          this._currentBlockIndex++;
+        }
+        j++;
+      }
+      i++;
+    }
+  }
+}

package/src/components/ChatThread/testing/thread.md

@@ -0,0 +1,37 @@
+<prompt>hi</prompt>
+Hi! I'm Kai, your AI assistant powered by DXOS. I see you have a document in your context. Let me take a look at it to see how I can help you.
+<toolCall id="toolu_012MB5XWrQhsyjUBoBCr7jXB" />
+
+<summary>OK (1 tool uses · 2.62k tokens · 4.8s)</summary>
+I can see you have a comprehensive welcome document for Composer by DXOS. This document explains what Composer is - an extensible collaborative application with features like documents, diagrams, tables, and sheets.
+
+Here are some suggestions based on what's available:
+<suggestion>Create a new document</suggestion>
+<suggestion>Edit the welcome document</suggestion>
+<suggestion>Create a table to organize information</suggestion>
+<suggestion>Create a sketch for diagrams</suggestion>
+<suggestion>Learn about collaboration features</suggestion>
+
+Is there something specific you'd like to do with this document or would you like to explore other features of Composer?
+
+<summary>OK (3.91k tokens · 7.0s)</summary>
+<prompt>Create a table to organize information</prompt>
+I'll help you create a table to organize information. Let me check what table creation tools are available.
+<toolCall id="toolu_01Gk8ZNGYQEczAjGkbDZ9n1D" />
+<summary>OK (1 tool uses · 3.99k tokens · 3.4s)</summary>
+I need to check what artifact definitions are available for creating tables. Based on the blueprint instructions, I should first query for available artifact definitions to see what table-related tools I can use.
+
+However, I notice that the function definitions provided don't include the artifact-related tools mentioned in the blueprint (like `require_artifact_definitions` or table creation tools). The available functions are focused on document operations (open, diff, add-to-context, open-item) and analysis mode.
+
+Let me work with what's available. Since I can't directly create a table artifact with the current tools, I can help you create a table structure within a markdown document instead.
+
+Would you like me to:
+
+1. Create a simple markdown table structure in a new document that you can use to organize your information?
+2. Or would you prefer to use Composer's built-in Tables plugin (as mentioned in the welcome document) by creating one through the Composer interface?
+
+What kind of information are you looking to organize? This will help me suggest the best table structure for your needs.
+<toolCall id="toolu_01CQXUsyLw2uoV3k1mPLqFee" />
+
+<summary>OK (1 tool uses · 4.28k tokens · 11.1s)</summary>
+<summary>OK (4.30k tokens · 1.6s)</summary>