@lvce-editor/static-server 0.75.14 → 0.75.16

package/static/{0b5a964 → 5a29bf2}/packages/chat-view/dist/chatViewWorkerMain.js

@@ -1118,9 +1118,15 @@ const sendMessagePortToExtensionHostWorker$1 = async (port, rpcId = 0) => {
   const command = 'HandleMessagePort.handleMessagePort2';
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
 };
+const sendMessagePortToChatNetworkWorker = async port => {
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToChatNetworkWorker', port, 'HandleMessagePort.handleMessagePort');
+};
 const activateByEvent$1 = (event, assetDir, platform) => {
   return invoke('ExtensionHostManagement.activateByEvent', event, assetDir, platform);
 };
+const getWorkspacePath = () => {
+  return invoke('Workspace.getPath');
+};
 const getPreference = async key => {
   return await invoke('Preferences.get', key);
 };
@@ -1272,6 +1278,9 @@ const getComposerHeight = async (state, value, width = state.width) => {
     composerLineHeight,
     maxComposerRows
   } = state;
+  if (value === '') {
+    return composerLineHeight;
+  }
   const minimumHeight = getMinComposerHeight(composerLineHeight);
   const maximumHeight = getMaxComposerHeight(composerLineHeight, maxComposerRows);
   const content = value || ' ';
