@dxos/plugin-assistant 0.8.4-main.72ec0f3 → 0.8.4-main.74a063c4e0

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

@@ -6,34 +6,32 @@ 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 React, { useEffect, useMemo, useState } from 'react';
 
-import { ContextQueueService, DatabaseService } from '@dxos/functions';
-import { faker } from '@dxos/random';
+import { Database } from '@dxos/echo';
+import { runAndForwardErrors } from '@dxos/effect';
+import { ContextQueueService } from '@dxos/functions';
+import { random } 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 { withLayout, withTheme } from '@dxos/react-ui/testing';
-import { MarkdownStream } from '@dxos/react-ui-components';
+import { Card } from '@dxos/react-ui';
 import { EditorPreviewProvider, useEditorPreview } from '@dxos/react-ui-editor';
-import { Card } from '@dxos/react-ui-stack';
-import { render } from '@dxos/storybook-utils';
+import { Loading, withLayout, withTheme } from '@dxos/react-ui/testing';
 import { type 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 ChatThreadProps } from './ChatThread';
-import { componentRegistry } from './registry';
-import TEXT from './testing/thread.md?raw';
 
-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 = { generator?: MessageGenerator[]; delay?: number; wait?: boolean } & ChatThreadProps;
+type DefaultStoryProps = { generator?: MessageGenerator[]; delay?: number; wait?: boolean } & ChatThreadProps;
 
-const DefaultStory = ({ generator = [], delay = 0, wait, ...props }: StoryProps) => {
+const DefaultStory = ({ generator = [], delay = 0, wait, ...props }: DefaultStoryProps) => {
   const space = useSpace();
   const queueDxn = useMemo(() => space?.queues.create().dxn, [space]);
   const queue = useQueue<Message.Message>(queueDxn);
@@ -54,20 +52,20 @@ const DefaultStory = ({ generator = [], delay = 0, wait, ...props }: StoryProps)
           }
         }
         setDone(true);
