@lvce-editor/static-server 0.77.0 → 0.77.1

package/static/{bff92c8/packages/chat-coordinator-worker/dist/chatCoordinatorWorkerMain.js → c62a2da/packages/chat-storage-worker/dist/chatStorageWorkerMain.js}

@@ -888,521 +888,646 @@ const create = async ({
   return rpc;
 };
 
-const sessions = [];
-const subscriberQueues = new Map();
-const subscriberWaiters = new Map();
-const activeRunBySessionId = new Map();
-const runById = new Map();
-const cancelledRunIds = new Set();
-const runPromises = new Map();
-const clone = value => {
-  return structuredClone(value);
-};
-const getSessionIndex = sessionId => {
-  return sessions.findIndex(session => session.id === sessionId);
-};
-const emitEvent = event => {
-  for (const queue of subscriberQueues.values()) {
-    queue.push(clone(event));
-  }
-  for (const [subscriberId, waiters] of subscriberWaiters) {
-    const queue = subscriberQueues.get(subscriberId);
-    if (!queue || queue.length === 0) {
-      continue;
-    }
-    const callbacks = [...waiters];
-    waiters.length = 0;
-    for (const callback of callbacks) {
-      callback();
-    }
+const toError = error => {
+  if (error instanceof Error) {
+    return error;
   }
+  return new Error('IndexedDB request failed');
 };
-const createMessage = (role, text) => {
-  return {
-    id: crypto.randomUUID(),
-    role,
-    text,
-    time: new Date().toLocaleTimeString([], {
-      hour: '2-digit',
-      minute: '2-digit'
-    })
-  };
+
+const requestToPromise = async createRequest => {
+  const request = createRequest();
+  const {
+    promise,
+    reject,
+    resolve
+  } = Promise.withResolvers();
+  request.addEventListener('success', () => {
+    resolve(request.result);
+  });
+  request.addEventListener('error', () => {
+    reject(toError(request.error));
+  });
+  return promise;
 };
-const updateMessage = (sessionId, messageId, text, inProgress) => {
-  const index = getSessionIndex(sessionId);
-  if (index === -1) {
-    return undefined;
-  }
-  const session = sessions[index];
-  const nextMessages = session.messages.map(message => {
-    if (message.id !== messageId) {
-      return message;
-    }
-    return {
-      ...message,
-      inProgress,
-      text
-    };
+
+const transactionToPromise = async createTransaction => {
+  const transaction = createTransaction();
+  const {
+    promise,
+    reject,
+    resolve
+  } = Promise.withResolvers();
+  transaction.addEventListener('complete', () => {
+    resolve();
   });
-  const updatedMessage = nextMessages.find(message => message.id === messageId);
-  if (!updatedMessage) {
-    return undefined;
-  }
-  sessions[index] = {
-    ...session,
-    messages: nextMessages
-  };
-  return updatedMessage;
+  transaction.addEventListener('error', () => {
+    reject(toError(transaction.error));
+  });
+  transaction.addEventListener('abort', () => {
+    reject(toError(transaction.error));
+  });
+  return promise;
 };
-const appendMessage = (sessionId, message) => {
-  const index = getSessionIndex(sessionId);
-  if (index === -1) {
+
+const toChatViewEvent = event => {
+  const {
+    eventId,
+    ...chatViewEvent
+  } = event;
+  return chatViewEvent;
+};
+const now$1 = () => {
+  return new Date().toISOString();
+};
+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 && JSON.stringify(a.toolCalls || []) === JSON.stringify(b.toolCalls || []);
+};
+const canAppendMessages$1 = (previousMessages, nextMessages) => {
+  if (nextMessages.length < previousMessages.length) {
     return false;
   }
-  const session = sessions[index];
-  sessions[index] = {
-    ...session,
-    messages: [...session.messages, message]
-  };
-  return true;
+  return previousMessages.every((message, index) => isSameMessage$1(message, nextMessages[index]));
 };
-const getChunks = text => {
-  const tokens = text.split(' ');
-  return tokens.map((token, index) => {
-    if (index === tokens.length - 1) {
-      return token;
+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 `${token} `;
-  });
+  }
+  return true;
 };
-const finalizeRun = (runId, sessionId) => {
-  activeRunBySessionId.delete(sessionId);
-  runById.delete(runId);
-  cancelledRunIds.delete(runId);
-  runPromises.delete(runId);
-};
-const processRun = async (runId, sessionId, assistantMessageId, prompt) => {
-  const baseText = `Coordinator pipeline placeholder response for: ${prompt}`;
-  const chunks = getChunks(baseText);
-  let currentText = '';
-  for (const chunk of chunks) {
-    if (cancelledRunIds.has(runId)) {
-      const cancelledMessage = updateMessage(sessionId, assistantMessageId, currentText, false);
-      if (cancelledMessage) {
-        emitEvent({
-          message: clone(cancelledMessage),
-          runId,
-          sessionId,
-          type: 'message-updated'
-        });
-      }
-      emitEvent({
-        runId,
-        sessionId,
-        type: 'run-cancelled'
+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'
       });
-      finalizeRun(runId, sessionId);
-      return;
     }
-    currentText += chunk;
-    const updatedMessage = updateMessage(sessionId, assistantMessageId, currentText, true);
-    if (updatedMessage) {
-      emitEvent({
-        message: clone(updatedMessage),
-        runId,
-        sessionId,
-        type: 'message-updated'
+    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'
       });
     }
-    await Promise.resolve();
-  }
-  const doneMessage = updateMessage(sessionId, assistantMessageId, currentText, false);
-  if (doneMessage) {
-    emitEvent({
-      message: clone(doneMessage),
-      runId,
-      sessionId,
-      type: 'message-updated'
-    });
+    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,
+          toolCalls: nextMessage.toolCalls,
+          type: 'chat-message-updated'
+        });
+      }
+    }
+    return events;
   }
-  emitEvent({
-    runId,
-    sessionId,
-    type: 'run-finished'
+  events.push({
+    messages: [...next.messages],
+    sessionId: next.id,
+    timestamp,
+    type: 'chat-session-messages-replaced'
   });
-  finalizeRun(runId, sessionId);
-};
-const listSessions$1 = () => {
-  return sessions.map(session => ({
-    id: session.id,
-    messageCount: session.messages.length,
-    title: session.title
-  }));
+  return events;
 };
-const getSession$1 = sessionId => {
-  const session = sessions.find(item => item.id === sessionId);
-  if (!session) {
+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,
+          ...(event.inProgress === undefined ? {} : {
+            inProgress: event.inProgress
+          }),
+          text: event.text,
+          time: event.time,
+          ...(event.toolCalls === undefined ? {} : {
+            toolCalls: event.toolCalls
+          })
+        };
+      });
+      continue;
+    }
+    if (event.type === 'chat-session-messages-replaced') {
+      messages = [...event.messages];
+    }
+  }
+  if (deleted || !title) {
     return undefined;
   }
-  return clone(session);
-};
-const createSession$1 = (title = `Chat ${sessions.length + 1}`) => {
-  const session = {
-    id: crypto.randomUUID(),
-    messages: [],
+  return {
+    id,
+    messages,
     title
   };
-  sessions.push(session);
-  emitEvent({
-    session,
-    type: 'session-created'
-  });
-  return clone(session);
 };
-const deleteSession$1 = sessionId => {
-  const index = getSessionIndex(sessionId);
-  if (index === -1) {
-    return false;
-  }
-  sessions.splice(index, 1);
-  emitEvent({
-    sessionId,
-    type: 'session-deleted'
-  });
-  return true;
-};
-const submit$1 = options => {
-  const text = options.text.trim();
-  if (!text) {
-    return {
-      message: 'Prompt is empty.',
-      type: 'error'
+class IndexedDbChatSessionStorage {
+  constructor(options = {}) {
+    this.state = {
+      databaseName: options.databaseName || 'lvce-chat-view-sessions',
+      databasePromise: undefined,
+      databaseVersion: options.databaseVersion || 2,
+      eventStoreName: options.eventStoreName || 'chat-view-events',
+      storeName: options.storeName || 'chat-sessions'
     };
   }
-  let session = options.sessionId ? sessions.find(item => item.id === options.sessionId) : undefined;
-  if (!session) {
-    session = createSession$1();
-  }
-  if (activeRunBySessionId.has(session.id)) {
-    return {
-      message: 'Session already has an active run.',
-      type: 'error'
-    };
-  }
-  const userMessage = createMessage('user', text);
-  const assistantMessage = {
-    ...createMessage('assistant', ''),
-    inProgress: true
-  };
-  appendMessage(session.id, userMessage);
-  appendMessage(session.id, assistantMessage);
-  const updatedSession = getSession$1(session.id);
-  if (updatedSession) {
-    emitEvent({
-      session: updatedSession,
-      type: 'session-updated'
+  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
+        });
+      }
     });
-  }
-  emitEvent({
-    message: clone(userMessage),
-    sessionId: session.id,
-    type: 'message-appended'
-  });
-  emitEvent({
-    message: clone(assistantMessage),
-    sessionId: session.id,
-    type: 'message-appended'
-  });
-  const runId = crypto.randomUUID();
-  activeRunBySessionId.set(session.id, runId);
-  runById.set(runId, {
-    assistantMessageId: assistantMessage.id,
-    sessionId: session.id
-  });
-  emitEvent({
-    assistantMessageId: assistantMessage.id,
-    runId,
-    sessionId: session.id,
-    type: 'run-started'
-  });
-  const runPromise = processRun(runId, session.id, assistantMessage.id, text);
-  runPromises.set(runId, runPromise);
-  return {
-    assistantMessageId: assistantMessage.id,
-    runId,
-    sessionId: session.id,
-    type: 'success',
-    userMessageId: userMessage.id
+    const databasePromise = requestToPromise(() => request);
+    this.state.databasePromise = databasePromise;
+    return databasePromise;
   };
-};
-const cancelRun$1 = runId => {
-  if (!runById.has(runId)) {
-    return false;
+  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() {
+    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) {
+    await this.appendEvent({
+      sessionId: id,
+      timestamp: now$1(),
+      type: 'chat-session-deleted'
+    });
   }
-  cancelledRunIds.add(runId);
-  return true;
-};
-const subscribe$1 = subscriberId => {
-  if (subscriberQueues.has(subscriberId)) {
-    return;
+  async getEvents(sessionId) {
+    if (sessionId) {
+      return this.getEventsBySessionId(sessionId);
+    }
+    return this.listEventsInternal();
+  }
+  async getSession(id) {
+    const [summary, events] = await Promise.all([this.getSummary(id), this.getEventsBySessionId(id)]);
+    return replaySession$1(id, summary, events);
+  }
+  async listSessions() {
+    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) {
+    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);
+    }
   }
-  subscriberQueues.set(subscriberId, []);
-  subscriberWaiters.set(subscriberId, []);
+}
+
+const now = () => {
+  return new Date().toISOString();
 };
-const unsubscribe$1 = subscriberId => {
-  subscriberQueues.delete(subscriberId);
-  subscriberWaiters.delete(subscriberId);
+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 && JSON.stringify(a.toolCalls || []) === JSON.stringify(b.toolCalls || []);
 };
-const consumeEvents$1 = subscriberId => {
-  const queue = subscriberQueues.get(subscriberId);
-  if (!queue) {
-    return [];
+const canAppendMessages = (previousMessages, nextMessages) => {
+  if (nextMessages.length < previousMessages.length) {
+    return false;
   }
-  const events = [...queue];
-  queue.length = 0;
-  return events;
+  return previousMessages.every((message, index) => isSameMessage(message, nextMessages[index]));
 };
-const waitForEvents$1 = async (subscriberId, timeout = 1000) => {
-  const queue = subscriberQueues.get(subscriberId);
-  if (!queue) {
-    return [];
-  }
-  if (queue.length > 0) {
-    return consumeEvents$1(subscriberId);
+const canUpdateMessages = (previousMessages, nextMessages) => {
+  if (previousMessages.length !== nextMessages.length) {
+    return false;
   }
-  await new Promise(resolve => {
-    const waiters = subscriberWaiters.get(subscriberId);
-    if (!waiters) {
-      resolve();
-      return;
+  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;
     }
-    waiters.push(resolve);
-    setTimeout(resolve, timeout);
-  });
-  return consumeEvents$1(subscriberId);
-};
-
-const createSession = async title => {
-  return createSession$1(title);
-};
-const listSessions = async () => {
-  return listSessions$1();
-};
-const getSession = async sessionId => {
-  return getSession$1(sessionId);
-};
-const deleteSession = async sessionId => {
-  return deleteSession$1(sessionId);
-};
-const submit = async options => {
-  return submit$1(options);
-};
-const cancelRun = async runId => {
-  return cancelRun$1(runId);
-};
-const subscribe = async subscriberId => {
-  subscribe$1(subscriberId);
-};
-const unsubscribe = async subscriberId => {
-  unsubscribe$1(subscriberId);
-};
-const consumeEvents = async subscriberId => {
-  return consumeEvents$1(subscriberId);
-};
-const waitForEvents = async (subscriberId, timeout) => {
-  return waitForEvents$1(subscriberId, timeout);
-};
-
-const getFetchErrorMessage = error => {
-  if (error instanceof Error) {
-    return error.message;
   }
-  return 'request failed';
-};
-
-const getFetchThrownErrorResult = error => {
-  return {
-    headers: {},
-    response: getFetchErrorMessage(error),
-    statusCode: 0,
-    type: 'error'
-  };
+  return true;
 };
-
-const getHeadersObject = headers => {
-  const result = {};
-  for (const [key, value] of headers) {
-    result[key] = value;
+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'
+    });
   }
-  return result;
-};
-
-const getRequestInit = options => {
-  return {
-    ...(options.postBody === undefined ? {} : {
-      body: JSON.stringify(options.postBody)
-    }),
-    ...(options.headers ? {
-      headers: options.headers
-    } : {}),
-    method: options.method
-  };
-};
-
-const parseResponseJson = responseText => {
-  if (!responseText) {
-    return null;
+  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,
+          toolCalls: nextMessage.toolCalls,
+          type: 'chat-message-updated'
+        });
+      }
+    }
+    return events;
   }
-  return JSON.parse(responseText);
+  events.push({
+    messages: [...next.messages],
+    sessionId: next.id,
+    timestamp,
+    type: 'chat-session-messages-replaced'
+  });
+  return events;
 };
-const makeApiRequest = async options => {
-  let response;
-  try {
-    response = await fetch(options.url, getRequestInit(options));
-  } catch (error) {
-    return getFetchThrownErrorResult(error);
-  }
-  const headers = getHeadersObject(response.headers);
-  const responseText = await response.text();
-  if (!response.ok) {
-    return {
-      headers,
-      response: responseText,
-      statusCode: response.status,
-      type: 'error'
-    };
+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,
+          ...(event.inProgress === undefined ? {} : {
+            inProgress: event.inProgress
+          }),
+          text: event.text,
+          time: event.time,
+          ...(event.toolCalls === undefined ? {} : {
+            toolCalls: event.toolCalls
+          })
+        };
+      });
+      continue;
+    }
+    if (event.type === 'chat-session-messages-replaced') {
+      messages = [...event.messages];
+    }
   }
