@dxos/plugin-assistant 0.8.4-main.21d9917 → 0.8.4-main.2244d791bb

package/src/components/Chat/Chat.tsx

@@ -10,10 +10,11 @@ import * as Array from 'effect/Array';
 import * as Option from 'effect/Option';
 import React, { type PropsWithChildren, useCallback, useEffect, useMemo, useRef, useState } from 'react';
 
+import { type Chat as ChatModule } from '@dxos/assistant-toolkit';
 import { Event } from '@dxos/async';
-import { type Database, Obj } from '@dxos/echo';
+import { type Database, Filter, Obj } from '@dxos/echo';
 import { useVoiceInput } from '@dxos/plugin-transcription';
-import { useQueue } from '@dxos/react-client/echo';
+import { useQuery } from '@dxos/react-client/echo';
 import { useIdentity } from '@dxos/react-client/halo';
 import { Input, type ThemedClassName, useDynamicRef, useTranslation } from '@dxos/react-ui';
 import { ChatEditor, type ChatEditorController, type ChatEditorProps } from '@dxos/react-ui-chat';
@@ -26,7 +27,6 @@ import { isTruthy } from '@dxos/util';
 import { useChatToolbarActions } from '../../hooks';
 import { meta } from '../../meta';
 import { type AiChatProcessor } from '../../processor';
-import { type Assistant } from '../../types';
 import {
   ChatActions,
   type ChatActionsProps,
@@ -49,7 +49,7 @@ type ChatContextValue = {
   debug?: boolean;
   event: Event<ChatEvent>;
   db?: Database.Database;
-  chat?: Assistant.Chat;
+  chat?: ChatModule.Chat;
   messages: Message.Message[];
   processor: AiChatProcessor;
 };
@@ -73,11 +73,10 @@ const ChatRoot = ({ children, chat, processor, onEvent, ...props }: ChatRootProp
   const lastPrompt = useRef<string | undefined>(undefined);
 
   // Messages.
-  const queue = useQueue<Message.Message>(chat?.queue.dxn);
+  const storedMessages = useQuery(chat?.queue?.target, Filter.type(Message.Message));
   const messages = useMemo(() => {
-    const queueMessages = queue?.objects?.filter(Obj.instanceOf(Message.Message)) ?? [];
-    return Array.dedupeWith([...queueMessages, ...pending], ({ id: a }, { id: b }) => a === b);
-  }, [queue?.objects, pending]);
+    return Array.dedupeWith([...storedMessages, ...pending], ({ id: a }, { id: b }) => a === b);
+  }, [storedMessages, pending]);
 
   // Events.
   const event = useMemo(() => new Event<ChatEvent>(), []);
