@dxos/plugin-assistant 0.8.4-main.937b3ca → 0.8.4-main.9be5663bfe

package/src/components/ChatThread/registry.tsx

@@ -5,56 +5,55 @@
 import React from 'react';
 
 import { log } from '@dxos/log';
-import { ToggleContainer } from '@dxos/react-ui-components';
+import { ContentBlock, type Message } from '@dxos/types';
+import { type XmlWidgetRegistry, getXmlTextChild } from '@dxos/ui-editor';
+
+import { type BlockRenderer, type MessageThreadContext } from './sync';
+import { applyToolBlockToWidgetState } from './tool-widget-state';
 import {
+  FallbackWidget,
   PromptWidget,
+  ReasoningWidget,
   ReferenceWidget,
   SelectWidget,
   SuggestionWidget,
+  StatsWidget,
   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>
-  );
-};
+  ToolWidget,
+  StatusWidget,
+} from './widgets';
 
 /**
  * Custom XML tags registry.
  */
 export const componentRegistry: XmlWidgetRegistry = {
   //
-  // Widgets
+  // DOM Widgets
   //
 
-  ['prompt' as const]: {
+  prompt: {
     block: true,
     factory: ({ children }) => {
       const text = getXmlTextChild(children);
       return text ? new PromptWidget(text) : null;
     },
   },
-  ['reference' as const]: {
+  reasoning: {
+    block: true,
+    streaming: true,
+    factory: ({ children, range }) => {
+      const text = getXmlTextChild(children);
+      return text ? new ReasoningWidget(text, range.from) : null;
+    },
+  },
+  reference: {
     block: false,
     factory: ({ children, ref }) => {
       const text = getXmlTextChild(children);
       return text && ref ? new ReferenceWidget(text, ref) : null;
     },
   },
-  ['select' as const]: {
+  select: {
     block: true,
     factory: ({ children }) => {
       const options = children
@@ -63,45 +62,61 @@ export const componentRegistry: XmlWidgetRegistry = {
       return options?.length ? new SelectWidget(options) : null;
     },
   },
-  ['suggestion' as const]: {
+  suggestion: {
     block: true,
     factory: ({ children }) => {
       const text = getXmlTextChild(children);
       return text ? new SuggestionWidget(text) : null;
     },
   },
-  ['summary' as const]: {
+  stats: {
     block: true,
     factory: ({ children }) => {
       const text = getXmlTextChild(children);
-      return text ? new SummaryWidget(text) : null;
+      return text ? new StatsWidget(text) : null;
+    },
+  },
+  status: {
+    block: true,
+    streaming: true,
+    factory: ({ children, range }) => {
+      const text = getXmlTextChild(children);
+      return text ? new StatusWidget(text, range.from) : null;
     },
   },
 
   //
-  // React
+  // React Widgets (portaled outside of the editor)
   //
 
-  ['toolCall' as const]: {
+  summary: {
+    block: true,
+    Component: SummaryWidget,
+  },
+  toolCall: {
     block: true,
-    Component: ToolBlock,
+    Component: (props) => (
+      <div role='none' className='py-2'>
+        <ToolWidget {...props} />
+      </div>
+    ),
   },
-  ['toolResult' as const]: {
+  toolResult: {
     block: true,
-    Component: Fallback,
+    Component: FallbackWidget,
   },
-  ['toolkit' as const]: {
+  toolkit: {
     block: true,
-    Component: Fallback,
+    Component: FallbackWidget,
   },
 
   //
   // Fallback
   //
 
-  ['json' as const]: {
+  json: {
     block: true,
-    Component: Fallback,
+    Component: FallbackWidget,
   },
 };
 
@@ -135,40 +150,89 @@ const blockToMarkdownImpl = (context: MessageThreadContext, message: Message.Mes
       }
       break;
     }
+
     case 'reference': {
+      if (block.pending) {
+        return;
+      }
       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],
-      });
+      applyToolBlockToWidgetState(context, block);
       return `<toolCall id="${block.toolCallId}" />`;
     }
+
     case 'toolResult': {
-      context.updateWidget<{ blocks: ContentBlock.Any[] }>(block.toolCallId, ({ blocks = [] }) => ({
-        blocks: [...blocks, block],
-      }));
+      // TODO(dmaretskyi): the parameter could be undefined, perhaps tool blocks are not arriving in order.
+      applyToolBlockToWidgetState(context, block);
       break;
     }
+
+    case 'stats': {
+      return '';
+    }
+
+    case 'reasoning': {
+      let text = block.reasoningText ?? block.redactedText;
+      if (!text) {
+        return;
+      }
+      return renderXMLBlock('reasoning', { content: text, pending: block.pending });
+    }
+
     case 'summary': {
-      return `<summary>${ContentBlock.createSummaryMessage(block)}</summary>`;
+      return renderXMLBlock('summary', { content: block.content, pending: block.pending });
+    }
+
+    case 'status': {
+      return renderXMLBlock('status', { content: block.statusText, pending: block.pending });
     }
+
     default: {
       // TODO(burdon): Needs stable ID.
       return `<json id="${message.id}">\n${JSON.stringify(block)}\n</json>`;
     }
   }
 };
+
+/**
+ * Escape text embedded in generated XML so the mixed XML parser does not treat `&`, `<`, `>` as markup.
+ */
+const escapeXmlTextContent = (raw: string): string =>
+  raw.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+
+/**
+ * Strip actual list-marker prefixes without removing meaningful leading content.
+ */
+const stripBulletLikeLinePrefixes = (raw: string): string =>
+  raw
+    .split(/\r?\n/)
+    .map((line) => line.replace(/^\s*(?:[-*+•]|\d+[.)]\s)/, ''))
+    .join('\n');
+
+const renderXMLBlock = (tag: string, opts: { content?: string; pending?: boolean; attributes?: string }) => {
+  // Replace paragraph breaks so that markdown parser does not split the content into multiple paragraphs.
+  const content = escapeXmlTextContent(stripBulletLikeLinePrefixes((opts.content ?? '').replace(/\n\n/g, ' ').trim()));
+
+  if (opts.pending) {
+    return `<${tag}${opts.attributes ? ` ${opts.attributes}` : ''}>${content}`;
+  } else {
+    return `<${tag}${opts.attributes ? ` ${opts.attributes}` : ''}>${content}</${tag}>`;
+  }
+};

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

@@ -1,3 +1,5 @@
+// @vitest-environment jsdom
+
 //
 // Copyright 2025 DXOS.org
 //
@@ -7,9 +9,10 @@ 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 { createMessage } from '#testing';
 
 import { blockToMarkdown } from './registry';
 import { MessageSyncer, type TextModel } from './sync';
@@ -17,15 +20,15 @@ import { MessageSyncer, type TextModel } from './sync';
 class TestDocument implements TextModel {
   private readonly _view = new EditorView({ extensions: [] });
 
-  get view() {
-    return this._view;
+  get length() {
+    return this._view.state.doc.length;
   }
 
   get content() {
     return this._view.state.doc.toString();
   }
 
-  async reset(text: string) {
+  async setContent(text: string) {
     this._view.dispatch({
       changes: { from: 0, to: this._view.state.doc.length, insert: text },
     });
@@ -55,8 +58,8 @@ describe('reducers', () => {
       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?' });
+      Obj.change(messages[1], (obj) => {
+        obj.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'));
@@ -77,15 +80,15 @@ describe('reducers', () => {
       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 ContentBlock.Text;
+      Obj.change(messages[1], (obj) => {
+        const block = obj.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?' });
+      Obj.change(messages[1], (obj) => {
+        obj.blocks.push({ _tag: 'text', text: 'How can I help?' });
       });
       syncer.append(messages);
       expect(doc.content).toEqual(

package/src/components/ChatThread/sync.ts

@@ -8,10 +8,12 @@ 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';
 
+import { rehydrateToolWidgetsFromMessages } from './tool-widget-state';
+
 /**
  * Update document.
  */
-export type TextModel = Pick<MarkdownStreamController, 'view' | 'reset' | 'append' | 'updateWidget'>;
+export type TextModel = Pick<MarkdownStreamController, 'length' | 'setContent' | 'append' | 'updateWidget'>;
 
 /**
  * Thread context passed to renderer.
@@ -42,6 +44,7 @@ export type BlockRenderer = (
  * Syncs messages with the editor.
  */
 export class MessageSyncer {
+  #syncEpoch = 0;
   private _initialMessageId?: string;
   private _currentMessageIndex = 0;
   private _currentBlockIndex = 0;
@@ -50,10 +53,10 @@ export class MessageSyncer {
   private readonly _context: MessageThreadContext;
 
   constructor(
-    private readonly _model: TextModel,
-    private readonly _blockRenderer: BlockRenderer,
+    private readonly _document: TextModel,
+    private readonly _renderer: BlockRenderer,
   ) {
-    this._context = new MessageThreadContext(this._model);
+    this._context = new MessageThreadContext(this._document);
   }
 
   get context() {
@@ -62,59 +65,67 @@ export class MessageSyncer {
 
   reset() {
     log('reset');
+    this.#syncEpoch++;
     this._initialMessageId = undefined;
     this._currentMessageIndex = 0;
     this._currentBlockIndex = 0;
     this._currentBlockContent = undefined;
-    void this._model.reset('');
+    void this._document.setContent('');
   }
 
   /**
    * Syncs messages with the editor.
    */
   append(messages: Message.Message[], flush = false): boolean {
+    // TODO(dmaretskyi): MarkdownStream currently does not support streaming XML tags, so we need to remove pending non-text blocks.
+    // messages = messages.map((message) => ({
+    //   ...message,
+    //   blocks: message.blocks.filter((block) => !block.pending || block._tag === 'text'),
+    // }));
+
     // 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) {
+    if (this._document.length === 0 && flush) {
       const buffer: string[] = [];
-      this.process(messages, (content) => {
-        buffer.push(content);
-      });
-
+      this.processBlocks(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 },
-      });
+      // `setContent` dispatches `xmlTagResetEffect`, which clears widget props accumulated during
+      // `processBlocks`; re-apply tool state after the document is replaced.
+      const epoch = this.#syncEpoch;
+      void this._document
+        .setContent(content)
+        .then(() => {
+          if (epoch !== this.#syncEpoch) {
+            return;
+          }
+          rehydrateToolWidgetsFromMessages(this._context, messages);
+        })
+        .catch((error) => {
+          log.warn('failed to replace thread content before widget rehydration', { error });
+        });
 
       return true;
     } else {
-      this.process(messages, (content) => {
-        void this._model.append(content);
+      this.processBlocks(messages, (content) => {
+        void this._document.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,
-    });
+  private processBlocks(messages: Message.Message[], append: (content: string) => void) {
+    // console.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)) {
@@ -126,7 +137,7 @@ export class MessageSyncer {
       let j = this._currentBlockIndex;
       for (const block of message.blocks.slice(this._currentBlockIndex)) {
         this._currentBlockIndex = j;
-        const currentBlockContent = this._blockRenderer(this._context, message, block);
+        const currentBlockContent = this._renderer(this._context, message, block);
         if (currentBlockContent) {
           let content: string = '';
           if (this._currentBlockContent && currentBlockContent.startsWith(this._currentBlockContent)) {
@@ -135,7 +146,7 @@ export class MessageSyncer {
             content = currentBlockContent;
           }
 
-          log('append', { message: i, block: j, content });
+          // console.log('append', { message: i, block: j, content });
           this._currentBlockContent = currentBlockContent;
           append(content);
         }

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

@@ -0,0 +1,21 @@
+<prompt>create a project to track what I order online based on my emails, dont asak me questions</prompt>
+<reasoning>The user wants me to create a project that tracks their online orders based on emails. They don't want me to ask questions - just go ahead and create it. Let me first get the project rules and query for available mailboxes/inboxes.</reasoning>
+<status>Getting the project rules and finding your mailboxes to set this up...</status>
+<toolCall id="toolu_01QJcUw8RZDyemLdvMe8nSGZ" />
+<toolCall id="toolu_01JJZrCc17JqV5r36aR9wcaj" />
+<toolCall id="toolu_012r3VQFxvWZ9UmKxMNiJP48" />
+<reasoning>The mailbox query failed. Let me try a different approach to find mailboxes. Let me also enable the inbox blueprint to find mailboxes, and create the Order schema first. Let me first search for mailboxes with a different query approach.</reasoning>
+<status>Looking for your mailboxes...</status>
+<toolCall id="toolu_01P4ekwYwYJfxUnGFPHNhcCu" />
+<toolCall id="toolu_017NHbtinMDcjmwqN6vLaNQp" />
+<reasoning>I found the mailbox with DXN `dxn:echo:B6ON2Y6HN4KLJWZD75VUUDCUQ552ERQSG:01KNHKXSWWCBZX6TCPMF1M0PDE`. Now I need to: 1. Create an Order schema for tracking online orders 2. Create the project with the right blueprints and subscriptions Let me first create the Order schema, then create the project.</reasoning>
+<status>Found your mailbox. Now creating an Order schema and setting up the project...</status>
+<toolCall id="toolu_01Gk4RcfdB4ttzsVN9mnatWn" />
+<status>Order schema created. Now creating the project...</status>
+<toolCall id="toolu_01QmJcua6jmRx15wnxo5bkNQ" />
+<reasoning>The service isn't available. Let me try again.</reasoning>
+<status>Encountered a temporary service issue. Retrying...</status>
+<toolCall id="toolu_01X4CVxXuBjgW2JESGUEsm6f" />
+<reasoning>The service seems to be temporarily unavailable. Let me try once more.</reasoning>
+<toolCall id="toolu_01S9vi1pMnwqUuxNpe5FU731" />
+Got the project created. Let me know if you need anything else.

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

@@ -0,0 +1,30 @@
+<prompt>What is markdown?</prompt>
+
+<reasoning>
+The user is asking me to think deeply about what markdown is.
+
+But given the context of our conversation - we've been trying to scrape slab data from a website - I think they might be hinting at something specific.
+</reasoning>
+
+### Markdown
+
+Markdown is a lightweight markup language used to format plain text in a simple and readable way.
+
+It allows you to create structured documents using conventions for headings, lists, emphasis (bold/italic), links, images, code, blockquotes, tables, and horizontal rules.
+
+Markdown documents look like this
+
+```
+# Markdown
+
+This is a plain text.
+```
+
+Composer supports extended components via XML tags.
+
+<summary>
+The user asked about Markdown.
+
+We responded with a summary.
+
+</summary>

package/src/components/ChatThread/testing/{thread.md → thread-2.md}

@@ -35,3 +35,22 @@ What kind of information are you looking to organize? This will help me suggest
 
 <summary>OK (1 tool uses · 4.28k tokens · 11.1s)</summary>
 <summary>OK (4.30k tokens · 1.6s)</summary>
+
+<reasoning>Based on the rules, this is similar to the "Parcel tracking" example. I should: 1. First create an Order schema 2. Query for mailboxes to subscribe to 3. Query for available blueprints 4. Create the project Let me first ask a couple of qualifying questions, then proceed. Actually, the example is pretty clear - let me set things up. But first let me check for mailboxes and blueprints. Let me query for mailboxes and blueprints in parallel.</reasoning>
+
+<reasoning>I found a mailbox at `dxn:echo:B6ON2Y6HN4KLJWZD75VUUDCUQ552ERQSG:01KNHKXSWWCBZX6TCPMF1M0PDE`. Now I have everything I need to create the CRM project. The project should:
+
+1. Subscribe to the mailbox
+2. Use database, web-search, and browser blueprints
+3. Extract People and Organizations from emails
+4. Research contacts on the web
+5. Save to database avoiding duplicates
+6. Now I'm building the project structure to tie all these components together.</reasoning>
+
+<reasoning>I found the mailbox. Now I have all the information I need to create the CRM project. Let me create it with the appropriate blueprints and subscription to the mailbox. The project should:
+
+- Subscribe to the mailbox
+- On every email, extract People and Organizations
+- Save them to the database (checking for duplicates first)
+- Run web searches to enrich contact/org data
+- Blueprints needed: database, web-search, browser</reasoning>

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

@@ -0,0 +1,79 @@
+<prompt>Analyze this codebase and suggest improvements.</prompt>
+
+<reasoning>
+The user wants a comprehensive analysis of their codebase. I should examine the project structure, identify key patterns, and look for areas that could be improved. Let me start by reviewing the main source files and dependencies.
+</reasoning>
+
+I'll start by examining the project structure and key files.
+
+<toolCall id="toolu_01ABC123analyze" />
+
+<summary>Analyzed 42 files across 8 packages. Found 3 areas for improvement.</summary>
+
+Here's what I found after reviewing the codebase:
+
+## Architecture
+
+The project follows a modular plugin architecture with clear separation of concerns. Each plugin manages its own state and communicates through a shared event bus.
+
+## Suggested Improvements
+
+1. **Type Safety** — Several utility functions use `any` types that could be narrowed. This would catch bugs at compile time rather than runtime.
+
+2. **Error Handling** — The API layer could benefit from structured error types using discriminated unions instead of thrown exceptions.
+
+3. **Performance** — The subscription handlers in the data layer create new closures on every update. Memoizing these would reduce GC pressure.
+
+<reference ref="dxn:echo:@:123e4567-e89b-12d3-a456-426614174000">ProjectConfig</reference>
+
+Would you like me to dive deeper into any of these areas?
+
+<select>
+<option>Improve type safety</option>
+<option>Refactor error handling</option>
+<option>Optimize performance</option>
+</select>
+
+<suggestion>Show me the specific files that need type improvements</suggestion>
+
+<suggestion>Generate a refactoring plan as a document</suggestion>
+
+<stats>3 tool uses · 12.4k tokens · 18.2s</stats>
+
+<prompt>Improve type safety</prompt>
+
+<reasoning>
+The user chose to focus on type safety improvements. I should identify the specific files and patterns where `any` types are used unnecessarily and propose concrete fixes with before/after examples.
+</reasoning>
+
+Let me find all the locations where type safety can be improved.
+
+<toolCall id="toolu_01DEF456typescan" />
+
+<summary>Scanned 42 files. Found 17 instances of unnecessary `any` usage across 6 modules.</summary>
+
+Here are the key changes I recommend:
+
+### `src/utils/transform.ts`
+
+The `transform` function currently accepts `any` for its input parameter. We can use a generic constraint instead:
+
+```typescript
+// Before
+const transform = (input: any) => { ... }
+
+// After
+const transform = <T extends Record<string, unknown>>(input: T) => { ... }
+```
+
+### `src/handlers/events.ts`
+
+The event handler map uses `any` for callback types. A mapped type would preserve type information:
+
+```typescript
+type EventHandlers = {
+  [K in keyof EventMap]: (event: EventMap[K]) => void;
+};
+```
+
+<stats>1 tool use · 8.7k tokens · 12.1s</stats>

package/src/components/ChatThread/tool-widget-state.test.ts

@@ -0,0 +1,34 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, expect, test } from 'vitest';
+
+import { createMessage } from '#testing';
+
+import { rehydrateToolWidgetsFromMessages } from './tool-widget-state';
+
+describe('rehydrateToolWidgetsFromMessages', () => {
+  test('replays toolCall then toolResult in order', () => {
+    const calls: Array<{ id: string; kind: 'object' | 'function' }> = [];
+    const sink = {
+      updateWidget: (id: string, value: unknown) => {
+        calls.push({ id, kind: typeof value === 'function' ? 'function' : 'object' });
+      },
+    };
+
+    const messages = [
+      createMessage('assistant', [
+        { _tag: 'toolCall', toolCallId: 't1', name: 'foo', input: '{}', providerExecuted: false },
+        { _tag: 'toolResult', toolCallId: 't1', name: 'foo', result: '{}', providerExecuted: false },
+      ]),
+    ];
+
+    rehydrateToolWidgetsFromMessages(sink, messages);
+
+    expect(calls).toEqual([
+      { id: 't1', kind: 'object' },
+      { id: 't1', kind: 'function' },
+    ]);
+  });
+});