@lvce-editor/static-server 0.75.9 → 0.75.11

package/static/{52a862f → c86dcc9}/packages/chat-view/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
@@ -1192,6 +1251,9 @@ const getComposerWidth = width => {
 const getMinComposerHeight = lineHeight => {
   return lineHeight + 8;
 };
+const getMaxComposerHeight = (lineHeight, maxComposerRows) => {
+  return lineHeight * Math.max(1, maxComposerRows) + 8;
+};
 const estimateComposerHeight = (value, lineHeight) => {
   const lineCount = value.split('\n').length;
   return lineCount * lineHeight + 8;
@@ -1200,17 +1262,19 @@ const getComposerHeight = async (state, value, width = state.width) => {
   const {
     composerFontFamily,
     composerFontSize,
-    composerLineHeight
+    composerLineHeight,
+    maxComposerRows
   } = state;
   const minimumHeight = getMinComposerHeight(composerLineHeight);
+  const maximumHeight = getMaxComposerHeight(composerLineHeight, maxComposerRows);
   const content = value || ' ';
   const composerWidth = getComposerWidth(width);
   try {
     const measuredHeight = await measureTextBlockHeight(content, composerFontFamily, composerFontSize, composerLineHeight, composerWidth);
     const height = Math.ceil(measuredHeight) + 8;
-    return Math.max(minimumHeight, height);
+    return Math.max(minimumHeight, Math.min(maximumHeight, height));
   } catch {
-    return Math.max(minimumHeight, estimateComposerHeight(value, composerLineHeight));
+    return Math.max(minimumHeight, Math.min(maximumHeight, estimateComposerHeight(value, composerLineHeight)));
   }
 };
 const getMinComposerHeightForState = state => {
@@ -1381,10 +1445,16 @@ const getDefaultModels = () => {
 const createDefaultState = () => {
   const defaultSessionId = 'session-1';
   const defaultModelId = 'test';
+  const chatMessageFontSize = 13;
+  const chatMessageLineHeight = 20;
   const composerFontSize = 13;
   const composerLineHeight = 20;
   return {
     assetDir: '',
+    chatListScrollTop: 0,
+    chatMessageFontFamily: 'system-ui',
+    chatMessageFontSize,
+    chatMessageLineHeight,
     composerFontFamily: 'system-ui',
     composerFontSize,
     composerHeight: composerLineHeight + 8,
@@ -1399,6 +1469,8 @@ const createDefaultState = () => {
     inputSource: 'script',
     lastSubmittedSessionId: '',
     listItemHeight: 40,
+    maxComposerRows: 5,
+    messagesScrollTop: 0,
     mockApiCommandId: '',
     models: getDefaultModels(),
     nextMessageId: 1,
@@ -1411,6 +1483,7 @@ const createDefaultState = () => {
     openRouterApiKeyInput: '',
     openRouterApiKeysSettingsUrl: 'https://openrouter.ai/settings/keys',
     openRouterApiKeyState: 'idle',
+    passIncludeObfuscation: false,
     platform: 0,
     renamingSessionId: '',
     selectedModelId: defaultModelId,
@@ -1420,6 +1493,7 @@ const createDefaultState = () => {
       messages: [],
       title: defaultSessionTitle()
     }],
+    streamingEnabled: false,
     tokensMax: 0,
     tokensUsed: 0,
     uid: 0,
@@ -1457,7 +1531,7 @@ const create = (uid, x, y, width, height, platform, assetDir) => {
 };
 
 const isEqual$1 = (oldState, newState) => {
-  return oldState.initial === newState.initial;
+  return oldState.initial === newState.initial && oldState.chatMessageFontFamily === newState.chatMessageFontFamily && oldState.chatMessageFontSize === newState.chatMessageFontSize && oldState.chatMessageLineHeight === newState.chatMessageLineHeight && oldState.composerHeight === newState.composerHeight && oldState.composerLineHeight === newState.composerLineHeight && oldState.composerFontFamily === newState.composerFontFamily && oldState.composerFontSize === newState.composerFontSize && oldState.listItemHeight === newState.listItemHeight;
 };
 
 const diffFocus = (oldState, newState) => {
@@ -1471,12 +1545,17 @@ const isEqual = (oldState, newState) => {
   return oldState.composerValue === newState.composerValue && oldState.initial === newState.initial && oldState.renamingSessionId === newState.renamingSessionId && oldState.selectedModelId === newState.selectedModelId && oldState.selectedSessionId === newState.selectedSessionId && oldState.sessions === newState.sessions && oldState.tokensMax === newState.tokensMax && oldState.tokensUsed === newState.tokensUsed && oldState.usageOverviewEnabled === newState.usageOverviewEnabled && oldState.viewMode === newState.viewMode;
 };
 
+const diffScrollTop = (oldState, newState) => {
+  return oldState.chatListScrollTop === newState.chatListScrollTop && oldState.messagesScrollTop === newState.messagesScrollTop;
+};
+
 const RenderItems = 4;
 const RenderFocus = 6;
 const RenderFocusContext = 7;
 const RenderValue = 8;
 const RenderCss = 10;
 const RenderIncremental = 11;
+const RenderScrollTop = 12;
 
 const diffValue = (oldState, newState) => {
   if (oldState.composerValue === newState.composerValue) {
@@ -1485,8 +1564,8 @@ const diffValue = (oldState, newState) => {
   return newState.inputSource !== 'script';
 };
 
-const modules = [isEqual, diffValue, diffFocus, isEqual$1, diffFocus];
-const numbers = [RenderIncremental, RenderValue, RenderFocus, RenderCss, RenderFocusContext];
+const modules = [isEqual, diffValue, diffFocus, isEqual$1, diffFocus, diffScrollTop];
+const numbers = [RenderIncremental, RenderValue, RenderFocus, RenderCss, RenderFocusContext, RenderScrollTop];
 
 const diff = (oldState, newState) => {
   const diffResult = [];
@@ -1508,22 +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 SetValueByName = 'Viewlet.setValueByName';
-const SetPatches = 'Viewlet.setPatches';
-
-const FocusChatInput = 8000;
-
 const Button$2 = 'button';
 
 const Button$1 = 1;
@@ -1868,18 +1931,12 @@ const getListIndex = (state, eventX, eventY) => {
     x,
     y
   } = state;
-  if (eventX < x || eventY < y) {
-    return -1;
-  }
-  if (eventX >= x + width || eventY >= y + height) {
+  const relativeX = eventX - x;
+  const relativeY = eventY - y - headerHeight;
+  if (relativeX < 0 || relativeY < 0 || relativeX >= width || relativeY >= height - headerHeight) {
     return -1;
   }
-  const listY = eventY - y - headerHeight;
-  if (listY < 0) {
-    return -1;
-  }
-  const itemHeight = listItemHeight > 0 ? listItemHeight : 40;
-  return Math.floor(listY / itemHeight);
+  return Math.floor(relativeY / listItemHeight);
 };
 
 const CHAT_LIST_ITEM_CONTEXT_MENU = 'ChatListItemContextMenu';
@@ -1919,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 {
@@ -1961,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);
   }
 }
 
@@ -2094,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();
@@ -2192,6 +2650,63 @@ const getMockAiResponse = async userMessage => {
   return `Mock AI response: I received "${userMessage}".`;
 };
 
+let queue = [];
+let waiters = [];
+let finished = false;
+const reset$1 = () => {
+  queue = [];
+  waiters = [];
+  finished = false;
+};
+const pushChunk = chunk => {
+  if (waiters.length > 0) {
+    const resolve = waiters.shift();
+    resolve?.(chunk);
+    return;
+  }
+  queue.push(chunk);
+};
+const finish = () => {
+  finished = true;
+  if (waiters.length === 0) {
+    return;
+  }
+  const activeWaiters = waiters;
+  waiters = [];
+  for (const resolve of activeWaiters) {
+    resolve(undefined);
+  }
+};
+const readNextChunk = async () => {
+  if (queue.length > 0) {
+    return queue.shift();
+  }
+  if (finished) {
+    return undefined;
+  }
+  return new Promise(resolve => {
+    waiters.push(resolve);
+  });
+};
+
+const getMockOpenApiAssistantText = async (stream, onTextChunk) => {
+  let text = '';
+  while (true) {
+    const chunk = await readNextChunk();
+    if (typeof chunk !== 'string') {
+      break;
+    }
+    text += chunk;
+    if (stream && onTextChunk) {
+      await onTextChunk(chunk);
+    }
+  }
+  return {
+    text,
+    type: 'success'
+  };
+};
+
 const activateByEvent = (event, assetDir, platform) => {
   // @ts-ignore
   return activateByEvent$1(event, assetDir, platform);
@@ -2495,7 +3010,16 @@ const executeChatTool = async (name, rawArguments, options) => {
   });
 };
 
-const getOpenApiApiEndpoint = openApiApiBaseUrl => {
+const getClientRequestIdHeader = () => {
+  return {
+    'x-client-request-id': crypto.randomUUID()
+  };
+};
+
+const getOpenApiApiEndpoint = (openApiApiBaseUrl, stream) => {
+  if (stream) {
+    return `${openApiApiBaseUrl}/chat/completions?stream=true`;
+  }
   return `${openApiApiBaseUrl}/chat/completions`;
 };
 
@@ -2506,20 +3030,176 @@ const getTextContent = content => {
   if (!Array.isArray(content)) {
     return '';
   }
-  const textParts = [];
-  for (const part of content) {
+  const textParts = [];
+  for (const part of content) {
+    if (!part || typeof part !== 'object') {
+      continue;
+    }
+    const maybeType = Reflect.get(part, 'type');
+    const maybeText = Reflect.get(part, 'text');
+    if (maybeType === 'text' && typeof maybeText === 'string') {
+      textParts.push(maybeText);
+    }
+  }
+  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;
+  }
+  if (!Array.isArray(content)) {
+    return '';
+  }
+  return content.map(part => {
     if (!part || typeof part !== 'object') {
+      return '';
+    }
+    const text = Reflect.get(part, 'text');
+    return typeof text === 'string' ? text : '';
+  }).join('');
+};
+const parseSseEvent = eventChunk => {
+  const lines = eventChunk.split('\n');
+  const dataLines = [];
+  for (const line of lines) {
+    if (!line.startsWith('data:')) {
       continue;
     }
-    const maybeType = Reflect.get(part, 'type');
-    const maybeText = Reflect.get(part, 'text');
-    if (maybeType === 'text' && typeof maybeText === 'string') {
-      textParts.push(maybeText);
+    dataLines.push(line.slice(5).trimStart());
+  }
+  return dataLines;
+};
+const parseOpenApiStream = async (response, onTextChunk) => {
+  if (!response.body) {
+    return {
+      details: 'request-failed',
+      type: 'error'
+    };
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let remainder = '';
+  let text = '';
+  let done = false;
+  while (!done) {
+    const {
+      done: streamDone,
+      value
+    } = await reader.read();
+    if (streamDone) {
+      done = true;
+    } else if (value) {
+      remainder += decoder.decode(value, {
+        stream: true
+      });
+    }
+    while (true) {
+      const separatorIndex = remainder.indexOf('\n\n');
+      if (separatorIndex === -1) {
+        break;
+      }
+      const rawEvent = remainder.slice(0, separatorIndex);
+      remainder = remainder.slice(separatorIndex + 2);
+      const dataLines = parseSseEvent(rawEvent);
+      if (dataLines.length === 0) {
+        continue;
+      }
+      for (const line of dataLines) {
+        if (line === '[DONE]') {
+          done = true;
+          break;
+        }
+        let parsed;
+        try {
+          parsed = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (!parsed || typeof parsed !== 'object') {
+          continue;
+        }
+        const choices = Reflect.get(parsed, 'choices');
+        if (!Array.isArray(choices)) {
+          continue;
+        }
+        const firstChoice = choices[0];
+        if (!firstChoice || typeof firstChoice !== 'object') {
+          continue;
+        }
+        const delta = Reflect.get(firstChoice, 'delta');
+        if (!delta || typeof delta !== 'object') {
+          continue;
+        }
+        const content = Reflect.get(delta, 'content');
+        const chunkText = getStreamChunkText(content);
+        if (!chunkText) {
+          continue;
+        }
+        text += chunkText;
+        if (onTextChunk) {
+          await onTextChunk(chunkText);
+        }
+      }
     }
   }
-  return textParts.join('\n');
+  if (remainder) {
+    const dataLines = parseSseEvent(remainder);
+    for (const line of dataLines) {
+      if (line === '[DONE]') {
+        continue;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (!parsed || typeof parsed !== 'object') {
+        continue;
+      }
+      const choices = Reflect.get(parsed, 'choices');
+      if (!Array.isArray(choices)) {
+        continue;
+      }
+      const firstChoice = choices[0];
+      if (!firstChoice || typeof firstChoice !== 'object') {
+        continue;
+      }
+      const delta = Reflect.get(firstChoice, 'delta');
+      if (!delta || typeof delta !== 'object') {
+        continue;
+      }
+      const content = Reflect.get(delta, 'content');
+      const chunkText = getStreamChunkText(content);
+      if (!chunkText) {
+        continue;
+      }
+      text += chunkText;
+      if (onTextChunk) {
+        await onTextChunk(chunkText);
+      }
+    }
+  }
+  return {
+    text,
+    type: 'success'
+  };
 };
-
 const getOpenApiErrorDetails = async response => {
   let parsed;
   try {
@@ -2543,7 +3223,14 @@ const getOpenApiErrorDetails = async response => {
     errorType: typeof errorType === 'string' ? errorType : undefined
   };
 };
-const getOpenApiAssistantText = async (messages, modelId, openApiApiKey, openApiApiBaseUrl, assetDir, platform) => {
+const getOpenApiAssistantText = async (messages, modelId, openApiApiKey, openApiApiBaseUrl, assetDir, platform, options) => {
+  const {
+    includeObfuscation = false,
+    onTextChunk,
+    stream
+  } = options ?? {
+    stream: false
+  };
   const completionMessages = messages.map(message => ({
     content: message.text,
     role: message.role
@@ -2553,16 +3240,12 @@ const getOpenApiAssistantText = async (messages, modelId, openApiApiKey, openApi
   for (let i = 0; i <= maxToolIterations; i++) {
     let response;
     try {
-      response = await fetch(getOpenApiApiEndpoint(openApiApiBaseUrl), {
-        body: JSON.stringify({
-          messages: completionMessages,
-          model: modelId,
-          tool_choice: 'auto',
-          tools
-        }),
+      response = await fetch(getOpenApiApiEndpoint(openApiApiBaseUrl, stream), {
+        body: JSON.stringify(getOpenAiParams(completionMessages, modelId, stream, includeObfuscation, tools)),
         headers: {
           Authorization: `Bearer ${openApiApiKey}`,
-          'Content-Type': 'application/json'
+          'Content-Type': 'application/json',
+          ...getClientRequestIdHeader()
         },
         method: 'POST'
       });
@@ -2587,6 +3270,9 @@ const getOpenApiAssistantText = async (messages, modelId, openApiApiKey, openApi
         type: 'error'
       };
     }
+    if (stream) {
+      return parseOpenApiStream(response, onTextChunk);
+    }
     let parsed;
     try {
       parsed = await response.json();
@@ -2758,7 +3444,8 @@ const getOpenRouterLimitInfo = async (openRouterApiKey, openRouterApiBaseUrl) =>
   try {
     response = await fetch(getOpenRouterKeyEndpoint(openRouterApiBaseUrl), {
       headers: {
-        Authorization: `Bearer ${openRouterApiKey}`
+        Authorization: `Bearer ${openRouterApiKey}`,
+        ...getClientRequestIdHeader()
       },
       method: 'GET'
     });
@@ -2816,7 +3503,8 @@ const getOpenRouterAssistantText = async (messages, modelId, openRouterApiKey, o
         }),
         headers: {
           Authorization: `Bearer ${openRouterApiKey}`,
-          'Content-Type': 'application/json'
+          'Content-Type': 'application/json',
+          ...getClientRequestIdHeader()
         },
         method: 'POST'
       });
@@ -2965,7 +3653,7 @@ const getOpenRouterErrorMessage = errorResult => {
   }
 };
 
-/* eslint-disable @cspell/spellchecker */
+// cspell:ignore openrouter
 const getOpenRouterModelId = selectedModelId => {
   const openRouterPrefix = 'openrouter/';
   if (selectedModelId.toLowerCase().startsWith(openRouterPrefix)) {
@@ -2984,7 +3672,7 @@ const isOpenApiModel = (selectedModelId, models) => {
   return normalizedModelId.startsWith('openapi/') || normalizedModelId.startsWith('openai/');
 };
 
-/* eslint-disable @cspell/spellchecker */
+// cspell:ignore openrouter
 
 const isOpenRouterModel = (selectedModelId, models) => {
   const selectedModel = models.find(model => model.id === selectedModelId);
@@ -3001,12 +3689,15 @@ const getAiResponse = async ({
   mockApiCommandId,
   models,
   nextMessageId,
+  onTextChunk,
   openApiApiBaseUrl,
   openApiApiKey,
   openRouterApiBaseUrl,
   openRouterApiKey,
+  passIncludeObfuscation = false,
   platform,
   selectedModelId,
+  streamingEnabled = false,
   useMockApi,
   userText
 }) => {
@@ -3014,8 +3705,22 @@ const getAiResponse = async ({
   const usesOpenApiModel = isOpenApiModel(selectedModelId, models);
   const usesOpenRouterModel = isOpenRouterModel(selectedModelId, models);
   if (usesOpenApiModel) {
-    if (openApiApiKey) {
-      const result = await getOpenApiAssistantText(messages, getOpenApiModelId(selectedModelId), openApiApiKey, openApiApiBaseUrl, assetDir, platform);
+    if (useMockApi) {
+      const result = await getMockOpenApiAssistantText(streamingEnabled, onTextChunk);
+      if (result.type === 'success') {
+        const {
+          text: assistantText
+        } = result;
+        text = assistantText;
+      } else {
+        text = getOpenApiErrorMessage(result);
+      }
+    } else if (openApiApiKey) {
+      const result = await getOpenApiAssistantText(messages, getOpenApiModelId(selectedModelId), openApiApiKey, openApiApiBaseUrl, assetDir, platform, {
+        includeObfuscation: passIncludeObfuscation,
+        onTextChunk,
+        stream: streamingEnabled
+      });
       if (result.type === 'success') {
         const {
           text: assistantText
@@ -3233,6 +3938,74 @@ const focusInput = state => {
   };
 };
 
+const updateMessageTextInSelectedSession = (sessions, selectedSessionId, messageId, text, inProgress) => {
+  return sessions.map(session => {
+    if (session.id !== selectedSessionId) {
+      return session;
+    }
+    return {
+      ...session,
+      messages: session.messages.map(message => {
+        if (message.id !== messageId) {
+          return message;
+        }
+        return {
+          ...message,
+          inProgress,
+          text
+        };
+      })
+    };
+  });
+};
+const handleTextChunkFunction = async (uid, assistantMessageId, chunk, handleTextChunkState) => {
+  const selectedSession = handleTextChunkState.latestState.sessions.find(session => session.id === handleTextChunkState.latestState.selectedSessionId);
+  if (!selectedSession) {
+    return {
+      latestState: handleTextChunkState.latestState,
+      previousState: handleTextChunkState.previousState
+    };
+  }
+  const assistantMessage = selectedSession.messages.find(message => message.id === assistantMessageId);
+  if (!assistantMessage) {
+    return {
+      latestState: handleTextChunkState.latestState,
+      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 = {
+    ...handleTextChunkState.latestState,
+    sessions: updatedSessions
+  };
+  set(uid, handleTextChunkState.previousState, nextState);
+  // @ts-ignore
+  await invoke('Chat.rerender');
+  return {
+    latestState: nextState,
+    previousState: nextState
+  };
+};
+
+const appendMessageToSelectedSession = (sessions, selectedSessionId, message) => {
+  return sessions.map(session => {
+    if (session.id !== selectedSessionId) {
+      return session;
+    }
+    return {
+      ...session,
+      messages: [...session.messages, message]
+    };
+  });
+};
 const handleSubmit = async state => {
   const {
     assetDir,
@@ -3244,10 +4017,12 @@ const handleSubmit = async state => {
     openApiApiKey,
     openRouterApiBaseUrl,
     openRouterApiKey,
+    passIncludeObfuscation,
     platform,
     selectedModelId,
     selectedSessionId,
     sessions,
+    streamingEnabled,
     useMockApi,
     viewMode
   } = state;
@@ -3265,6 +4040,18 @@ const handleSubmit = async state => {
     text: userText,
     time: userTime
   };
+  const assistantMessageId = `message-${nextMessageId + 1}`;
+  const assistantTime = new Date().toLocaleTimeString([], {
+    hour: '2-digit',
+    minute: '2-digit'
+  });
+  const inProgressAssistantMessage = {
+    id: assistantMessageId,
+    inProgress: true,
+    role: 'assistant',
+    text: '',
+    time: assistantTime
+  };
   let workingSessions = sessions;
   if (viewMode === 'detail') {
     const loadedSession = await getChatSession(selectedSessionId);
@@ -3280,9 +4067,15 @@ 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: [userMessage],
+      messages: streamingEnabled ? [userMessage, inProgressAssistantMessage] : [userMessage],
       title: `Chat ${workingSessions.length + 1}`
     };
     await saveChatSession(newSession);
@@ -3298,15 +4091,14 @@ const handleSubmit = async state => {
       viewMode: 'detail'
     });
   } else {
-    const updatedSessions = workingSessions.map(session => {
-      if (session.id !== selectedSessionId) {
-        return session;
-      }
-      return {
-        ...session,
-        messages: [...session.messages, userMessage]
-      };
+    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);
     if (selectedSession) {
       await saveChatSession(selectedSession);
@@ -3324,39 +4116,44 @@ const handleSubmit = async state => {
   set(state.uid, state, optimisticState);
   // @ts-ignore
   await invoke('Chat.rerender');
+  let handleTextChunkState = {
+    latestState: optimisticState,
+    previousState: optimisticState
+  };
   const selectedOptimisticSession = optimisticState.sessions.find(session => session.id === optimisticState.selectedSessionId);
-  const messages = selectedOptimisticSession?.messages ?? [];
+  const messages = (selectedOptimisticSession?.messages ?? []).filter(message => !message.inProgress);
+  const handleTextChunkFunctionRef = streamingEnabled ? async chunk => {
+    handleTextChunkState = await handleTextChunkFunction(state.uid, assistantMessageId, chunk, handleTextChunkState);
+  } : undefined;
   const assistantMessage = await getAiResponse({
     assetDir,
     messages,
     mockApiCommandId,
     models,
     nextMessageId: optimisticState.nextMessageId,
+    onTextChunk: handleTextChunkFunctionRef,
     openApiApiBaseUrl,
     openApiApiKey,
     openRouterApiBaseUrl,
     openRouterApiKey,
+    passIncludeObfuscation,
     platform,
     selectedModelId,
+    streamingEnabled,
     useMockApi,
     userText
   });
-  const updatedSessions = optimisticState.sessions.map(session => {
-    if (session.id !== optimisticState.selectedSessionId) {
-      return session;
-    }
-    return {
-      ...session,
-      messages: [...session.messages, assistantMessage]
-    };
-  });
-  const selectedSession = updatedSessions.find(session => session.id === optimisticState.selectedSessionId);
+  const {
+    latestState
+  } = handleTextChunkState;
+  const updatedSessions = streamingEnabled ? updateMessageTextInSelectedSession(latestState.sessions, latestState.selectedSessionId, assistantMessageId, assistantMessage.text, false) : appendMessageToSelectedSession(latestState.sessions, latestState.selectedSessionId, assistantMessage);
+  const selectedSession = updatedSessions.find(session => session.id === latestState.selectedSessionId);
   if (selectedSession) {
     await saveChatSession(selectedSession);
   }
   return focusInput({
-    ...optimisticState,
-    nextMessageId: optimisticState.nextMessageId + 1,
+    ...latestState,
+    nextMessageId: latestState.nextMessageId + 1,
     sessions: updatedSessions
   });
 };
@@ -3405,7 +4202,7 @@ const OpenApiApiKeyInput = 'open-api-api-key';
 const SaveOpenApiApiKey = 'save-openapi-api-key';
 const OpenOpenApiApiKeySettings = 'open-openapi-api-key-settings';
 
-/* eslint-disable @cspell/spellchecker */
+// cspell:ignore openrouter
 const OpenRouterApiKeyInput = 'open-router-api-key';
 const SaveOpenRouterApiKey = 'save-openrouter-api-key';
 const OpenOpenRouterApiKeySettings = 'open-openrouter-api-key-settings';
@@ -3545,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,
@@ -3652,7 +4457,29 @@ const handleModelChange = async (state, value) => {
 };
 
 const handleNewline = async state => {
-  return handleInput(state, Composer, `${state.composerValue}\n`);
+  const {
+    composerValue
+  } = state;
+  return handleInput(state, Composer, `${composerValue}\n`);
+};
+
+const handleChatListScroll = async (state, chatListScrollTop) => {
+  if (state.chatListScrollTop === chatListScrollTop) {
+    return state;
+  }
+  return {
+    ...state,
+    chatListScrollTop
+  };
+};
+const handleMessagesScroll = async (state, messagesScrollTop) => {
+  if (state.messagesScrollTop === messagesScrollTop) {
+    return state;
+  }
+  return {
+    ...state,
+    messagesScrollTop
+  };
 };
 
 const id = 7201;
@@ -3662,7 +4489,7 @@ const sendMessagePortToExtensionHostWorker = async port => {
 
 const createExtensionHostRpc = async () => {
   try {
-    const rpc = await create$4({
+    const rpc = await create$5({
       commandMap: {},
       send: sendMessagePortToExtensionHostWorker
     });
@@ -3681,6 +4508,32 @@ const isObject = value => {
   return typeof value === 'object' && value !== null;
 };
 
+const getSavedChatListScrollTop = savedState => {
+  if (!isObject(savedState)) {
+    return undefined;
+  }
+  const {
+    chatListScrollTop
+  } = savedState;
+  if (typeof chatListScrollTop !== 'number') {
+    return undefined;
+  }
+  return chatListScrollTop;
+};
+
+const getSavedMessagesScrollTop = savedState => {
+  if (!isObject(savedState)) {
+    return undefined;
+  }
+  const {
+    messagesScrollTop
+  } = savedState;
+  if (typeof messagesScrollTop !== 'number') {
+    return undefined;
+  }
+  return messagesScrollTop;
+};
+
 const getSavedSelectedModelId = savedState => {
   if (!isObject(savedState)) {
     return undefined;
@@ -3733,6 +4586,63 @@ const getSavedViewMode = savedState => {
   return viewMode;
 };
 
+const loadOpenApiApiKey = async () => {
+  try {
+    const savedOpenApiKey = await get('secrets.openApiKey');
+    if (typeof savedOpenApiKey === 'string' && savedOpenApiKey) {
+      return savedOpenApiKey;
+    }
+    const legacySavedOpenApiApiKey = await get('secrets.openApiApiKey');
+    if (typeof legacySavedOpenApiApiKey === 'string' && legacySavedOpenApiApiKey) {
+      return legacySavedOpenApiApiKey;
+    }
+    const legacySavedOpenAiApiKey = await get('secrets.openAiApiKey');
+    return typeof legacySavedOpenAiApiKey === 'string' ? legacySavedOpenAiApiKey : '';
+  } catch {
+    return '';
+  }
+};
+
+const loadOpenRouterApiKey = async () => {
+  try {
+    const savedOpenRouterApiKey = await get('secrets.openRouterApiKey');
+    return typeof savedOpenRouterApiKey === 'string' ? savedOpenRouterApiKey : '';
+  } catch {
+    return '';
+  }
+};
+
+const loadPassIncludeObfuscation = async () => {
+  try {
+    const savedPassIncludeObfuscation = await get('chatView.passIncludeObfuscation');
+    return typeof savedPassIncludeObfuscation === 'boolean' ? savedPassIncludeObfuscation : false;
+  } catch {
+    return false;
+  }
+};
+
+const loadStreamingEnabled = async () => {
+  try {
+    const savedStreamingEnabled = await get('chatView.streamingEnabled');
+    return typeof savedStreamingEnabled === 'boolean' ? savedStreamingEnabled : false;
+  } catch {
+    return false;
+  }
+};
+
+const loadPreferences = async () => {
+  const openApiApiKey = await loadOpenApiApiKey();
+  const openRouterApiKey = await loadOpenRouterApiKey();
+  const streamingEnabled = await loadStreamingEnabled();
+  const passIncludeObfuscation = await loadPassIncludeObfuscation();
+  return {
+    openApiApiKey,
+    openRouterApiKey,
+    passIncludeObfuscation,
+    streamingEnabled
+  };
+};
+
 const toSummarySession = session => {
   return {
     id: session.id,
@@ -3758,30 +4668,12 @@ const loadSelectedSessionMessages = async (sessions, selectedSessionId) => {
 const loadContent = async (state, savedState) => {
   const savedSelectedModelId = getSavedSelectedModelId(savedState);
   const savedViewMode = getSavedViewMode(savedState);
-  let openApiApiKey = '';
-  try {
-    const savedOpenApiKey = await get('secrets.openApiKey');
-    if (typeof savedOpenApiKey === 'string' && savedOpenApiKey) {
-      openApiApiKey = savedOpenApiKey;
-    } else {
-      const legacySavedOpenApiApiKey = await get('secrets.openApiApiKey');
-      if (typeof legacySavedOpenApiApiKey === 'string' && legacySavedOpenApiApiKey) {
-        openApiApiKey = legacySavedOpenApiApiKey;
-      } else {
-        const legacySavedOpenAiApiKey = await get('secrets.openAiApiKey');
-        openApiApiKey = typeof legacySavedOpenAiApiKey === 'string' ? legacySavedOpenAiApiKey : '';
-      }
-    }
-  } catch {
-    openApiApiKey = '';
-  }
-  let openRouterApiKey = '';
-  try {
-    const savedOpenRouterApiKey = await get('secrets.openRouterApiKey');
-    openRouterApiKey = typeof savedOpenRouterApiKey === 'string' ? savedOpenRouterApiKey : '';
-  } catch {
-    openRouterApiKey = '';
-  }
+  const {
+    openApiApiKey,
+    openRouterApiKey,
+    passIncludeObfuscation,
+    streamingEnabled
+  } = await loadPreferences();
   const legacySavedSessions = getSavedSessions(savedState);
   const storedSessions = await listChatSessions();
   let sessions = storedSessions;
@@ -3799,6 +4691,8 @@ const loadContent = async (state, savedState) => {
   }
   const preferredSessionId = getSavedSelectedSessionId(savedState) || state.selectedSessionId;
   const preferredModelId = savedSelectedModelId || state.selectedModelId;
+  const chatListScrollTop = getSavedChatListScrollTop(savedState) ?? state.chatListScrollTop;
+  const messagesScrollTop = getSavedMessagesScrollTop(savedState) ?? state.messagesScrollTop;
   const selectedModelId = state.models.some(model => model.id === preferredModelId) ? preferredModelId : state.models[0]?.id || '';
   const selectedSessionId = sessions.some(session => session.id === preferredSessionId) ? preferredSessionId : sessions[0]?.id || '';
   sessions = await loadSelectedSessionMessages(sessions, selectedSessionId);
@@ -3806,18 +4700,37 @@ const loadContent = async (state, savedState) => {
   const viewMode = sessions.length === 0 || !selectedSessionId ? 'list' : preferredViewMode === 'detail' ? 'detail' : 'list';
   return {
     ...state,
+    chatListScrollTop,
     initial: false,
+    messagesScrollTop,
     openApiApiKey,
     openApiApiKeyInput: openApiApiKey,
     openRouterApiKey,
     openRouterApiKeyInput: openRouterApiKey,
+    passIncludeObfuscation,
     selectedModelId,
     selectedSessionId,
     sessions,
+    streamingEnabled,
     viewMode
   };
 };
 
+const mockOpenApiStreamFinish = state => {
+  finish();
+  return state;
+};
+
+const mockOpenApiStreamPushChunk = (state, chunk) => {
+  pushChunk(chunk);
+  return state;
+};
+
+const mockOpenApiStreamReset = state => {
+  reset$1();
+  return state;
+};
+
 const openMockSession = async (state, mockSessionId, mockChatMessages) => {
   const {
     sessions: currentSessions
@@ -3852,12 +4765,30 @@ const openMockSession = async (state, mockSessionId, mockChatMessages) => {
   };
 };
 
+const getCss = (composerHeight, listItemHeight, chatMessageFontSize, chatMessageLineHeight, chatMessageFontFamily) => {
+  return `:root {
+  --ChatInputBoxHeight: ${composerHeight}px;
+  --ChatListItemHeight: ${listItemHeight}px;
+  --ChatMessageFontSize: ${chatMessageFontSize}px;
+  --ChatMessageLineHeight: ${chatMessageLineHeight}px;
+  --ChatMessageFontFamily: ${chatMessageFontFamily};
+}`;
+};
+
 // TODO render things like scrollbar height,scrollbar offset, textarea height,
 // list height
-const css = `
-`;
+
 const renderCss = (oldState, newState) => {
-  return [SetCss, newState.uid, css];
+  const {
+    chatMessageFontFamily,
+    chatMessageFontSize,
+    chatMessageLineHeight,
+    composerHeight,
+    listItemHeight,
+    uid
+  } = newState;
+  const css = getCss(composerHeight, listItemHeight, chatMessageFontSize, chatMessageLineHeight, chatMessageFontFamily);
+  return [SetCss, uid, css];
 };
 
 const getFocusSelector = focus => {
@@ -3933,6 +4864,8 @@ const HandleClickList = 17;
 const HandleClickDelete = 18;
 const HandleSubmit = 19;
 const HandleModelChange = 20;
+const HandleChatListScroll = 21;
+const HandleMessagesScroll = 22;
 
 const getModelLabel = model => {
   if (model.provider === 'openRouter') {
@@ -4029,7 +4962,7 @@ const getChatSendAreaDom = (composerValue, models, selectedModelId, usageOvervie
     onFocus: HandleFocus,
     onInput: HandleInput,
     placeholder: composePlaceholder(),
-    style: `height:${composerHeight}px;font-size:${composerFontSize}px;font-family:${composerFontFamily};line-height:${composerLineHeight}px;`,
+    // style: `height:${composerHeight}px;font-size:${composerFontSize}px;font-family:${composerFontFamily};line-height:${composerLineHeight}px;`,
     type: TextArea,
     value: composerValue
   }, {
@@ -4240,18 +5173,20 @@ const getEmptyMessagesDom = () => {
   }, text(startConversation())];
 };
 
-const getMessagesDom = (messages, openRouterApiKeyInput, openApiApiKeyInput = '', openRouterApiKeyState = 'idle') => {
+const getMessagesDom = (messages, openRouterApiKeyInput, openApiApiKeyInput = '', openRouterApiKeyState = 'idle', messagesScrollTop = 0) => {
   if (messages.length === 0) {
     return getEmptyMessagesDom();
   }
   return [{
     childCount: messages.length,
     className: 'ChatMessages',
+    onScroll: HandleMessagesScroll,
+    scrollTop: messagesScrollTop,
     type: Div
   }, ...messages.flatMap(message => getChatMessageDom(message, openRouterApiKeyInput, openApiApiKeyInput, openRouterApiKeyState))];
 };
 
-const getChatModeDetailVirtualDom = (sessions, selectedSessionId, composerValue, openRouterApiKeyInput, openApiApiKeyInput, models, selectedModelId, usageOverviewEnabled, tokensUsed, tokensMax, openRouterApiKeyState = 'idle', composerHeight = 28, composerFontSize = 13, composerFontFamily = 'system-ui', composerLineHeight = 20) => {
+const getChatModeDetailVirtualDom = (sessions, selectedSessionId, composerValue, openRouterApiKeyInput, openApiApiKeyInput, models, selectedModelId, usageOverviewEnabled, tokensUsed, tokensMax, openRouterApiKeyState = 'idle', composerHeight = 28, composerFontSize = 13, composerFontFamily = 'system-ui', composerLineHeight = 20, messagesScrollTop = 0) => {
   const selectedSession = sessions.find(session => session.id === selectedSessionId);
   const selectedSessionTitle = selectedSession?.title || chatTitle();
   const messages = selectedSession ? selectedSession.messages : [];
@@ -4259,7 +5194,7 @@ const getChatModeDetailVirtualDom = (sessions, selectedSessionId, composerValue,
     childCount: 3,
     className: mergeClassNames(Viewlet, Chat),
     type: Div
-  }, ...getChatHeaderDomDetailMode(selectedSessionTitle), ...getMessagesDom(messages, openRouterApiKeyInput, openApiApiKeyInput, openRouterApiKeyState), ...getChatSendAreaDom(composerValue, models, selectedModelId, usageOverviewEnabled, tokensUsed, tokensMax, composerHeight, composerFontSize, composerFontFamily, composerLineHeight)];
+  }, ...getChatHeaderDomDetailMode(selectedSessionTitle), ...getMessagesDom(messages, openRouterApiKeyInput, openApiApiKeyInput, openRouterApiKeyState, messagesScrollTop), ...getChatSendAreaDom(composerValue, models, selectedModelId, usageOverviewEnabled, tokensUsed, tokensMax, composerHeight, composerFontSize, composerFontFamily, composerLineHeight)];
 };
 
 const getChatHeaderListModeDom = () => {
@@ -4316,7 +5251,7 @@ const getSessionDom = session => {
   }, text('🗑')];
 };
 
-const getChatListDom = (sessions, selectedSessionId) => {
+const getChatListDom = (sessions, selectedSessionId, chatListScrollTop = 0) => {
   if (sessions.length === 0) {
     return getEmptyChatSessionsDom();
   }
@@ -4324,16 +5259,18 @@ const getChatListDom = (sessions, selectedSessionId) => {
     childCount: sessions.length,
     className: ChatList,
     onClick: HandleClickList,
+    onScroll: HandleChatListScroll,
+    scrollTop: chatListScrollTop,
     type: Div
   }, ...sessions.flatMap(getSessionDom)];
 };
 
-const getChatModeListVirtualDom = (sessions, selectedSessionId, composerValue, models, selectedModelId, usageOverviewEnabled, tokensUsed, tokensMax, composerHeight = 28, composerFontSize = 13, composerFontFamily = 'system-ui', composerLineHeight = 20) => {
+const getChatModeListVirtualDom = (sessions, selectedSessionId, composerValue, models, selectedModelId, usageOverviewEnabled, tokensUsed, tokensMax, composerHeight = 28, composerFontSize = 13, composerFontFamily = 'system-ui', composerLineHeight = 20, chatListScrollTop = 0) => {
   return [{
     childCount: 3,
     className: mergeClassNames(Viewlet, Chat),
     type: Div
-  }, ...getChatHeaderListModeDom(), ...getChatListDom(sessions), ...getChatSendAreaDom(composerValue, models, selectedModelId, usageOverviewEnabled, tokensUsed, tokensMax, composerHeight, composerFontSize, composerFontFamily, composerLineHeight)];
+  }, ...getChatHeaderListModeDom(), ...getChatListDom(sessions, selectedSessionId, chatListScrollTop), ...getChatSendAreaDom(composerValue, models, selectedModelId, usageOverviewEnabled, tokensUsed, tokensMax, composerHeight, composerFontSize, composerFontFamily, composerLineHeight)];
 };
 
 const getChatModeUnsupportedVirtualDom = () => {
@@ -4343,12 +5280,12 @@ const getChatModeUnsupportedVirtualDom = () => {
   }, text(unknownViewMode())];
 };
 
-const getChatVirtualDom = (sessions, selectedSessionId, composerValue, openRouterApiKeyInput, viewMode, models, selectedModelId, usageOverviewEnabled, tokensUsed, tokensMax, openApiApiKeyInput = '', openRouterApiKeyState = 'idle', composerHeight = 28, composerFontSize = 13, composerFontFamily = 'system-ui', composerLineHeight = 20) => {
+const getChatVirtualDom = (sessions, selectedSessionId, composerValue, openRouterApiKeyInput, viewMode, models, selectedModelId, usageOverviewEnabled, tokensUsed, tokensMax, openApiApiKeyInput = '', openRouterApiKeyState = 'idle', composerHeight = 28, composerFontSize = 13, composerFontFamily = 'system-ui', composerLineHeight = 20, chatListScrollTop = 0, messagesScrollTop = 0) => {
   switch (viewMode) {
     case 'detail':
-      return getChatModeDetailVirtualDom(sessions, selectedSessionId, composerValue, openRouterApiKeyInput, openApiApiKeyInput, models, selectedModelId, usageOverviewEnabled, tokensUsed, tokensMax, openRouterApiKeyState, composerHeight, composerFontSize, composerFontFamily, composerLineHeight);
+      return getChatModeDetailVirtualDom(sessions, selectedSessionId, composerValue, openRouterApiKeyInput, openApiApiKeyInput, models, selectedModelId, usageOverviewEnabled, tokensUsed, tokensMax, openRouterApiKeyState, composerHeight, composerFontSize, composerFontFamily, composerLineHeight, messagesScrollTop);
     case 'list':
-      return getChatModeListVirtualDom(sessions, selectedSessionId, composerValue, models, selectedModelId, usageOverviewEnabled, tokensUsed, tokensMax, composerHeight, composerFontSize, composerFontFamily, composerLineHeight);
+      return getChatModeListVirtualDom(sessions, selectedSessionId, composerValue, models, selectedModelId, usageOverviewEnabled, tokensUsed, tokensMax, composerHeight, composerFontSize, composerFontFamily, composerLineHeight, chatListScrollTop);
     default:
       return getChatModeUnsupportedVirtualDom();
   }
@@ -4356,12 +5293,14 @@ const getChatVirtualDom = (sessions, selectedSessionId, composerValue, openRoute
 
 const renderItems = (oldState, newState) => {
   const {
+    chatListScrollTop,
     composerFontFamily,
     composerFontSize,
     composerHeight,
     composerLineHeight,
     composerValue,
     initial,
+    messagesScrollTop,
     models,
     openApiApiKeyInput,
     openRouterApiKeyInput,
@@ -4378,7 +5317,7 @@ const renderItems = (oldState, newState) => {
   if (initial) {
     return [SetDom2, uid, []];
   }
-  const dom = getChatVirtualDom(sessions, selectedSessionId, composerValue, openRouterApiKeyInput, viewMode, models, selectedModelId, usageOverviewEnabled, tokensUsed, tokensMax, openApiApiKeyInput, openRouterApiKeyState, composerHeight, composerFontSize, composerFontFamily, composerLineHeight);
+  const dom = getChatVirtualDom(sessions, selectedSessionId, composerValue, openRouterApiKeyInput, viewMode, models, selectedModelId, usageOverviewEnabled, tokensUsed, tokensMax, openApiApiKeyInput, openRouterApiKeyState, composerHeight, composerFontSize, composerFontFamily, composerLineHeight, chatListScrollTop, messagesScrollTop);
   return [SetDom2, uid, dom];
 };
 
@@ -4389,6 +5328,14 @@ const renderIncremental = (oldState, newState) => {
   return [SetPatches, newState.uid, patches];
 };
 
+const renderScrollTop = (oldState, newState) => {
+  const {
+    messagesScrollTop,
+    uid
+  } = newState;
+  return [SetProperty, uid, '.ChatMessages', 'scrollTop', messagesScrollTop];
+};
+
 const renderValue = (oldState, newState) => {
   const {
     composerValue
@@ -4408,6 +5355,8 @@ const getRenderer = diffType => {
       return renderIncremental;
     case RenderItems:
       return renderItems;
+    case RenderScrollTop:
+      return renderScrollTop;
     case RenderValue:
       return renderValue;
     default:
@@ -4469,6 +5418,12 @@ const renderEventListeners = () => {
   }, {
     name: HandleModelChange,
     params: ['handleModelChange', TargetValue]
+  }, {
+    name: HandleChatListScroll,
+    params: ['handleChatListScroll', 'event.target.scrollTop']
+  }, {
+    name: HandleMessagesScroll,
+    params: ['handleMessagesScroll', 'event.target.scrollTop']
   }, {
     name: HandleFocus,
     params: ['handleInputFocus', TargetName]
@@ -4492,8 +5447,10 @@ const reset = async state => {
     composerHeight: getMinComposerHeightForState(state),
     composerValue: '',
     openRouterApiKey: '',
+    selectedModelId: 'test',
     selectedSessionId: '',
     sessions: [],
+    streamingEnabled: false,
     viewMode: 'list'
   };
 };
@@ -4507,8 +5464,10 @@ const resize = (state, dimensions) => {
 
 const saveState = state => {
   const {
+    chatListScrollTop,
     composerValue,
     height,
+    messagesScrollTop,
     nextMessageId,
     renamingSessionId,
     selectedModelId,
@@ -4519,8 +5478,10 @@ const saveState = state => {
     y
   } = state;
   return {
+    chatListScrollTop,
     composerValue,
     height,
+    messagesScrollTop,
     nextMessageId,
     renamingSessionId,
     selectedModelId,
@@ -4554,6 +5515,13 @@ const setChatList = state => {
   };
 };
 
+const setStreamingEnabled = (state, streamingEnabled) => {
+  return {
+    ...state,
+    streamingEnabled
+  };
+};
+
 const defaultMockApiCommandId = 'ChatE2e.mockApi';
 const useMockApi = (state, value, mockApiCommandId = defaultMockApiCommandId) => {
   if (!value) {
@@ -4578,6 +5546,7 @@ const commandMap = {
   'Chat.getKeyBindings': getKeyBindings,
   'Chat.getSelectedSessionId': wrapGetter(getSelectedSessionId),
   'Chat.handleChatListContextMenu': handleChatListContextMenu,
+  'Chat.handleChatListScroll': wrapCommand(handleChatListScroll),
   'Chat.handleClick': wrapCommand(handleClick),
   'Chat.handleClickBack': wrapCommand(handleClickBack),
   'Chat.handleClickClose': handleClickClose,
@@ -4588,11 +5557,15 @@ const commandMap = {
   'Chat.handleInput': wrapCommand(handleInput),
   'Chat.handleInputFocus': wrapCommand(handleInputFocus),
   'Chat.handleKeyDown': wrapCommand(handleKeyDown),
+  'Chat.handleMessagesScroll': wrapCommand(handleMessagesScroll),
   'Chat.handleModelChange': wrapCommand(handleModelChange),
   'Chat.handleSubmit': wrapCommand(handleSubmit),
   'Chat.initialize': initialize,
   'Chat.loadContent': wrapCommand(loadContent),
   'Chat.loadContent2': wrapCommand(loadContent),
+  'Chat.mockOpenApiStreamFinish': wrapCommand(mockOpenApiStreamFinish),
+  'Chat.mockOpenApiStreamPushChunk': wrapCommand(mockOpenApiStreamPushChunk),
+  'Chat.mockOpenApiStreamReset': wrapCommand(mockOpenApiStreamReset),
   'Chat.openMockSession': wrapCommand(openMockSession),
   'Chat.render2': render2,
   'Chat.renderEventListeners': renderEventListeners,
@@ -4602,16 +5575,29 @@ const commandMap = {
   'Chat.saveState': wrapGetter(saveState),
   'Chat.setChatList': wrapCommand(setChatList),
   'Chat.setOpenRouterApiKey': wrapCommand(setOpenRouterApiKey),
+  'Chat.setStreamingEnabled': wrapCommand(setStreamingEnabled),
   'Chat.terminate': terminate,
   '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 () => {