@@ -86,6 +85,24 @@ const ChatRoot = ({ children, chat, processor, onEvent, ...props }: ChatRootProp
       switch (ev.type) {
         case 'toggle-debug': {
           setDebug((current) => !current);
+          // Dump state to console.
+          queueMicrotask(async () => {
+            const objects = processor.context.getObjects();
+            const blueprints = processor.context.getBlueprints();
+            const tools = await processor.getTools();
+            const system = await processor.getSystemPrompt();
+            // eslint-disable-next-line no-console
+            console.log('Chat processor state:', { objects, blueprints });
+            // eslint-disable-next-line no-console
+            console.log(`
+              ==== System Prompt ====
+              ${system}
+              ==== Tools ====
+              ${Object.values(tools)
+                .map((tool) => JSON.stringify(tool, null, 2))
+                .join('\n')}
+            `);
+          });
           break;
         }
 
@@ -143,6 +160,8 @@ ChatRoot.displayName = 'Chat.Root';
 // Viewport
 //
 
+const CHAT_VIEWPORT_NAME = 'Chat.Viewport';
+
 type ChatViewportProps = ThemedClassName<PropsWithChildren>;
 
 const ChatViewport = ({ classNames, children }: ChatViewportProps) => {
@@ -153,14 +172,18 @@ const ChatViewport = ({ classNames, children }: ChatViewportProps) => {
   );
 };
 
+ChatViewport.displayName = CHAT_VIEWPORT_NAME;
+
 //
 // Thread
 //
 
+const CHAT_THREAD_NAME = 'Chat.Thread';
+
 type ChatThreadProps = Omit<NaturalChatThreadProps, 'identity' | 'messages' | 'tools'>;
 
 const ChatThread = (props: ChatThreadProps) => {
-  const { debug, event, messages, processor } = useChatContext(ChatThread.displayName);
+  const { debug, event, messages, processor } = useChatContext(CHAT_THREAD_NAME);
   const identity = useIdentity();
   const error = useAtomValue(processor.error).pipe(Option.getOrUndefined);
 
@@ -206,12 +229,14 @@ const ChatThread = (props: ChatThreadProps) => {
   );
 };
 
-ChatThread.displayName = 'Chat.Thread';
+ChatThread.displayName = CHAT_THREAD_NAME;
 
 //
 // Prompt
 //
 
+const CHAT_PROMPT_NAME = 'Chat.Prompt';
+
 type ChatPromptProps = ThemedClassName<
   {
     outline?: boolean;
@@ -238,7 +263,7 @@ const ChatPrompt = ({
   onOnlineChange,
 }: ChatPromptProps) => {
   const { t } = useTranslation(meta.id);
-  const { db, processor, event } = useChatContext(ChatPrompt.displayName);
+  const { db, processor, event } = useChatContext(CHAT_PROMPT_NAME);
 
   const error = useAtomValue(processor.error).pipe(Option.getOrUndefined);
   const streaming = useAtomValue(processor.streaming);
@@ -392,16 +417,18 @@ const ChatPrompt = ({
   );
 };
 
-ChatPrompt.displayName = 'Chat.Prompt';
+ChatPrompt.displayName = CHAT_PROMPT_NAME;
 
 //
 // Toolbar
 //
 
+const CHAT_TOOLBAR_NAME = 'Chat.Toolbar';
+
 type ChatToolbarProps = ThemedClassName<{ companionTo?: Obj.Unknown }>;
 
 const ChatToolbar = ({ classNames, companionTo }: ChatToolbarProps) => {
-  const { chat } = useChatContext(ChatToolbar.displayName);
+  const { chat } = useChatContext(CHAT_TOOLBAR_NAME);
   const menu = useChatToolbarActions({ chat, companionTo });
 
   return (
@@ -414,7 +441,7 @@ const ChatToolbar = ({ classNames, companionTo }: ChatToolbarProps) => {
   );
 };
 
-ChatToolbar.displayName = 'Chat.Toolbar';
+ChatToolbar.displayName = CHAT_TOOLBAR_NAME;
 
 //
 // Chat

package/src/components/ChatCompanion.tsx

@@ -5,25 +5,26 @@
 import * as Array from 'effect/Array';
 import * as Function from 'effect/Function';
 import * as Option from 'effect/Option';
-import React, { forwardRef, useCallback, useEffect, useMemo, useState } from 'react';
+import React, { forwardRef, useCallback, useEffect, useMemo, useRef, useState } from 'react';
 
-import { Common } from '@dxos/app-framework';
-import { useCapabilities, useOperationInvoker } from '@dxos/app-framework/react';
+import { useAtomCapability, useCapabilities, useOperationInvoker } from '@dxos/app-framework/ui';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { Chat } from '@dxos/assistant-toolkit';
 import { Blueprint } from '@dxos/blueprints';
 import { getSpace } from '@dxos/client/echo';
-import { Filter, Obj, Ref } from '@dxos/echo';
+import { DXN, Filter, Obj, Query, Ref } from '@dxos/echo';
 import { SpaceOperation } from '@dxos/plugin-space/types';
 import { useQuery } from '@dxos/react-client/echo';
 import { useAsyncEffect } from '@dxos/react-ui';
 
 import { ChatContainer, type ChatEvent } from '../components';
 import { useBlueprintRegistry, useContextBinder } from '../hooks';
-import { Assistant, AssistantOperation } from '../types';
+import { Assistant, AssistantCapabilities, AssistantOperation } from '../types';
 
 export type ChatCompanionProps = {
   role?: string;
   data: {
-    subject: Assistant.Chat | 'assistant-chat';
+    subject: Chat.Chat | 'assistant-chat';
     companionTo: Obj.Unknown;
   };
 };
@@ -36,9 +37,49 @@ export const ChatCompanion = forwardRef<HTMLDivElement, ChatCompanionProps>(
 
     const space = getSpace(companionTo);
     const [chat, setChat] = useState(data.subject === 'assistant-chat' ? undefined : data.subject);
+
+    // Watch the state atom directly to detect when plus button clears the chat selection.
+    const state = useAtomCapability(AssistantCapabilities.State);
+    const companionToId = Obj.getDXN(companionTo).toString();
+    const currentChatState = state?.currentChat[companionToId];
+
+    // Track if initial setup has been done (to distinguish initial mount from plus button click).
+    // Reset when companionTo changes.
+    const initialSetupDoneRef = useRef(false);
+    const prevCompanionToIdRef = useRef(companionToId);
+    if (prevCompanionToIdRef.current !== companionToId) {
+      initialSetupDoneRef.current = false;
+      prevCompanionToIdRef.current = companionToId;
+    }
+
+    // Sync local chat state with the state atom.
+    // When currentChatState is undefined (plus button clicked), reset local chat.
+    // When data.subject is a Chat object, use it directly.
+    // When currentChatState is a different chat, fetch and set it.
     useEffect(() => {
-      setChat(data.subject === 'assistant-chat' ? undefined : data.subject);
-    }, [data.subject]);
+      // If state says no chat selected AND current chat is persisted, reset local state (handles plus button click).
+      // Don't reset in-memory chats - they're expected to have currentChatState === undefined.
+      if (!currentChatState && chat && getSpace(chat)) {
+        setChat(undefined);
+      } else if (data.subject !== 'assistant-chat') {
+        // If data.subject is a Chat object (resolved from graph), use it.
+        setChat(data.subject);
+      } else if (currentChatState && space) {
+        // currentChatState is set but graph couldn't resolve it - fetch manually.
+        const currentChatDxnStr = chat ? Obj.getDXN(chat).toString() : undefined;
+        if (currentChatState !== currentChatDxnStr) {
+          // Parse DXN and fetch the chat object from the database.
+          const parsedDxn = DXN.tryParse(currentChatState);
+          if (parsedDxn) {
+            const chatRef = space.db.makeRef(parsedDxn);
+            const resolvedChat = chatRef?.target;
+            if (Obj.instanceOf(Assistant.Chat, resolvedChat)) {
+              setChat(resolvedChat);
+            }
+          }
+        }
+      }
+    }, [currentChatState, data.subject, space, chat]);
 
     const chatQueue = space && chat ? space.queues.get(chat.queue.dxn) : undefined;
     const binder = useContextBinder(chatQueue);
@@ -49,19 +90,41 @@ export const ChatCompanion = forwardRef<HTMLDivElement, ChatCompanionProps>(
         return;
       }
 
-      const { data } = await invokePromise(AssistantOperation.CreateChat, { db: space.db });
-      setChat(data?.object);
-    }, [chat, space]);
+      // Only query for existing chats on initial mount, not when plus button is clicked.
+      if (!initialSetupDoneRef.current) {
+        // Query for existing companion chats linked to this object.
+        const existingChats = await space.db
+          .query(Query.select(Filter.id(companionTo.id)).targetOf(Chat.CompanionTo).source())
+          .run();
+
+        initialSetupDoneRef.current = true;
+
+        // Use existing chat if found on initial mount.
+        if (existingChats.length > 0) {
+          const existingChat = existingChats.at(-1) as Assistant.Chat;
+          setChat(existingChat);
+          await invokePromise(AssistantOperation.SetCurrentChat, { companionTo, chat: existingChat });
+          return;
+        }
+      }
+
+      // Create chat in-memory only - it will be added to space on first message.
+      const { data: createResult } = await invokePromise(AssistantOperation.CreateChat, {
+        db: space.db,
+        addToSpace: false,
+      });
+      setChat(createResult?.object);
+    }, [chat, space, companionTo, invokePromise]);
 
