@lvce-editor/chat-view 1.20.0 → 2.0.0

package/dist/chatViewWorkerMain.js

@@ -698,7 +698,7 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const errorProperty = getErrorProperty(error, prettyError);
   return create$1$1(id, errorProperty);
 };
-const create$9 = (message, result) => {
+const create$a = (message, result) => {
   return {
     id: message.id,
     jsonrpc: Two$1,
@@ -707,7 +707,7 @@ const create$9 = (message, result) => {
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$9(message, resultProperty);
+  return create$a(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
@@ -801,7 +801,7 @@ const handleJsonRpcMessage = async (...args) => {
 
 const Two = '2.0';
 
-const create$8 = (method, params) => {
+const create$9 = (method, params) => {
   return {
     jsonrpc: Two,
     method,
@@ -809,7 +809,7 @@ const create$8 = (method, params) => {
   };
 };
 
-const create$7 = (id, method, params) => {
+const create$8 = (id, method, params) => {
   const message = {
     id,
     jsonrpc: Two,
@@ -820,12 +820,12 @@ const create$7 = (id, method, params) => {
 };
 
 let id$1 = 0;
-const create$6 = () => {
+const create$7 = () => {
   return ++id$1;
 };
 
 const registerPromise = map => {
-  const id = create$6();
+  const id = create$7();
   const {
     promise,
     resolve
@@ -842,7 +842,7 @@ const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer)
     id,
     promise
   } = registerPromise(callbacks);
-  const message = create$7(id, method, params);
+  const message = create$8(id, method, params);
   if (useSendAndTransfer && ipc.sendAndTransfer) {
     ipc.sendAndTransfer(message);
   } else {
@@ -878,7 +878,7 @@ const createRpc = ipc => {
      * @deprecated
      */
     send(method, ...params) {
-      const message = create$8(method, params);
+      const message = create$9(method, params);
       ipc.send(message);
     }
   };
@@ -918,7 +918,7 @@ const listen$1 = async (module, options) => {
   return ipc;
 };
 
-const create$5 = async ({
+const create$6 = async ({
   commandMap,
   isMessagePortOpen = true,
   messagePort
@@ -936,7 +936,7 @@ const create$5 = async ({
   return rpc;
 };
 
-const create$4 = async ({
+const create$5 = async ({
   commandMap,
   isMessagePortOpen,
   send
@@ -946,13 +946,55 @@ const create$4 = async ({
     port2
   } = new MessageChannel();
   await send(port1);
-  return create$5({
+  return create$6({
     commandMap,
     isMessagePortOpen,
     messagePort: port2
   });
 };
 
+const createSharedLazyRpc = factory => {
+  let rpcPromise;
+  const getOrCreate = () => {
+    if (!rpcPromise) {
+      rpcPromise = factory();
+    }
+    return rpcPromise;
+  };
+  return {
+    async dispose() {
+      const rpc = await getOrCreate();
+      await rpc.dispose();
+    },
+    async invoke(method, ...params) {
+      const rpc = await getOrCreate();
+      return rpc.invoke(method, ...params);
+    },
+    async invokeAndTransfer(method, ...params) {
+      const rpc = await getOrCreate();
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    async send(method, ...params) {
+      const rpc = await getOrCreate();
+      rpc.send(method, ...params);
+    }
+  };
+};
+
+const create$4 = async ({
+  commandMap,
+  isMessagePortOpen,
+  send
+}) => {
+  return createSharedLazyRpc(() => {
+    return create$5({
+      commandMap,
+      isMessagePortOpen,
+      send
+    });
+  });
+};
+
 const create$3 = async ({
   commandMap
 }) => {
@@ -964,9 +1006,6 @@ const create$3 = async ({
   return rpc;
 };
 
-const ExtensionHostWorker = 44;
-const RendererWorker = 1;
-
 const createMockRpc = ({
   commandMap
 }) => {
@@ -1035,6 +1074,26 @@ const create$2 = rpcId => {
   };
 };
 
+const ClientX = 'event.clientX';
+const ClientY = 'event.clientY';
+const Key = 'event.key';
+const ShiftKey = 'event.shiftKey';
+const TargetName = 'event.target.name';
+const TargetValue = 'event.target.value';
+
+const ExtensionHostWorker = 44;
+const RendererWorker = 1;
+
+const FocusSelector = 'Viewlet.focusSelector';
+const SetCss = 'Viewlet.setCss';
+const SetDom2 = 'Viewlet.setDom2';
+const SetFocusContext = 'Viewlet.setFocusContext';
+const SetProperty = 'Viewlet.setProperty';
+const SetValueByName = 'Viewlet.setValueByName';
+const SetPatches = 'Viewlet.setPatches';
+
+const FocusChatInput = 8000;
+
 const {
   invoke: invoke$1,
   set: set$2
@@ -1528,23 +1587,6 @@ const diff2 = uid => {
   return result;
 };
 
-const ClientX = 'event.clientX';
-const ClientY = 'event.clientY';
-const Key = 'event.key';
-const ShiftKey = 'event.shiftKey';
-const TargetName = 'event.target.name';
-const TargetValue = 'event.target.value';
-
-const FocusSelector = 'Viewlet.focusSelector';
-const SetCss = 'Viewlet.setCss';
-const SetDom2 = 'Viewlet.setDom2';
-const SetFocusContext = 'Viewlet.setFocusContext';
-const SetProperty = 'Viewlet.setProperty';
-const SetValueByName = 'Viewlet.setValueByName';
-const SetPatches = 'Viewlet.setPatches';
-
-const FocusChatInput = 8000;
-
 const Button$2 = 'button';
 
 const Button$1 = 1;
@@ -1934,29 +1976,6 @@ const requestToPromise = async createRequest => {
   return promise;
 };
 
-const openSessionsDatabase = async (databaseName, databaseVersion, storeName) => {
-  const request = indexedDB.open(databaseName, databaseVersion);
-  request.addEventListener('upgradeneeded', () => {
-    const database = request.result;
-    if (!database.objectStoreNames.contains(storeName)) {
-      database.createObjectStore(storeName, {
-        keyPath: 'id'
-      });
-    }
-  });
-  return requestToPromise(() => request);
-};
-
-const getDatabase = async (getDatabasePromise, setDatabasePromise, databaseName, databaseVersion, storeName) => {
-  const existingDatabasePromise = getDatabasePromise();
-  if (existingDatabasePromise) {
-    return existingDatabasePromise;
-  }
-  const nextDatabasePromise = openSessionsDatabase(databaseName, databaseVersion, storeName);
-  setDatabasePromise(nextDatabasePromise);
-  return nextDatabasePromise;
-};
-
 const transactionToPromise = async createTransaction => {
   const transaction = createTransaction();
   const {
@@ -1976,97 +1995,518 @@ const transactionToPromise = async createTransaction => {
   return promise;
 };
 
-const clear = async (getDatabasePromise, setDatabasePromise, databaseName, databaseVersion, storeName) => {
-  const database = await getDatabase(getDatabasePromise, setDatabasePromise, databaseName, databaseVersion, storeName);
-  const transaction = database.transaction(storeName, 'readwrite');
-  const createTransaction = () => transaction;
-  const store = transaction.objectStore(storeName);
-  store.clear();
-  await transactionToPromise(createTransaction);
+const toChatViewEvent = event => {
+  const {
+    eventId,
+    ...chatViewEvent
+  } = event;
+  return chatViewEvent;
 };
-
-const deleteSession$1 = async (getDatabasePromise, setDatabasePromise, databaseName, databaseVersion, storeName, id) => {
-  const database = await getDatabase(getDatabasePromise, setDatabasePromise, databaseName, databaseVersion, storeName);
-  const transaction = database.transaction(storeName, 'readwrite');
-  const createTransaction = () => transaction;
-  const store = transaction.objectStore(storeName);
-  store.delete(id);
-  await transactionToPromise(createTransaction);
+const now$1 = () => {
+  return new Date().toISOString();
 };
-
-const getSession = async (getDatabasePromise, setDatabasePromise, databaseName, databaseVersion, storeName, id) => {
-  const database = await getDatabase(getDatabasePromise, setDatabasePromise, databaseName, databaseVersion, storeName);
-  const transaction = database.transaction(storeName, 'readonly');
-  const store = transaction.objectStore(storeName);
-  const result = await requestToPromise(() => store.get(id));
-  return result;
+const isSameMessage$1 = (a, b) => {
+  return a.id === b.id && a.inProgress === b.inProgress && a.role === b.role && a.text === b.text && a.time === b.time;
 };
-
-const listSessions = async (getDatabasePromise, setDatabasePromise, databaseName, databaseVersion, storeName) => {
-  const database = await getDatabase(getDatabasePromise, setDatabasePromise, databaseName, databaseVersion, storeName);
-  const transaction = database.transaction(storeName, 'readonly');
-  const store = transaction.objectStore(storeName);
-  const result = await requestToPromise(() => store.getAll());
-  return result;
+const canAppendMessages$1 = (previousMessages, nextMessages) => {
+  if (nextMessages.length < previousMessages.length) {
+    return false;
+  }
+  return previousMessages.every((message, index) => isSameMessage$1(message, nextMessages[index]));
 };
-
-const setSession = async (getDatabasePromise, setDatabasePromise, databaseName, databaseVersion, storeName, session) => {
-  const database = await getDatabase(getDatabasePromise, setDatabasePromise, databaseName, databaseVersion, storeName);
-  const transaction = database.transaction(storeName, 'readwrite');
-  const createTransaction = () => transaction;
-  const store = transaction.objectStore(storeName);
-  store.put(session);
-  await transactionToPromise(createTransaction);
+const canUpdateMessages$1 = (previousMessages, nextMessages) => {
+  if (previousMessages.length !== nextMessages.length) {
+    return false;
+  }
+  for (let i = 0; i < previousMessages.length; i += 1) {
+    const previous = previousMessages[i];
+    const next = nextMessages[i];
+    if (previous.id !== next.id || previous.role !== next.role) {
+      return false;
+    }
+  }
+  return true;
+};
+const getMutationEvents$1 = (previous, next) => {
+  const timestamp = now$1();
+  const events = [];
+  if (!previous) {
+    events.push({
+      sessionId: next.id,
+      timestamp,
+      title: next.title,
+      type: 'chat-session-created'
+    });
+    for (const message of next.messages) {
+      events.push({
+        message,
+        sessionId: next.id,
+        timestamp,
+        type: 'chat-message-added'
+      });
+    }
+    return events;
+  }
+  if (previous.title !== next.title) {
+    events.push({
+      sessionId: next.id,
+      timestamp,
+      title: next.title,
+      type: 'chat-session-title-updated'
+    });
+  }
+  if (canAppendMessages$1(previous.messages, next.messages)) {
+    for (let i = previous.messages.length; i < next.messages.length; i += 1) {
+      events.push({
+        message: next.messages[i],
+        sessionId: next.id,
+        timestamp,
+        type: 'chat-message-added'
+      });
+    }
+    return events;
+  }
+  if (canUpdateMessages$1(previous.messages, next.messages)) {
+    for (let i = 0; i < previous.messages.length; i += 1) {
+      const previousMessage = previous.messages[i];
+      const nextMessage = next.messages[i];
+      if (!isSameMessage$1(previousMessage, nextMessage)) {
+        events.push({
+          inProgress: nextMessage.inProgress,
+          messageId: nextMessage.id,
+          sessionId: next.id,
+          text: nextMessage.text,
+          time: nextMessage.time,
+          timestamp,
+          type: 'chat-message-updated'
+        });
+      }
+    }
+    return events;
+  }
+  events.push({
+    messages: [...next.messages],
+    sessionId: next.id,
+    timestamp,
+    type: 'chat-session-messages-replaced'
+  });
+  return events;
+};
+const replaySession$1 = (id, summary, events) => {
+  let deleted = false;
+  let title = summary?.title || '';
+  let messages = summary?.messages ? [...summary.messages] : [];
+  for (const event of events) {
+    if (event.sessionId !== id) {
+      continue;
+    }
+    if (event.type === 'chat-session-created') {
+      const {
+        title: eventTitle
+      } = event;
+      deleted = false;
+      title = eventTitle;
+      continue;
+    }
+    if (event.type === 'chat-session-deleted') {
+      deleted = true;
+      continue;
+    }
+    if (event.type === 'chat-session-title-updated') {
+      const {
+        title: eventTitle
+      } = event;
+      title = eventTitle;
+      continue;
+    }
+    if (event.type === 'chat-message-added') {
+      messages = [...messages, event.message];
+      continue;
+    }
+    if (event.type === 'chat-message-updated') {
+      messages = messages.map(message => {
+        if (message.id !== event.messageId) {
+          return message;
+        }
+        return {
+          ...message,
+          inProgress: event.inProgress,
+          text: event.text,
+          time: event.time
+        };
+      });
+      continue;
+    }
+    if (event.type === 'chat-session-messages-replaced') {
+      messages = [...event.messages];
+    }
+  }
+  if (deleted || !title) {
+    return undefined;
+  }
+  return {
+    id,
+    messages,
+    title
+  };
 };
-
 class IndexedDbChatSessionStorage {
   constructor(options = {}) {
     this.state = {
       databaseName: options.databaseName || 'lvce-chat-view-sessions',
       databasePromise: undefined,
-      databaseVersion: options.databaseVersion || 1,
+      databaseVersion: options.databaseVersion || 2,
+      eventStoreName: options.eventStoreName || 'chat-view-events',
       storeName: options.storeName || 'chat-sessions'
     };
   }
-  getDatabasePromise = () => {
-    return this.state.databasePromise;
-  };
-  setDatabasePromise = databasePromise => {
+  openDatabase = async () => {
+    if (this.state.databasePromise) {
+      return this.state.databasePromise;
+    }
+    const request = indexedDB.open(this.state.databaseName, this.state.databaseVersion);
+    request.addEventListener('upgradeneeded', () => {
+      const database = request.result;
+      if (!database.objectStoreNames.contains(this.state.storeName)) {
+        database.createObjectStore(this.state.storeName, {
+          keyPath: 'id'
+        });
+      }
+      if (database.objectStoreNames.contains(this.state.eventStoreName)) {
+        const {
+          transaction
+        } = request;
+        if (!transaction) {
+          return;
+        }
+        const eventStore = transaction.objectStore(this.state.eventStoreName);
+        if (!eventStore.indexNames.contains('sessionId')) {
+          eventStore.createIndex('sessionId', 'sessionId', {
+            unique: false
+          });
+        }
+      } else {
+        const eventStore = database.createObjectStore(this.state.eventStoreName, {
+          autoIncrement: true,
+          keyPath: 'eventId'
+        });
+        eventStore.createIndex('sessionId', 'sessionId', {
+          unique: false
+        });
+      }
+    });
+    const databasePromise = requestToPromise(() => request);
     this.state.databasePromise = databasePromise;
+    return databasePromise;
+  };
+  listSummaries = async () => {
+    const database = await this.openDatabase();
+    const transaction = database.transaction(this.state.storeName, 'readonly');
+    const store = transaction.objectStore(this.state.storeName);
+    const summaries = await requestToPromise(() => store.getAll());
+    return summaries;
   };
+  getSummary = async id => {
+    const database = await this.openDatabase();
+    const transaction = database.transaction(this.state.storeName, 'readonly');
+    const store = transaction.objectStore(this.state.storeName);
+    const summary = await requestToPromise(() => store.get(id));
+    return summary;
+  };
+  getEventsBySessionId = async sessionId => {
+    const database = await this.openDatabase();
+    const transaction = database.transaction(this.state.eventStoreName, 'readonly');
+    const store = transaction.objectStore(this.state.eventStoreName);
+    const index = store.index('sessionId');
+    const events = await requestToPromise(() => index.getAll(IDBKeyRange.only(sessionId)));
+    return events.map(toChatViewEvent);
+  };
+  listEventsInternal = async () => {
+    const database = await this.openDatabase();
+    const transaction = database.transaction(this.state.eventStoreName, 'readonly');
+    const store = transaction.objectStore(this.state.eventStoreName);
+    const events = await requestToPromise(() => store.getAll());
+    return events.map(toChatViewEvent);
+  };
+  appendEvents = async events => {
+    if (events.length === 0) {
+      return;
+    }
+    const database = await this.openDatabase();
+    const transaction = database.transaction([this.state.storeName, this.state.eventStoreName], 'readwrite');
+    const summaryStore = transaction.objectStore(this.state.storeName);
+    const eventStore = transaction.objectStore(this.state.eventStoreName);
+    for (const event of events) {
+      eventStore.add(event);
+      if (event.type === 'chat-session-created' || event.type === 'chat-session-title-updated') {
+        summaryStore.put({
+          id: event.sessionId,
+          title: event.title
+        });
+      }
+      if (event.type === 'chat-session-deleted') {
+        summaryStore.delete(event.sessionId);
+      }
+    }
+    await transactionToPromise(() => transaction);
+  };
+  async appendEvent(event) {
+    await this.appendEvents([event]);
+  }
   async clear() {
-    return clear(this.getDatabasePromise, this.setDatabasePromise, this.state.databaseName, this.state.databaseVersion, this.state.storeName);
+    const database = await this.openDatabase();
+    const transaction = database.transaction([this.state.storeName, this.state.eventStoreName], 'readwrite');
+    transaction.objectStore(this.state.storeName).clear();
+    transaction.objectStore(this.state.eventStoreName).clear();
+    await transactionToPromise(() => transaction);
   }
   async deleteSession(id) {
-    return deleteSession$1(this.getDatabasePromise, this.setDatabasePromise, this.state.databaseName, this.state.databaseVersion, this.state.storeName, id);
+    await this.appendEvent({
+      sessionId: id,
+      timestamp: now$1(),
+      type: 'chat-session-deleted'
+    });
+  }
+  async getEvents(sessionId) {
+    if (sessionId) {
+      return this.getEventsBySessionId(sessionId);
+    }
+    return this.listEventsInternal();
   }
   async getSession(id) {
-    return getSession(this.getDatabasePromise, this.setDatabasePromise, this.state.databaseName, this.state.databaseVersion, this.state.storeName, id);
+    const [summary, events] = await Promise.all([this.getSummary(id), this.getEventsBySessionId(id)]);
+    return replaySession$1(id, summary, events);
   }
   async listSessions() {
-    return listSessions(this.getDatabasePromise, this.setDatabasePromise, this.state.databaseName, this.state.databaseVersion, this.state.storeName);
+    const summaries = await this.listSummaries();
+    const sessions = [];
+    for (const summary of summaries) {
+      const events = await this.getEventsBySessionId(summary.id);
+      const session = replaySession$1(summary.id, summary, events);
+      if (!session) {
+        continue;
+      }
+      sessions.push(session);
+    }
+    return sessions;
   }
   async setSession(session) {
-    return setSession(this.getDatabasePromise, this.setDatabasePromise, this.state.databaseName, this.state.databaseVersion, this.state.storeName, session);
+    const previous = await this.getSession(session.id);
+    const events = getMutationEvents$1(previous, session);
+    await this.appendEvents(events);
+    if (events.length === 0) {
+      const database = await this.openDatabase();
+      const transaction = database.transaction(this.state.storeName, 'readwrite');
+      const summaryStore = transaction.objectStore(this.state.storeName);
+      summaryStore.put({
+        id: session.id,
+        title: session.title
+      });
+      await transactionToPromise(() => transaction);
+    }
   }
 }
 
+const now = () => {
+  return new Date().toISOString();
+};
+const isSameMessage = (a, b) => {
+  return a.id === b.id && a.inProgress === b.inProgress && a.role === b.role && a.text === b.text && a.time === b.time;
+};
+const canAppendMessages = (previousMessages, nextMessages) => {
+  if (nextMessages.length < previousMessages.length) {
+    return false;
+  }
+  return previousMessages.every((message, index) => isSameMessage(message, nextMessages[index]));
+};
+const canUpdateMessages = (previousMessages, nextMessages) => {
+  if (previousMessages.length !== nextMessages.length) {
+    return false;
+  }
+  for (let i = 0; i < previousMessages.length; i += 1) {
+    const previous = previousMessages[i];
+    const next = nextMessages[i];
+    if (previous.id !== next.id || previous.role !== next.role) {
+      return false;
+    }
+  }
+  return true;
+};
+const getMutationEvents = (previous, next) => {
+  const timestamp = now();
+  const events = [];
+  if (!previous) {
+    events.push({
+      sessionId: next.id,
+      timestamp,
+      title: next.title,
+      type: 'chat-session-created'
+    });
+    for (const message of next.messages) {
+      events.push({
+        message,
+        sessionId: next.id,
+        timestamp,
+        type: 'chat-message-added'
+      });
+    }
+    return events;
+  }
+  if (previous.title !== next.title) {
+    events.push({
+      sessionId: next.id,
+      timestamp,
+      title: next.title,
+      type: 'chat-session-title-updated'
+    });
+  }
+  if (canAppendMessages(previous.messages, next.messages)) {
+    for (let i = previous.messages.length; i < next.messages.length; i += 1) {
+      events.push({
+        message: next.messages[i],
+        sessionId: next.id,
+        timestamp,
+        type: 'chat-message-added'
+      });
+    }
+    return events;
+  }
+  if (canUpdateMessages(previous.messages, next.messages)) {
+    for (let i = 0; i < previous.messages.length; i += 1) {
+      const previousMessage = previous.messages[i];
+      const nextMessage = next.messages[i];
+      if (!isSameMessage(previousMessage, nextMessage)) {
+        events.push({
+          inProgress: nextMessage.inProgress,
+          messageId: nextMessage.id,
+          sessionId: next.id,
+          text: nextMessage.text,
+          time: nextMessage.time,
+          timestamp,
+          type: 'chat-message-updated'
+        });
+      }
+    }
+    return events;
+  }
+  events.push({
+    messages: [...next.messages],
+    sessionId: next.id,
+    timestamp,
+    type: 'chat-session-messages-replaced'
+  });
+  return events;
+};
+const replaySession = (id, title, events) => {
+  let deleted = false;
+  let currentTitle = title || '';
+  let messages = [];
+  for (const event of events) {
+    if (event.sessionId !== id) {
+      continue;
+    }
+    if (event.type === 'chat-session-created') {
+      deleted = false;
+      currentTitle = event.title;
+      continue;
+    }
+    if (event.type === 'chat-session-deleted') {
+      deleted = true;
+      continue;
+    }
+    if (event.type === 'chat-session-title-updated') {
+      currentTitle = event.title;
+      continue;
+    }
+    if (event.type === 'chat-message-added') {
+      messages = [...messages, event.message];
+      continue;
+    }
+    if (event.type === 'chat-message-updated') {
+      messages = messages.map(message => {
+        if (message.id !== event.messageId) {
+          return message;
+        }
+        return {
+          ...message,
+          inProgress: event.inProgress,
+          text: event.text,
+          time: event.time
+        };
+      });
+      continue;
+    }
+    if (event.type === 'chat-session-messages-replaced') {
+      messages = [...event.messages];
+    }
+  }
+  if (deleted || !currentTitle) {
+    return undefined;
+  }
+  return {
+    id,
+    messages,
+    title: currentTitle
+  };
+};
 class InMemoryChatSessionStorage {
-  sessions = new Map();
+  events = [];
+  summaries = new Map();
+  async appendEvent(event) {
+    this.events.push(event);
+    if (event.type === 'chat-session-created' || event.type === 'chat-session-title-updated') {
+      this.summaries.set(event.sessionId, event.title);
+      return;
+    }
+    if (event.type === 'chat-session-deleted') {
+      this.summaries.delete(event.sessionId);
+    }
+  }
   async clear() {
-    this.sessions.clear();
+    this.events.length = 0;
+    this.summaries.clear();
   }
   async deleteSession(id) {
-    this.sessions.delete(id);
+    await this.appendEvent({
+      sessionId: id,
+      timestamp: now(),
+      type: 'chat-session-deleted'
+    });
+  }
+  async getEvents(sessionId) {
+    if (!sessionId) {
+      return [...this.events];
+    }
+    return this.events.filter(event => event.sessionId === sessionId);
   }
   async getSession(id) {
-    return this.sessions.get(id);
+    return replaySession(id, this.summaries.get(id), this.events);
   }
   async listSessions() {
-    return [...this.sessions.values()];
+    const ids = new Set();
+    for (const id of this.summaries.keys()) {
+      ids.add(id);
+    }
+    for (const event of this.events) {
+      ids.add(event.sessionId);
+    }
+    const sessions = [];
+    for (const id of ids) {
+      const session = replaySession(id, this.summaries.get(id), this.events);
+      if (!session) {
+        continue;
+      }
+      sessions.push(session);
+    }
+    return sessions;
   }
   async setSession(session) {
-    this.sessions.set(session.id, session);
+    const previous = await this.getSession(session.id);
+    const events = getMutationEvents(previous, session);
+    for (const event of events) {
+      await this.appendEvent(event);
+    }
+    this.summaries.set(session.id, session.title);
   }
 }
 
@@ -2109,6 +2549,9 @@ const deleteChatSession = async id => {
 const clearChatSessions = async () => {
   await chatSessionStorage.clear();
 };
+const appendChatViewEvent = async event => {
+  await chatSessionStorage.appendEvent(event);
+};
 
 const generateSessionId = () => {
   return crypto.randomUUID();
@@ -2601,6 +3044,20 @@ const getTextContent = content => {
   return textParts.join('\n');
 };
 
+const getOpenAiParams = (completionMessages, modelId, stream, includeObfuscation, tools) => {
+  return {
+    messages: completionMessages,
+    model: modelId,
+    ...(stream ? {
+      stream: true
+    } : {}),
+    ...(includeObfuscation ? {
+      include_obfuscation: true
+    } : {}),
+    tool_choice: 'auto',
+    tools
+  };
+};
 const getStreamChunkText = content => {
   if (typeof content === 'string') {
     return content;
@@ -2784,18 +3241,7 @@ const getOpenApiAssistantText = async (messages, modelId, openApiApiKey, openApi
     let response;
     try {
       response = await fetch(getOpenApiApiEndpoint(openApiApiBaseUrl, stream), {
-        body: JSON.stringify({
-          messages: completionMessages,
-          model: modelId,
-          ...(stream ? {
-            stream: true
-          } : {}),
-          ...(includeObfuscation ? {
-            include_obfuscation: true
-          } : {}),
-          tool_choice: 'auto',
-          tools
-        }),
+        body: JSON.stringify(getOpenAiParams(completionMessages, modelId, stream, includeObfuscation, tools)),
         headers: {
           Authorization: `Bearer ${openApiApiKey}`,
           'Content-Type': 'application/json',
@@ -3527,6 +3973,13 @@ const handleTextChunkFunction = async (uid, assistantMessageId, chunk, handleTex
       previousState: handleTextChunkState.previousState
     };
   }
+  await appendChatViewEvent({
+    content: chunk,
+    messageId: assistantMessageId,
+    sessionId: handleTextChunkState.latestState.selectedSessionId,
+    timestamp: new Date().toISOString(),
+    type: 'handle-response-chunk'
+  });
   const updatedText = assistantMessage.text + chunk;
   const updatedSessions = updateMessageTextInSelectedSession(handleTextChunkState.latestState.sessions, handleTextChunkState.latestState.selectedSessionId, assistantMessageId, updatedText, true);
   const nextState = {
@@ -3614,6 +4067,12 @@ const handleSubmit = async state => {
   let optimisticState;
   if (viewMode === 'list') {
     const newSessionId = generateSessionId();
+    await appendChatViewEvent({
+      sessionId: newSessionId,
+      timestamp: new Date().toISOString(),
+      type: 'handle-submit',
+      value: userText
+    });
     const newSession = {
       id: newSessionId,
       messages: streamingEnabled ? [userMessage, inProgressAssistantMessage] : [userMessage],
@@ -3632,6 +4091,12 @@ const handleSubmit = async state => {
       viewMode: 'detail'
     });
   } else {
+    await appendChatViewEvent({
+      sessionId: selectedSessionId,
+      timestamp: new Date().toISOString(),
+      type: 'handle-submit',
+      value: userText
+    });
     const updatedWithUser = appendMessageToSelectedSession(workingSessions, selectedSessionId, userMessage);
     const updatedSessions = streamingEnabled ? appendMessageToSelectedSession(updatedWithUser, selectedSessionId, inProgressAssistantMessage) : updatedWithUser;
     const selectedSession = updatedSessions.find(session => session.id === selectedSessionId);
@@ -3877,6 +4342,14 @@ const handleInput = async (state, name, value, inputSource = 'user') => {
   if (name !== Composer) {
     return state;
   }
+  if (state.selectedSessionId) {
+    await appendChatViewEvent({
+      sessionId: state.selectedSessionId,
+      timestamp: new Date().toISOString(),
+      type: 'handle-input',
+      value
+    });
+  }
   const composerHeight = await getComposerHeight(state, value);
   return {
     ...state,
@@ -4016,7 +4489,7 @@ const sendMessagePortToExtensionHostWorker = async port => {
 
 const createExtensionHostRpc = async () => {
   try {
-    const rpc = await create$4({
+    const rpc = await create$5({
       commandMap: {},
       send: sendMessagePortToExtensionHostWorker
     });
@@ -5107,12 +5580,24 @@ const commandMap = {
   'Chat.useMockApi': wrapCommand(useMockApi)
 };
 
+const send = port => {
+  return invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToChatNetworkWorker', port, 'HandleMessagePort.handleMessagePort');
+};
+const initializeChatNetworkWorker = async () => {
+  const rpc = await create$4({
+    commandMap: {},
+    send
+  });
+  return rpc;
+};
+
 const listen = async () => {
   registerCommands(commandMap);
   const rpc = await create$3({
     commandMap: commandMap
   });
   set$1(rpc);
+  await initializeChatNetworkWorker();
 };
 
 const main = async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/chat-view",
-  "version": "1.20.0",
+  "version": "2.0.0",
   "description": "Chat View Worker",
   "repository": {
     "type": "git",
@@ -9,10 +9,5 @@
   "license": "MIT",
   "author": "Lvce Editor",
   "type": "module",
-  "main": "dist/chatViewWorkerMain.js",
-  "dependencies": {
-    "@lvce-editor/constants": "^4.1.0",
-    "@lvce-editor/i18n": "^2.1.0",
-    "@lvce-editor/virtual-dom-worker": "^8.9.0"
-  }
+  "main": "dist/chatViewWorkerMain.js"
 }