@lvce-editor/chat-debug-view 5.5.0 → 6.0.0

package/dist/chatDebugViewWorkerMain.js

@@ -368,6 +368,100 @@ const IpcChildWithModuleWorkerAndMessagePort$1 = {
   listen: listen$6,
   wrap: wrap$e
 };
+const addListener = (emitter, type, callback) => {
+  if ('addEventListener' in emitter) {
+    emitter.addEventListener(type, callback);
+  } else {
+    emitter.on(type, callback);
+  }
+};
+const removeListener = (emitter, type, callback) => {
+  if ('removeEventListener' in emitter) {
+    emitter.removeEventListener(type, callback);
+  } else {
+    emitter.off(type, callback);
+  }
+};
+const getFirstEvent = (eventEmitter, eventMap) => {
+  const {
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  const listenerMap = Object.create(null);
+  const cleanup = value => {
+    for (const event of Object.keys(eventMap)) {
+      removeListener(eventEmitter, event, listenerMap[event]);
+    }
+    resolve(value);
+  };
+  for (const [event, type] of Object.entries(eventMap)) {
+    const listener = event => {
+      cleanup({
+        event,
+        type
+      });
+    };
+    addListener(eventEmitter, event, listener);
+    listenerMap[event] = listener;
+  }
+  return promise;
+};
+const Message$1 = 3;
+const create$5$1 = async ({
+  isMessagePortOpen,
+  messagePort
+}) => {
+  if (!isMessagePort(messagePort)) {
+    throw new IpcError('port must be of type MessagePort');
+  }
+  if (isMessagePortOpen) {
+    return messagePort;
+  }
+  const eventPromise = getFirstEvent(messagePort, {
+    message: Message$1
+  });
+  messagePort.start();
+  const {
+    event,
+    type
+  } = await eventPromise;
+  if (type !== Message$1) {
+    throw new IpcError('Failed to wait for ipc message');
+  }
+  if (event.data !== readyMessage) {
+    throw new IpcError('unexpected first message');
+  }
+  return messagePort;
+};
+const signal$1 = messagePort => {
+  messagePort.start();
+};
+class IpcParentWithMessagePort extends Ipc {
+  getData = getData$2;
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const transfer = getTransferrables(message);
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    this._rawIpc.close();
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+  }
+  onClose(callback) {}
+}
+const wrap$5 = messagePort => {
+  return new IpcParentWithMessagePort(messagePort);
+};
+const IpcParentWithMessagePort$1 = {
+  __proto__: null,
+  create: create$5$1,
+  signal: signal$1,
+  wrap: wrap$5
+};
 
 class CommandNotFoundError extends Error {
   constructor(command) {
@@ -392,10 +486,10 @@ const execute = (command, ...args) => {
 
 const Two$1 = '2.0';
 const callbacks = Object.create(null);
-const get$1 = id => {
+const get$2 = id => {
   return callbacks[id];
 };
-const remove = id => {
+const remove$1 = id => {
   delete callbacks[id];
 };
 class JsonRpcError extends Error {
@@ -541,14 +635,14 @@ const warn = (...args) => {
   console.warn(...args);
 };
 const resolve = (id, response) => {
-  const fn = get$1(id);
+  const fn = get$2(id);
   if (!fn) {
     console.log(response);
     warn(`callback ${id} may already be disposed`);
     return;
   }
   fn(response);
-  remove(id);
+  remove$1(id);
 };
 const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
 const getErrorType = prettyError => {
@@ -604,7 +698,7 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const errorProperty = getErrorProperty(error, prettyError);
   return create$1$1(id, errorProperty);
 };
-const create$6 = (message, result) => {
+const create$a = (message, result) => {
   return {
     id: message.id,
     jsonrpc: Two$1,
@@ -613,7 +707,7 @@ const create$6 = (message, result) => {
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$6(message, resultProperty);
+  return create$a(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
@@ -707,7 +801,7 @@ const handleJsonRpcMessage = async (...args) => {
 
 const Two = '2.0';
 
-const create$5 = (method, params) => {
+const create$9 = (method, params) => {
   return {
     jsonrpc: Two,
     method,
@@ -715,7 +809,7 @@ const create$5 = (method, params) => {
   };
 };
 
-const create$4 = (id, method, params) => {
+const create$8 = (id, method, params) => {
   const message = {
     id,
     jsonrpc: Two,
@@ -726,12 +820,12 @@ const create$4 = (id, method, params) => {
 };
 
 let id = 0;
-const create$3 = () => {
+const create$7 = () => {
   return ++id;
 };
 
 const registerPromise = map => {
-  const id = create$3();
+  const id = create$7();
   const {
     promise,
     resolve
@@ -748,7 +842,7 @@ const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer)
     id,
     promise
   } = registerPromise(callbacks);
-  const message = create$4(id, method, params);
+  const message = create$8(id, method, params);
   if (useSendAndTransfer && ipc.sendAndTransfer) {
     ipc.sendAndTransfer(message);
   } else {
@@ -784,7 +878,7 @@ const createRpc = ipc => {
      * @deprecated
      */
     send(method, ...params) {
-      const message = create$5(method, params);
+      const message = create$9(method, params);
       ipc.send(message);
     }
   };
@@ -824,7 +918,84 @@ const listen$1 = async (module, options) => {
   return ipc;
 };
 
-const create$2 = async ({
+const create$6 = async ({
+  commandMap,
+  isMessagePortOpen = true,
+  messagePort
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const rawIpc = await IpcParentWithMessagePort$1.create({
+    isMessagePortOpen,
+    messagePort
+  });
+  const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  messagePort.start();
+  return rpc;
+};
+
+const create$5 = async ({
+  commandMap,
+  isMessagePortOpen,
+  send
+}) => {
+  const {
+    port1,
+    port2
+  } = new MessageChannel();
+  await send(port1);
+  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
 }) => {
   // TODO create a commandMap per rpc instance
@@ -835,6 +1006,114 @@ const create$2 = async ({
   return rpc;
 };
 
+const createMockRpc = ({
+  commandMap
+}) => {
+  const invocations = [];
+  const invoke = (method, ...params) => {
+    invocations.push([method, ...params]);
+    const command = commandMap[method];
+    if (!command) {
+      throw new Error(`command ${method} not found`);
+    }
+    return command(...params);
+  };
+  const mockRpc = {
+    invocations,
+    invoke,
+    invokeAndTransfer: invoke
+  };
+  return mockRpc;
+};
+
+const rpcs = Object.create(null);
+const set$3 = (id, rpc) => {
+  rpcs[id] = rpc;
+};
+const get$1 = id => {
+  return rpcs[id];
+};
+const remove = id => {
+  delete rpcs[id];
+};
+
+/* eslint-disable  @typescript-eslint/explicit-function-return-type */
+const create$2 = rpcId => {
+  return {
+    async dispose() {
+      const rpc = get$1(rpcId);
+      await rpc.dispose();
+    },
+    // @ts-ignore
+    invoke(method, ...params) {
+      const rpc = get$1(rpcId);
+      // @ts-ignore
+      return rpc.invoke(method, ...params);
+    },
+    // @ts-ignore
+    invokeAndTransfer(method, ...params) {
+      const rpc = get$1(rpcId);
+      // @ts-ignore
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    registerMockRpc(commandMap) {
+      const mockRpc = createMockRpc({
+        commandMap
+      });
+      set$3(rpcId, mockRpc);
+      // @ts-ignore
+      mockRpc[Symbol.dispose] = () => {
+        remove(rpcId);
+      };
+      // @ts-ignore
+      return mockRpc;
+    },
+    set(rpc) {
+      set$3(rpcId, rpc);
+    }
+  };
+};
+
+const Button = 1;
+const Div = 4;
+const Input = 6;
+const Span = 8;
+const Table = 9;
+const TBody = 10;
+const Td = 11;
+const Text = 12;
+const Th = 13;
+const THead = 14;
+const Tr = 15;
+const Search = 42;
+const Label = 66;
+const Reference = 100;
+
+const ClientX = 'event.clientX';
+const ClientY = 'event.clientY';
+const TargetName = 'event.target.name';
+const TargetValue = 'event.target.value';
+
+const ChatStorageWorker = 6003;
+const RendererWorker = 1;
+
+const SetCss = 'Viewlet.setCss';
+const SetDom2 = 'Viewlet.setDom2';
+const SetPatches = 'Viewlet.setPatches';
+
+const {
+  invoke,
+  set: set$2
+} = create$2(ChatStorageWorker);
+
+const {
+  invokeAndTransfer,
+  set: set$1
+} = create$2(RendererWorker);
+const sendMessagePortToChatStorageWorker$1 = async port => {
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToChatStorageWorker', port, 'HandleMessagePort.handleMessagePort');
+};
+
 const toCommandId = key => {
   const dotIndex = key.indexOf('.');
   return key.slice(dotIndex + 1);
@@ -1079,7 +1358,6 @@ const createDefaultState = () => {
     eventStoreName: 'chat-view-events',
     filterValue: '',
     height: 0,
-    indexedDbSupportOverride: undefined,
     initial: false,
     platform: 0,
     selectedDetailTab: Response,
@@ -1194,7 +1472,7 @@ const handleDetailTab = (state, value) => {
   };
 };
 
-const hasMatchingToolName$1 = (startedEvent, finishedEvent) => {
+const hasMatchingToolName = (startedEvent, finishedEvent) => {
   if (typeof startedEvent.toolName === 'string' && typeof finishedEvent.toolName === 'string') {
     return startedEvent.toolName === finishedEvent.toolName;
   }
@@ -1202,27 +1480,27 @@ const hasMatchingToolName$1 = (startedEvent, finishedEvent) => {
 };
 
 const isMatchingToolExecutionPair = (startedEvent, finishedEvent) => {
-  return startedEvent.sessionId === finishedEvent.sessionId && hasMatchingToolName$1(startedEvent, finishedEvent);
+  return startedEvent.sessionId === finishedEvent.sessionId && hasMatchingToolName(startedEvent, finishedEvent);
 };
 
-const startedEventType$1 = 'tool-execution-started';
-const finishedEventType$1 = 'tool-execution-finished';
+const startedEventType = 'tool-execution-started';
+const finishedEventType = 'tool-execution-finished';
 const mergedEventType = 'tool-execution';
 
 const isToolExecutionFinishedEvent = event => {
-  return event.type === finishedEventType$1;
+  return event.type === finishedEventType;
 };
 
 const isToolExecutionStartedEvent = event => {
-  return event.type === startedEventType$1;
+  return event.type === startedEventType;
 };
 
-const getTimestamp$1 = value => {
+const getTimestamp = value => {
   return typeof value === 'string' || typeof value === 'number' ? value : undefined;
 };
 
 const getEndedTimestamp = event => {
-  return getTimestamp$1(event.ended) ?? getTimestamp$1(event.endTime) ?? getTimestamp$1(event.endTimestamp) ?? getTimestamp$1(event.timestamp);
+  return getTimestamp(event.ended) ?? getTimestamp(event.endTime) ?? getTimestamp(event.endTimestamp) ?? getTimestamp(event.timestamp);
 };
 
 const eventStableIds = new WeakMap();
@@ -1241,14 +1519,14 @@ const getOrCreateStableEventId = event => {
 };
 
 const getStartedTimestamp = event => {
-  return getTimestamp$1(event.started) ?? getTimestamp$1(event.startTime) ?? getTimestamp$1(event.startTimestamp) ?? getTimestamp$1(event.timestamp);
+  return getTimestamp(event.started) ?? getTimestamp(event.startTime) ?? getTimestamp(event.startTimestamp) ?? getTimestamp(event.timestamp);
 };
 
 const setStableEventId = (event, stableEventId) => {
   eventStableIds.set(event, stableEventId);
 };
 
-const mergeToolExecutionEvents$1 = (startedEvent, finishedEvent) => {
+const mergeToolExecutionEvents = (startedEvent, finishedEvent) => {
   const ended = getEndedTimestamp(finishedEvent);
   const {
     eventId
@@ -1284,7 +1562,7 @@ const collapseToolExecutionEvents = events => {
     if (isToolExecutionStartedEvent(event)) {
       const nextEvent = events[i + 1];
       if (nextEvent && isToolExecutionFinishedEvent(nextEvent) && isMatchingToolExecutionPair(event, nextEvent)) {
-        collapsedEvents.push(mergeToolExecutionEvents$1(event, nextEvent));
+        collapsedEvents.push(mergeToolExecutionEvents(event, nextEvent));
         i++;
         continue;
       }
@@ -1575,383 +1853,18 @@ const handleEventCategoryFilter = (state, value) => {
   return withPreservedSelection$1(state, nextState);
 };
 
-let workerRpc;
-const setWorkerRpc = value => {
-  workerRpc = value;
-};
-const invoke = async (method, ...params) => {
-  if (!workerRpc) {
-    throw new Error('worker rpc is not initialized');
-  }
-  return workerRpc.invoke(method, ...params);
-};
-
-const chatStorageWorkerClientDependencies = {
-  invoke: invoke
-};
 const listChatViewEvents$1 = async sessionId => {
-  return chatStorageWorkerClientDependencies.invoke('ChatStorage.listChatViewEvents', sessionId);
+  return invoke('ChatStorage.listChatViewEvents', sessionId);
 };
 const loadSelectedEvent$1 = async (sessionId, eventId, type) => {
-  return chatStorageWorkerClientDependencies.invoke('ChatStorage.loadSelectedEvent', sessionId, eventId, type);
-};
-
-// cspell:ignore IDBP
-
-const startedEventType = 'tool-execution-started';
-const finishedEventType = 'tool-execution-finished';
-const getRawEventBySessionIdAndEventId = async (store, sessionId, sessionIdIndexName, eventId) => {
-  if (eventId < 1) {
-    return undefined;
-  }
-  if (store.indexNames.contains(sessionIdIndexName)) {
-    const index = store.index(sessionIdIndexName);
-    const keys = await index.getAllKeys(sessionId, eventId);
-    if (keys.length < eventId) {
-      return undefined;
-    }
-    const key = keys.at(-1);
-    if (key === undefined) {
-      return undefined;
-    }
-    const event = await store.get(key);
-    return event;
-  }
-  const all = await store.getAll();
-  const events = all.filter(event => event.sessionId === sessionId);
-  return events[eventId - 1];
-};
-const getTimestamp = value => {
-  return typeof value === 'string' || typeof value === 'number' ? value : undefined;
-};
-const hasMatchingToolName = (startedEvent, finishedEvent) => {
-  if (typeof startedEvent.toolName === 'string' && typeof finishedEvent.toolName === 'string') {
-    return startedEvent.toolName === finishedEvent.toolName;
-  }
-  return true;
-};
-const mergeToolExecutionEvents = (startedEvent, finishedEvent, eventId) => {
-  const ended = getTimestamp(finishedEvent.ended) ?? getTimestamp(finishedEvent.endTime) ?? getTimestamp(finishedEvent.timestamp);
-  const started = getTimestamp(startedEvent.started) ?? getTimestamp(startedEvent.startTime) ?? getTimestamp(startedEvent.timestamp);
-  return {
-    ...startedEvent,
-    ...finishedEvent,
-    ...(ended === undefined ? {} : {
-      ended
-    }),
-    eventId,
-    ...(started === undefined ? {} : {
-      started
-    }),
-    type: 'tool-execution'
-  };
-};
-const getEventDetailsBySessionIdAndEventId = async (store, sessionId, sessionIdIndexName, eventId, summaryType) => {
-  const event = await getRawEventBySessionIdAndEventId(store, sessionId, sessionIdIndexName, eventId);
-  if (!event) {
-    return undefined;
-  }
-  if (summaryType !== 'tool-execution') {
-    return {
-      ...event,
-      eventId
-    };
-  }
-  if (event.type !== startedEventType) {
-    return {
-      ...event,
-      eventId
-    };
-  }
-  const nextEvent = await getRawEventBySessionIdAndEventId(store, sessionId, sessionIdIndexName, eventId + 1);
-  if (!nextEvent || nextEvent.type !== finishedEventType || nextEvent.sessionId !== sessionId || !hasMatchingToolName(event, nextEvent)) {
-    return {
-      ...event,
-      eventId
-    };
-  }
-  return mergeToolExecutionEvents(event, nextEvent, eventId);
-};
-
-const instanceOfAny = (object, constructors) => constructors.some(c => object instanceof c);
-let idbProxyableTypes;
-let cursorAdvanceMethods;
-// This is a function to prevent it throwing up in node environments.
-function getIdbProxyableTypes() {
-  return idbProxyableTypes || (idbProxyableTypes = [IDBDatabase, IDBObjectStore, IDBIndex, IDBCursor, IDBTransaction]);
-}
-// This is a function to prevent it throwing up in node environments.
-function getCursorAdvanceMethods() {
-  return cursorAdvanceMethods || (cursorAdvanceMethods = [IDBCursor.prototype.advance, IDBCursor.prototype.continue, IDBCursor.prototype.continuePrimaryKey]);
-}
-const transactionDoneMap = new WeakMap();
-const transformCache = new WeakMap();
-const reverseTransformCache = new WeakMap();
-function promisifyRequest(request) {
-  const promise = new Promise((resolve, reject) => {
-    const unlisten = () => {
-      request.removeEventListener('success', success);
-      request.removeEventListener('error', error);
-    };
-    const success = () => {
-      resolve(wrap(request.result));
-      unlisten();
-    };
-    const error = () => {
-      reject(request.error);
-      unlisten();
-    };
-    request.addEventListener('success', success);
-    request.addEventListener('error', error);
-  });
-  // This mapping exists in reverseTransformCache but doesn't exist in transformCache. This
-  // is because we create many promises from a single IDBRequest.
-  reverseTransformCache.set(promise, request);
-  return promise;
-}
-function cacheDonePromiseForTransaction(tx) {
-  // Early bail if we've already created a done promise for this transaction.
-  if (transactionDoneMap.has(tx)) return;
-  const done = new Promise((resolve, reject) => {
-    const unlisten = () => {
-      tx.removeEventListener('complete', complete);
-      tx.removeEventListener('error', error);
-      tx.removeEventListener('abort', error);
-    };
-    const complete = () => {
-      resolve();
-      unlisten();
-    };
-    const error = () => {
-      reject(tx.error || new DOMException('AbortError', 'AbortError'));
-      unlisten();
-    };
-    tx.addEventListener('complete', complete);
-    tx.addEventListener('error', error);
-    tx.addEventListener('abort', error);
-  });
-  // Cache it for later retrieval.
-  transactionDoneMap.set(tx, done);
-}
-let idbProxyTraps = {
-  get(target, prop, receiver) {
-    if (target instanceof IDBTransaction) {
-      // Special handling for transaction.done.
-      if (prop === 'done') return transactionDoneMap.get(target);
-      // Make tx.store return the only store in the transaction, or undefined if there are many.
-      if (prop === 'store') {
-        return receiver.objectStoreNames[1] ? undefined : receiver.objectStore(receiver.objectStoreNames[0]);
-      }
-    }
-    // Else transform whatever we get back.
-    return wrap(target[prop]);
-  },
-  set(target, prop, value) {
-    target[prop] = value;
-    return true;
-  },
-  has(target, prop) {
-    if (target instanceof IDBTransaction && (prop === 'done' || prop === 'store')) {
-      return true;
-    }
-    return prop in target;
-  }
-};
-function replaceTraps(callback) {
-  idbProxyTraps = callback(idbProxyTraps);
-}
-function wrapFunction(func) {
-  // Due to expected object equality (which is enforced by the caching in `wrap`), we
-  // only create one new func per func.
-  // Cursor methods are special, as the behaviour is a little more different to standard IDB. In
-  // IDB, you advance the cursor and wait for a new 'success' on the IDBRequest that gave you the
-  // cursor. It's kinda like a promise that can resolve with many values. That doesn't make sense
-  // with real promises, so each advance methods returns a new promise for the cursor object, or
-  // undefined if the end of the cursor has been reached.
-  if (getCursorAdvanceMethods().includes(func)) {
-    return function (...args) {
-      // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use
-      // the original object.
-      func.apply(unwrap(this), args);
-      return wrap(this.request);
-    };
-  }
-  return function (...args) {
-    // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use
-    // the original object.
-    return wrap(func.apply(unwrap(this), args));
-  };
-}
-function transformCachableValue(value) {
-  if (typeof value === 'function') return wrapFunction(value);
-  // This doesn't return, it just creates a 'done' promise for the transaction,
-  // which is later returned for transaction.done (see idbObjectHandler).
-  if (value instanceof IDBTransaction) cacheDonePromiseForTransaction(value);
-  if (instanceOfAny(value, getIdbProxyableTypes())) return new Proxy(value, idbProxyTraps);
-  // Return the same value back if we're not going to transform it.
-  return value;
-}
-function wrap(value) {
-  // We sometimes generate multiple promises from a single IDBRequest (eg when cursoring), because
-  // IDB is weird and a single IDBRequest can yield many responses, so these can't be cached.
-  if (value instanceof IDBRequest) return promisifyRequest(value);
-  // If we've already transformed this value before, reuse the transformed value.
-  // This is faster, but it also provides object equality.
-  if (transformCache.has(value)) return transformCache.get(value);
-  const newValue = transformCachableValue(value);
-  // Not all types are transformed.
-  // These may be primitive types, so they can't be WeakMap keys.
-  if (newValue !== value) {
-    transformCache.set(value, newValue);
-    reverseTransformCache.set(newValue, value);
-  }
-  return newValue;
-}
-const unwrap = value => reverseTransformCache.get(value);
-
-/**
- * Open a database.
- *
- * @param name Name of the database.
- * @param version Schema version.
- * @param callbacks Additional callbacks.
- */
-function openDB(name, version, {
-  blocked,
-  upgrade,
-  blocking,
-  terminated
-} = {}) {
-  const request = indexedDB.open(name, version);
-  const openPromise = wrap(request);
-  if (upgrade) {
-    request.addEventListener('upgradeneeded', event => {
-      upgrade(wrap(request.result), event.oldVersion, event.newVersion, wrap(request.transaction), event);
-    });
-  }
-  if (blocked) {
-    request.addEventListener('blocked', event => blocked(
-    // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405
-    event.oldVersion, event.newVersion, event));
-  }
-  openPromise.then(db => {
-    if (terminated) db.addEventListener('close', () => terminated());
-    if (blocking) {
-      db.addEventListener('versionchange', event => blocking(event.oldVersion, event.newVersion, event));
-    }
-  }).catch(() => {});
-  return openPromise;
-}
-const readMethods = ['get', 'getKey', 'getAll', 'getAllKeys', 'count'];
-const writeMethods = ['put', 'add', 'delete', 'clear'];
-const cachedMethods = new Map();
-function getMethod(target, prop) {
-  if (!(target instanceof IDBDatabase && !(prop in target) && typeof prop === 'string')) {
-    return;
-  }
-  if (cachedMethods.get(prop)) return cachedMethods.get(prop);
-  const targetFuncName = prop.replace(/FromIndex$/, '');
-  const useIndex = prop !== targetFuncName;
-  const isWrite = writeMethods.includes(targetFuncName);
-  if (
-  // Bail if the target doesn't exist on the target. Eg, getAll isn't in Edge.
-  !(targetFuncName in (useIndex ? IDBIndex : IDBObjectStore).prototype) || !(isWrite || readMethods.includes(targetFuncName))) {
-    return;
-  }
-  const method = async function (storeName, ...args) {
-    // isWrite ? 'readwrite' : undefined gzipps better, but fails in Edge :(
-    const tx = this.transaction(storeName, isWrite ? 'readwrite' : 'readonly');
-    let target = tx.store;
-    if (useIndex) target = target.index(args.shift());
-    // Must reject if op rejects.
-    // If it's a write operation, must reject if tx.done rejects.
-    // Must reject with op rejection first.
-    // Must resolve with op value.
-    // Must handle both promises (no unhandled rejections)
-    return (await Promise.all([target[targetFuncName](...args), isWrite && tx.done]))[0];
-  };
-  cachedMethods.set(prop, method);
-  return method;
-}
-replaceTraps(oldTraps => ({
-  ...oldTraps,
-  get: (target, prop, receiver) => getMethod(target, prop) || oldTraps.get(target, prop, receiver),
-  has: (target, prop) => !!getMethod(target, prop) || oldTraps.has(target, prop)
-}));
-const advanceMethodProps = ['continue', 'continuePrimaryKey', 'advance'];
-const methodMap = {};
-const advanceResults = new WeakMap();
-const ittrProxiedCursorToOriginalProxy = new WeakMap();
-const cursorIteratorTraps = {
-  get(target, prop) {
-    if (!advanceMethodProps.includes(prop)) return target[prop];
-    let cachedFunc = methodMap[prop];
-    if (!cachedFunc) {
-      cachedFunc = methodMap[prop] = function (...args) {
-        advanceResults.set(this, ittrProxiedCursorToOriginalProxy.get(this)[prop](...args));
-      };
-    }
-    return cachedFunc;
-  }
-};
-async function* iterate(...args) {
-  // tslint:disable-next-line:no-this-assignment
-  let cursor = this;
-  if (!(cursor instanceof IDBCursor)) {
-    cursor = await cursor.openCursor(...args);
-  }
-  if (!cursor) return;
-  cursor = cursor;
-  const proxiedCursor = new Proxy(cursor, cursorIteratorTraps);
-  ittrProxiedCursorToOriginalProxy.set(proxiedCursor, cursor);
-  // Map this double-proxy back to the original, so other cursor methods work.
-  reverseTransformCache.set(proxiedCursor, unwrap(cursor));
-  while (cursor) {
-    yield proxiedCursor;
-    // If one of the advancing methods was not called, call continue().
-    cursor = await (advanceResults.get(proxiedCursor) || cursor.continue());
-    advanceResults.delete(proxiedCursor);
-  }
-}
-function isIteratorProp(target, prop) {
-  return prop === Symbol.asyncIterator && instanceOfAny(target, [IDBIndex, IDBObjectStore, IDBCursor]) || prop === 'iterate' && instanceOfAny(target, [IDBIndex, IDBObjectStore]);
-}
-replaceTraps(oldTraps => ({
-  ...oldTraps,
-  get(target, prop, receiver) {
-    if (isIteratorProp(target, prop)) return iterate;
-    return oldTraps.get(target, prop, receiver);
-  },
-  has(target, prop) {
-    return isIteratorProp(target, prop) || oldTraps.has(target, prop);
-  }
-}));
-
-const openDatabaseDependencies = {
-  openDB: openDB
-};
-const openDatabase = async (databaseName, dataBaseVersion) => {
-  return openDatabaseDependencies.openDB(databaseName, dataBaseVersion);
+  return invoke('ChatStorage.loadSelectedEvent', sessionId, eventId, type);
 };
 
 const loadSelectedEventDependencies = {
-  getEventDetailsBySessionIdAndEventId: getEventDetailsBySessionIdAndEventId,
-  loadSelectedEventFromWorker: loadSelectedEvent$1,
-  openDatabase: openDatabase
+  loadSelectedEventFromWorker: loadSelectedEvent$1
 };
-const loadSelectedEvent = async (databaseName, dataBaseVersion, eventStoreName, sessionId, sessionIdIndexName, eventId, type) => {
-  const database = await loadSelectedEventDependencies.openDatabase(databaseName, dataBaseVersion);
-  try {
-    if (!database.objectStoreNames.contains(eventStoreName)) {
-      return null;
-    }
-    const transaction = database.transaction(eventStoreName, 'readonly');
-    const store = transaction.objectStore(eventStoreName);
-    const event = await loadSelectedEventDependencies.getEventDetailsBySessionIdAndEventId(store, sessionId, sessionIdIndexName, eventId, type);
-    return event ?? null;
-  } finally {
-    database.close();
-  }
+const loadSelectedEvent = async (_databaseName, _dataBaseVersion, _eventStoreName, sessionId, _sessionIdIndexName, eventId, type) => {
+  return loadSelectedEventDependencies.loadSelectedEventFromWorker(sessionId, eventId, type);
 };
 
 const getCurrentEvents$2 = state => {
@@ -2394,12 +2307,24 @@ const handleShowResponsePartEvents = (state, checked) => {
   return withPreservedSelection$1(state, nextState);
 };
 
-const getFailedToLoadMessage = sessionId => {
-  return `Failed to load chat debug session "${sessionId}". Please try again.`;
+const getErrorMessage = error => {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === 'string') {
+    return error;
+  }
+  if (error && typeof error === 'object' && 'message' in error && typeof error.message === 'string') {
+    return error.message;
+  }
+  return undefined;
 };
-
-const getIndexedDbNotSupportedMessage = () => {
-  return 'Unable to load chat debug session: IndexedDB is not supported in this environment.';
+const getFailedToLoadMessage = (sessionId, error) => {
+  const errorMessage = getErrorMessage(error);
+  if (errorMessage) {
+    return `Failed to load chat debug session "${sessionId}": ${errorMessage}`;
+  }
+  return `Failed to load chat debug session "${sessionId}". Please try again.`;
 };
 
 const ParseChatDebugUriErrorCode = {
@@ -2420,135 +2345,12 @@ const getSessionNotFoundMessage = sessionId => {
   return `No chat session found for sessionId "${sessionId}".`;
 };
 
-const filterEventsBySessionId = (events, sessionId) => {
-  return events.filter(event => event.sessionId === sessionId);
-};
-
-// cspell:ignore IDBP
-
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-const getAllEvents = async store => {
-  const all = await store.getAll();
-  return all;
-};
-
-const getEndTime = event => {
-  return event.ended ?? event.endTime ?? event.timestamp;
-};
-
-const getStartTime = event => {
-  return event.started ?? event.startTime ?? event.timestamp;
-};
-
-const getDuration = event => {
-  const explicitDuration = event.durationMs ?? event.duration;
-  if (typeof explicitDuration === 'number' && Number.isFinite(explicitDuration)) {
-    return explicitDuration;
-  }
-  const start = toTimeNumber(getStartTime(event));
-  const end = toTimeNumber(getEndTime(event));
-  if (start === undefined || end === undefined || !Number.isFinite(start) || !Number.isFinite(end)) {
-    return 0;
-  }
-  return Math.max(0, end - start);
-};
-
-const isTimeValue = value => {
-  return typeof value === 'number' || typeof value === 'string';
-};
-
-const getLightweightEvent = (event, fallbackEventId) => {
-  const startTime = getStartTime(event);
-  const endTime = getEndTime(event);
-  return {
-    duration: getDuration(event),
-    ...(isTimeValue(endTime) ? {
-      endTime
-    } : {}),
-    eventId: typeof event.eventId === 'number' ? event.eventId : fallbackEventId,
-    ...(isTimeValue(startTime) ? {
-      startTime
-    } : {}),
-    type: event.type
-  };
-};
-
-// cspell:ignore IDBP
-
-const toLightweightEvents = events => {
-  const eventsWithIds = events.map((event, index) => {
-    return {
-      ...event,
-      eventId: index + 1
-    };
-  });
-  return collapseToolExecutionEvents(eventsWithIds).map((event, index) => getLightweightEvent(event, index + 1));
-};
-const getEventsBySessionId = async (store, sessionId, sessionIdIndexName) => {
-  if (store.indexNames.contains(sessionIdIndexName)) {
-    const index = store.index(sessionIdIndexName);
-    const events = await index.getAll(sessionId);
-    return toLightweightEvents(filterEventsBySessionId(events, sessionId));
-  }
-  const all = await getAllEvents(store);
-  return toLightweightEvents(filterEventsBySessionId(all, sessionId));
-};
-
-let indexedDbSupportOverride;
-const getIndexedDbSupportOverride = () => {
-  return indexedDbSupportOverride;
-};
-const setIndexedDbSupportOverride = supported => {
-  indexedDbSupportOverride = supported;
-};
-
-const isIndexedDbSupported = indexedDbSupportOverride => {
-  if (typeof indexedDbSupportOverride === 'boolean') {
-    return indexedDbSupportOverride;
-  }
-  const override = getIndexedDbSupportOverride();
-  if (typeof override === 'boolean') {
-    return override;
-  }
-  return globalThis.indexedDB !== undefined;
-};
-
 const listChatViewEventsDependencies = {
-  getEventsBySessionId: getEventsBySessionId,
-  listChatViewEventsFromWorker: listChatViewEvents$1,
-  openDatabase: openDatabase
+  listChatViewEventsFromWorker: listChatViewEvents$1
 };
-const listChatViewEvents = async (sessionId, databaseName, dataBaseVersion, eventStoreName, sessionIdIndexName, indexedDbSupportOverride) => {
-  if (!isIndexedDbSupported(indexedDbSupportOverride)) {
-    return {
-      type: 'not-supported'
-    };
-  }
+const listChatViewEvents = async (sessionId, _databaseName, _dataBaseVersion, _eventStoreName, _sessionIdIndexName) => {
   try {
-    const database = await listChatViewEventsDependencies.openDatabase(databaseName, dataBaseVersion);
-    try {
-      if (!database.objectStoreNames.contains(eventStoreName)) {
-        return {
-          events: [],
-          type: 'success'
-        };
-      }
-      const transaction = database.transaction(eventStoreName, 'readonly');
-      const store = transaction.objectStore(eventStoreName);
-      if (!sessionId) {
-        return {
-          events: [],
-          type: 'success'
-        };
-      }
-      const events = await listChatViewEventsDependencies.getEventsBySessionId(store, sessionId, sessionIdIndexName);
-      return {
-        events,
-        type: 'success'
-      };
-    } finally {
-      database.close();
-    }
+    return await listChatViewEventsDependencies.listChatViewEventsFromWorker(sessionId);
   } catch (error) {
     return {
       error,
@@ -2670,26 +2472,13 @@ const loadEventsForSessionId = async (state, sessionId) => {
     databaseName,
     dataBaseVersion,
     eventStoreName,
-    indexedDbSupportOverride,
     sessionIdIndexName
   } = state;
-  const result = await loadEventsDependencies.listChatViewEvents(sessionId, databaseName, dataBaseVersion, eventStoreName, sessionIdIndexName, indexedDbSupportOverride);
-  if (result.type === 'not-supported') {
-    return {
-      ...state,
-      errorMessage: getIndexedDbNotSupportedMessage(),
-      events: [],
-      initial: false,
-      selectedEvent: null,
-      selectedEventId: null,
-      selectedEventIndex: null,
-      sessionId
-    };
-  }
+  const result = await loadEventsDependencies.listChatViewEvents(sessionId, databaseName, dataBaseVersion, eventStoreName, sessionIdIndexName);
   if (result.type === 'error') {
     return {
       ...state,
-      errorMessage: getFailedToLoadMessage(sessionId),
+      errorMessage: getFailedToLoadMessage(sessionId, result.error),
       events: [],
       initial: false,
       selectedEvent: null,
@@ -2745,30 +2534,6 @@ const refresh = async state => {
   return refreshEvents(state);
 };
 
-const Button = 1;
-const Div = 4;
-const Input = 6;
-const Span = 8;
-const Table = 9;
-const TBody = 10;
-const Td = 11;
-const Text = 12;
-const Th = 13;
-const THead = 14;
-const Tr = 15;
-const Search = 42;
-const Label = 66;
-const Reference = 100;
-
-const ClientX = 'event.clientX';
-const ClientY = 'event.clientY';
-const TargetName = 'event.target.name';
-const TargetValue = 'event.target.value';
-
-const SetCss = 'Viewlet.setCss';
-const SetDom2 = 'Viewlet.setDom2';
-const SetPatches = 'Viewlet.setPatches';
-
 const getCss = state => {
   const tableWidth = clampTableWidth(state.width, state.tableWidth);
   const detailsWidth = getDetailsWidth(state.width, state.tableWidth);
@@ -4151,6 +3916,9 @@ const hasErrorStatus = event => {
     if (isErrorStatusCode(result.status)) {
       return true;
     }
+    if (isToolEvent(event) && 'error' in result && result.error !== undefined) {
+      return true;
+    }
     if (typeof result.error === 'string' || typeof result.errorMessage === 'string' || typeof result.exception === 'string') {
       return true;
     }
@@ -4871,31 +4639,15 @@ const setEvents = (state, events) => {
   };
 };
 
-const setIndexedDbSupportForTest = supported => {
-  return setIndexedDbSupportOverride(supported);
-};
-
 const setSessionIdDependencies = {
   listChatViewEvents: listChatViewEvents
 };
 const setSessionId = async (state, sessionId) => {
-  const result = await setSessionIdDependencies.listChatViewEvents(sessionId, state.databaseName, state.dataBaseVersion, state.eventStoreName, state.sessionIdIndexName, state.indexedDbSupportOverride);
-  if (result.type === 'not-supported') {
-    return {
-      ...state,
-      errorMessage: getIndexedDbNotSupportedMessage(),
-      events: [],
-      initial: false,
-      selectedEvent: null,
-      selectedEventId: null,
-      selectedEventIndex: null,
-      sessionId
-    };
-  }
+  const result = await setSessionIdDependencies.listChatViewEvents(sessionId, state.databaseName, state.dataBaseVersion, state.eventStoreName, state.sessionIdIndexName);
   if (result.type === 'error') {
     return {
       ...state,
-      errorMessage: getFailedToLoadMessage(sessionId),
+      errorMessage: getFailedToLoadMessage(sessionId, result.error),
       events: [],
       initial: false,
       selectedEvent: null,
@@ -4954,17 +4706,28 @@ const commandMap = {
   'ChatDebug.resize': wrapCommand(resize),
   'ChatDebug.saveState': wrapGetter(saveState),
   'ChatDebug.setEvents': wrapCommand(setEvents),
-  'ChatDebug.setIndexedDbSupportForTest': setIndexedDbSupportForTest,
   'ChatDebug.setSessionId': wrapCommand(setSessionId),
   'ChatDebug.terminate': terminate
 };
 
+const sendMessagePortToChatStorageWorker = async port => {
+  await sendMessagePortToChatStorageWorker$1(port);
+};
+const initializeChatStorageWorker = async () => {
+  const rpc = await create$4({
+    commandMap: {},
+    send: sendMessagePortToChatStorageWorker
+  });
+  set$2(rpc);
+};
+
 const listen = async () => {
   registerCommands(commandMap);
-  const rpc = await create$2({
+  const r = await create$3({
     commandMap: commandMap
   });
-  setWorkerRpc(rpc);
+  set$1(r);
+  await initializeChatStorageWorker();
 };
 
 const main = async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/chat-debug-view",
-  "version": "5.5.0",
+  "version": "6.0.0",
   "description": "Chat Debug View Worker",
   "repository": {
     "type": "git",