-      }).pipe(Effect.provide(Layer.mergeAll(DatabaseService.layer(space.db), ContextQueueService.layer(queue)))),
+      }).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]);
 
   if (wait && !done) {
-    return null;
+    return <Loading data={{ wait, done }} />;
   }
 
   return (
-    <EditorPreviewProvider onLookup={async ({ label, ref }) => ({ label, text: ref })}>
+    <EditorPreviewProvider onLookup={async ({ dxn, label }) => ({ label, text: dxn })}>
       <ChatThread {...props} messages={queue?.objects} />
       <PreviewCard />
     </EditorPreviewProvider>
@@ -81,10 +79,10 @@ const PreviewCard = () => {
     <Popover.Portal>
       <Popover.Content onOpenAutoFocus={(event) => event.preventDefault()}>
         <Popover.Viewport>
-          <Card.SurfaceRoot role='card--popover'>
+          <Card.Root>
             <Card.Heading>{target?.label}</Card.Heading>
             {target && <Card.Text classNames='truncate line-clamp-3'>{target.text}</Card.Text>}
-          </Card.SurfaceRoot>
+          </Card.Root>
         </Popover.Viewport>
         <Popover.Arrow />
       </Popover.Content>
@@ -93,12 +91,12 @@ const PreviewCard = () => {
 };
 
 const meta = {
-  title: 'plugins/plugin-assistant/ChatThread',
+  title: 'plugins/plugin-assistant/components/ChatThread',
   component: ChatThread,
-  render: render(DefaultStory),
+  render: DefaultStory,
   decorators: [
-    withTheme,
-    withLayout({ container: 'column' }),
+    withTheme(),
+    withLayout({ layout: 'column' }),
     withClientProvider({
       createIdentity: true,
       createSpace: true,
@@ -109,11 +107,11 @@ const meta = {
     layout: 'fullscreen',
     translations,
   },
-} satisfies Meta<StoryProps>;
+} satisfies Meta<DefaultStoryProps>;
 
 export default meta;
 
-type Story = StoryObj<StoryProps>;
+type Story = StoryObj<DefaultStoryProps>;
 
 export const Default: Story = {
   args: {
@@ -126,23 +124,10 @@ export const Delayed: Story = {
   args: {
     generator: createMessageGenerator(),
     delay: 1_000,
-    fadeIn: true,
-    cursor: false,
+    options: {
+      autoScroll: true,
+      wire: true,
+      cursor: true,
+    },
   },
 };
-
-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,38 +2,46 @@
 // Copyright 2025 DXOS.org
 //
 
-import React, { type CSSProperties, forwardRef, useCallback, useEffect, useMemo } from 'react';
+import React, { type CSSProperties, forwardRef, useCallback, useEffect, useMemo, useState } from 'react';
 
 import { PublicKey } from '@dxos/keys';
 import { type Identity } from '@dxos/react-client/halo';
-import { type ThemedClassName, useForwardedRef } from '@dxos/react-ui';
+import { type ThemedClassName, setRef } from '@dxos/react-ui';
 import { MarkdownStream, type MarkdownStreamController, type MarkdownStreamProps } from '@dxos/react-ui-components';
-import { mx } from '@dxos/react-ui-theme';
 import { type Message } from '@dxos/types';
+import { mx } from '@dxos/ui-theme';
 import { keyToFallback } from '@dxos/util';
 
 import { type ChatEvent } from '../Chat';
-
 import { blockToMarkdown, componentRegistry } from './registry';
 import { MessageSyncer } from './sync';
 
+const defaultOptions: MarkdownStreamProps['options'] = {
+  autoScroll: true,
+  // wire: true,
+  cursor: true,
+};
+
 export type ChatThreadProps = ThemedClassName<
   {
     identity?: Identity;
     messages?: Message.Message[];
     error?: Error;
     onEvent?: (event: ChatEvent) => void;
-  } & Pick<MarkdownStreamProps, 'cursor' | 'fadeIn' | 'debug'>
+  } & Pick<MarkdownStreamProps, 'options' | 'debug'>
 >;
 
 // 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;
+export const ChatThread = forwardRef<MarkdownStreamController | null, ChatThreadProps>(
+  ({ classNames, identity, messages = [], error, options = defaultOptions, debug = false, onEvent }, forwardedRef) => {
+    const [controller, setController] = useState<MarkdownStreamController | null>(null);
+    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,
@@ -52,7 +60,7 @@ export const ChatThread = forwardRef<MarkdownStreamController, ChatThreadProps>(
       if (reset) {
         controller?.scrollToBottom('instant');
       }
-    }, [syncer, messages]);
+    }, [controller, syncer, messages]);
 
     // Event adapter.
     const handleEvent = useCallback<NonNullable<MarkdownStreamProps['onEvent']>>(
@@ -70,16 +78,19 @@ export const ChatThread = forwardRef<MarkdownStreamController, ChatThreadProps>(
     return (
       <div
         role='none'
-        className={mx('flex bs-full is-full justify-center overflow-hidden', classNames)}
-        style={{ '--user-fill': `var(--dx-${userHue}Fill)` } as CSSProperties}
+        className={mx('flex h-full w-full justify-center overflow-hidden', classNames)}
+        style={
+          {
+            '--user-fill': `var(--color-${userHue}-fill)`,
+          } as CSSProperties
+        }
       >
         <MarkdownStream
-          ref={controllerRef}
           registry={componentRegistry}
-          cursor={cursor}
-          fadeIn={fadeIn}
+          options={options}
           debug={debug}
           onEvent={handleEvent}
+          ref={handleMarkdownStreamRef}
         />
       </div>
     );

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>
   );

package/src/components/ChatThread/registry.tsx

@@ -2,59 +2,54 @@
 // Copyright 2025 DXOS.org
 //
 
-import React from 'react';
-
 import { log } from '@dxos/log';
+import { ContentBlock, type Message } from '@dxos/types';
+import { type XmlWidgetRegistry, getXmlTextChild } from '@dxos/ui-editor';
+
+import { type BlockRenderer, type MessageThreadContext } from './sync';
 import {
+  FallbackWidget,
   PromptWidget,
+  ReasoningWidget,
   ReferenceWidget,
   SelectWidget,
   SuggestionWidget,
+  StatsWidget,
   SummaryWidget,
-  ToggleContainer,
-} from '@dxos/react-ui-components';
-import { type XmlWidgetProps, type XmlWidgetRegistry, getXmlTextChild } from '@dxos/react-ui-editor';
-import { Json } from '@dxos/react-ui-syntax-highlighter';
-import { ContentBlock, type Message } from '@dxos/types';
-
-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,
+} 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 +58,50 @@ 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;
     },
   },
 
   //
-  // React
+  // React Widgets (portaled outside of the editor)
   //
 
-  ['toolCall' as const]: {
+  summary: {
     block: true,
-    Component: ToolBlock,
+    Component: SummaryWidget,
   },
-  ['toolResult' as const]: {
+  toolCall: {
     block: true,
-    Component: Fallback,
+    Component: ToolWidget,
   },
-  ['toolkit' as const]: {
+
+  toolResult: {
     block: true,
-    Component: Fallback,
+    Component: FallbackWidget,
+  },
+  toolkit: {
+    block: true,
+    Component: FallbackWidget,
   },
 
   //
   // Fallback
   //
 
-  ['json' as const]: {
+  json: {
     block: true,
-    Component: Fallback,
+    Component: FallbackWidget,
   },
 };
 
@@ -135,40 +135,74 @@ 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],
       });
       return `<toolCall id="${block.toolCallId}" />`;
     }
+
     case 'toolResult': {
-      context.updateWidget<{ blocks: ContentBlock.Any[] }>(block.toolCallId, ({ blocks = [] }) => ({
+      // TODO(dmaretskyi): the parameter could be undefined, perhaps tool blocks are not arriving in order.
+      context.updateWidget<{ blocks: ContentBlock.Any[] }>(block.toolCallId, ({ blocks = [] } = { blocks: [] }) => ({
         blocks: [...blocks, block],
       }));
       break;
     }
+
+    case 'stats': {
+      return renderXMLBlock('stats', { content: ContentBlock.createStatsMessage(block) });
+    }
+
+    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 });
     }
+
     default: {
       // TODO(burdon): Needs stable ID.
       return `<json id="${message.id}">\n${JSON.stringify(block)}\n</json>`;
     }
   }
 };
