chore: bump version (#3197)

plugins/copilot/src/core/components/conversation-list/index.tsx

@@ -1,10 +1,10 @@
-import type { BaseChatMessage } from 'langchain/schema';
+import type { BaseMessage } from 'langchain/schema';
 
 import { Conversation } from '../conversation';
 import { conversationListStyle } from './index.css';
 
 export type ConversationListProps = {
-  conversations: BaseChatMessage[];
+  conversations: BaseMessage[];
 };
 
 export const ConversationList = (props: ConversationListProps) => {
@@ -13,7 +13,7 @@ export const ConversationList = (props: ConversationListProps) => {
       {props.conversations.map((conversation, idx) => (
         <Conversation
           type={conversation._getType()}
-          text={conversation.text}
+          text={conversation.content}
           key={idx}
         />
       ))}

plugins/copilot/src/core/hooks/index.ts

@@ -6,11 +6,9 @@ import type { WritableAtom } from 'jotai/vanilla';
 import type { LLMChain } from 'langchain/chains';
 import { type ConversationChain } from 'langchain/chains';
 import { type BufferMemory } from 'langchain/memory';
-import {
-  AIChatMessage,
-  type BaseChatMessage,
-  HumanChatMessage,
-} from 'langchain/schema';
+import type { BaseMessage } from 'langchain/schema';
+import { AIMessage } from 'langchain/schema';
+import { HumanMessage } from 'langchain/schema';
 import { z } from 'zod';
 
 import { createChatAI } from '../chat';
@@ -32,18 +30,18 @@ export const chatAtom = atom(async get => {
 
 const conversationWeakMap = new WeakMap<
   ConversationChain,
-  WritableAtom<BaseChatMessage[], [string], Promise<void>>
+  WritableAtom<BaseMessage[], [string], Promise<void>>
 >();
 
 const getConversationAtom = (chat: ConversationChain) => {
   if (conversationWeakMap.has(chat)) {
     return conversationWeakMap.get(chat) as WritableAtom<
-      BaseChatMessage[],
+      BaseMessage[],
       [string],
       Promise<void>
     >;
   }
-  const conversationBaseAtom = atom<BaseChatMessage[]>([]);
+  const conversationBaseAtom = atom<BaseMessage[]>([]);
   conversationBaseAtom.onMount = setAtom => {
     if (!chat) {
       throw new Error();
@@ -58,12 +56,12 @@ const getConversationAtom = (chat: ConversationChain) => {
         console.error(err);
       });
     const llmStart = (): void => {
-      setAtom(conversations => [...conversations, new AIChatMessage('')]);
+      setAtom(conversations => [...conversations, new AIMessage('')]);
     };
     const llmNewToken = (event: CustomEvent<{ token: string }>): void => {
       setAtom(conversations => {
-        const last = conversations[conversations.length - 1] as AIChatMessage;
-        last.text += event.detail.token;
+        const last = conversations[conversations.length - 1] as AIMessage;
+        last.content += event.detail.token;
         return [...conversations];
       });
     };
@@ -75,7 +73,7 @@ const getConversationAtom = (chat: ConversationChain) => {
     };
   };
 
-  const conversationAtom = atom<BaseChatMessage[], [string], Promise<void>>(
+  const conversationAtom = atom<BaseMessage[], [string], Promise<void>>(
     get => get(conversationBaseAtom),
     async (get, set, input) => {
       if (!chat) {
@@ -84,7 +82,7 @@ const getConversationAtom = (chat: ConversationChain) => {
       // set dirty value
       set(conversationBaseAtom, [
         ...get(conversationBaseAtom),
-        new HumanChatMessage(input),
+        new HumanMessage(input),
       ]);
       await chat.call({
         input,

plugins/copilot/src/core/langchain/message-history.ts

@@ -1,13 +1,13 @@
 import type { DBSchema, IDBPDatabase } from 'idb';
 import { openDB } from 'idb';
 import { ChatMessageHistory } from 'langchain/memory';
+import type { BaseMessage } from 'langchain/schema';
 import {
-  AIChatMessage,
-  type BaseChatMessage,
+  AIMessage,
   ChatMessage,
-  HumanChatMessage,
+  HumanMessage,
   type StoredMessage,
-  SystemChatMessage,
+  SystemMessage,
 } from 'langchain/schema';
 
 interface ChatMessageDBV1 extends DBSchema {
@@ -40,7 +40,7 @@ export const conversationHistoryDBName = 'affine-copilot-chat';
 
 export class IndexedDBChatMessageHistory extends ChatMessageHistory {
   public id: string;
-  private chatMessages: BaseChatMessage[] = [];
+  private chatMessages: BaseMessage[] = [];
 
   private readonly dbPromise: Promise<IDBPDatabase<ChatMessageDBV2>>;
   private readonly initPromise: Promise<void>;
@@ -74,11 +74,11 @@ export class IndexedDBChatMessageHistory extends ChatMessageHistory {
         this.chatMessages = chat.messages.map(message => {
           switch (message.type) {
             case 'ai':
-              return new AIChatMessage(message.data.content);
+              return new AIMessage(message.data.content);
             case 'human':
-              return new HumanChatMessage(message.data.content);
+              return new HumanMessage(message.data.content);
             case 'system':
-              return new SystemChatMessage(message.data.content);
+              return new SystemMessage(message.data.content);
             default:
               return new ChatMessage(
                 message.data.content,
@@ -115,29 +115,29 @@ export class IndexedDBChatMessageHistory extends ChatMessageHistory {
     return [];
   }
 
-  override async addMessage(message: BaseChatMessage): Promise<void> {
+  override async addMessage(message: BaseMessage): Promise<void> {
     await this.initPromise;
     this.chatMessages.push(message);
     const db = await this.dbPromise;
     const objectStore = db.transaction('chat', 'readwrite').objectStore('chat');
     const chat = await objectStore.get(this.id);
     if (chat != null) {
-      chat.messages.push(message.toJSON());
+      chat.messages.push(message.toDict());
       await objectStore.put(chat);
     } else {
       await objectStore.add({
         id: this.id,
-        messages: [message.toJSON()],
+        messages: [message.toDict()],
       });
     }
   }
 
   override async addAIChatMessage(message: string): Promise<void> {
-    await this.addMessage(new AIChatMessage(message));
+    await this.addMessage(new AIMessage(message));
   }
 
   override async addUserMessage(message: string): Promise<void> {
-    await this.addMessage(new HumanChatMessage(message));
+    await this.addMessage(new HumanMessage(message));
   }
 
   override async clear(): Promise<void> {
@@ -148,7 +148,7 @@ export class IndexedDBChatMessageHistory extends ChatMessageHistory {
     await objectStore.delete(this.id);
   }
 
-  override async getMessages(): Promise<BaseChatMessage[]> {
+  override async getMessages(): Promise<BaseMessage[]> {
     return this.initPromise.then(() => this.chatMessages);
   }
 }