jupyterlab-chat 0.24.0 → 0.24.2

package/lib/__tests__/model.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/__tests__/model.spec.js

@@ -0,0 +1,248 @@
+/*
+ * Copyright (c) Jupyter Development Team.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { UUID } from '@lumino/coreutils';
+import { Signal } from '@lumino/signaling';
+import { LabChatModel } from '../model';
+import { YChat } from '../ychat';
+const flushPromises = () => new Promise(resolve => setTimeout(resolve, 0));
+const TEST_USER = {
+    username: 'test-user',
+    name: 'Test User',
+    display_name: 'Test',
+    initials: 'TU',
+    color: '#aabbcc'
+};
+const TEST_BOT = {
+    username: 'test-bot',
+    name: 'Test Bot',
+    display_name: 'Bot',
+    initials: 'BU',
+    color: '#aabbcc',
+    bot: true
+};
+function makeWidgetConfig() {
+    const owner = {};
+    owner.config = {};
+    owner.configChanged = new Signal(owner);
+    return owner;
+}
+describe('LabChatModel', () => {
+    let sharedModel;
+    let model;
+    beforeEach(() => {
+        sharedModel = YChat.create();
+        model = new LabChatModel({
+            widgetConfig: makeWidgetConfig(),
+            user: TEST_USER,
+            sharedModel
+        });
+        model.markDocumentSynced();
+    });
+    afterEach(() => {
+        Signal.clearData(model);
+        sharedModel.dispose();
+    });
+    describe('message update from model', () => {
+        it('should set edited when user message is updated', async () => {
+            const id = model.sendMessage({
+                body: 'original',
+                sender: TEST_USER
+            });
+            await flushPromises();
+            model.updateMessage(id, {
+                type: 'msg',
+                id,
+                body: 'updated',
+                time: 1000,
+                sender: TEST_USER
+            });
+            await flushPromises();
+            expect(model.messages[0].body).toBe('updated');
+            expect(model.messages[0].edited).toBe(true);
+        });
+        it('should not set edited when bot message is updated', async () => {
+            const id = model.sendMessage({
+                body: 'original',
+                sender: TEST_BOT
+            });
+            await flushPromises();
+            model.updateMessage(id, {
+                type: 'msg',
+                id,
+                body: 'updated',
+                time: 1000,
+                sender: TEST_BOT
+            });
+            await flushPromises();
+            expect(model.messages[0].body).toBe('updated');
+            expect(model.messages[0].edited).toBeUndefined();
+        });
+    });
+    describe('message attribute updates from shared model', () => {
+        it('should reflect a body change', async () => {
+            const id = UUID.uuid4();
+            sharedModel.addMessage({
+                type: 'msg',
+                id,
+                body: 'original',
+                time: 1000,
+                sender: TEST_USER.username
+            });
+            await flushPromises();
+            sharedModel.updateMessage(0, {
+                type: 'msg',
+                id,
+                body: 'updated',
+                time: 1000,
+                sender: TEST_USER.username
+            });
+            await flushPromises();
+            expect(model.messages[0].body).toBe('updated');
+        });
+        it('should reflect a mime_model change', async () => {
+            const id = UUID.uuid4();
+            sharedModel.addMessage({
+                type: 'msg',
+                id,
+                body: '',
+                time: 1000,
+                sender: TEST_USER.username
+            });
+            await flushPromises();
+            const mimeModel = { data: { 'text/plain': 'streamed output' } };
+            sharedModel.updateMessage(0, {
+                type: 'msg',
+                id,
+                body: '',
+                time: 1000,
+                sender: TEST_USER.username,
+                mime_model: mimeModel
+            });
+            await flushPromises();
+            expect(model.messages[0].mime_model).toEqual(mimeModel);
+        });
+    });
+    describe('ready resolves after messages are loaded', () => {
+        it('messages present in sharedModel before sync are buffered, not yet in model', () => {
+            const sm = YChat.create();
+            const m = new LabChatModel({
+                widgetConfig: makeWidgetConfig(),
+                user: TEST_USER,
+                sharedModel: sm
+            });
+            sm.addMessage({
+                type: 'msg',
+                id: UUID.uuid4(),
+                body: 'pre-sync',
+                time: 1000,
+                sender: TEST_USER.username
+            });
+            // Not yet synced: message must be buffered, not inserted.
+            expect(m.messages).toHaveLength(0);
+            sm.dispose();
+        });
+        it('messages are in model.messages when ready resolves', async () => {
+            const sm = YChat.create();
+            const m = new LabChatModel({
+                widgetConfig: makeWidgetConfig(),
+                user: TEST_USER,
+                sharedModel: sm
+            });
+            sm.addMessage({
+                type: 'msg',
+                id: UUID.uuid4(),
+                body: 'pre-sync',
+                time: 1000,
+                sender: TEST_USER.username
+            });
+            m.markDocumentSynced();
+            await m.ready;
+            expect(m.messages).toHaveLength(1);
+            expect(m.messages[0].body).toBe('pre-sync');
+            sm.dispose();
+        });
+        it('model.messages is already populated inside the ready .then() callback', async () => {
+            const sm = YChat.create();
+            const m = new LabChatModel({
+                widgetConfig: makeWidgetConfig(),
+                user: TEST_USER,
+                sharedModel: sm
+            });
+            sm.addMessage({
+                type: 'msg',
+                id: UUID.uuid4(),
+                body: 'pre-sync',
+                time: 1000,
+                sender: TEST_USER.username
+            });
+            let messagesAtReady = -1;
+            const check = m.ready.then(() => {
+                messagesAtReady = m.messages.length;
+            });
+            m.markDocumentSynced();
+            await check;
+            expect(messagesAtReady).toBe(1);
+            sm.dispose();
+        });
+        it('messages added after sync are inserted directly without buffering', async () => {
+            await model.ready;
+            sharedModel.addMessage({
+                type: 'msg',
+                id: UUID.uuid4(),
+                body: 'post-sync',
+                time: 1000,
+                sender: TEST_USER.username
+            });
+            expect(model.messages).toHaveLength(1);
+            expect(model.messages[0].body).toBe('post-sync');
+        });
+    });
+    describe('rerender tracking', () => {
+        it('should replace renderedDelegate when mime_model changes', async () => {
+            const id = UUID.uuid4();
+            sharedModel.addMessage({
+                type: 'msg',
+                id,
+                body: '',
+                time: 1000,
+                sender: TEST_USER.username
+            });
+            await flushPromises();
+            const delegateBefore = model.messages[0].renderedDelegate;
+            sharedModel.updateMessage(0, {
+                type: 'msg',
+                id,
+                body: '',
+                time: 1000,
+                sender: TEST_USER.username,
+                mime_model: { data: { 'text/plain': 'streamed output' } }
+            });
+            await flushPromises();
+            expect(model.messages[0].renderedDelegate).not.toBe(delegateBefore);
+        });
+        it('should not replace renderedDelegate when only edited changes', async () => {
+            const id = UUID.uuid4();
+            sharedModel.addMessage({
+                type: 'msg',
+                id,
+                body: 'hello',
+                time: 1000,
+                sender: TEST_USER.username
+            });
+            await flushPromises();
+            const delegateBefore = model.messages[0].renderedDelegate;
+            sharedModel.updateMessage(0, {
+                type: 'msg',
+                id,
+                body: 'hello',
+                time: 1000,
+                sender: TEST_USER.username,
+                edited: true
+            });
+            await flushPromises();
+            expect(model.messages[0].renderedDelegate).toBe(delegateBefore);
+        });
+    });
+});

package/lib/model.d.ts

@@ -63,7 +63,7 @@ export declare class LabChatModel extends AbstractChatModel implements DocumentR
     set dirty(value: boolean);
     get readOnly(): boolean;
     set readOnly(value: boolean);
-    set id(value: string | undefined);
+    protected setReady(): void;
     /**
      * Notify the model that its shared document has been synchronized with the
      * server, and give it an ID if the document does not carry one yet.
@@ -85,7 +85,8 @@ export declare class LabChatModel extends AbstractChatModel implements DocumentR
     toJSON(): PartialJSONObject;
     fromJSON(data: PartialJSONObject): void;
     createChatContext(): IChatContext;
-    messagesInserted(index: number, messages: IMessageContent[]): Promise<void>;
+    messagesInserted(index: number, messages: IMessageContent[]): void;
+    private _flushPreReadyMessages;
     sendMessage(message: INewMessage): string | null;
     /**
      * Override the clear messages method.
@@ -116,6 +117,8 @@ export declare class LabChatModel extends AbstractChatModel implements DocumentR
     readonly defaultKernelName: string;
     readonly defaultKernelLanguage: string;
     private _sharedModel;
+    private _documentSynced;
+    private _preReadyMessages;
     private _dirty;
     private _readOnly;
     private _contentChanged;

package/lib/model.js

@@ -196,7 +196,8 @@ export class LabChatModel extends AbstractChatModel {
                             'raw_time',
                             'deleted',
                             'edited',
-                            'metadata'
+                            'metadata',
+                            'mime_model'
                         ].includes(key)) {
                             const update = {};
                             update[key] = value;
@@ -233,11 +234,14 @@ export class LabChatModel extends AbstractChatModel {
             if (changes.stateChange && !this._sharedModel.id) {
                 if (changes.stateChange.some(change => change.name === 'dirty' && !change.newValue)) {
                     this._sharedModel.id = UUID.uuid4();
+                    this.setReady();
                 }
             }
         };
         this.defaultKernelName = '';
         this.defaultKernelLanguage = '';
+        this._documentSynced = false;
+        this._preReadyMessages = [];
         this._dirty = false;
         this._readOnly = false;
         this._contentChanged = new Signal(this);
@@ -293,11 +297,10 @@ export class LabChatModel extends AbstractChatModel {
     set readOnly(value) {
         this._readOnly = value;
     }
-    set id(value) {
-        super.id = value;
-        if (value) {
-            this.setReady();
-        }
+    setReady() {
+        this._documentSynced = true;
+        this._flushPreReadyMessages();
+        super.setReady();
     }
     /**
      * Notify the model that its shared document has been synchronized with the
@@ -315,10 +318,13 @@ export class LabChatModel extends AbstractChatModel {
      */
     markDocumentSynced() {
         if (!this._sharedModel.id) {
-            // Assigning the shared ID emits a metadata change, which sets the model
-            // ID - and therefore resolves `ready` - through `_onchange`.
+            // Brand-new document: writing the id fires _onchange synchronously, which
+            // sets this.id via metadataChanges before setReady() is called.
             this._sharedModel.id = UUID.uuid4();
         }
+        // For an existing document, _onchange already fired for the id metadata
+        // during the initial Yjs sync and set this.id before this method was called.
+        this.setReady();
     }
     dispose() {
         if (this.isDisposed) {
@@ -345,24 +351,39 @@ export class LabChatModel extends AbstractChatModel {
     createChatContext() {
         return new LabChatContext({ model: this });
     }
-    async messagesInserted(index, messages) {
-        // Ensure the chat has an ID before inserting the messages, to properly catch the
-        // unread messages (the last read message is saved using the chat ID).
-        return this.ready.then(() => {
+    messagesInserted(index, messages) {
+        // Buffer messages that arrive before the document is synced. They are
+        // flushed synchronously in markDocumentSynced() so that `ready` resolves
+        // only after all initial messages and metadata are already in the model.
+        // This ensures that the chat has an ID before inserting the messages, to properly
+        // catch the unread messages (the last read message is saved using the chat ID).
+        if (!this._documentSynced) {
+            this._preReadyMessages.push({ index, messages });
+            return;
+        }
+        super.messagesInserted(index, messages);
+    }
+    _flushPreReadyMessages() {
+        for (const { index, messages } of this._preReadyMessages) {
             super.messagesInserted(index, messages);
-        });
+        }
+        this._preReadyMessages = [];
     }
     sendMessage(message) {
-        var _a, _b, _c, _d;
-        if (!message.body && !message.mime_model && !((_a = message.attachments) === null || _a === void 0 ? void 0 : _a.length)) {
+        var _a, _b, _c, _d, _e;
+        // Allow empty message for bot only, as it may be streamed later.
+        if (!message.body &&
+            !message.mime_model &&
+            !((_a = message.attachments) === null || _a === void 0 ? void 0 : _a.length) &&
+            !((_b = message.sender) === null || _b === void 0 ? void 0 : _b.bot)) {
             return null;
         }
         this._resetWritingStatus();
         if (this._timeoutWriting !== null) {
             window.clearTimeout(this._timeoutWriting);
         }
-        const body = (_b = message.body) !== null && _b !== void 0 ? _b : '';
-        const user = (_c = message.sender) !== null && _c !== void 0 ? _c : this._user;
+        const body = (_c = message.body) !== null && _c !== void 0 ? _c : '';
+        const user = (_d = message.sender) !== null && _d !== void 0 ? _d : this._user;
         const msg = {
             type: 'msg',
             id: UUID.uuid4(),
@@ -380,7 +401,7 @@ export class LabChatModel extends AbstractChatModel {
             this.sharedModel.setUser(user);
         }
         // Add the attachments to the message.
-        const attachmentIds = (_d = message.attachments) === null || _d === void 0 ? void 0 : _d.map(attachment => this.sharedModel.setAttachment(attachment));
+        const attachmentIds = (_e = message.attachments) === null || _e === void 0 ? void 0 : _e.map(attachment => this.sharedModel.setAttachment(attachment));
         if (attachmentIds === null || attachmentIds === void 0 ? void 0 : attachmentIds.length) {
             msg.attachments = attachmentIds;
         }
@@ -408,7 +429,7 @@ export class LabChatModel extends AbstractChatModel {
         let message = this.sharedModel.getMessage(index);
         if (message) {
             message.body = updatedMessage.body;
-            message.edited = true;
+            message.edited = updatedMessage.sender.bot ? updatedMessage.edited : true;
         }
         else {
             const sender = updatedMessage.sender.username;
@@ -418,9 +439,13 @@ export class LabChatModel extends AbstractChatModel {
                 body: updatedMessage.body,
                 time: updatedMessage.time || Date.now() / 1000,
                 sender: sender,
-                edited: true
+                edited: updatedMessage.sender.bot ? false : true
             };
         }
+        // Update the mime model.
+        if (updatedMessage.mime_model) {
+            message.mime_model = updatedMessage.mime_model;
+        }
         // Update the attachments.
         const attachmentIds = (_a = updatedMessage.attachments) === null || _a === void 0 ? void 0 : _a.map(attachment => this.sharedModel.setAttachment(attachment));
         if (attachmentIds === null || attachmentIds === void 0 ? void 0 : attachmentIds.length) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jupyterlab-chat",
-  "version": "0.24.0",
+  "version": "0.24.2",
   "description": "The library to build a chat based on shared document",
   "keywords": [
     "jupyter",
@@ -42,7 +42,7 @@
     "watch:src": "tsc -w --sourceMap"
   },
   "dependencies": {
-    "@jupyter/chat": "^0.24.0",
+    "@jupyter/chat": "^0.24.2",
     "@jupyter/collaborative-drive": "^4.4.0 || ^5.0.0",
     "@jupyter/ydoc": "^3.0.0 || ^4.0.0",
     "@jupyterlab/application": "^4.5.0",

package/src/__tests__/model.spec.ts

@@ -0,0 +1,289 @@
+/*
+ * Copyright (c) Jupyter Development Team.
+ * Distributed under the terms of the Modified BSD License.
+ */
+
+import { UUID } from '@lumino/coreutils';
+import { Signal } from '@lumino/signaling';
+
+import { LabChatModel } from '../model';
+import { IWidgetConfig } from '../token';
+import { YChat } from '../ychat';
+
+const flushPromises = () => new Promise(resolve => setTimeout(resolve, 0));
+
+const TEST_USER = {
+  username: 'test-user',
+  name: 'Test User',
+  display_name: 'Test',
+  initials: 'TU',
+  color: '#aabbcc'
+};
+
+const TEST_BOT = {
+  username: 'test-bot',
+  name: 'Test Bot',
+  display_name: 'Bot',
+  initials: 'BU',
+  color: '#aabbcc',
+  bot: true
+};
+
+function makeWidgetConfig(): IWidgetConfig {
+  const owner = {} as IWidgetConfig;
+  owner.config = {};
+  (owner as any).configChanged = new Signal<IWidgetConfig, any>(owner);
+  return owner;
+}
+
+describe('LabChatModel', () => {
+  let sharedModel: YChat;
+  let model: LabChatModel;
+
+  beforeEach(() => {
+    sharedModel = YChat.create();
+    model = new LabChatModel({
+      widgetConfig: makeWidgetConfig(),
+      user: TEST_USER,
+      sharedModel
+    });
+    model.markDocumentSynced();
+  });
+
+  afterEach(() => {
+    Signal.clearData(model);
+    sharedModel.dispose();
+  });
+
+  describe('message update from model', () => {
+    it('should set edited when user message is updated', async () => {
+      const id = model.sendMessage({
+        body: 'original',
+        sender: TEST_USER
+      }) as string;
+      await flushPromises();
+
+      model.updateMessage(id, {
+        type: 'msg',
+        id,
+        body: 'updated',
+        time: 1000,
+        sender: TEST_USER
+      });
+      await flushPromises();
+
+      expect(model.messages[0].body).toBe('updated');
+      expect(model.messages[0].edited).toBe(true);
+    });
+
+    it('should not set edited when bot message is updated', async () => {
+      const id = model.sendMessage({
+        body: 'original',
+        sender: TEST_BOT
+      }) as string;
+      await flushPromises();
+
+      model.updateMessage(id, {
+        type: 'msg',
+        id,
+        body: 'updated',
+        time: 1000,
+        sender: TEST_BOT
+      });
+      await flushPromises();
+
+      expect(model.messages[0].body).toBe('updated');
+      expect(model.messages[0].edited).toBeUndefined();
+    });
+  });
+
+  describe('message attribute updates from shared model', () => {
+    it('should reflect a body change', async () => {
+      const id = UUID.uuid4();
+      sharedModel.addMessage({
+        type: 'msg',
+        id,
+        body: 'original',
+        time: 1000,
+        sender: TEST_USER.username
+      });
+      await flushPromises();
+
+      sharedModel.updateMessage(0, {
+        type: 'msg',
+        id,
+        body: 'updated',
+        time: 1000,
+        sender: TEST_USER.username
+      });
+      await flushPromises();
+
+      expect(model.messages[0].body).toBe('updated');
+    });
+
+    it('should reflect a mime_model change', async () => {
+      const id = UUID.uuid4();
+      sharedModel.addMessage({
+        type: 'msg',
+        id,
+        body: '',
+        time: 1000,
+        sender: TEST_USER.username
+      });
+      await flushPromises();
+
+      const mimeModel = { data: { 'text/plain': 'streamed output' } };
+      sharedModel.updateMessage(0, {
+        type: 'msg',
+        id,
+        body: '',
+        time: 1000,
+        sender: TEST_USER.username,
+        mime_model: mimeModel
+      });
+      await flushPromises();
+
+      expect(model.messages[0].mime_model).toEqual(mimeModel);
+    });
+  });
+
+  describe('ready resolves after messages are loaded', () => {
+    it('messages present in sharedModel before sync are buffered, not yet in model', () => {
+      const sm = YChat.create();
+      const m = new LabChatModel({
+        widgetConfig: makeWidgetConfig(),
+        user: TEST_USER,
+        sharedModel: sm
+      });
+      sm.addMessage({
+        type: 'msg',
+        id: UUID.uuid4(),
+        body: 'pre-sync',
+        time: 1000,
+        sender: TEST_USER.username
+      });
+      // Not yet synced: message must be buffered, not inserted.
+      expect(m.messages).toHaveLength(0);
+      sm.dispose();
+    });
+
+    it('messages are in model.messages when ready resolves', async () => {
+      const sm = YChat.create();
+      const m = new LabChatModel({
+        widgetConfig: makeWidgetConfig(),
+        user: TEST_USER,
+        sharedModel: sm
+      });
+      sm.addMessage({
+        type: 'msg',
+        id: UUID.uuid4(),
+        body: 'pre-sync',
+        time: 1000,
+        sender: TEST_USER.username
+      });
+
+      m.markDocumentSynced();
+      await m.ready;
+
+      expect(m.messages).toHaveLength(1);
+      expect(m.messages[0].body).toBe('pre-sync');
+      sm.dispose();
+    });
+
+    it('model.messages is already populated inside the ready .then() callback', async () => {
+      const sm = YChat.create();
+      const m = new LabChatModel({
+        widgetConfig: makeWidgetConfig(),
+        user: TEST_USER,
+        sharedModel: sm
+      });
+      sm.addMessage({
+        type: 'msg',
+        id: UUID.uuid4(),
+        body: 'pre-sync',
+        time: 1000,
+        sender: TEST_USER.username
+      });
+
+      let messagesAtReady = -1;
+      const check = m.ready.then(() => {
+        messagesAtReady = m.messages.length;
+      });
+
+      m.markDocumentSynced();
+      await check;
+
+      expect(messagesAtReady).toBe(1);
+      sm.dispose();
+    });
+
+    it('messages added after sync are inserted directly without buffering', async () => {
+      await model.ready;
+
+      sharedModel.addMessage({
+        type: 'msg',
+        id: UUID.uuid4(),
+        body: 'post-sync',
+        time: 1000,
+        sender: TEST_USER.username
+      });
+
+      expect(model.messages).toHaveLength(1);
+      expect(model.messages[0].body).toBe('post-sync');
+    });
+  });
+
+  describe('rerender tracking', () => {
+    it('should replace renderedDelegate when mime_model changes', async () => {
+      const id = UUID.uuid4();
+      sharedModel.addMessage({
+        type: 'msg',
+        id,
+        body: '',
+        time: 1000,
+        sender: TEST_USER.username
+      });
+      await flushPromises();
+
+      const delegateBefore = model.messages[0].renderedDelegate;
+
+      sharedModel.updateMessage(0, {
+        type: 'msg',
+        id,
+        body: '',
+        time: 1000,
+        sender: TEST_USER.username,
+        mime_model: { data: { 'text/plain': 'streamed output' } }
+      });
+      await flushPromises();
+
+      expect(model.messages[0].renderedDelegate).not.toBe(delegateBefore);
+    });
+
+    it('should not replace renderedDelegate when only edited changes', async () => {
+      const id = UUID.uuid4();
+      sharedModel.addMessage({
+        type: 'msg',
+        id,
+        body: 'hello',
+        time: 1000,
+        sender: TEST_USER.username
+      });
+      await flushPromises();
+
+      const delegateBefore = model.messages[0].renderedDelegate;
+
+      sharedModel.updateMessage(0, {
+        type: 'msg',
+        id,
+        body: 'hello',
+        time: 1000,
+        sender: TEST_USER.username,
+        edited: true
+      });
+      await flushPromises();
+
+      expect(model.messages[0].renderedDelegate).toBe(delegateBefore);
+    });
+  });
+});

package/src/model.ts

@@ -162,11 +162,10 @@ export class LabChatModel
     this._readOnly = value;
   }
 
-  set id(value: string | undefined) {
-    super.id = value;
-    if (value) {
-      this.setReady();
-    }
+  protected setReady(): void {
+    this._documentSynced = true;
+    this._flushPreReadyMessages();
+    super.setReady();
   }
 
   /**
@@ -185,10 +184,13 @@ export class LabChatModel
    */
   markDocumentSynced(): void {
     if (!this._sharedModel.id) {
-      // Assigning the shared ID emits a metadata change, which sets the model
-      // ID - and therefore resolves `ready` - through `_onchange`.
+      // Brand-new document: writing the id fires _onchange synchronously, which
+      // sets this.id via metadataChanges before setReady() is called.
       this._sharedModel.id = UUID.uuid4();
     }
+    // For an existing document, _onchange already fired for the id metadata
+    // during the initial Yjs sync and set this.id before this method was called.
+    this.setReady();
   }
 
   dispose(): void {
@@ -222,19 +224,34 @@ export class LabChatModel
     return new LabChatContext({ model: this });
   }
 
-  async messagesInserted(
-    index: number,
-    messages: IMessageContent[]
-  ): Promise<void> {
-    // Ensure the chat has an ID before inserting the messages, to properly catch the
-    // unread messages (the last read message is saved using the chat ID).
-    return this.ready.then(() => {
+  messagesInserted(index: number, messages: IMessageContent[]): void {
+    // Buffer messages that arrive before the document is synced. They are
+    // flushed synchronously in markDocumentSynced() so that `ready` resolves
+    // only after all initial messages and metadata are already in the model.
+    // This ensures that the chat has an ID before inserting the messages, to properly
+    // catch the unread messages (the last read message is saved using the chat ID).
+    if (!this._documentSynced) {
+      this._preReadyMessages.push({ index, messages });
+      return;
+    }
+    super.messagesInserted(index, messages);
+  }
+
+  private _flushPreReadyMessages(): void {
+    for (const { index, messages } of this._preReadyMessages) {
       super.messagesInserted(index, messages);
-    });
+    }
+    this._preReadyMessages = [];
   }
 
   sendMessage(message: INewMessage): string | null {
-    if (!message.body && !message.mime_model && !message.attachments?.length) {
+    // Allow empty message for bot only, as it may be streamed later.
+    if (
+      !message.body &&
+      !message.mime_model &&
+      !message.attachments?.length &&
+      !message.sender?.bot
+    ) {
       return null;
     }
     this._resetWritingStatus();
@@ -302,7 +319,7 @@ export class LabChatModel
     let message = this.sharedModel.getMessage(index);
     if (message) {
       message.body = updatedMessage.body;
-      message.edited = true;
+      message.edited = updatedMessage.sender.bot ? updatedMessage.edited : true;
     } else {
       const sender = updatedMessage.sender.username;
 
@@ -312,10 +329,15 @@ export class LabChatModel
         body: updatedMessage.body,
         time: updatedMessage.time || Date.now() / 1000,
         sender: sender,
-        edited: true
+        edited: updatedMessage.sender.bot ? false : true
       };
     }
 
+    // Update the mime model.
+    if (updatedMessage.mime_model) {
+      message.mime_model = updatedMessage.mime_model;
+    }
+
     // Update the attachments.
     const attachmentIds = updatedMessage.attachments?.map(attachment =>
       this.sharedModel.setAttachment(attachment)
@@ -551,7 +573,8 @@ export class LabChatModel
               'raw_time',
               'deleted',
               'edited',
-              'metadata'
+              'metadata',
+              'mime_model'
             ].includes(key)
           ) {
             const update: Partial<IMessageContent> = {};
@@ -597,6 +620,7 @@ export class LabChatModel
         )
       ) {
         this._sharedModel.id = UUID.uuid4();
+        this.setReady();
       }
     }
   };
@@ -606,6 +630,11 @@ export class LabChatModel
 
   private _sharedModel: YChat;
 
+  private _documentSynced = false;
+  private _preReadyMessages: Array<{
+    index: number;
+    messages: IMessageContent[];
+  }> = [];
   private _dirty = false;
   private _readOnly = false;
   private _contentChanged = new Signal<this, void>(this);