-    // Add chat to space when user submits the first message.
+    // Add chat to space and create relation when user submits the first message.
     const handleEvent = useCallback(
       async (event: ChatEvent) => {
-        const chatInSpace = !!getSpace(chat);
-        if (chatInSpace || !chat || !space) {
+        if (!chat || !space) {
           return;
         }
 
-        if (event.type === 'submit') {
+        // If chat is not in space yet, persist it on first submit.
+        if (event.type === 'submit' && !getSpace(chat)) {
           await invokePromise(SpaceOperation.AddObject, {
             object: chat,
             target: space.db,
@@ -69,7 +132,7 @@ export const ChatCompanion = forwardRef<HTMLDivElement, ChatCompanionProps>(
           });
           await invokePromise(SpaceOperation.AddRelation, {
             db: space.db,
-            schema: Assistant.CompanionTo,
+            schema: Chat.CompanionTo,
             source: chat,
             target: companionTo,
           });
@@ -82,7 +145,7 @@ export const ChatCompanion = forwardRef<HTMLDivElement, ChatCompanionProps>(
       [chat, space, companionTo, invokePromise],
     );
 
-    const metadata = useCapabilities(Common.Capability.Metadata);
+    const metadata = useCapabilities(AppCapabilities.Metadata);
     const blueprintKeys = useMemo(
       () =>
         Function.pipe(
@@ -125,7 +188,7 @@ export const ChatCompanion = forwardRef<HTMLDivElement, ChatCompanionProps>(
           continue;
         }
 
-        space.db.add(Obj.clone(blueprint));
+        space.db.add(Obj.clone(blueprint, { deep: true }));
       }
     }, [space, blueprintRegistry, blueprintKeys]);
 

package/src/components/ChatContainer.tsx

@@ -4,18 +4,19 @@
 
 import React, { forwardRef } from 'react';
 
-import { type SurfaceComponentProps, useAtomCapability } from '@dxos/app-framework/react';
+import { useAtomCapability } from '@dxos/app-framework/ui';
+import { type SurfaceComponentProps } from '@dxos/app-toolkit/ui';
 import { type Space, getSpace } from '@dxos/client/echo';
 import { type Obj } from '@dxos/echo';
-import { Layout } from '@dxos/react-ui-mosaic';
+import { Layout } from '@dxos/react-ui';
 
 import { useBlueprintRegistry, useChatProcessor, useChatServices, useOnline, usePresets } from '../hooks';
-import { type Assistant, AssistantCapabilities } from '../types';
+import { AssistantCapabilities, type ChatType } from '../types';
 
-import { Chat, type ChatRootProps } from './Chat';
+import { Chat as ChatComponent, type ChatRootProps } from './Chat';
 
 export type ChatContainerProps = SurfaceComponentProps<
-  Assistant.Chat | undefined,
+  ChatType.Chat | undefined,
   {
     space?: Space;
     companionTo?: Obj.Unknown;
@@ -44,16 +45,22 @@ export const ChatContainer = forwardRef<HTMLDivElement, ChatContainerProps>((pro
   }
 
   return (
-    <Layout.Main role={role} ref={forwardedRef}>
-      <Chat.Root db={space?.db} chat={chat} processor={processor} onEvent={onEvent}>
-        <Chat.Toolbar companionTo={companionTo} />
-        <Chat.Viewport classNames='container-max-width'>
-          <Chat.Thread />
+    <Layout.Main toolbar role={role} ref={forwardedRef}>
+      <ChatComponent.Root db={space?.db} chat={chat} processor={processor} onEvent={onEvent}>
+        <ChatComponent.Toolbar companionTo={companionTo} />
+        <ChatComponent.Viewport classNames='container-max-width'>
+          <ChatComponent.Thread />
           <div role='none' className='p-4'>
-            <Chat.Prompt {...chatProps} outline preset={preset?.id} online={online} onOnlineChange={setOnline} />
+            <ChatComponent.Prompt
+              {...chatProps}
+              outline
+              preset={preset?.id}
+              online={online}
+              onOnlineChange={setOnline}
+            />
           </div>
-        </Chat.Viewport>
-      </Chat.Root>
+        </ChatComponent.Viewport>
+      </ChatComponent.Root>
     </Layout.Main>
   );
 });

package/src/components/ChatDialog.tsx

@@ -4,19 +4,20 @@
 
 import React, { useCallback, useState } from 'react';
 
-import { useAtomCapability } from '@dxos/app-framework/react';
+import { useAtomCapability } from '@dxos/app-framework/ui';
+import { type Chat as ChatTypes } from '@dxos/assistant-toolkit';
 import { Obj } from '@dxos/echo';
 import { useTranslation } from '@dxos/react-ui';
 import { ChatDialog as NaturalChatDialog } from '@dxos/react-ui-chat';
 
 import { useBlueprintRegistry, useChatProcessor, useChatServices, useOnline, usePresets } from '../hooks';
 import { meta } from '../meta';
-import { type Assistant, AssistantCapabilities } from '../types';
+import { AssistantCapabilities } from '../types';
 
 import { Chat, type ChatRootProps } from './Chat';
 
 export type ChatDialogProps = {
-  chat?: Assistant.Chat;
+  chat?: ChatTypes.Chat;
 };
 
 export const ChatDialog = ({ chat }: ChatDialogProps) => {

package/src/components/ChatProgress/ChatProgress.tsx

@@ -4,13 +4,12 @@
 
 import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 
+import { type Chat } from '@dxos/assistant-toolkit';
 import { addEventListener } from '@dxos/async';
 import { ProgressBar, type ProgressBarProps, TextCrawl, useExecutionGraph } from '@dxos/react-ui-components';
 
-import { type Assistant } from '../../types';
-
 export type ChatProgressProps = {
-  chat: Assistant.Chat;
+  chat: Chat.Chat;
 };
 
 export const ChatProgress = ({ chat }: ChatProgressProps) => {

package/src/components/ChatPrompt/ChatActions.tsx

@@ -50,6 +50,14 @@ export const ChatActions = ({ classNames, children, microphone, recording, proce
           onTouchEnd={() => onEvent?.({ type: 'record-stop' })}
         />
       )}
+
+      <IconButton
+        variant='ghost'
+        icon='ph--wrench--regular'
+        iconOnly
+        label={t('debug button')}
+        onClick={() => onEvent?.({ type: 'toggle-debug' })}
+      />
     </div>
   );
 };

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

@@ -56,7 +56,7 @@ const DefaultStory = ({ generator = [], delay = 0, wait, ...props }: StoryProps)
           }
         }
         setDone(true);
-      }).pipe(Effect.provide(Layer.mergeAll(Database.Service.layer(space.db), ContextQueueService.layer(queue)))),
+      }).pipe(Effect.provide(Layer.mergeAll(Database.layer(space.db), ContextQueueService.layer(queue)))),
     );
 
     return () => {
@@ -69,7 +69,7 @@ const DefaultStory = ({ generator = [], delay = 0, wait, ...props }: StoryProps)
   }
 
   return (
-    <EditorPreviewProvider onLookup={async ({ label, ref }) => ({ label, text: ref })}>
+    <EditorPreviewProvider onLookup={async ({ dxn, label }) => ({ label, text: dxn })}>
       <ChatThread {...props} messages={queue?.objects} />
       <PreviewCard />
     </EditorPreviewProvider>
@@ -99,7 +99,7 @@ const meta = {
   component: ChatThread,
   render: render(DefaultStory),
   decorators: [
-    withTheme,
+    withTheme(),
     withLayout({ layout: 'column' }),
     withClientProvider({
       createIdentity: true,

package/src/components/ChatThread/ChatThread.tsx

@@ -2,7 +2,7 @@
 // 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';
@@ -27,13 +27,22 @@ export type ChatThreadProps = ThemedClassName<
 >;
 
 // TODO(burdon): Memo thread position.
-export const ChatThread = forwardRef<MarkdownStreamController, ChatThreadProps>(
+export const ChatThread = forwardRef<MarkdownStreamController | null, ChatThreadProps>(
   (
     { classNames, identity, messages = [], error, cursor = false, fadeIn = true, debug = false, onEvent },
     forwardedRef,
   ) => {
     const controllerRef = useForwardedRef(forwardedRef);
-    const controller = controllerRef.current;
+    const [controller, setController] = useState<MarkdownStreamController | null>(null);
+
+    // Callback ref to capture when MarkdownStream is mounted and trigger re-render.
+    const refCallback = useCallback(
+      (node: MarkdownStreamController | null) => {
+        controllerRef.current = node;
+        setController(node);
+      },
+      [controllerRef],
+    );
 
     const userHue = useMemo(
       () => identity?.profile?.data?.hue || keyToFallback(identity?.identityKey ?? PublicKey.random()).hue,
@@ -74,7 +83,7 @@ export const ChatThread = forwardRef<MarkdownStreamController, ChatThreadProps>(
         style={{ '--user-fill': `var(--dx-${userHue}Fill)` } as CSSProperties}
       >
         <MarkdownStream
-          ref={controllerRef}
+          ref={refCallback}
           registry={componentRegistry}
           cursor={cursor}
           fadeIn={fadeIn}

package/src/components/ChatThread/Link.tsx

@@ -19,7 +19,7 @@ export const ObjectLink = ({ space, dxn }: ObjectLinkProps) => {
 
   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

@@ -8,6 +8,7 @@ import { log } from '@dxos/log';
 import { ToggleContainer } from '@dxos/react-ui-components';
 import {
   PromptWidget,
+  ReasoningWidget,
   ReferenceWidget,
   SelectWidget,
   SuggestionWidget,
@@ -47,6 +48,13 @@ export const componentRegistry: XmlWidgetRegistry = {
       return text ? new PromptWidget(text) : null;
     },
   },
+  ['reasoning' as const]: {
+    block: true,
+    factory: ({ children }) => {
+      const text = getXmlTextChild(children);
+      return text ? new ReasoningWidget(text) : null;
+    },
+  },
   ['reference' as const]: {
     block: false,
     factory: ({ children, ref }) => {
@@ -158,7 +166,8 @@ const blockToMarkdownImpl = (context: MessageThreadContext, message: Message.Mes
       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;
@@ -166,6 +175,14 @@ const blockToMarkdownImpl = (context: MessageThreadContext, message: Message.Mes
     case 'summary': {
       return `<summary>${ContentBlock.createSummaryMessage(block)}</summary>`;
     }
+    case 'reasoning': {
+      const text = block.reasoningText ?? block.redactedText;
+      if (!text) {
+        return;
+      }
+      // TODO(dmaretskyi): The mixed Markdown/XML parser does not support parsing multi-line XML tags.
+      return `<reasoning>${text.replace(/\n/g, ' ').trim()}</reasoning>`;
+    }
     default: {
       // TODO(burdon): Needs stable ID.
       return `<json id="${message.id}">\n${JSON.stringify(block)}\n</json>`;

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

@@ -7,6 +7,7 @@ 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';
@@ -78,7 +79,7 @@ describe('reducers', () => {
       expect(doc.content).toEqual(['<prompt>Hello</prompt>', 'Hi there!'].join('\n'));
 
       Obj.change(messages[1], (m) => {
-        const block = m.blocks[0] as ContentBlock.Text;
+        const block = m.blocks[0] as Mutable<ContentBlock.Text>;
         block.text = 'Hi there! How are you?';
         block.pending = false;
       });

package/src/components/ChatThread/sync.ts

@@ -73,6 +73,12 @@ export class MessageSyncer {
    * 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();
@@ -108,13 +114,13 @@ export class MessageSyncer {
   }
 
   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,
-    });
+    // 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)) {
@@ -135,7 +141,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);
         }