+
+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 = (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
 //
@@ -6,9 +8,11 @@ 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 { createMessage } from '#testing';
 
 import { blockToMarkdown } from './registry';
 import { MessageSyncer, type TextModel } from './sync';
@@ -16,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 },
     });
@@ -54,7 +58,9 @@ describe('reducers', () => {
       syncer.append(messages);
       expect(doc.content).toEqual(['<prompt>Hello</prompt>', 'Hi there!', ''].join('\n'));
 
-      messages[1].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'));
     }),
@@ -74,12 +80,16 @@ describe('reducers', () => {
       syncer.append(messages);
       expect(doc.content).toEqual(['<prompt>Hello</prompt>', 'Hi there!'].join('\n'));
 
-      const block = messages[1].blocks[0] as ContentBlock.Text;
-      block.text = 'Hi there! How are you?';
-      block.pending = false;
+      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);
 
-      messages[1].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 are you?', 'How can I help?', ''].join('\n'),

package/src/components/ChatThread/sync.ts

@@ -5,13 +5,13 @@
 import { type DXN } from '@dxos/echo';
 import { log } from '@dxos/log';
 import { type MarkdownStreamController } from '@dxos/react-ui-components';
-import { type StateDispatch, type XmlWidgetStateManager } from '@dxos/react-ui-editor';
 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'>;
+export type TextModel = Pick<MarkdownStreamController, 'length' | 'setContent' | 'append' | 'updateWidget'>;
 
 /**
  * Thread context passed to renderer.
@@ -50,10 +50,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() {
@@ -66,49 +66,49 @@ export class MessageSyncer {
     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 },
-      });
+      void this._document.setContent(content);
 
       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)) {
@@ -120,7 +120,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)) {
@@ -129,7 +129,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);
         }