-  let parsed;
-  try {
-    parsed = parseResponseJson(responseText);
-  } catch {
-    return {
-      headers,
-      response: responseText,
-      statusCode: response.status,
-      type: 'error'
-    };
+  if (deleted || !currentTitle) {
+    return undefined;
   }
   return {
-    body: parsed,
-    headers,
-    statusCode: response.status,
-    type: 'success'
+    id,
+    messages,
+    title: currentTitle
   };
 };
-
-const splitSseEvents = chunk => {
-  return chunk.split(/\r?\n\r?\n/);
-};
-const getSseDataLines = event => {
-  const lines = event.split(/\r?\n/);
-  const dataLines = [];
-  for (const line of lines) {
-    if (!line.startsWith('data:')) {
-      continue;
+class InMemoryChatSessionStorage {
+  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);
     }
-    dataLines.push(line.slice(5).trimStart());
   }
-  return dataLines;
-};
-const parseSseData = text => {
-  if (text === '[DONE]') {
-    return text;
+  async clear() {
+    this.events.length = 0;
+    this.summaries.clear();
   }
-  try {
-    return JSON.parse(text);
-  } catch {
-    return text;
+  async deleteSession(id) {
+    await this.appendEvent({
+      sessionId: id,
+      timestamp: now(),
+      type: 'chat-session-deleted'
+    });
   }
-};
-const parseSseFromReader = async responseBody => {
-  if (!responseBody) {
-    return [];
+  async getEvents(sessionId) {
+    if (!sessionId) {
+      return [...this.events];
+    }
+    return this.events.filter(event => event.sessionId === sessionId);
   }
-  const reader = responseBody.getReader();
-  const decoder = new TextDecoder();
-  let remainder = '';
-  const events = [];
-  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
-      });
+  async getSession(id) {
+    return replaySession(id, this.summaries.get(id), this.events);
+  }
+  async listSessions() {
+    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 chunks = splitSseEvents(remainder);
-    remainder = chunks.pop() ?? '';
-    for (const chunk of chunks) {
-      const dataLines = getSseDataLines(chunk);
-      for (const line of dataLines) {
-        events.push(parseSseData(line));
+    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;
   }
-  if (remainder) {
-    const dataLines = getSseDataLines(remainder);
-    for (const line of dataLines) {
-      events.push(parseSseData(line));
+  async setSession(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);
   }
-  return events;
-};
-const makeStreamingApiRequest = async options => {
-  let response;
-  try {
-    response = await fetch(options.url, getRequestInit(options));
-  } catch (error) {
-    return getFetchThrownErrorResult(error);
-  }
-  const headers = getHeadersObject(response.headers);
-  if (!response.ok) {
-    const responseText = await response.text();
+}
+
+const createDefaultStorage = () => {
+  if (typeof indexedDB === 'undefined') {
+    return new InMemoryChatSessionStorage();
+  }
+  return new IndexedDbChatSessionStorage();
+};
+let chatSessionStorage = createDefaultStorage();
+const setSession = async session => {
+  await chatSessionStorage.setSession(session);
+};
+const listChatSessions = async () => {
+  const sessions = await chatSessionStorage.listSessions();
+  return sessions.map(session => {
+    const summary = {
+      id: session.id,
+      messages: [],
+      title: session.title
+    };
+    if (!session.projectId) {
+      return summary;
+    }
     return {
-      headers,
-      response: responseText,
-      statusCode: response.status,
-      type: 'error'
+      ...summary,
+      projectId: session.projectId
     };
+  });
+};
+const getChatSession = async id => {
+  const session = await chatSessionStorage.getSession(id);
+  if (!session) {
+    return undefined;
   }
-  const body = await parseSseFromReader(response.body);
-  return {
-    body,
-    headers,
-    statusCode: response.status,
-    type: 'success'
+  const resultBase = {
+    id: session.id,
+    messages: [...session.messages],
+    title: session.title
   };
+  const result = session.projectId ? {
+    ...resultBase,
+    projectId: session.projectId
+  } : resultBase;
+  return result;
 };
-
-const networkCommandMap = {
-  'chatCoordinator.makeApiRequest': makeApiRequest,
-  'chatCoordinator.makeStreamingApiRequest': makeStreamingApiRequest
+const deleteChatSession = async id => {
+  await chatSessionStorage.deleteSession(id);
+};
+const clearChatSessions = async () => {
+  await chatSessionStorage.clear();
+};
+const appendChatViewEvent = async event => {
+  await chatSessionStorage.appendEvent(event);
+};
+const getChatViewEvents = async sessionId => {
+  return chatSessionStorage.getEvents(sessionId);
 };
 
 const handleMessagePort = async port => {
   await create$1({
-    commandMap: networkCommandMap,
+    commandMap: commandMap,
     messagePort: port
   });
 };
 
 const commandMap = {
-  ...networkCommandMap,
-  'chatCoordinator.cancelRun': cancelRun,
-  'chatCoordinator.consumeEvents': consumeEvents,
-  'chatCoordinator.createSession': createSession,
-  'chatCoordinator.deleteSession': deleteSession,
-  'chatCoordinator.getSession': getSession,
-  'chatCoordinator.listSessions': listSessions,
-  'chatCoordinator.submit': submit,
-  'chatCoordinator.subscribe': subscribe,
-  'chatCoordinator.unsubscribe': unsubscribe,
-  'chatCoordinator.waitForEvents': waitForEvents,
+  'ChatStorage.appendEvent': appendChatViewEvent,
+  'ChatStorage.clear': clearChatSessions,
+  'ChatStorage.deleteSession': deleteChatSession,
+  'ChatStorage.getEvents': getChatViewEvents,
+  'ChatStorage.getSession': getChatSession,
+  'ChatStorage.listSessions': listChatSessions,
+  'ChatStorage.setSession': setSession,
   'HandleMessagePort.handleMessagePort': handleMessagePort
 };