@lvce-editor/static-server 0.77.3 → 0.77.5

package/static/{01dd1a1 → e30ed59}/packages/chat-tool-worker/dist/chatToolWorkerMain.js

@@ -407,6 +407,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) {
@@ -643,7 +737,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$9 = (message, result) => {
   return {
     id: message.id,
     jsonrpc: Two$1,
@@ -652,7 +746,7 @@ const create$6 = (message, result) => {
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$6(message, resultProperty);
+  return create$9(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
@@ -746,7 +840,7 @@ const handleJsonRpcMessage = async (...args) => {
 
 const Two = '2.0';
 
-const create$5 = (method, params) => {
+const create$8 = (method, params) => {
   return {
     jsonrpc: Two,
     method,
@@ -754,7 +848,7 @@ const create$5 = (method, params) => {
   };
 };
 
-const create$4 = (id, method, params) => {
+const create$7 = (id, method, params) => {
   const message = {
     id,
     jsonrpc: Two,
@@ -765,12 +859,12 @@ const create$4 = (id, method, params) => {
 };
 
 let id = 0;
-const create$3 = () => {
+const create$6 = () => {
   return ++id;
 };
 
 const registerPromise = map => {
-  const id = create$3();
+  const id = create$6();
   const {
     promise,
     resolve
@@ -787,7 +881,7 @@ const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer)
     id,
     promise
   } = registerPromise(callbacks);
-  const message = create$4(id, method, params);
+  const message = create$7(id, method, params);
   if (useSendAndTransfer && ipc.sendAndTransfer) {
     ipc.sendAndTransfer(message);
   } else {
@@ -823,7 +917,7 @@ const createRpc = ipc => {
      * @deprecated
      */
     send(method, ...params) {
-      const message = create$5(method, params);
+      const message = create$8(method, params);
       ipc.send(message);
     }
   };
@@ -863,6 +957,83 @@ const listen$1 = async (module, options) => {
   return ipc;
 };
 
+const create$5 = 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$4 = async ({
+  commandMap,
+  isMessagePortOpen,
+  send
+}) => {
+  const {
+    port1,
+    port2
+  } = new MessageChannel();
+  await send(port1);
+  return create$5({
+    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$3 = async ({
+  commandMap,
+  isMessagePortOpen,
+  send
+}) => {
+  return createSharedLazyRpc(() => {
+    return create$4({
+      commandMap,
+      isMessagePortOpen,
+      send
+    });
+  });
+};
+
 const create$2 = async ({
   commandMap,
   messagePort
@@ -909,7 +1080,7 @@ const createMockRpc = ({
 };
 
 const rpcs = Object.create(null);
-const set$1 = (id, rpc) => {
+const set$3 = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get = id => {
@@ -942,7 +1113,7 @@ const create = rpcId => {
       const mockRpc = createMockRpc({
         commandMap
       });
-      set$1(rpcId, mockRpc);
+      set$3(rpcId, mockRpc);
       // @ts-ignore
       mockRpc[Symbol.dispose] = () => {
         remove(rpcId);
@@ -951,20 +1122,38 @@ const create = rpcId => {
       return mockRpc;
     },
     set(rpc) {
-      set$1(rpcId, rpc);
+      set$3(rpcId, rpc);
     }
   };
 };
 
+const ChatStorageWorker = 6003;
+const FileSystemWorker = 209;
 const RendererWorker = 1;
 
+const {
+  set: set$2
+} = create(ChatStorageWorker);
+
+const {
+  set: set$1
+} = create(FileSystemWorker);
+
 const {
   invoke,
+  invokeAndTransfer,
   set
 } = create(RendererWorker);
+const sendMessagePortToFileSystemWorker = async (port, rpcId) => {
+  const command = 'FileSystem.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
+};
 const readFile = async uri => {
   return invoke('FileSystem.readFile', uri);
 };
+const sendMessagePortToChatStorageWorker = async port => {
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToChatStorageWorker', port, 'HandleMessagePort.handleMessagePort');
+};
 const writeFile = async (uri, text) => {
   await invoke('FileSystem.writeFile', uri, text);
 };
@@ -1107,6 +1296,158 @@ const executeGlobTool = async (args, _options) => {
   };
 };
 
+const formatSearchProcessResults = results => {
+  if (!results || results.length === 0) {
+    return 'No matches found.';
+  }
+  let currentFile = '';
+  const lines = [];
+  for (const result of results) {
+    if (result.type === 1) {
+      currentFile = result.text;
+      continue;
+    }
+    if (result.type === 2) {
+      if (currentFile) {
+        lines.push(`${currentFile}:${result.lineNumber}:${result.text}`);
+      } else {
+        lines.push(`${result.lineNumber}:${result.text}`);
+      }
+    }
+  }
+  if (lines.length === 0) {
+    return 'No matches found.';
+  }
+  return lines.join('\n');
+};
+
+const windowsDrivePathRegex = /^[a-zA-Z]:[\\/]/;
+const isAbsoluteFileSystemPath = value => {
+  return value.startsWith('/') || windowsDrivePathRegex.test(value);
+};
+
+const isFileUri = value => {
+  return value.startsWith('file://');
+};
+
+const getRipGrepArgs = ({
+  includeIgnoredFiles,
+  includePattern,
+  isRegexp,
+  query
+}) => {
+  const ripGrepArgs = ['--hidden', '--no-require-git', '--smart-case', '--stats', '--json', '--threads', '1', '--ignore-case'];
+  if (includeIgnoredFiles) {
+    ripGrepArgs.push('--no-ignore');
+  }
+  if (includePattern && !isFileUri(includePattern) && !isAbsoluteFileSystemPath(includePattern)) {
+    ripGrepArgs.push('--glob', includePattern);
+  }
+  if (isRegexp) {
+    ripGrepArgs.push('--regexp', query);
+  } else {
+    ripGrepArgs.push('--fixed-strings', '--', query);
+  }
+  ripGrepArgs.push('.');
+  return ripGrepArgs;
+};
+
+const windowsPathWithLeadingSlashRegex = /^\/[a-zA-Z]:/;
+const getFilePathFromUri = uri => {
+  const url = new URL(uri);
+  const decodedPath = decodeURIComponent(url.pathname);
+  if (windowsPathWithLeadingSlashRegex.test(decodedPath)) {
+    return decodedPath.slice(1);
+  }
+  return decodedPath;
+};
+
+const getScheme = uriOrPath => {
+  if (!uriOrPath.includes('://')) {
+    return '';
+  }
+  return new URL(uriOrPath).protocol.slice(0, -1);
+};
+
+const getSearchDir = (workspaceUri, includePattern) => {
+  if (!includePattern) {
+    return getScheme(workspaceUri) === 'file' ? getFilePathFromUri(workspaceUri) : workspaceUri;
+  }
+  if (isFileUri(includePattern)) {
+    return getFilePathFromUri(includePattern);
+  }
+  if (isAbsoluteFileSystemPath(includePattern)) {
+    return includePattern;
+  }
+  return getScheme(workspaceUri) === 'file' ? getFilePathFromUri(workspaceUri) : workspaceUri;
+};
+
+const executeFileGrepSearch = async (workspaceUri, grepSearchArgs) => {
+  const result = await invoke('SearchProcess.invoke', 'TextSearch.search', {
+    maxSearchResults: grepSearchArgs.maxResults,
+    ripGrepArgs: getRipGrepArgs(grepSearchArgs),
+    searchDir: getSearchDir(workspaceUri, grepSearchArgs.includePattern)
+  });
+  return {
+    arguments: grepSearchArgs,
+    result: formatSearchProcessResults(result.results),
+    workspaceUri,
+    ...(result.limitHit ? {
+      warning: 'Search result limit reached.'
+    } : {})
+  };
+};
+
+const formatLegacyMemorySearchResults = results => {
+  const lines = [];
+  for (const result of results) {
+    const [path, matches] = result;
+    for (const match of matches) {
+      const preview = typeof match?.preview === 'string' ? match.preview : '';
+      lines.push(preview ? `${path}: ${preview}` : path);
+    }
+  }
+  if (lines.length === 0) {
+    return 'No matches found.';
+  }
+  return lines.join('\n');
+};
+
+const isLegacyMemorySearchResult = value => {
+  return Array.isArray(value);
+};
+
+const executeMemoryGrepSearch = async (workspaceUri, grepSearchArgs, options) => {
+  const searchOptions = {
+    exclude: '',
+    include: grepSearchArgs.includePattern || '',
+    isCaseSensitive: false,
+    query: grepSearchArgs.query,
+    root: workspaceUri,
+    scheme: getScheme(workspaceUri),
+    threads: 1,
+    useRegularExpression: grepSearchArgs.isRegexp
+  };
+  try {
+    const result = await invoke('ExtensionHostTextSearch.textSearchMemory2', searchOptions.scheme, workspaceUri, grepSearchArgs.query, searchOptions, options.assetDir);
+    return {
+      arguments: grepSearchArgs,
+      result: formatLegacyMemorySearchResults(result.results || []),
+      workspaceUri,
+      ...(result.limitHit ? {
+        warning: 'Search result limit reached.'
+      } : {})
+    };
+  } catch {
+    const legacyResults = await invoke('ExtensionHostTextSearch.textSearchMemory', searchOptions.scheme, workspaceUri, grepSearchArgs.query, searchOptions, options.assetDir);
+    return {
+      arguments: grepSearchArgs,
+      result: isLegacyMemorySearchResult(legacyResults) ? formatLegacyMemorySearchResults(legacyResults) : 'No matches found.',
+      workspaceUri
+    };
+  }
+};
+
 const getGrepSearchArgs = args => {
   const {
     includeIgnoredFiles,
@@ -1141,17 +1482,29 @@ const getGrepSearchArgs = args => {
     query
   };
 };
-const executeGrepSearchTool = async (args, _options) => {
+
+const grepSearchArgumentError = 'Invalid argument: grep_search requires query (string), isRegexp (boolean), optional includePattern (string), optional maxResults (number), and optional includeIgnoredFiles (boolean).';
+
+const executeGrepSearchTool = async (args, options) => {
   const grepSearchArgs = getGrepSearchArgs(args);
   if (!grepSearchArgs) {
     return {
-      error: 'Invalid argument: grep_search requires query (string), isRegexp (boolean), optional includePattern (string), optional maxResults (number), and optional includeIgnoredFiles (boolean).'
+      error: grepSearchArgumentError
+    };
+  }
+  try {
+    const workspaceUri = await getWorkspacePath();
+    const scheme = getScheme(workspaceUri);
+    if (scheme === '' || scheme === 'file') {
+      return executeFileGrepSearch(workspaceUri, grepSearchArgs);
+    }
+    return executeMemoryGrepSearch(workspaceUri, grepSearchArgs, options);
+  } catch (error) {
+    return {
+      ...getToolErrorPayload(error),
+      arguments: grepSearchArgs
     };
   }
-  return {
-    arguments: grepSearchArgs,
-    result: 'No matches found.'
-  };
 };
 
 const executeListFilesTool = async (args, _options) => {
@@ -1588,7 +1941,7 @@ const executeChatTool = async (name, rawArguments, options) => {
     case 'glob':
       return executeGlobTool(args);
     case 'grep_search':
-      return executeGrepSearchTool(args);
+      return executeGrepSearchTool(args, options);
     case 'list_files':
       return executeListFilesTool(args);
     case 'open_preview':
@@ -1618,16 +1971,31 @@ const executeChatTool = async (name, rawArguments, options) => {
   }
 };
 
-const getReadFileTool = () => {
+const getClosePreviewTool = () => {
   return {
     function: {
-      description: 'Read UTF-8 text content from a file inside the currently open workspace folder. Only pass an absolute URI.',
-      name: 'read_file',
+      description: 'Close the right-side preview if it is currently open.',
+      name: 'close_preview',
+      parameters: {
+        additionalProperties: false,
+        properties: {},
+        type: 'object'
+      }
+    },
+    type: 'function'
+  };
+};
+
+const getCreateDirectoryTool = () => {
+  return {
+    function: {
+      description: 'Create a new directory at the given absolute URI (for example `file://...`, `memfs://...`, or extension-provided file system URIs). Do not pass a relative path.',
+      name: 'create_directory',
       parameters: {
         additionalProperties: false,
         properties: {
           uri: {
-            description: 'Absolute file URI for a real path inside the currently open workspace folder. Do not use placeholder URIs.',
+            description: 'Absolute URI for the target directory (for example `file://...`, `memfs://...`, or extension-provided file system URIs). Relative paths are not allowed.',
             type: 'string'
           }
         },
@@ -1638,16 +2006,25 @@ const getReadFileTool = () => {
     type: 'function'
   };
 };
-const getWriteFileTool = () => {
+
+const getEditFileTool = () => {
   return {
     function: {
-      description: 'Write UTF-8 text content to a file for an absolute URI (for example `file://...`, `memfs://...`, or extension-provided file system URIs). Do not pass a relative path and do not use a `path` argument.',
-      name: 'write_file',
+      description: 'Apply a targeted text edit to an existing file by character offsets. This reads the current file, applies the edit, and writes the updated result. Use this for small changes instead of rewriting the full file.',
+      name: 'edit_file',
       parameters: {
         additionalProperties: false,
         properties: {
-          content: {
-            description: 'New UTF-8 text content to write to the file.',
+          end: {
+            description: 'Zero-based end character offset (exclusive) in the current file content.',
+            type: 'number'
+          },
+          start: {
+            description: 'Zero-based start character offset (inclusive) in the current file content.',
+            type: 'number'
+          },
+          text: {
+            description: 'Replacement text inserted at the range [start, end).',
             type: 'string'
           },
           uri: {
@@ -1655,69 +2032,87 @@ const getWriteFileTool = () => {
             type: 'string'
           }
         },
-        required: ['uri', 'content'],
+        required: ['uri', 'start', 'end', 'text'],
         type: 'object'
       }
     },
     type: 'function'
   };
 };
-const getRenameTool = () => {
+
+const getGetWorkspaceUriTool = () => {
   return {
     function: {
-      description: 'Rename or move a file or folder from one absolute URI to another absolute URI (for example `file://...`, `memfs://...`, or extension-provided file system URIs).',
-      name: 'rename',
+      description: 'Get the URI of the currently open workspace folder. Call this first before using list_files, read_file, write_file, edit_file, open_preview, or openEditor when you do not already have a concrete workspace URI.',
+      name: 'getWorkspaceUri',
+      parameters: {
+        additionalProperties: false,
+        properties: {},
+        type: 'object'
+      }
+    },
+    type: 'function'
+  };
+};
+
+const getGlobTool = () => {
+  return {
+    function: {
+      description: 'Find files by glob pattern and return matching relative paths.',
+      name: 'glob',
       parameters: {
         additionalProperties: false,
         properties: {
-          newUri: {
-            description: 'Absolute target URI for the file or folder after renaming.',
-            type: 'string'
-          },
-          oldUri: {
-            description: 'Absolute source URI for the existing file or folder to rename.',
+          pattern: {
+            description: 'Glob pattern to match files, for example `packages/e2e/src/*.ts`.',
             type: 'string'
           }
         },
-        required: ['oldUri', 'newUri'],
+        required: ['pattern'],
         type: 'object'
       }
     },
     type: 'function'
   };
 };
-const getEditFileTool = () => {
+
+const getGrepSearchTool = () => {
   return {
     function: {
-      description: 'Apply a targeted text edit to an existing file by character offsets. This reads the current file, applies the edit, and writes the updated result. Use this for small changes instead of rewriting the full file.',
-      name: 'edit_file',
+      description: "Do a fast text search in the workspace. Use this tool when you want to search with an exact string or regex. If you are not sure what words will appear in the workspace, prefer using regex patterns with alternation (|) or character classes to search for multiple potential words at once instead of making separate searches. For example, use 'function|method|procedure' to look for all of those words at once. Use includePattern to search within files matching a specific pattern, or in a specific file, using a relative path. Use 'includeIgnoredFiles' to include files normally ignored by .gitignore, other ignore files, and `files.exclude` and `search.exclude` settings. Warning: using this may cause the search to be slower, only set it when you want to search in ignored folders like node_modules or build outputs. Use this tool when you want to see an overview of a particular file, instead of using read_file many times to look for code within a file.\n\nIn a multi-root workspace, you can scope the search to a specific workspace folder by using the absolute path to the folder as the includePattern, e.g. /path/to/folder.",
+      name: 'grep_search',
       parameters: {
         additionalProperties: false,
         properties: {
-          end: {
-            description: 'Zero-based end character offset (exclusive) in the current file content.',
-            type: 'number'
-          },
-          start: {
-            description: 'Zero-based start character offset (inclusive) in the current file content.',
-            type: 'number'
+          includeIgnoredFiles: {
+            description: 'Whether to include files that would normally be ignored according to .gitignore, other ignore files and `files.exclude` and `search.exclude` settings. Warning: using this may cause the search to be slower. Only set it when you want to search in ignored folders like node_modules or build outputs.',
+            type: 'boolean'
           },
-          text: {
-            description: 'Replacement text inserted at the range [start, end).',
+          includePattern: {
+            description: 'Search files matching this glob pattern. Will be applied to the relative path of files within the workspace. To search recursively inside a folder, use a proper glob pattern like "src/folder/**". Do not use | in includePattern. Can also be an absolute path to a workspace folder to scope the search in a multi-root workspace.',
             type: 'string'
           },
-          uri: {
-            description: 'Absolute URI for the target file (for example `file://...`, `memfs://...`, or extension-provided file system URIs). Relative paths are not allowed.',
+          isRegexp: {
+            description: 'Whether the pattern is a regex.',
+            type: 'boolean'
+          },
+          maxResults: {
+            description: "The maximum number of results to return. Do not use this unless necessary, it can slow things down. By default, only some matches are returned. If you use this and don't see what you're looking for, you can try again with a more specific query or a larger maxResults.",
+            type: 'number'
+          },
+          query: {
+            description: "The pattern to search for in files in the workspace. Use regex with alternation (e.g., 'word1|word2|word3') or character classes to find multiple potential words in a single search. Be sure to set the isRegexp property properly to declare whether it's a regex or plain text pattern. Is case-insensitive.",
             type: 'string'
           }
         },
-        required: ['uri', 'start', 'end', 'text'],
+        required: ['query', 'isRegexp'],
         type: 'object'
       }
     },
     type: 'function'
   };
 };
+
 const getListFilesTool = () => {
   return {
     function: {
@@ -1738,48 +2133,28 @@ const getListFilesTool = () => {
     type: 'function'
   };
 };
-const getGetWorkspaceUriTool = () => {
-  return {
-    function: {
-      description: 'Get the URI of the currently open workspace folder. Call this first before using list_files, read_file, write_file, edit_file, open_preview, or openEditor when you do not already have a concrete workspace URI.',
-      name: 'getWorkspaceUri',
-      parameters: {
-        additionalProperties: false,
-        properties: {},
-        type: 'object'
-      }
-    },
-    type: 'function'
-  };
-};
-const getRenderHtmlTool = () => {
+
+const getOpenEditorTool = () => {
   return {
     function: {
-      description: 'Render custom HTML and optional CSS directly in the chat tool call list using native chat UI rendering. Use this for structured cards, tables, and small dashboards. After calling this tool, do not repeat the same HTML, data table, or long content again as plain text unless the user explicitly asks for a text-only version.',
-      name: 'render_html',
+      description: 'Open a file URI in the editor.',
+      name: 'openEditor',
       parameters: {
         additionalProperties: false,
         properties: {
-          css: {
-            description: 'Optional CSS string applied inside the preview document.',
-            type: 'string'
-          },
-          html: {
-            description: 'HTML string to render in the preview document.',
-            type: 'string'
-          },
-          title: {
-            description: 'Optional short title for the preview.',
+          uri: {
+            description: 'Absolute file URI for a real path inside the currently open workspace folder. Do not use placeholder URIs.',
             type: 'string'
           }
         },
-        required: ['html'],
+        required: ['uri'],
         type: 'object'
       }
     },
     type: 'function'
   };
 };
+
 const getOpenPreviewTool = () => {
   return {
     function: {
@@ -1800,11 +2175,12 @@ const getOpenPreviewTool = () => {
     type: 'function'
   };
 };
-const getOpenEditorTool = () => {
+
+const getReadFileTool = () => {
   return {
     function: {
-      description: 'Open a file URI in the editor.',
-      name: 'openEditor',
+      description: 'Read UTF-8 text content from a file inside the currently open workspace folder. Only pass an absolute URI.',
+      name: 'read_file',
       parameters: {
         additionalProperties: false,
         properties: {
@@ -1820,61 +2196,61 @@ const getOpenEditorTool = () => {
     type: 'function'
   };
 };
-const getClosePreviewTool = () => {
+
+const getRenameTool = () => {
   return {
     function: {
-      description: 'Close the right-side preview if it is currently open.',
-      name: 'close_preview',
+      description: 'Rename or move a file or folder from one absolute URI to another absolute URI (for example `file://...`, `memfs://...`, or extension-provided file system URIs).',
+      name: 'rename',
       parameters: {
         additionalProperties: false,
-        properties: {},
+        properties: {
+          newUri: {
+            description: 'Absolute target URI for the file or folder after renaming.',
+            type: 'string'
+          },
+          oldUri: {
+            description: 'Absolute source URI for the existing file or folder to rename.',
+            type: 'string'
+          }
+        },
+        required: ['oldUri', 'newUri'],
         type: 'object'
       }
     },
     type: 'function'
   };
 };
-const getSearchTextTool = () => {
+
+const getRenderHtmlTool = () => {
   return {
     function: {
-      description: 'Search text in workspace files using query options and return matching results.',
-      name: 'search_text',
+      description: 'Render custom HTML and optional CSS directly in the chat tool call list using native chat UI rendering. Use this for structured cards, tables, and small dashboards. After calling this tool, do not repeat the same HTML, data table, or long content again as plain text unless the user explicitly asks for a text-only version.',
+      name: 'render_html',
       parameters: {
         additionalProperties: false,
         properties: {
-          options: {
-            additionalProperties: false,
-            properties: {
-              exclude: {
-                items: {
-                  type: 'string'
-                },
-                type: 'array'
-              },
-              isRegex: {
-                type: 'boolean'
-              },
-              machWholeWord: {
-                type: 'boolean'
-              },
-              matchCase: {
-                type: 'boolean'
-              },
-              value: {
-                type: 'string'
-              }
-            },
-            required: ['value', 'isRegex', 'matchCase', 'machWholeWord', 'exclude'],
-            type: 'object'
+          css: {
+            description: 'Optional CSS string applied inside the preview document.',
+            type: 'string'
+          },
+          html: {
+            description: 'HTML string to render in the preview document.',
+            type: 'string'
+          },
+          title: {
+            description: 'Optional short title for the preview.',
+            type: 'string'
           }
         },
-        required: ['options'],
+        required: ['html'],
         type: 'object'
       }
     },
     type: 'function'
   };
 };
+
 const getRgTool = () => {
   return {
     function: {
@@ -1908,42 +2284,7 @@ const getRgTool = () => {
     type: 'function'
   };
 };
-const getGrepSearchTool = () => {
-  return {
-    function: {
-      description: "Do a fast text search in the workspace. Use this tool when you want to search with an exact string or regex. If you are not sure what words will appear in the workspace, prefer using regex patterns with alternation (|) or character classes to search for multiple potential words at once instead of making separate searches. For example, use 'function|method|procedure' to look for all of those words at once. Use includePattern to search within files matching a specific pattern, or in a specific file, using a relative path. Use 'includeIgnoredFiles' to include files normally ignored by .gitignore, other ignore files, and `files.exclude` and `search.exclude` settings. Warning: using this may cause the search to be slower, only set it when you want to search in ignored folders like node_modules or build outputs. Use this tool when you want to see an overview of a particular file, instead of using read_file many times to look for code within a file.\n\nIn a multi-root workspace, you can scope the search to a specific workspace folder by using the absolute path to the folder as the includePattern, e.g. /path/to/folder.",
-      name: 'grep_search',
-      parameters: {
-        additionalProperties: false,
-        properties: {
-          includeIgnoredFiles: {
-            description: 'Whether to include files that would normally be ignored according to .gitignore, other ignore files and `files.exclude` and `search.exclude` settings. Warning: using this may cause the search to be slower. Only set it when you want to search in ignored folders like node_modules or build outputs.',
-            type: 'boolean'
-          },
-          includePattern: {
-            description: 'Search files matching this glob pattern. Will be applied to the relative path of files within the workspace. To search recursively inside a folder, use a proper glob pattern like "src/folder/**". Do not use | in includePattern. Can also be an absolute path to a workspace folder to scope the search in a multi-root workspace.',
-            type: 'string'
-          },
-          isRegexp: {
-            description: 'Whether the pattern is a regex.',
-            type: 'boolean'
-          },
-          maxResults: {
-            description: "The maximum number of results to return. Do not use this unless necessary, it can slow things down. By default, only some matches are returned. If you use this and don't see what you're looking for, you can try again with a more specific query or a larger maxResults.",
-            type: 'number'
-          },
-          query: {
-            description: "The pattern to search for in files in the workspace. Use regex with alternation (e.g., 'word1|word2|word3') or character classes to find multiple potential words in a single search. Be sure to set the isRegexp property properly to declare whether it's a regex or plain text pattern. Is case-insensitive.",
-            type: 'string'
-          }
-        },
-        required: ['query', 'isRegexp'],
-        type: 'object'
-      }
-    },
-    type: 'function'
-  };
-};
+
 const getRunInTerminalTool = () => {
   return {
     function: {
@@ -1973,66 +2314,95 @@ const getRunInTerminalTool = () => {
     type: 'function'
   };
 };
-const getCreateDirectoryTool = () => {
+
+const getSearchTextTool = () => {
   return {
     function: {
-      description: 'Create a new directory at the given absolute URI (for example `file://...`, `memfs://...`, or extension-provided file system URIs). Do not pass a relative path.',
-      name: 'create_directory',
+      description: 'Search text in workspace files using query options and return matching results.',
+      name: 'search_text',
       parameters: {
         additionalProperties: false,
         properties: {
-          uri: {
-            description: 'Absolute URI for the target directory (for example `file://...`, `memfs://...`, or extension-provided file system URIs). Relative paths are not allowed.',
-            type: 'string'
+          options: {
+            additionalProperties: false,
+            properties: {
+              exclude: {
+                items: {
+                  type: 'string'
+                },
+                type: 'array'
+              },
+              isRegex: {
+                type: 'boolean'
+              },
+              machWholeWord: {
+                type: 'boolean'
+              },
+              matchCase: {
+                type: 'boolean'
+              },
+              value: {
+                type: 'string'
+              }
+            },
+            required: ['value', 'isRegex', 'matchCase', 'machWholeWord', 'exclude'],
+            type: 'object'
           }
         },
-        required: ['uri'],
+        required: ['options'],
         type: 'object'
       }
     },
     type: 'function'
   };
 };
-const getGlobTool = () => {
+
+const getUpdateTodoTool = () => {
   return {
     function: {
-      description: 'Find files by glob pattern and return matching relative paths.',
-      name: 'glob',
+      description: 'Update the active TODO checklist for the current chat session. Pass the full markdown checklist text with one item per line (for example "- [ ] Step one").',
+      name: 'update_todo',
       parameters: {
         additionalProperties: false,
         properties: {
-          pattern: {
-            description: 'Glob pattern to match files, for example `packages/e2e/src/*.ts`.',
+          todos: {
+            description: 'Complete markdown checklist content to store as the current TODO list state.',
             type: 'string'
           }
         },
-        required: ['pattern'],
+        required: ['todos'],
         type: 'object'
       }
     },
     type: 'function'
   };
 };
-const getUpdateTodoTool = () => {
+
+const getWriteFileTool = () => {
   return {
     function: {
-      description: 'Update the active TODO checklist for the current chat session. Pass the full markdown checklist text with one item per line (for example "- [ ] Step one").',
-      name: 'update_todo',
+      description: 'Write UTF-8 text content to a file for an absolute URI (for example `file://...`, `memfs://...`, or extension-provided file system URIs). Do not pass a relative path and do not use a `path` argument.',
+      name: 'write_file',
       parameters: {
         additionalProperties: false,
         properties: {
-          todos: {
-            description: 'Complete markdown checklist content to store as the current TODO list state.',
+          content: {
+            description: 'New UTF-8 text content to write to the file.',
+            type: 'string'
+          },
+          uri: {
+            description: 'Absolute URI for the target file (for example `file://...`, `memfs://...`, or extension-provided file system URIs). Relative paths are not allowed.',
             type: 'string'
           }
         },
-        required: ['todos'],
+        required: ['uri', 'content'],
         type: 'object'
       }
     },
     type: 'function'
   };
 };
+
 const getBasicChatTools = () => {
   return [getReadFileTool(), getWriteFileTool(), getRenameTool(), getEditFileTool(), getListFilesTool(), getGetWorkspaceUriTool(), getRenderHtmlTool(), getOpenPreviewTool(), getOpenEditorTool(), getClosePreviewTool(), getSearchTextTool(), getRgTool(), getGrepSearchTool(), getRunInTerminalTool(), getCreateDirectoryTool(), getGlobTool(), getUpdateTodoTool()];
 };
@@ -2050,6 +2420,28 @@ const commandMap = {
   'HandleMessagePort.handleMessagePort': handleMessagePort
 };
 
+const send$1 = async port => {
+  await sendMessagePortToChatStorageWorker(port);
+};
+const initializeChatStorageWorker = async () => {
+  const rpc = await create$3({
+    commandMap: commandMap,
+    send: send$1
+  });
+  set$2(rpc);
+};
+
+const send = async port => {
+  await sendMessagePortToFileSystemWorker(port, 0);
+};
+const initializeFileSystemWorker = async () => {
+  const rpc = await create$3({
+    commandMap: commandMap,
+    send: send
+  });
+  set$1(rpc);
+};
+
 const initializeRendererWorker = async () => {
   const rpc = await create$1({
     commandMap: commandMap
@@ -2058,7 +2450,7 @@ const initializeRendererWorker = async () => {
 };
 
 const listen = async () => {
-  await initializeRendererWorker();
+  await Promise.all([initializeRendererWorker(), initializeFileSystemWorker(), initializeChatStorageWorker()]);
 };
 
 const main = async () => {