@@ -1460,6 +1469,7 @@ const createDefaultState = () => {
   const composerFontSize = 13;
   const composerLineHeight = 20;
   return {
+    aiSessionTitleGenerationEnabled: false,
     assetDir: '',
     chatListScrollTop: 0,
     chatMessageFontFamily: 'system-ui',
@@ -1505,7 +1515,7 @@ const createDefaultState = () => {
       messages: [],
       title: defaultSessionTitle()
     }],
-    streamingEnabled: false,
+    streamingEnabled: true,
     tokensMax: 0,
     tokensUsed: 0,
     uid: 0,
@@ -1543,8 +1553,56 @@ const create = (uid, x, y, width, height, platform, assetDir) => {
   set(uid, state, state);
 };
 
+const parseRenderHtmlArguments = rawArguments => {
+  try {
+    const parsed = JSON.parse(rawArguments);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+      return undefined;
+    }
+    const html = typeof Reflect.get(parsed, 'html') === 'string' ? String(Reflect.get(parsed, 'html')) : '';
+    if (!html) {
+      return undefined;
+    }
+    const css = typeof Reflect.get(parsed, 'css') === 'string' ? String(Reflect.get(parsed, 'css')) : '';
+    const title = typeof Reflect.get(parsed, 'title') === 'string' ? String(Reflect.get(parsed, 'title')) : 'visual preview';
+    return {
+      css,
+      html,
+      title
+    };
+  } catch {
+    return undefined;
+  }
+};
+
+const getRenderHtmlCss = (sessions, selectedSessionId) => {
+  const selectedSession = sessions.find(session => session.id === selectedSessionId);
+  if (!selectedSession) {
+    return '';
+  }
+  const cssRules = new Set();
+  for (const message of selectedSession.messages) {
+    if (message.role !== 'assistant' || !message.toolCalls) {
+      continue;
+    }
+    for (const toolCall of message.toolCalls) {
+      if (toolCall.name !== 'render_html') {
+        continue;
+      }
+      const parsed = parseRenderHtmlArguments(toolCall.arguments);
+      if (!parsed || !parsed.css.trim()) {
+        continue;
+      }
+      cssRules.add(parsed.css);
+    }
+  }
+  return [...cssRules].join('\n\n');
+};
+
 const isEqual$1 = (oldState, newState) => {
-  return oldState.initial === newState.initial && oldState.chatMessageFontFamily === newState.chatMessageFontFamily && oldState.chatMessageFontSize === newState.chatMessageFontSize && oldState.chatMessageLineHeight === newState.chatMessageLineHeight && oldState.composerHeight === newState.composerHeight && oldState.composerLineHeight === newState.composerLineHeight && oldState.composerFontFamily === newState.composerFontFamily && oldState.composerFontSize === newState.composerFontSize && oldState.listItemHeight === newState.listItemHeight;
+  const oldRenderHtmlCss = getRenderHtmlCss(oldState.sessions, oldState.selectedSessionId);
+  const newRenderHtmlCss = getRenderHtmlCss(newState.sessions, newState.selectedSessionId);
+  return oldState.initial === newState.initial && oldState.chatMessageFontFamily === newState.chatMessageFontFamily && oldState.chatMessageFontSize === newState.chatMessageFontSize && oldState.chatMessageLineHeight === newState.chatMessageLineHeight && oldState.composerHeight === newState.composerHeight && oldState.composerLineHeight === newState.composerLineHeight && oldState.composerFontFamily === newState.composerFontFamily && oldState.composerFontSize === newState.composerFontSize && oldState.listItemHeight === newState.listItemHeight && oldRenderHtmlCss === newRenderHtmlCss;
 };
 
 const diffFocus = (oldState, newState) => {
@@ -1602,17 +1660,57 @@ const diff2 = uid => {
 
 const Button$2 = 'button';
 
+const Audio = 0;
 const Button$1 = 1;
+const Col = 2;
+const ColGroup = 3;
 const Div = 4;
+const H1 = 5;
 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 I = 16;
+const Img = 17;
+const H2 = 22;
+const H3 = 23;
+const H4 = 24;
+const H5 = 25;
+const H6 = 26;
+const Article = 27;
+const Aside = 28;
+const Footer = 29;
+const Header = 30;
+const Nav = 40;
+const Section = 41;
+const Dd = 43;
+const Dl = 44;
+const Figcaption = 45;
+const Figure = 46;
+const Hr = 47;
 const Li = 48;
 const Ol = 49;
 const P = 50;
+const Pre = 51;
+const A = 53;
+const Abbr = 54;
+const Br = 55;
+const Tfoot = 59;
+const Ul = 60;
 const TextArea = 62;
 const Select$1 = 63;
 const Option$1 = 64;
+const Code = 65;
+const Label$1 = 66;
+const Dt = 67;
+const Main = 69;
+const Strong = 70;
+const Em = 71;
 const Reference = 100;
 
 const Enter = 3;
@@ -2649,18 +2747,28 @@ const deleteSession = async (state, id) => {
 };
 
 const handleClickOpenApiApiKeySettings = async state => {
-  // Open the built-in settings editor so the user can inspect or edit their OpenAI API key.
   await invoke('Main.openUri', 'app://settings.json');
   return state;
 };
 
+const handleClickOpenApiApiKeyWebsite = async state => {
+  await openExternal(state.openApiApiKeysSettingsUrl);
+  return state;
+};
+
 const handleClickOpenRouterApiKeySettings = async state => {
+  await invoke('Main.openUri', 'app://settings.json');
+  return state;
+};
+
+const handleClickOpenRouterApiKeyWebsite = async state => {
   await openExternal(state.openRouterApiKeysSettingsUrl);
   return state;
 };
 
 const openApiApiKeyRequiredMessage = 'OpenAI API key is not configured. Enter your OpenAI API key below and click Save.';
 const openApiRequestFailedMessage = 'OpenAI request failed.';
+const openApiRequestFailedOfflineMessage = 'OpenAI request failed because you are offline. Please check your internet connection.';
 const openRouterApiKeyRequiredMessage = 'OpenRouter API key is not configured. Enter your OpenRouter API key below and click Save.';
 const openRouterRequestFailedMessage = 'OpenRouter request failed. Possible reasons:';
 const openRouterTooManyRequestsMessage = 'OpenRouter rate limit reached (429). Please try again soon. Helpful tips:';
@@ -3054,6 +3162,43 @@ const getMockOpenRouterAssistantText = async (messages, modelId, openRouterApiBa
   }
 };
 
+const executeGetWorkspaceUriTool = async (_args, _options) => {
+  try {
+    const workspaceUri = await getWorkspacePath();
+    return JSON.stringify({
+      workspaceUri
+    });
+  } catch (error) {
+    return JSON.stringify({
+      error: String(error)
+    });
+  }
+};
+
+const isAbsoluteUri$1 = value => {
+  return /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(value);
+};
+const executeListFilesTool = async (args, _options) => {
+  const uri = typeof args.uri === 'string' ? args.uri : '';
+  if (!uri || !isAbsoluteUri$1(uri)) {
+    return JSON.stringify({
+      error: 'Invalid argument: uri must be an absolute URI.'
+    });
+  }
+  try {
+    const entries = await invoke('FileSystem.readDirWithFileTypes', uri);
+    return JSON.stringify({
+      entries,
+      uri
+    });
+  } catch (error) {
+    return JSON.stringify({
+      error: String(error),
+      uri
+    });
+  }
+};
+
 const isPathTraversalAttempt = path => {
   if (!path) {
     return false;
@@ -3079,18 +3224,41 @@ const normalizeRelativePath = path => {
   return segments.join('/');
 };
 
-const executeListFilesTool = async (args, _options) => {
-  const folderPath = typeof args.path === 'string' && args.path ? args.path : '.';
-  if (isPathTraversalAttempt(folderPath)) {
+const isAbsoluteUri = value => {
+  return /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(value);
+};
+const executeReadFileTool = async (args, _options) => {
+  const uri = typeof args.uri === 'string' ? args.uri : '';
+  if (uri) {
+    if (!isAbsoluteUri(uri)) {
+      return JSON.stringify({
+        error: 'Invalid argument: uri must be an absolute URI.'
+      });
+    }
+    try {
+      const content = await readFile(uri);
+      return JSON.stringify({
+        content,
+        uri
+      });
+    } catch (error) {
+      return JSON.stringify({
+        error: String(error),
+        uri
+      });
+    }
+  }
+  const filePath = typeof args.path === 'string' ? args.path : '';
+  if (!filePath || isPathTraversalAttempt(filePath)) {
     return JSON.stringify({
       error: 'Access denied: path must be relative and stay within the open workspace folder.'
     });
   }
-  const normalizedPath = normalizeRelativePath(folderPath);
+  const normalizedPath = normalizeRelativePath(filePath);
   try {
-    const entries = await invoke('FileSystem.readDirWithFileTypes', normalizedPath);
+    const content = await readFile(normalizedPath);
     return JSON.stringify({
-      entries,
+      content,
       path: normalizedPath
     });
   } catch (error) {
@@ -3101,26 +3269,27 @@ const executeListFilesTool = async (args, _options) => {
   }
 };
 
-const executeReadFileTool = async (args, _options) => {
-  const filePath = typeof args.path === 'string' ? args.path : '';
-  if (!filePath || isPathTraversalAttempt(filePath)) {
+const maxPayloadLength = 40_000;
+const executeRenderHtmlTool = async (args, _options) => {
+  const html = typeof args.html === 'string' ? args.html : '';
+  const css = typeof args.css === 'string' ? args.css : '';
+  const title = typeof args.title === 'string' ? args.title : '';
+  if (!html) {
     return JSON.stringify({
-      error: 'Access denied: path must be relative and stay within the open workspace folder.'
+      error: 'Missing required argument: html'
     });
   }
-  const normalizedPath = normalizeRelativePath(filePath);
-  try {
-    const content = await readFile(normalizedPath);
+  if (html.length > maxPayloadLength || css.length > maxPayloadLength) {
     return JSON.stringify({
-      content,
-      path: normalizedPath
-    });
-  } catch (error) {
-    return JSON.stringify({
-      error: String(error),
-      path: normalizedPath
+      error: 'Payload too large: keep html/css under 40,000 characters each.'
     });
   }
+  return JSON.stringify({
+    css,
+    html,
+    ok: true,
+    title
+  });
 };
 
 const OnFileSystem = 'onFileSystem';
@@ -3185,30 +3354,39 @@ const executeChatTool = async (name, rawArguments, options) => {
   if (name === 'list_files') {
     return executeListFilesTool(args);
   }
+  if (name === 'getWorkspaceUri') {
+    return executeGetWorkspaceUriTool();
+  }
+  if (name === 'render_html') {
+    return executeRenderHtmlTool(args);
+  }
   return JSON.stringify({
     error: `Unknown tool: ${name}`
   });
 };
 
-const getBasicChatTools = () => {
-  return [{
+const getReadFileTool = () => {
+  return {
     function: {
-      description: 'Read UTF-8 text content from a file inside the currently open workspace folder.',
+      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: {
-          path: {
-            description: 'Relative file path within the workspace (for example: src/index.ts).',
+          uri: {
+            description: 'Absolute file URI within the workspace (for example: file:///workspace/src/index.ts).',
             type: 'string'
           }
         },
-        required: ['path'],
+        required: ['uri'],
         type: 'object'
       }
     },
     type: 'function'
-  }, {
+  };
+};
+const getWriteFileTool = () => {
+  return {
     function: {
       description: 'Write UTF-8 text content to a file inside the currently open workspace folder.',
       name: 'write_file',
@@ -3229,23 +3407,72 @@ const getBasicChatTools = () => {
       }
     },
     type: 'function'
-  }, {
+  };
+};
+const getListFilesTool = () => {
+  return {
     function: {
-      description: 'List direct children (files and folders) for a folder inside the currently open workspace folder.',
+      description: 'List direct children (files and folders) for a folder URI inside the currently open workspace folder. Only pass an absolute URI.',
       name: 'list_files',
       parameters: {
         additionalProperties: false,
         properties: {
-          path: {
-            description: 'Relative folder path within the workspace. Use "." for the workspace root.',
+          uri: {
+            description: 'Absolute folder URI within the workspace (for example: file:///workspace/src).',
             type: 'string'
           }
         },
+        required: ['uri'],
         type: 'object'
       }
     },
     type: 'function'
-  }];
+  };
+};
+const getGetWorkspaceUriTool = () => {
+  return {
+    function: {
+      description: 'Get the URI of the currently open workspace folder.',
+      name: 'getWorkspaceUri',
+      parameters: {
+        additionalProperties: false,
+        properties: {},
+        type: 'object'
+      }
+    },
+    type: 'function'
+  };
+};
+const getRenderHtmlTool = () => {
+  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',
+      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.',
+            type: 'string'
+          }
+        },
+        required: ['html'],
+        type: 'object'
+      }
+    },
+    type: 'function'
+  };
+};
+const getBasicChatTools = () => {
+  return [getReadFileTool(), getWriteFileTool(), getListFilesTool(), getGetWorkspaceUriTool(), getRenderHtmlTool()];
 };
 
 const getClientRequestIdHeader = () => {
@@ -4060,6 +4287,12 @@ const getOpenApiAssistantText = async (messages, modelId, openApiApiKey, openApi
   };
 };
 
+const isOffline = () => {
+  if (!globalThis.navigator) {
+    return false;
+  }
+  return globalThis.navigator.onLine === false;
+};
 const getOpenApiErrorMessage = errorResult => {
   switch (errorResult.details) {
     case 'http-error':
@@ -4071,7 +4304,7 @@ const getOpenApiErrorMessage = errorResult => {
         // Provide a concise, user-friendly message when OpenAI reports an invalid API key.
         if (errorResult.errorCode === 'invalid_api_key') {
           const status = typeof errorResult.statusCode === 'number' ? errorResult.statusCode : 401;
-          return `OpenAI request failed (status ${status}): Invalid API key. Please verify your OpenAI API key in Chat settings.`;
+          return `OpenAI request failed (Status ${status}): Invalid API key. Please verify your OpenAI API key in Chat Settings.`;
         }
         if (errorResult.statusCode === 429) {
           let prefix = 'OpenAI rate limit exceeded (429)';
@@ -4107,6 +4340,9 @@ const getOpenApiErrorMessage = errorResult => {
         return openApiRequestFailedMessage;
       }
     case 'request-failed':
+      if (isOffline()) {
+        return openApiRequestFailedOfflineMessage;
+      }
       return openApiRequestFailedMessage;
   }
 };
@@ -4434,7 +4670,7 @@ const getAiResponse = async ({
   passIncludeObfuscation = false,
   platform,
   selectedModelId,
-  streamingEnabled = false,
+  streamingEnabled = true,
   useMockApi,
   userText,
   webSearchEnabled = false
@@ -4578,6 +4814,7 @@ const handleClickSaveOpenApiApiKey = async state => {
     openRouterApiKey: updatedState.openRouterApiKey,
     platform: updatedState.platform,
     selectedModelId: updatedState.selectedModelId,
+    streamingEnabled: updatedState.streamingEnabled,
     useMockApi: updatedState.useMockApi,
     userText: previousUserMessage.text
   });
@@ -4785,6 +5022,10 @@ const handleToolCallsChunkFunction = async (uid, assistantMessageId, toolCalls,
   };
 };
 
+const slashCommandRegex = /^\/(clear|export|help|new)(?:\s+.*)?$/;
+const mentionRegex = /(^|\s)@([^\s]+)/g;
+const maxMentionCount = 5;
+const maxMentionTextLength = 8000;
 const appendMessageToSelectedSession = (sessions, selectedSessionId, message) => {
   return sessions.map(session => {
     if (session.id !== selectedSessionId) {
@@ -4838,8 +5079,208 @@ const isStreamingFunctionCallEvent = parsed => {
 const getSseEventType = value => {
   return value && typeof value === 'object' && Reflect.get(value, 'type') === 'response.completed' ? 'sse-response-completed' : 'sse-response-part';
 };
+const getCommandHelpText = () => {
+  return ['Available commands:', '/new - Create and switch to a new chat session.', '/clear - Clear messages in the selected chat session.', '/export - Export current chat session as Markdown.', '/help - Show this help.'].join('\n');
+};
+const withClearedComposer = state => {
+  return focusInput({
+    ...state,
+    composerHeight: getMinComposerHeightForState(state),
+    composerValue: '',
+    inputSource: 'script'
+  });
+};
+const toMarkdownTranscript = session => {
+  const lines = [`# ${session.title}`, ''];
+  for (const message of session.messages) {
+    const role = message.role === 'assistant' ? 'Assistant' : 'User';
+    lines.push(`## ${role}`);
+    lines.push(message.text || '(empty)');
+    lines.push('');
+  }
+  return lines.join('\n').trim();
+};
+const executeSlashCommand = async (state, command) => {
+  if (command === 'new') {
+    const nextState = await createSession(state);
+    return withClearedComposer({
+      ...nextState,
+      viewMode: 'detail'
+    });
+  }
+  const selectedSession = state.sessions.find(session => session.id === state.selectedSessionId);
+  if (!selectedSession) {
+    return withClearedComposer(state);
+  }
+  if (command === 'clear') {
+    const updatedSessions = state.sessions.map(session => {
+      if (session.id !== state.selectedSessionId) {
+        return session;
+      }
+      return {
+        ...session,
+        messages: []
+      };
+    });
+    const updatedSelectedSession = updatedSessions.find(session => session.id === state.selectedSessionId);
+    if (updatedSelectedSession) {
+      await saveChatSession(updatedSelectedSession);
+    }
+    return withClearedComposer({
+      ...state,
+      sessions: updatedSessions
+    });
+  }
+  const assistantText = command === 'help' ? getCommandHelpText() : ['```md', toMarkdownTranscript(selectedSession), '```'].join('\n');
+  const assistantMessage = {
+    id: crypto.randomUUID(),
+    role: 'assistant',
+    text: assistantText,
+    time: new Date().toLocaleTimeString([], {
+      hour: '2-digit',
+      minute: '2-digit'
+    })
+  };
+  const updatedSessions = appendMessageToSelectedSession(state.sessions, state.selectedSessionId, assistantMessage);
+  const updatedSelectedSession = updatedSessions.find(session => session.id === state.selectedSessionId);
+  if (updatedSelectedSession) {
+    await saveChatSession(updatedSelectedSession);
+  }
+  return withClearedComposer({
+    ...state,
+    sessions: updatedSessions
+  });
+};
+const getSlashCommand = value => {
+  const trimmed = value.trim();
+  const match = trimmed.match(slashCommandRegex);
+  if (!match) {
+    return undefined;
+  }
+  return match[1];
+};
+const parseMentionedPaths = value => {
+  const matches = value.matchAll(mentionRegex);
+  const paths = [];
+  for (const match of matches) {
+    const rawPath = match[2] || '';
+    const cleanedPath = rawPath.replaceAll(/[),.;:!?]+$/g, '');
+    if (!cleanedPath || isPathTraversalAttempt(cleanedPath)) {
+      continue;
+    }
+    const normalizedPath = normalizeRelativePath(cleanedPath);
+    if (paths.includes(normalizedPath)) {
+      continue;
+    }
+    paths.push(normalizedPath);
+    if (paths.length >= maxMentionCount) {
+      break;
+    }
+  }
+  return paths;
+};
+const getMentionContextMessage = async value => {
+  const paths = parseMentionedPaths(value);
+  if (paths.length === 0) {
+    return undefined;
+  }
+  const sections = [];
+  for (const path of paths) {
+    try {
+      const fileContent = await readFile(path);
+      const truncatedContent = fileContent.length > maxMentionTextLength ? `${fileContent.slice(0, maxMentionTextLength)}\n... [truncated]` : fileContent;
+      sections.push([`File: ${path}`, '```text', truncatedContent, '```'].join('\n'));
+    } catch (error) {
+      sections.push([`File: ${path}`, `Error: ${String(error)}`].join('\n'));
+    }
+  }
+  return {
+    id: crypto.randomUUID(),
+    role: 'user',
+    text: ['Referenced file context:', ...sections].join('\n\n'),
+    time: new Date().toLocaleTimeString([], {
+      hour: '2-digit',
+      minute: '2-digit'
+    })
+  };
+};
+const isDefaultSessionTitle = title => {
+  return /^Chat \d+$/.test(title);
+};
+const sanitizeGeneratedTitle = value => {
+  return value.replace(/^title:\s*/i, '').replaceAll(/^['"`\s]+|['"`\s]+$/g, '').replaceAll(/\s+/g, ' ').trim().slice(0, 80);
+};
+const updateSessionTitle = (sessions, selectedSessionId, title) => {
+  return sessions.map(session => {
+    if (session.id !== selectedSessionId) {
+      return session;
+    }
+    return {
+      ...session,
+      title
+    };
+  });
+};
+const getAiSessionTitle = async (state, userText, assistantText) => {
+  const {
+    models,
+    openApiApiBaseUrl,
+    openApiApiKey,
+    openRouterApiBaseUrl,
+    openRouterApiKey,
+    selectedModelId,
+    useMockApi
+  } = state;
+  if (useMockApi) {
+    return '';
+  }
+  const usesOpenApiModel = isOpenApiModel(selectedModelId, models);
+  const usesOpenRouterModel = isOpenRouterModel(selectedModelId, models);
+  if (usesOpenApiModel && !openApiApiKey) {
+    return '';
+  }
+  if (usesOpenRouterModel && !openRouterApiKey) {
+    return '';
+  }
+  if (!usesOpenApiModel && !usesOpenRouterModel) {
+    return '';
+  }
+  const titlePrompt = `Create a concise title (max 6 words) for this conversation. Respond only with the title, no punctuation at the end.
+User: ${userText}
+Assistant: ${assistantText}`;
+  const promptMessage = {
+    id: crypto.randomUUID(),
+    role: 'user',
+    text: titlePrompt,
+    time: new Date().toLocaleTimeString([], {
+      hour: '2-digit',
+      minute: '2-digit'
+    })
+  };
+  const titleResponse = await getAiResponse({
+    assetDir: state.assetDir,
+    messages: [promptMessage],
+    mockAiResponseDelay: state.mockAiResponseDelay,
+    mockApiCommandId: state.mockApiCommandId,
+    models,
+    openApiApiBaseUrl,
+    openApiApiKey,
+    openRouterApiBaseUrl,
+    openRouterApiKey,
+    passIncludeObfuscation: state.passIncludeObfuscation,
+    platform: state.platform,
+    selectedModelId,
+    streamingEnabled: false,
+    useMockApi,
+    userText: titlePrompt,
+    webSearchEnabled: false
+  });
+  const title = sanitizeGeneratedTitle(titleResponse.text);
+  return title && !isDefaultSessionTitle(title) ? title : '';
+};
 const handleSubmit = async state => {
   const {
+    aiSessionTitleGenerationEnabled,
     assetDir,
     composerValue,
     emitStreamingFunctionCallEvents,
@@ -4865,6 +5306,10 @@ const handleSubmit = async state => {
   if (!userText) {
     return state;
   }
+  const slashCommand = getSlashCommand(userText);
+  if (slashCommand) {
+    return executeSlashCommand(state, slashCommand);
+  }
   const userTime = new Date().toLocaleTimeString([], {
     hour: '2-digit',
     minute: '2-digit'
@@ -4901,6 +5346,7 @@ const handleSubmit = async state => {
     }
   }
   let optimisticState;
+  const createsNewSession = viewMode === 'list';
   if (viewMode === 'list') {
     const newSessionId = generateSessionId();
     await appendChatViewEvent({
@@ -4958,13 +5404,15 @@ const handleSubmit = async state => {
   };
   const selectedOptimisticSession = optimisticState.sessions.find(session => session.id === optimisticState.selectedSessionId);
   const messages = (selectedOptimisticSession?.messages ?? []).filter(message => !message.inProgress);
+  const mentionContextMessage = await getMentionContextMessage(userText);
+  const messagesWithMentionContext = mentionContextMessage ? [...messages, mentionContextMessage] : messages;
   const handleTextChunkFunctionRef = streamingEnabled ? async chunk => {
     handleTextChunkState = await handleTextChunkFunction(state.uid, assistantMessageId, chunk, handleTextChunkState);
   } : undefined;
   const assistantMessage = await getAiResponse({
     assetDir,
     messageId: assistantMessageId,
-    messages,
+    messages: messagesWithMentionContext,
     mockAiResponseDelay,
     mockApiCommandId,
     models,
@@ -5009,7 +5457,16 @@ const handleSubmit = async state => {
   const {
     latestState
   } = handleTextChunkState;
-  const updatedSessions = streamingEnabled ? updateMessageTextInSelectedSession(latestState.sessions, latestState.selectedSessionId, assistantMessageId, assistantMessage.text, false) : appendMessageToSelectedSession(latestState.sessions, latestState.selectedSessionId, assistantMessage);
+  let updatedSessions = streamingEnabled ? updateMessageTextInSelectedSession(latestState.sessions, latestState.selectedSessionId, assistantMessageId, assistantMessage.text, false) : appendMessageToSelectedSession(latestState.sessions, latestState.selectedSessionId, assistantMessage);
+  if (aiSessionTitleGenerationEnabled && createsNewSession) {
+    const selectedSession = updatedSessions.find(session => session.id === latestState.selectedSessionId);
+    if (selectedSession && isDefaultSessionTitle(selectedSession.title)) {
+      const generatedTitle = await getAiSessionTitle(latestState, userText, assistantMessage.text);
+      if (generatedTitle) {
+        updatedSessions = updateSessionTitle(updatedSessions, latestState.selectedSessionId, generatedTitle);
+      }
+    }
+  }
   const selectedSession = updatedSessions.find(session => session.id === latestState.selectedSessionId);
   if (selectedSession) {
     await saveChatSession(selectedSession);
@@ -5065,11 +5522,13 @@ const getRenameIdFromInputName = name => {
 const OpenApiApiKeyInput = 'open-api-api-key';
 const SaveOpenApiApiKey = 'save-openapi-api-key';
 const OpenOpenApiApiKeySettings = 'open-openapi-api-key-settings';
+const OpenOpenApiApiKeyWebsite = 'open-openapi-api-key-website';
 
 // cspell:ignore openrouter
 const OpenRouterApiKeyInput = 'open-router-api-key';
 const SaveOpenRouterApiKey = 'save-openrouter-api-key';
 const OpenOpenRouterApiKeySettings = 'open-openrouter-api-key-settings';
+const OpenOpenRouterApiKeyWebsite = 'open-openrouter-api-key-website';
 
 const selectSession = async (state, id) => {
   const exists = state.sessions.some(session => session.id === id);
@@ -5158,9 +5617,15 @@ const handleClick = async (state, name, id = '') => {
   if (name === OpenOpenRouterApiKeySettings) {
     return handleClickOpenRouterApiKeySettings(state);
   }
+  if (name === OpenOpenRouterApiKeyWebsite) {
+    return handleClickOpenRouterApiKeyWebsite(state);
+  }
   if (name === OpenOpenApiApiKeySettings) {
     return handleClickOpenApiApiKeySettings(state);
   }
+  if (name === OpenOpenApiApiKeyWebsite) {
+    return handleClickOpenApiApiKeyWebsite(state);
+  }
   return state;
 };
 
@@ -5203,6 +5668,9 @@ const handleClickSettings = async () => {
 };
 
 const handleInput = async (state, name, value, inputSource = 'user') => {
+  const {
+    selectedSessionId
+  } = state;
   if (name === OpenApiApiKeyInput) {
     return {
       ...state,
@@ -5218,9 +5686,9 @@ const handleInput = async (state, name, value, inputSource = 'user') => {
   if (name !== Composer) {
     return state;
   }
-  if (state.selectedSessionId) {
+  if (selectedSessionId) {
     await appendChatViewEvent({
-      sessionId: state.selectedSessionId,
+      sessionId: selectedSessionId,
       timestamp: new Date().toISOString(),
       type: 'handle-input',
       value
@@ -5467,6 +5935,15 @@ const getSavedViewMode = savedState => {
   return viewMode;
 };
 
+const loadAiSessionTitleGenerationEnabled = async () => {
+  try {
+    const savedAiSessionTitleGenerationEnabled = await get('chatView.aiSessionTitleGenerationEnabled');
+    return typeof savedAiSessionTitleGenerationEnabled === 'boolean' ? savedAiSessionTitleGenerationEnabled : false;
+  } catch {
+    return false;
+  }
+};
+
 const loadEmitStreamingFunctionCallEvents = async () => {
   try {
     const savedEmitStreamingFunctionCallEvents = await get('chatView.emitStreamingFunctionCallEvents');
@@ -5514,19 +5991,16 @@ const loadPassIncludeObfuscation = async () => {
 const loadStreamingEnabled = async () => {
   try {
     const savedStreamingEnabled = await get('chatView.streamingEnabled');
-    return typeof savedStreamingEnabled === 'boolean' ? savedStreamingEnabled : false;
+    return typeof savedStreamingEnabled === 'boolean' ? savedStreamingEnabled : true;
   } catch {
-    return false;
+    return true;
   }
 };
 
 const loadPreferences = async () => {
-  const openApiApiKey = await loadOpenApiApiKey();
-  const openRouterApiKey = await loadOpenRouterApiKey();
-  const emitStreamingFunctionCallEvents = await loadEmitStreamingFunctionCallEvents();
-  const streamingEnabled = await loadStreamingEnabled();
-  const passIncludeObfuscation = await loadPassIncludeObfuscation();
+  const [aiSessionTitleGenerationEnabled, openApiApiKey, openRouterApiKey, emitStreamingFunctionCallEvents, streamingEnabled, passIncludeObfuscation] = await Promise.all([loadAiSessionTitleGenerationEnabled(), loadOpenApiApiKey(), loadOpenRouterApiKey(), loadEmitStreamingFunctionCallEvents(), loadStreamingEnabled(), loadPassIncludeObfuscation()]);
   return {
+    aiSessionTitleGenerationEnabled,
     emitStreamingFunctionCallEvents,
     openApiApiKey,
     openRouterApiKey,
@@ -5562,6 +6036,7 @@ const loadContent = async (state, savedState) => {
   const savedSelectedModelId = getSavedSelectedModelId(savedState);
   const savedViewMode = getSavedViewMode(savedState);
   const {
+    aiSessionTitleGenerationEnabled,
     emitStreamingFunctionCallEvents,
     openApiApiKey,
     openRouterApiKey,
@@ -5594,6 +6069,7 @@ const loadContent = async (state, savedState) => {
   const viewMode = sessions.length === 0 || !selectedSessionId ? 'list' : preferredViewMode === 'detail' ? 'detail' : 'list';
   return {
     ...state,
+    aiSessionTitleGenerationEnabled,
     chatListScrollTop,
     emitStreamingFunctionCallEvents,
     initial: false,
@@ -5665,8 +6141,15 @@ const openMockSession = async (state, mockSessionId, mockChatMessages) => {
   };
 };
 
-const getCss = (composerHeight, listItemHeight, chatMessageFontSize, chatMessageLineHeight, chatMessageFontFamily) => {
-  return `:root {
+const registerMockResponse = (state, mockResponse) => {
+  reset$1();
+  pushChunk(mockResponse.text);
+  finish();
+  return state;
+};
+
+const getCss = (composerHeight, listItemHeight, chatMessageFontSize, chatMessageLineHeight, chatMessageFontFamily, renderHtmlCss) => {
+  const baseCss = `:root {
   --ChatInputBoxHeight: ${composerHeight}px;
   --ChatListItemHeight: ${listItemHeight}px;
   --ChatMessageFontSize: ${chatMessageFontSize}px;
@@ -5700,7 +6183,72 @@ const getCss = (composerHeight, listItemHeight, chatMessageFontSize, chatMessage
 .ChatToolCallReadFileLink {
   color: var(--vscode-textLink-foreground);
   text-decoration: underline;
+}
+
+.ChatToolCallRenderHtmlLabel {
+  margin-bottom: 6px;
+  color: var(--vscode-descriptionForeground);
+  font-size: 12px;
+}
+
+.ChatToolCallRenderHtmlContent {
+  border: 1px solid var(--vscode-editorWidget-border);
+  border-radius: 6px;
+  background: var(--vscode-editor-background);
+  overflow: hidden;
+}
+
+.ChatToolCallRenderHtmlBody {
+  min-height: 180px;
+  padding: 12px;
+}
+
+.ChatToolCallRenderHtmlBody * {
+  box-sizing: border-box;
+}
+
+.ChatMessageLink {
+  color: #4d94ff;
+  text-decoration: underline;
+  cursor: pointer;
+}
+
+.ChatOrderedList,
+.ChatUnorderedList {
+  margin: 6px 0;
+  padding-inline-start: 20px;
+}
+
+.ChatOrderedListItem,
+.ChatUnorderedListItem {
+  margin: 2px 0;
+}
+
+.MarkdownTable {
+  width: 100%;
+  margin: 6px 0;
+  border-collapse: collapse;
+  border: 1px solid var(--vscode-editorWidget-border);
+}
+
+.MarkdownTable th,
+.MarkdownTable td {
+  border: 1px solid var(--vscode-editorWidget-border);
+  padding: 4px 8px;
+  text-align: left;
+}
+
+.MarkdownTable th {
+  background: var(--vscode-editorWidget-background);
+}
 }`;
+  if (!renderHtmlCss.trim()) {
+    return baseCss;
+  }
+  return `${baseCss}
+
+/* render_html tool css */
+${renderHtmlCss}`;
 };
 
 // TODO render things like scrollbar height,scrollbar offset, textarea height,
@@ -5713,9 +6261,12 @@ const renderCss = (oldState, newState) => {
     chatMessageLineHeight,
     composerHeight,
     listItemHeight,
+    selectedSessionId,
+    sessions,
     uid
   } = newState;
-  const css = getCss(composerHeight, listItemHeight, chatMessageFontSize, chatMessageLineHeight, chatMessageFontFamily);
+  const renderHtmlCss = getRenderHtmlCss(sessions, selectedSessionId);
+  const css = getCss(composerHeight, listItemHeight, chatMessageFontSize, chatMessageLineHeight, chatMessageFontFamily, renderHtmlCss);
   return [SetCss, uid, css];
 };
 
@@ -5765,13 +6316,20 @@ const ChatListEmpty = 'ChatListEmpty';
 const ChatListItem = 'ChatListItem';
 const ChatListItemLabel = 'ChatListItemLabel';
 const Markdown = 'Markdown';
+const MarkdownTable = 'MarkdownTable';
 const Message = 'Message';
 const ChatMessageContent = 'ChatMessageContent';
 const ChatToolCalls = 'ChatToolCalls';
 const ChatToolCallsLabel = 'ChatToolCallsLabel';
 const ChatToolCallReadFileLink = 'ChatToolCallReadFileLink';
+const ChatToolCallRenderHtmlLabel = 'ChatToolCallRenderHtmlLabel';
+const ChatToolCallRenderHtmlContent = 'ChatToolCallRenderHtmlContent';
+const ChatToolCallRenderHtmlBody = 'ChatToolCallRenderHtmlBody';
+const ChatMessageLink = 'ChatMessageLink';
 const ChatOrderedList = 'ChatOrderedList';
 const ChatOrderedListItem = 'ChatOrderedListItem';
+const ChatUnorderedList = 'ChatUnorderedList';
+const ChatUnorderedListItem = 'ChatUnorderedListItem';
 const MessageUser = 'MessageUser';
 const MessageAssistant = 'MessageAssistant';
 const MultilineInputBox = 'MultilineInputBox';
@@ -5939,7 +6497,6 @@ const getHeaderActionVirtualDom = item => {
     className: IconButton,
     name: item.name,
     onClick: item.onClick,
-    role: Button$2,
     title: item.title,
     type: Button$1
   }, {
@@ -5994,25 +6551,135 @@ const getChatHeaderDomDetailMode = selectedSessionTitle => {
   }, text(selectedSessionTitle), ...getChatHeaderActionsDom()];
 };
 
+const getInlineNodeDom = inlineNode => {
+  if (inlineNode.type === 'text') {
+    return [text(inlineNode.text)];
+  }
+  if (inlineNode.type === 'bold') {
+    return [{
+      childCount: 1,
+      type: Strong
+    }, text(inlineNode.text)];
+  }
+  return [{
+    childCount: 1,
+    className: ChatMessageLink,
+    href: inlineNode.href,
+    rel: 'noopener noreferrer',
+    target: '_blank',
+    title: inlineNode.href,
+    type: A
+  }, text(inlineNode.text)];
+};
+
+const getCodeBlockDom = node => {
+  return [{
+    childCount: 1,
+    type: Pre
+  }, {
+    childCount: 1,
+    type: Code
+  }, text(node.text)];
+};
+const getOrderedListItemDom = item => {
+  return [{
+    childCount: item.children.length,
+    className: ChatOrderedListItem,
+    type: Li
+  }, ...item.children.flatMap(getInlineNodeDom)];
+};
+const getUnorderedListItemDom = item => {
+  return [{
+    childCount: item.children.length,
+    className: ChatUnorderedListItem,
+    type: Li
+  }, ...item.children.flatMap(getInlineNodeDom)];
+};
+const getTableHeadCellDom = cell => {
+  return [{
+    childCount: cell.children.length,
+    type: Th
+  }, ...cell.children.flatMap(getInlineNodeDom)];
+};
+const getTableBodyCellDom = cell => {
+  return [{
+    childCount: cell.children.length,
+    type: Td
+  }, ...cell.children.flatMap(getInlineNodeDom)];
+};
+const getTableRowDom = row => {
+  return [{
+    childCount: row.cells.length,
+    type: Tr
+  }, ...row.cells.flatMap(getTableBodyCellDom)];
+};
+const getTableDom = node => {
+  return [{
+    childCount: 2,
+    className: MarkdownTable,
+    type: Table
+  }, {
+    childCount: 1,
+    type: THead
+  }, {
+    childCount: node.headers.length,
+    type: Tr
+  }, ...node.headers.flatMap(getTableHeadCellDom), {
+    childCount: node.rows.length,
+    type: TBody
+  }, ...node.rows.flatMap(getTableRowDom)];
+};
+const getHeadingElementType = level => {
+  switch (level) {
+    case 1:
+      return H1;
+    case 2:
+      return H2;
+    case 3:
+      return H3;
+    case 4:
+      return H4;
+    case 5:
+      return H5;
+    case 6:
+      return H6;
+  }
+};
+const getHeadingDom = node => {
+  return [{
+    childCount: node.children.length,
+    type: getHeadingElementType(node.level)
+  }, ...node.children.flatMap(getInlineNodeDom)];
+};
 const getMessageNodeDom = node => {
   if (node.type === 'text') {
     return [{
-      childCount: 1,
+      childCount: node.children.length,
       className: Markdown,
       type: P
-    }, text(node.text)];
+    }, ...node.children.flatMap(getInlineNodeDom)];
+  }
+  if (node.type === 'table') {
+    return getTableDom(node);
+  }
+  if (node.type === 'code-block') {
+    return getCodeBlockDom(node);
+  }
+  if (node.type === 'heading') {
+    return getHeadingDom(node);
+  }
+  if (node.type === 'ordered-list') {
+    return [{
+      childCount: node.items.length,
+      className: ChatOrderedList,
+      type: Ol
+    }, ...node.items.flatMap(getOrderedListItemDom)];
   }
   return [{
     childCount: node.items.length,
-    className: ChatOrderedList,
-    type: Ol
-  }, ...node.items.flatMap(item => {
-    return [{
-      childCount: 1,
-      className: ChatOrderedListItem,
-      type: Li
-    }, text(item.text)];
-  })];
+    className: ChatUnorderedList,
+    type: Ul
+  }, ...node.items.flatMap(getUnorderedListItemDom)];
 };
 
 const getMessageContentDom = nodes => {
@@ -6167,7 +6834,7 @@ const getReadFileTarget = rawArguments => {
   if (!title) {
     return undefined;
   }
-  // `read_file` tool calls usually provide a relative `path`; pass it through so UI clicks can open the file.
+  // `read_file` tool calls now use absolute `uri`; keep `path` as a legacy fallback for old transcripts.
   const clickableUri = uriValue || pathValue;
   return {
     clickableUri,
@@ -6175,7 +6842,7 @@ const getReadFileTarget = rawArguments => {
   };
 };
 
-const getToolCallStatusLabel$1 = toolCall => {
+const getToolCallStatusLabel = toolCall => {
   if (toolCall.status === 'not-found') {
     return ' (not-found)';
   }
@@ -6195,7 +6862,7 @@ const getToolCallReadFileVirtualDom = toolCall => {
   }
   const fileName = getFileNameFromUri(target.title);
   const toolNameLabel = `${toolCall.name} `;
-  const statusLabel = getToolCallStatusLabel$1(toolCall);
+  const statusLabel = getToolCallStatusLabel(toolCall);
   const fileNameClickableProps = target.clickableUri ? {
     'data-uri': target.clickableUri,
     onClick: HandleClickReadFile
@@ -6217,25 +6884,318 @@ const getToolCallReadFileVirtualDom = toolCall => {
   }, text(fileName), ...(statusLabel ? [text(statusLabel)] : [])];
 };
 
-const getToolCallStatusLabel = toolCall => {
-  if (toolCall.status === 'not-found') {
-    return ' (not-found)';
+const maxHtmlLength = 40_000;
+const tokenRegex = /<!--[\s\S]*?-->|<\/?[a-zA-Z][\w:-]*(?:\s[^<>]*?)?>|[^<]+/g;
+const attributeRegex = /([^\s=/>]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/g;
+const inlineTags = new Set(['a', 'abbr', 'b', 'code', 'em', 'i', 'label', 'small', 'span', 'strong', 'sub', 'sup', 'u']);
+const voidElements = new Set(['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr']);
+const sanitizeHtml = value => {
+  return value.slice(0, maxHtmlLength).replaceAll(/<script\b[\s\S]*?<\/script>/gi, '').replaceAll(/<style\b[\s\S]*?<\/style>/gi, '').replaceAll(/<head\b[\s\S]*?<\/head>/gi, '').replaceAll(/<meta\b[^>]*>/gi, '').replaceAll(/<link\b[^>]*>/gi, '');
+};
+const decodeEntities = value => {
+  return value.replaceAll('&nbsp;', ' ').replaceAll('&quot;', '"').replaceAll('&#39;', "'").replaceAll('&lt;', '<').replaceAll('&gt;', '>').replaceAll('&amp;', '&');
+};
+const parseAttributes = token => {
+  const withoutTag = token.replace(/^<\/?\s*[a-zA-Z][\w:-]*/, '').replace(/\/?\s*>$/, '').trim();
+  if (!withoutTag) {
+    return Object.create(null);
   }
-  if (toolCall.status === 'error') {
-    if (toolCall.errorMessage) {
-      return ` (error: ${toolCall.errorMessage})`;
+  const attributes = Object.create(null);
+  const matches = withoutTag.matchAll(attributeRegex);
+  for (const match of matches) {
+    const name = String(match[1] || '').toLowerCase();
+    if (!name || name.startsWith('on')) {
+      continue;
     }
-    return ' (error)';
+    const value = String(match[2] ?? match[3] ?? match[4] ?? '');
+    attributes[name] = decodeEntities(value);
   }
-  return '';
+  return attributes;
+};
+const parseHtml = value => {
+  const root = {
+    attributes: Object.create(null),
+    children: [],
+    tagName: 'root',
+    type: 'element'
+  };
+  const stack = [root];
+  const matches = sanitizeHtml(value).match(tokenRegex);
+  if (!matches) {
+    return [];
+  }
+  for (const token of matches) {
+    if (token.startsWith('<!--')) {
+      continue;
+    }
+    if (token.startsWith('</')) {
+      const closingTagName = token.slice(2, -1).trim().toLowerCase();
+      while (stack.length > 1) {
+        const top = stack.at(-1);
+        if (!top) {
+          break;
+        }
+        stack.pop();
+        if (top.tagName === closingTagName) {
+          break;
+        }
+      }
+      continue;
+    }
+    if (token.startsWith('<')) {
+      const openTagNameMatch = /^<\s*([a-zA-Z][\w:-]*)/.exec(token);
+      if (!openTagNameMatch) {
+        continue;
+      }
+      const tagName = openTagNameMatch[1].toLowerCase();
+      const elementNode = {
+        attributes: parseAttributes(token),
+        children: [],
+        tagName,
+        type: 'element'
+      };
+      const parent = stack.at(-1);
+      if (!parent) {
+        continue;
+      }
+      parent.children.push(elementNode);
+      const selfClosing = token.endsWith('/>') || voidElements.has(tagName);
+      if (!selfClosing) {
+        stack.push(elementNode);
+      }
+      continue;
+    }
+    const decoded = decodeEntities(token);
+    if (!decoded) {
+      continue;
+    }
+    const parent = stack.at(-1);
+    if (!parent) {
+      continue;
+    }
+    parent.children.push({
+      type: 'text',
+      value: decoded
+    });
+  }
+  return root.children;
+};
+const getElementType = tagName => {
+  switch (tagName) {
+    case 'a':
+      return A;
+    case 'abbr':
+      return Abbr;
+    case 'article':
+      return Article;
+    case 'aside':
+      return Aside;
+    case 'audio':
+      return Audio;
+    case 'br':
+      return Br;
+    case 'button':
+      return Button$1;
+    case 'code':
+      return Code;
+    case 'col':
+      return Col;
+    case 'colgroup':
+      return ColGroup;
+    case 'dd':
+      return Dd;
+    case 'dl':
+      return Dl;
+    case 'dt':
+      return Dt;
+    case 'em':
+      return Em;
+    case 'figcaption':
+      return Figcaption;
+    case 'figure':
+      return Figure;
+    case 'footer':
+      return Footer;
+    case 'h1':
+      return H1;
+    case 'h2':
+      return H2;
+    case 'h3':
+      return H3;
+    case 'h4':
+      return H4;
+    case 'h5':
+      return H5;
+    case 'h6':
+      return H6;
+    case 'header':
+      return Header;
+    case 'hr':
+      return Hr;
+    case 'i':
+      return I;
+    case 'img':
+      return Img;
+    case 'input':
+      return Input;
+    case 'label':
+      return Label$1;
+    case 'li':
+      return Li;
+    case 'main':
+      return Main;
+    case 'nav':
+      return Nav;
+    case 'ol':
+      return Ol;
+    case 'option':
+      return Option$1;
+    case 'p':
+      return P;
+    case 'pre':
+      return Pre;
+    case 'section':
+      return Section;
+    case 'select':
+      return Select$1;
+    case 'span':
+      return Span;
+    case 'strong':
+      return Strong;
+    case 'table':
+      return Table;
+    case 'tbody':
+      return TBody;
+    case 'td':
+      return Td;
+    case 'textarea':
+      return TextArea;
+    case 'tfoot':
+      return Tfoot;
+    case 'th':
+      return Th;
+    case 'thead':
+      return THead;
+    case 'tr':
+      return Tr;
+    case 'ul':
+      return Ul;
+    default:
+      return inlineTags.has(tagName) ? Span : Div;
+  }
+};
+const normalizeUrl = url => {
+  return url.toLowerCase().startsWith('javascript:') ? '#' : url;
+};
+const getElementAttributes = node => {
+  const attributes = {};
+  const className = node.attributes.class || node.attributes.classname;
+  if (className) {
+    attributes.className = className;
+  }
+  if (node.attributes.style) {
+    attributes.style = node.attributes.style;
+  }
+  if (node.attributes.id) {
+    attributes.id = node.attributes.id;
+  }
+  if (node.attributes.name) {
+    attributes.name = node.attributes.name;
+  }
+  if (node.attributes.placeholder) {
+    attributes.placeholder = node.attributes.placeholder;
+  }
+  if (node.attributes.title) {
+    attributes.title = node.attributes.title;
+  }
+  if (node.attributes.value) {
+    attributes.value = node.attributes.value;
+  }
+  if (node.attributes.href) {
+    attributes.href = normalizeUrl(node.attributes.href);
+  }
+  if (node.attributes.src) {
+    attributes.src = normalizeUrl(node.attributes.src);
+  }
+  if (node.attributes.target) {
+    attributes.target = node.attributes.target;
+  }
+  if (node.attributes.rel) {
+    attributes.rel = node.attributes.rel;
+  }
+  if ('checked' in node.attributes) {
+    attributes.checked = node.attributes.checked !== 'false';
+  }
+  if ('disabled' in node.attributes) {
+    attributes.disabled = node.attributes.disabled !== 'false';
+  }
+  if ('readonly' in node.attributes) {
+    attributes.readOnly = node.attributes.readonly !== 'false';
+  }
+  return attributes;
+};
+const toVirtualDom = node => {
+  if (node.type === 'text') {
+    return [text(node.value)];
+  }
+  const children = node.children.flatMap(toVirtualDom);
+  return [{
+    childCount: node.children.length,
+    ...getElementAttributes(node),
+    type: getElementType(node.tagName)
+  }, ...children];
+};
+const parseHtmlToVirtualDomWithRootCount = value => {
+  const rootNodes = parseHtml(value);
+  return {
+    rootChildCount: rootNodes.length,
+    virtualDom: rootNodes.flatMap(toVirtualDom)
+  };
 };
+
+const getToolCallRenderHtmlVirtualDom = toolCall => {
+  const parsed = parseRenderHtmlArguments(toolCall.arguments);
+  if (!parsed) {
+    return [];
+  }
+  const statusLabel = getToolCallStatusLabel(toolCall);
+  const label = `${toolCall.name}: ${parsed.title}${statusLabel}`;
+  const parsedHtml = parseHtmlToVirtualDomWithRootCount(parsed.html);
+  const {
+    rootChildCount
+  } = parsedHtml;
+  return [{
+    childCount: 2,
+    className: ChatOrderedListItem,
+    type: Li
+  }, {
+    childCount: 1,
+    className: ChatToolCallRenderHtmlLabel,
+    type: Div
+  }, text(label), {
+    childCount: 1,
+    className: ChatToolCallRenderHtmlContent,
+    type: Div
+  }, {
+    childCount: rootChildCount,
+    className: ChatToolCallRenderHtmlBody,
+    type: Div
+  }, ...parsedHtml.virtualDom];
+};
+
 const getToolCallDom = toolCall => {
-  if (toolCall.name === 'read_file') {
+  if (toolCall.name === 'read_file' || toolCall.name === 'list_files' || toolCall.name === 'list_file') {
     const virtualDom = getToolCallReadFileVirtualDom(toolCall);
     if (virtualDom.length > 0) {
       return virtualDom;
     }
   }
+  if (toolCall.name === 'render_html') {
+    const virtualDom = getToolCallRenderHtmlVirtualDom(toolCall);
+    if (virtualDom.length > 0) {
+      return virtualDom;
+    }
+  }
   const argumentPreview = getToolCallArgumentPreview(toolCall.arguments);
   const label = `${toolCall.name} ${argumentPreview}${getToolCallStatusLabel(toolCall)}`;
   return [{
@@ -6265,23 +7225,120 @@ const getToolCallsDom = message => {
 };
 
 const orderedListItemRegex = /^\s*\d+\.\s+(.*)$/;
+const unorderedListItemRegex = /^\s*[-*]\s+(.*)$/;
+const markdownInlineRegex = /\[([^\]]+)\]\(([^)]+)\)|\*\*([^*]+)\*\*/g;
+const markdownTableSeparatorCellRegex = /^:?-{3,}:?$/;
+const fencedCodeBlockRegex = /^```/;
+const markdownHeadingRegex = /^\s*(#{1,6})\s+(.*)$/;
+const normalizeInlineTables = value => {
+  return value.split(/\r?\n/).map(line => {
+    if (!line.includes('|')) {
+      return line;
+    }
+    if (!/\|\s*[-:]{3,}/.test(line)) {
+      return line;
+    }
+    return line.replaceAll(/\|\s+\|/g, '|\n|');
+  }).join('\n');
+};
+const isTableRow = line => {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith('|') || !trimmed.endsWith('|')) {
+    return false;
+  }
+  return trimmed.length > 2 && trimmed.slice(1, -1).includes('|');
+};
+const getTableCells = line => {
+  const trimmed = line.trim();
+  return trimmed.slice(1, -1).split('|').map(part => part.trim());
+};
+const isTableSeparatorRow = (line, expectedColumns) => {
+  if (!isTableRow(line)) {
+    return false;
+  }
+  const cells = getTableCells(line);
+  if (cells.length !== expectedColumns) {
+    return false;
+  }
+  return cells.every(cell => markdownTableSeparatorCellRegex.test(cell));
+};
+const toTableCell = value => {
+  return {
+    children: parseInlineNodes(value),
+    type: 'table-cell'
+  };
+};
+const toTableRow = line => {
+  return {
+    cells: getTableCells(line).map(toTableCell),
+    type: 'table-row'
+  };
+};
+const parseInlineNodes = value => {
+  const matches = value.matchAll(markdownInlineRegex);
+  const nodes = [];
+  let lastIndex = 0;
+  for (const match of matches) {
+    const fullMatch = match[0];
+    const linkText = match[1];
+    const href = match[2];
+    const boldText = match[3];
+    const index = match.index ?? 0;
+    if (index > lastIndex) {
+      nodes.push({
+        text: value.slice(lastIndex, index),
+        type: 'text'
+      });
+    }
+    if (linkText && href) {
+      nodes.push({
+        href,
+        text: linkText,
+        type: 'link'
+      });
+    } else if (boldText) {
+      nodes.push({
+        text: boldText,
+        type: 'bold'
+      });
+    }
+    lastIndex = index + fullMatch.length;
+  }
+  if (lastIndex < value.length) {
+    nodes.push({
+      text: value.slice(lastIndex),
+      type: 'text'
+    });
+  }
+  if (nodes.length === 0) {
+    return [{
+      text: value,
+      type: 'text'
+    }];
+  }
+  return nodes;
+};
 const parseMessageContent = rawMessage => {
   if (rawMessage === '') {
     return [{
-      text: '',
+      children: [{
+        text: '',
+        type: 'text'
+      }],
       type: 'text'
     }];
   }
-  const lines = rawMessage.split(/\r?\n/);
+  const lines = normalizeInlineTables(rawMessage).split(/\r?\n/);
   const nodes = [];
   let paragraphLines = [];
   let listItems = [];
+  let listType = '';
   const flushParagraph = () => {
     if (paragraphLines.length === 0) {
       return;
     }
     nodes.push({
-      text: paragraphLines.join('\n'),
+      children: parseInlineNodes(paragraphLines.join('\n')),
       type: 'text'
     });
     paragraphLines = [];
@@ -6292,32 +7349,103 @@ const parseMessageContent = rawMessage => {
     }
     nodes.push({
       items: listItems,
-      type: 'list'
+      type: listType || 'ordered-list'
     });
     listItems = [];
+    listType = '';
   };
-  for (const line of lines) {
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
     if (!line.trim()) {
       flushList();
       flushParagraph();
       continue;
     }
-    const match = line.match(orderedListItemRegex);
-    if (match) {
+    if (fencedCodeBlockRegex.test(line.trim())) {
+      flushList();
+      flushParagraph();
+      const codeLines = [];
+      i++;
+      while (i < lines.length && !fencedCodeBlockRegex.test(lines[i].trim())) {
+        codeLines.push(lines[i]);
+        i++;
+      }
+      nodes.push({
+        text: codeLines.join('\n'),
+        type: 'code-block'
+      });
+      continue;
+    }
+    if (isTableRow(line) && i + 1 < lines.length) {
+      const headerCells = getTableCells(line);
+      if (isTableSeparatorRow(lines[i + 1], headerCells.length)) {
+        flushList();
+        flushParagraph();
+        const rows = [];
+        i += 2;
+        while (i < lines.length && isTableRow(lines[i])) {
+          const row = toTableRow(lines[i]);
+          if (row.cells.length === headerCells.length) {
+            rows.push(row);
+          }
+          i++;
+        }
+        i--;
+        nodes.push({
+          headers: headerCells.map(toTableCell),
+          rows,
+          type: 'table'
+        });
+        continue;
+      }
+    }
+    const orderedMatch = line.match(orderedListItemRegex);
+    if (orderedMatch) {
+      if (listType && listType !== 'ordered-list') {
+        flushList();
+      }
+      flushParagraph();
+      listType = 'ordered-list';
+      listItems.push({
+        children: parseInlineNodes(orderedMatch[1]),
+        type: 'list-item'
+      });
+      continue;
+    }
+    const unorderedMatch = line.match(unorderedListItemRegex);
+    if (unorderedMatch) {
+      if (listType && listType !== 'unordered-list') {
+        flushList();
+      }
       flushParagraph();
+      listType = 'unordered-list';
       listItems.push({
-        text: match[1],
+        children: parseInlineNodes(unorderedMatch[1]),
         type: 'list-item'
       });
       continue;
     }
+    const headingMatch = line.match(markdownHeadingRegex);
+    if (headingMatch) {
+      flushList();
+      flushParagraph();
+      nodes.push({
+        children: parseInlineNodes(headingMatch[2]),
+        level: headingMatch[1].length,
+        type: 'heading'
+      });
+      continue;
+    }
     flushList();
     paragraphLines.push(line);
   }
   flushList();
   flushParagraph();
   return nodes.length === 0 ? [{
-    text: '',
+    children: [{
+      text: '',
+      type: 'text'
+    }],
     type: 'text'
   }] : nodes;
 };
@@ -6424,7 +7552,6 @@ const getSessionDom = session => {
     'data-id': session.id,
     name: SessionDelete,
     onClick: HandleClickDelete,
-    role: Button$2,
     tabIndex: 0,
     title: deleteChatSession$1(),
     type: Button$1
@@ -6761,6 +7888,7 @@ const commandMap = {
   'Chat.mockOpenApiStreamPushChunk': wrapCommand(mockOpenApiStreamPushChunk),
   'Chat.mockOpenApiStreamReset': wrapCommand(mockOpenApiStreamReset),
   'Chat.openMockSession': wrapCommand(openMockSession),
+  'Chat.registerMockResponse': wrapCommand(registerMockResponse),
   'Chat.render2': render2,
   'Chat.renderEventListeners': renderEventListeners,
   'Chat.rerender': wrapCommand(rerender),
@@ -6776,7 +7904,7 @@ const commandMap = {
 };
 
 const send = port => {
-  return invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToChatNetworkWorker', port, 'HandleMessagePort.handleMessagePort');
+  return sendMessagePortToChatNetworkWorker(port);
 };
 const initializeChatNetworkWorker = async () => {
   const rpc = await create$4({