@lvce-editor/static-server 0.75.12 → 0.75.14

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

@@ -1078,6 +1078,9 @@ const {
   set: set$3
 } = create$2(6002);
 
+const Div$1 = 4;
+const Ol$1 = 49;
+
 const ClientX = 'event.clientX';
 const ClientY = 'event.clientY';
 const Key = 'event.key';
@@ -1467,6 +1470,7 @@ const createDefaultState = () => {
     composerHeight: composerLineHeight + 8,
     composerLineHeight,
     composerValue: '',
+    emitStreamingFunctionCallEvents: false,
     errorCount: 0,
     focus: 'composer',
     focused: false,
@@ -1509,6 +1513,7 @@ const createDefaultState = () => {
     useMockApi: false,
     viewMode: 'list',
     warningCount: 0,
+    webSearchEnabled: true,
     width: 0,
     x: 0,
     y: 0
@@ -2644,7 +2649,8 @@ const deleteSession = async (state, id) => {
 };
 
 const handleClickOpenApiApiKeySettings = async state => {
-  await openExternal(state.openApiApiKeysSettingsUrl);
+  // 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;
 };
 
@@ -2739,22 +2745,166 @@ const readNextChunk = async () => {
   return promise;
 };
 
-const getMockOpenApiAssistantText = async (stream, onTextChunk) => {
+const parseSseDataLines = eventChunk => {
+  const lines = eventChunk.split('\n');
+  const dataLines = [];
+  for (const line of lines) {
+    if (!line.startsWith('data:')) {
+      continue;
+    }
+    dataLines.push(line.slice(5).trimStart());
+  }
+  return dataLines;
+};
+const emitToolCalls = async (toolCallAccumulator, onToolCallsChunk) => {
+  if (!onToolCallsChunk) {
+    return;
+  }
+  const toolCalls = Object.entries(toolCallAccumulator).toSorted((a, b) => Number(a[0]) - Number(b[0])).map(entry => entry[1]).filter(toolCall => !!toolCall.name);
+  if (toolCalls.length === 0) {
+    return;
+  }
+  await onToolCallsChunk(toolCalls);
+};
+const getMockOpenApiAssistantText = async (stream, onTextChunk, onToolCallsChunk, onDataEvent, onEventStreamFinished) => {
   const error = takeErrorResponse();
   if (error) {
     return error;
   }
   let text = '';
+  let remainder = '';
+  let toolCallAccumulator = {};
+  let finishedNotified = false;
+  const notifyFinished = async () => {
+    if (finishedNotified) {
+      return;
+    }
+    finishedNotified = true;
+    if (onEventStreamFinished) {
+      await onEventStreamFinished();
+    }
+  };
+  const handleParsedSseEvent = async parsed => {
+    if (onDataEvent) {
+      await onDataEvent(parsed);
+    }
+    if (!parsed || typeof parsed !== 'object') {
+      return;
+    }
+    const eventType = Reflect.get(parsed, 'type');
+    if (eventType === 'response.completed') {
+      await notifyFinished();
+      return;
+    }
+    if (eventType === 'response.output_text.delta') {
+      const delta = Reflect.get(parsed, 'delta');
+      if (typeof delta !== 'string' || !delta) {
+        return;
+      }
+      text += delta;
+      if (stream && onTextChunk) {
+        await onTextChunk(delta);
+      }
+      return;
+    }
+    if (eventType === 'response.output_item.added') {
+      const outputIndex = Reflect.get(parsed, 'output_index');
+      const item = Reflect.get(parsed, 'item');
+      if (typeof outputIndex !== 'number' || !item || typeof item !== 'object') {
+        return;
+      }
+      if (Reflect.get(item, 'type') !== 'function_call') {
+        return;
+      }
+      const name = Reflect.get(item, 'name');
+      const argumentsValue = Reflect.get(item, 'arguments');
+      const callId = Reflect.get(item, 'call_id');
+      toolCallAccumulator = {
+        ...toolCallAccumulator,
+        [outputIndex]: {
+          arguments: typeof argumentsValue === 'string' ? argumentsValue : '',
+          ...(typeof callId === 'string' ? {
+            id: callId
+          } : {}),
+          name: typeof name === 'string' ? name : ''
+        }
+      };
+      await emitToolCalls(toolCallAccumulator, onToolCallsChunk);
+      return;
+    }
+    if (eventType === 'response.function_call_arguments.delta' || eventType === 'response.function_call_arguments.done') {
+      const outputIndex = Reflect.get(parsed, 'output_index');
+      if (typeof outputIndex !== 'number') {
+        return;
+      }
+      const current = toolCallAccumulator[outputIndex] || {
+        arguments: '',
+        name: ''
+      };
+      const delta = Reflect.get(parsed, 'delta');
+      const argumentsValue = Reflect.get(parsed, 'arguments');
+      const name = Reflect.get(parsed, 'name');
+      const callId = Reflect.get(parsed, 'call_id');
+      const next = {
+        arguments: typeof argumentsValue === 'string' ? argumentsValue : typeof delta === 'string' ? `${current.arguments}${delta}` : current.arguments,
+        ...(typeof callId === 'string' ? {
+          id: callId
+        } : current.id ? {
+          id: current.id
+        } : {}),
+        name: typeof name === 'string' && name ? name : current.name
+      };
+      toolCallAccumulator = {
+        ...toolCallAccumulator,
+        [outputIndex]: next
+      };
+      await emitToolCalls(toolCallAccumulator, onToolCallsChunk);
+    }
+  };
+  const consumeSseDataLines = async dataLines => {
+    for (const line of dataLines) {
+      if (line === '[DONE]') {
+        await notifyFinished();
+        continue;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      await handleParsedSseEvent(parsed);
+    }
+  };
   while (true) {
     const chunk = await readNextChunk();
     if (typeof chunk !== 'string') {
       break;
     }
+    if (chunk.startsWith('data:')) {
+      remainder += chunk;
+      while (true) {
+        const separatorIndex = remainder.indexOf('\n\n');
+        if (separatorIndex === -1) {
+          break;
+        }
+        const rawEvent = remainder.slice(0, separatorIndex);
+        remainder = remainder.slice(separatorIndex + 2);
+        const dataLines = parseSseDataLines(rawEvent);
+        await consumeSseDataLines(dataLines);
+      }
+      continue;
+    }
     text += chunk;
     if (stream && onTextChunk) {
       await onTextChunk(chunk);
     }
   }
+  if (remainder) {
+    const dataLines = parseSseDataLines(remainder);
+    await consumeSseDataLines(dataLines);
+  }
+  await notifyFinished();
   return {
     text,
     type: 'success'
@@ -2904,8 +3054,6 @@ const getMockOpenRouterAssistantText = async (messages, modelId, openRouterApiBa
   }
 };
 
-const OnFileSystem = 'onFileSystem';
-
 const isPathTraversalAttempt = path => {
   if (!path) {
     return false;
@@ -2922,6 +3070,7 @@ const isPathTraversalAttempt = path => {
   const segments = path.split(/[\\/]/);
   return segments.includes('..');
 };
+
 const normalizeRelativePath = path => {
   const segments = path.split(/[\\/]/).filter(segment => segment && segment !== '.');
   if (segments.length === 0) {
@@ -2929,6 +3078,87 @@ const normalizeRelativePath = path => {
   }
   return segments.join('/');
 };
+
+const executeListFilesTool = async (args, _options) => {
+  const folderPath = typeof args.path === 'string' && args.path ? args.path : '.';
+  if (isPathTraversalAttempt(folderPath)) {
+    return JSON.stringify({
+      error: 'Access denied: path must be relative and stay within the open workspace folder.'
+    });
+  }
+  const normalizedPath = normalizeRelativePath(folderPath);
+  try {
+    const entries = await invoke('FileSystem.readDirWithFileTypes', normalizedPath);
+    return JSON.stringify({
+      entries,
+      path: normalizedPath
+    });
+  } catch (error) {
+    return JSON.stringify({
+      error: String(error),
+      path: normalizedPath
+    });
+  }
+};
+
+const executeReadFileTool = async (args, _options) => {
+  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(filePath);
+  try {
+    const content = await readFile(normalizedPath);
+    return JSON.stringify({
+      content,
+      path: normalizedPath
+    });
+  } catch (error) {
+    return JSON.stringify({
+      error: String(error),
+      path: normalizedPath
+    });
+  }
+};
+
+const OnFileSystem = 'onFileSystem';
+
+const executeFileSystemCommand = async (method, params, options) => {
+  return executeProvider({
+    assetDir: options.assetDir,
+    event: OnFileSystem,
+    method,
+    noProviderFoundMessage: 'No file system provider found',
+    params,
+    platform: options.platform
+  });
+};
+
+const executeWriteFileTool = async (args, options) => {
+  const filePath = typeof args.path === 'string' ? args.path : '';
+  const content = typeof args.content === 'string' ? args.content : '';
+  if (!filePath || isPathTraversalAttempt(filePath)) {
+    return JSON.stringify({
+      error: 'Access denied: path must be relative and stay within the open workspace folder.'
+    });
+  }
+  const normalizedPath = normalizeRelativePath(filePath);
+  try {
+    await executeFileSystemCommand(FileSystemWriteFile, ['file', normalizedPath, content], options);
+    return JSON.stringify({
+      ok: true,
+      path: normalizedPath
+    });
+  } catch (error) {
+    return JSON.stringify({
+      error: String(error),
+      path: normalizedPath
+    });
+  }
+};
+
 const parseToolArguments = rawArguments => {
   if (typeof rawArguments !== 'string') {
     return {};
@@ -2943,16 +3173,23 @@ const parseToolArguments = rawArguments => {
     return {};
   }
 };
-const executeFileSystemCommand = async (method, params, options) => {
-  return executeProvider({
-    assetDir: options.assetDir,
-    event: OnFileSystem,
-    method,
-    noProviderFoundMessage: 'No file system provider found',
-    params,
-    platform: options.platform
+
+const executeChatTool = async (name, rawArguments, options) => {
+  const args = parseToolArguments(rawArguments);
+  if (name === 'read_file') {
+    return executeReadFileTool(args);
+  }
+  if (name === 'write_file') {
+    return executeWriteFileTool(args, options);
+  }
+  if (name === 'list_files') {
+    return executeListFilesTool(args);
+  }
+  return JSON.stringify({
+    error: `Unknown tool: ${name}`
   });
 };
+
 const getBasicChatTools = () => {
   return [{
     function: {
@@ -3010,76 +3247,6 @@ const getBasicChatTools = () => {
     type: 'function'
   }];
 };
-const executeChatTool = async (name, rawArguments, options) => {
-  const args = parseToolArguments(rawArguments);
-  if (name === 'read_file') {
-    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(filePath);
-    try {
-      const content = await readFile(normalizedPath);
-      return JSON.stringify({
-        content,
-        path: normalizedPath
-      });
-    } catch (error) {
-      return JSON.stringify({
-        error: String(error),
-        path: normalizedPath
-      });
-    }
-  }
-  if (name === 'write_file') {
-    const filePath = typeof args.path === 'string' ? args.path : '';
-    const content = typeof args.content === 'string' ? args.content : '';
-    if (!filePath || isPathTraversalAttempt(filePath)) {
-      return JSON.stringify({
-        error: 'Access denied: path must be relative and stay within the open workspace folder.'
-      });
-    }
-    const normalizedPath = normalizeRelativePath(filePath);
-    try {
-      await executeFileSystemCommand(FileSystemWriteFile, ['file', normalizedPath, content], options);
-      return JSON.stringify({
-        ok: true,
-        path: normalizedPath
-      });
-    } catch (error) {
-      return JSON.stringify({
-        error: String(error),
-        path: normalizedPath
-      });
-    }
-  }
-  if (name === 'list_files') {
-    const folderPath = typeof args.path === 'string' && args.path ? args.path : '.';
-    if (isPathTraversalAttempt(folderPath)) {
-      return JSON.stringify({
-        error: 'Access denied: path must be relative and stay within the open workspace folder.'
-      });
-    }
-    const normalizedPath = normalizeRelativePath(folderPath);
-    try {
-      const entries = await invoke('FileSystem.readDirWithFileTypes', normalizedPath);
-      return JSON.stringify({
-        entries,
-        path: normalizedPath
-      });
-    } catch (error) {
-      return JSON.stringify({
-        error: String(error),
-        path: normalizedPath
-      });
-    }
-  }
-  return JSON.stringify({
-    error: `Unknown tool: ${name}`
-  });
-};
 
 const getClientRequestIdHeader = () => {
   return {
@@ -3139,7 +3306,8 @@ const getOpenAiTools = tools => {
     };
   });
 };
-const getOpenAiParams = (input, modelId, stream, includeObfuscation, tools, previousResponseId) => {
+const getOpenAiParams = (input, modelId, stream, includeObfuscation, tools, webSearchEnabled, previousResponseId) => {
+  const openAiTools = getOpenAiTools(tools);
   return {
     input,
     model: modelId,
@@ -3155,7 +3323,9 @@ const getOpenAiParams = (input, modelId, stream, includeObfuscation, tools, prev
       previous_response_id: previousResponseId
     } : {}),
     tool_choice: 'auto',
-    tools: getOpenAiTools(tools)
+    tools: webSearchEnabled ? [...openAiTools, {
+      type: 'web_search'
+    }] : openAiTools
   };
 };
 const getStreamChunkText = content => {
@@ -3173,6 +3343,47 @@ const getStreamChunkText = content => {
     return typeof text === 'string' ? text : '';
   }).join('');
 };
+const getShortToolErrorMessage = error => {
+  const trimmed = error.trim().replace(/^Error:\s*/, '');
+  const firstLine = trimmed.split('\n')[0];
+  if (firstLine.length <= 80) {
+    return firstLine;
+  }
+  return `${firstLine.slice(0, 77)}...`;
+};
+const getToolCallExecutionStatus = content => {
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    return {
+      errorMessage: 'Invalid tool output',
+      status: 'error'
+    };
+  }
+  if (!parsed || typeof parsed !== 'object') {
+    return {
+      errorMessage: 'Invalid tool output',
+      status: 'error'
+    };
+  }
+  const rawError = Reflect.get(parsed, 'error');
+  if (typeof rawError !== 'string' || !rawError.trim()) {
+    return {
+      status: 'success'
+    };
+  }
+  const errorMessage = getShortToolErrorMessage(rawError);
+  if (/not[\s_-]?found|enoent/i.test(errorMessage)) {
+    return {
+      status: 'not-found'
+    };
+  }
+  return {
+    errorMessage,
+    status: 'error'
+  };
+};
 const getResponseOutputText = parsed => {
   if (!parsed || typeof parsed !== 'object') {
     return '';
@@ -3309,7 +3520,31 @@ const updateToolCallAccumulator = (accumulator, chunk) => {
     toolCalls
   };
 };
-const parseOpenApiStream = async (response, onTextChunk, onToolCallsChunk, onDataEvent, onEventStreamFinished) => {
+const getResponseFunctionCallsFromStreamingAccumulator = toolCallAccumulator => {
+  return Object.entries(toolCallAccumulator).toSorted((a, b) => a[0].localeCompare(b[0])).map(entry => entry[1]).filter(toolCall => typeof toolCall.id === 'string' && !!toolCall.id && !!toolCall.name).map(toolCall => ({
+    arguments: toolCall.arguments,
+    callId: toolCall.id,
+    name: toolCall.name
+  }));
+};
+const getStreamingToolCallKey = value => {
+  if (!value || typeof value !== 'object') {
+    return undefined;
+  }
+  const outputIndex = Reflect.get(value, 'output_index');
+  if (typeof outputIndex === 'number') {
+    return String(outputIndex);
+  }
+  if (typeof outputIndex === 'string' && outputIndex) {
+    return outputIndex;
+  }
+  const itemId = Reflect.get(value, 'item_id');
+  if (typeof itemId === 'string' && itemId) {
+    return itemId;
+  }
+  return undefined;
+};
+const parseOpenApiStream = async (response, onTextChunk, onToolCallsChunk, onDataEvent) => {
   if (!response.body) {
     return {
       details: 'request-failed',
@@ -3321,22 +3556,14 @@ const parseOpenApiStream = async (response, onTextChunk, onToolCallsChunk, onDat
   let remainder = '';
   let text = '';
   let done = false;
-  let finishedNotified = false;
   let toolCallAccumulator = {};
-  const notifyFinished = async () => {
-    if (finishedNotified) {
-      return;
-    }
-    finishedNotified = true;
-    if (onEventStreamFinished) {
-      await onEventStreamFinished();
-    }
-  };
+  let responseId;
+  let completedResponseFunctionCalls = [];
   const emitToolCallAccumulator = async () => {
     if (!onToolCallsChunk) {
       return;
     }
-    const toolCalls = Object.entries(toolCallAccumulator).toSorted((a, b) => Number(a[0]) - Number(b[0])).map(entry => entry[1]).filter(toolCall => !!toolCall.name);
+    const toolCalls = Object.entries(toolCallAccumulator).toSorted((a, b) => a[0].localeCompare(b[0])).map(entry => entry[1]).filter(toolCall => !!toolCall.name);
     if (toolCalls.length === 0) {
       return;
     }
@@ -3351,7 +3578,25 @@ const parseOpenApiStream = async (response, onTextChunk, onToolCallsChunk, onDat
     }
     const eventType = Reflect.get(parsed, 'type');
     if (eventType === 'response.completed') {
-      await notifyFinished();
+      const response = Reflect.get(parsed, 'response');
+      if (response && typeof response === 'object') {
+        const parsedResponseId = Reflect.get(response, 'id');
+        if (typeof parsedResponseId === 'string' && parsedResponseId) {
+          responseId = parsedResponseId;
+        }
+        completedResponseFunctionCalls = getResponseFunctionCalls(response);
+      }
+      return;
+    }
+    if (eventType === 'response.created' || eventType === 'response.in_progress') {
+      const response = Reflect.get(parsed, 'response');
+      if (!response || typeof response !== 'object') {
+        return;
+      }
+      const parsedResponseId = Reflect.get(response, 'id');
+      if (typeof parsedResponseId === 'string' && parsedResponseId) {
+        responseId = parsedResponseId;
+      }
       return;
     }
     if (eventType === 'response.output_text.delta') {
@@ -3366,9 +3611,9 @@ const parseOpenApiStream = async (response, onTextChunk, onToolCallsChunk, onDat
       return;
     }
     if (eventType === 'response.output_item.added') {
-      const outputIndex = Reflect.get(parsed, 'output_index');
+      const toolCallKey = getStreamingToolCallKey(parsed);
       const item = Reflect.get(parsed, 'item');
-      if (typeof outputIndex !== 'number' || !item || typeof item !== 'object') {
+      if (!toolCallKey || !item || typeof item !== 'object') {
         return;
       }
       const itemType = Reflect.get(item, 'type');
@@ -3387,17 +3632,49 @@ const parseOpenApiStream = async (response, onTextChunk, onToolCallsChunk, onDat
       };
       toolCallAccumulator = {
         ...toolCallAccumulator,
-        [outputIndex]: next
+        [toolCallKey]: next
+      };
+      await emitToolCallAccumulator();
+      return;
+    }
+    if (eventType === 'response.output_item.done') {
+      const toolCallKey = getStreamingToolCallKey(parsed);
+      const item = Reflect.get(parsed, 'item');
+      if (!toolCallKey || !item || typeof item !== 'object') {
+        return;
+      }
+      const itemType = Reflect.get(item, 'type');
+      if (itemType !== 'function_call') {
+        return;
+      }
+      const callId = Reflect.get(item, 'call_id');
+      const name = Reflect.get(item, 'name');
+      const rawArguments = Reflect.get(item, 'arguments');
+      const current = toolCallAccumulator[toolCallKey] || {
+        arguments: '',
+        name: ''
+      };
+      toolCallAccumulator = {
+        ...toolCallAccumulator,
+        [toolCallKey]: {
+          arguments: typeof rawArguments === 'string' ? rawArguments : current.arguments,
+          ...(typeof callId === 'string' ? {
+            id: callId
+          } : current.id ? {
+            id: current.id
+          } : {}),
+          name: typeof name === 'string' && name ? name : current.name
+        }
       };
       await emitToolCallAccumulator();
       return;
     }
     if (eventType === 'response.function_call_arguments.delta' || eventType === 'response.function_call_arguments.done') {
-      const outputIndex = Reflect.get(parsed, 'output_index');
-      if (typeof outputIndex !== 'number') {
+      const toolCallKey = getStreamingToolCallKey(parsed);
+      if (!toolCallKey) {
         return;
       }
-      const current = toolCallAccumulator[outputIndex] || {
+      const current = toolCallAccumulator[toolCallKey] || {
         arguments: '',
         name: ''
       };
@@ -3416,7 +3693,7 @@ const parseOpenApiStream = async (response, onTextChunk, onToolCallsChunk, onDat
       };
       toolCallAccumulator = {
         ...toolCallAccumulator,
-        [outputIndex]: next
+        [toolCallKey]: next
       };
       await emitToolCallAccumulator();
       return;
@@ -3476,7 +3753,6 @@ const parseOpenApiStream = async (response, onTextChunk, onToolCallsChunk, onDat
       }
       for (const line of dataLines) {
         if (line === '[DONE]') {
-          await notifyFinished();
           done = true;
           break;
         }
@@ -3494,7 +3770,6 @@ const parseOpenApiStream = async (response, onTextChunk, onToolCallsChunk, onDat
     const dataLines = parseSseEvent(remainder);
     for (const line of dataLines) {
       if (line === '[DONE]') {
-        await notifyFinished();
         continue;
       }
       let parsed;
@@ -3506,8 +3781,12 @@ const parseOpenApiStream = async (response, onTextChunk, onToolCallsChunk, onDat
       await handleParsedStreamEvent(parsed);
     }
   }
-  await notifyFinished();
+  const responseFunctionCalls = completedResponseFunctionCalls.length > 0 ? completedResponseFunctionCalls : getResponseFunctionCallsFromStreamingAccumulator(toolCallAccumulator);
   return {
+    ...(responseId ? {
+      responseId
+    } : {}),
+    responseFunctionCalls,
     text,
     type: 'success'
   };
@@ -3548,7 +3827,8 @@ const getOpenApiAssistantText = async (messages, modelId, openApiApiKey, openApi
     onEventStreamFinished,
     onTextChunk,
     onToolCallsChunk,
-    stream
+    stream,
+    webSearchEnabled = false
   } = options ?? {
     stream: false
   };
@@ -3563,7 +3843,7 @@ const getOpenApiAssistantText = async (messages, modelId, openApiApiKey, openApi
     let response;
     try {
       response = await fetch(getOpenApiApiEndpoint(openApiApiBaseUrl), {
-        body: JSON.stringify(getOpenAiParams(openAiInput, modelId, stream, includeObfuscation, tools, previousResponseId)),
+        body: JSON.stringify(getOpenAiParams(openAiInput, modelId, stream, includeObfuscation, tools, webSearchEnabled, previousResponseId)),
         headers: {
           Authorization: `Bearer ${openApiApiKey}`,
           'Content-Type': 'application/json',
@@ -3599,7 +3879,51 @@ const getOpenApiAssistantText = async (messages, modelId, openApiApiKey, openApi
       };
     }
     if (stream) {
-      return parseOpenApiStream(response, onTextChunk, onToolCallsChunk, onDataEvent, onEventStreamFinished);
+      const streamResult = await parseOpenApiStream(response, onTextChunk, onToolCallsChunk, onDataEvent);
+      if (streamResult.type !== 'success') {
+        return streamResult;
+      }
+      if (streamResult.responseId) {
+        previousResponseId = streamResult.responseId;
+      }
+      if (streamResult.responseFunctionCalls.length > 0) {
+        openAiInput.length = 0;
+        const executedToolCalls = [];
+        for (const toolCall of streamResult.responseFunctionCalls) {
+          const content = await executeChatTool(toolCall.name, toolCall.arguments, {
+            assetDir,
+            platform
+          });
+          const executionStatus = getToolCallExecutionStatus(content);
+          executedToolCalls.push({
+            arguments: toolCall.arguments,
+            ...(executionStatus.errorMessage ? {
+              errorMessage: executionStatus.errorMessage
+            } : {}),
+            id: toolCall.callId,
+            name: toolCall.name,
+            ...(executionStatus.status ? {
+              status: executionStatus.status
+            } : {})
+          });
+          openAiInput.push({
+            call_id: toolCall.callId,
+            output: content,
+            type: 'function_call_output'
+          });
+        }
+        if (onToolCallsChunk && executedToolCalls.length > 0) {
+          await onToolCallsChunk(executedToolCalls);
+        }
+        continue;
+      }
+      if (onEventStreamFinished) {
+        await onEventStreamFinished();
+      }
+      return {
+        text: streamResult.text,
+        type: 'success'
+      };
     }
     let parsed;
     try {
@@ -3623,17 +3947,33 @@ const getOpenApiAssistantText = async (messages, modelId, openApiApiKey, openApi
     const responseFunctionCalls = getResponseFunctionCalls(parsed);
     if (responseFunctionCalls.length > 0) {
       openAiInput.length = 0;
+      const executedToolCalls = [];
       for (const toolCall of responseFunctionCalls) {
         const content = await executeChatTool(toolCall.name, toolCall.arguments, {
           assetDir,
           platform
         });
+        const executionStatus = getToolCallExecutionStatus(content);
+        executedToolCalls.push({
+          arguments: toolCall.arguments,
+          ...(executionStatus.errorMessage ? {
+            errorMessage: executionStatus.errorMessage
+          } : {}),
+          id: toolCall.callId,
+          name: toolCall.name,
+          ...(executionStatus.status ? {
+            status: executionStatus.status
+          } : {})
+        });
         openAiInput.push({
           call_id: toolCall.callId,
           output: content,
           type: 'function_call_output'
         });
       }
+      if (onToolCallsChunk && executedToolCalls.length > 0) {
+        await onToolCallsChunk(executedToolCalls);
+      }
       continue;
     }
     const outputText = getResponseOutputText(parsed);
@@ -3662,6 +4002,7 @@ const getOpenApiAssistantText = async (messages, modelId, openApiApiKey, openApi
       const toolCalls = Reflect.get(message, 'tool_calls');
       if (Array.isArray(toolCalls) && toolCalls.length > 0) {
         openAiInput.length = 0;
+        const executedToolCalls = [];
         for (const toolCall of toolCalls) {
           if (!toolCall || typeof toolCall !== 'object') {
             continue;
@@ -3677,12 +4018,29 @@ const getOpenApiAssistantText = async (messages, modelId, openApiApiKey, openApi
             assetDir,
             platform
           }) : '{}';
+          if (typeof name === 'string') {
+            const executionStatus = getToolCallExecutionStatus(content);
+            executedToolCalls.push({
+              arguments: typeof rawArguments === 'string' ? rawArguments : '',
+              ...(executionStatus.errorMessage ? {
+                errorMessage: executionStatus.errorMessage
+              } : {}),
+              id,
+              name,
+              ...(executionStatus.status ? {
+                status: executionStatus.status
+              } : {})
+            });
+          }
           openAiInput.push({
             call_id: id,
             output: content,
             type: 'function_call_output'
           });
         }
+        if (onToolCallsChunk && executedToolCalls.length > 0) {
+          await onToolCallsChunk(executedToolCalls);
+        }
         continue;
       }
       const content = Reflect.get(message, 'content');
@@ -3709,6 +4067,12 @@ const getOpenApiErrorMessage = errorResult => {
         const errorMessage = errorResult.errorMessage?.trim();
         const hasErrorCode = typeof errorResult.errorCode === 'string' && errorResult.errorCode.length > 0;
         const hasErrorType = typeof errorResult.errorType === 'string' && errorResult.errorType.length > 0;
+
+        // 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.`;
+        }
         if (errorResult.statusCode === 429) {
           let prefix = 'OpenAI rate limit exceeded (429)';
           if (hasErrorCode) {
@@ -4072,14 +4436,15 @@ const getAiResponse = async ({
   selectedModelId,
   streamingEnabled = false,
   useMockApi,
-  userText
+  userText,
+  webSearchEnabled = false
 }) => {
   let text = '';
   const usesOpenApiModel = isOpenApiModel(selectedModelId, models);
   const usesOpenRouterModel = isOpenRouterModel(selectedModelId, models);
   if (usesOpenApiModel) {
     if (useMockApi) {
-      const result = await getMockOpenApiAssistantText(streamingEnabled, onTextChunk);
+      const result = await getMockOpenApiAssistantText(streamingEnabled, onTextChunk, onToolCallsChunk, onDataEvent, onEventStreamFinished);
       if (result.type === 'success') {
         const {
           text: assistantText
@@ -4103,7 +4468,8 @@ const getAiResponse = async ({
         ...(onToolCallsChunk ? {
           onToolCallsChunk
         } : {}),
-        stream: streamingEnabled
+        stream: streamingEnabled,
+        webSearchEnabled
       });
       if (result.type === 'success') {
         const {
@@ -4430,10 +4796,53 @@ const appendMessageToSelectedSession = (sessions, selectedSessionId, message) =>
     };
   });
 };
+const hasLegacyStreamingToolCalls = parsed => {
+  if (!parsed || typeof parsed !== 'object') {
+    return false;
+  }
+  const choices = Reflect.get(parsed, 'choices');
+  if (!Array.isArray(choices) || choices.length === 0) {
+    return false;
+  }
+  const firstChoice = choices[0];
+  if (!firstChoice || typeof firstChoice !== 'object') {
+    return false;
+  }
+  const delta = Reflect.get(firstChoice, 'delta');
+  if (!delta || typeof delta !== 'object') {
+    return false;
+  }
+  const toolCalls = Reflect.get(delta, 'tool_calls');
+  return Array.isArray(toolCalls) && toolCalls.length > 0;
+};
+const isStreamingFunctionCallEvent = parsed => {
+  if (hasLegacyStreamingToolCalls(parsed)) {
+    return true;
+  }
+  if (!parsed || typeof parsed !== 'object') {
+    return false;
+  }
+  const type = Reflect.get(parsed, 'type');
+  if (type === 'response.function_call_arguments.delta' || type === 'response.function_call_arguments.done') {
+    return true;
+  }
+  if (type !== 'response.output_item.added' && type !== 'response.output_item.done') {
+    return false;
+  }
+  const item = Reflect.get(parsed, 'item');
+  if (!item || typeof item !== 'object') {
+    return false;
+  }
+  return Reflect.get(item, 'type') === 'function_call';
+};
+const getSseEventType = value => {
+  return value && typeof value === 'object' && Reflect.get(value, 'type') === 'response.completed' ? 'sse-response-completed' : 'sse-response-part';
+};
 const handleSubmit = async state => {
   const {
     assetDir,
     composerValue,
+    emitStreamingFunctionCallEvents,
     mockAiResponseDelay,
     mockApiCommandId,
     models,
@@ -4449,7 +4858,8 @@ const handleSubmit = async state => {
     sessions,
     streamingEnabled,
     useMockApi,
-    viewMode
+    viewMode,
+    webSearchEnabled
   } = state;
   const userText = composerValue.trim();
   if (!userText) {
@@ -4559,10 +4969,14 @@ const handleSubmit = async state => {
     mockApiCommandId,
     models,
     onDataEvent: async value => {
+      if (!emitStreamingFunctionCallEvents && isStreamingFunctionCallEvent(value)) {
+        return;
+      }
+      const sseEventType = getSseEventType(value);
       await appendChatViewEvent({
         sessionId: optimisticState.selectedSessionId,
         timestamp: new Date().toISOString(),
-        type: 'sse-response-part',
+        type: sseEventType,
         value
       });
     },
@@ -4589,7 +5003,8 @@ const handleSubmit = async state => {
     selectedModelId,
     streamingEnabled,
     useMockApi,
-    userText
+    userText,
+    webSearchEnabled
   });
   const {
     latestState
@@ -4770,6 +5185,13 @@ const handleClickNew = async state => {
   return createSession(state);
 };
 
+const handleClickReadFile = async uri => {
+  if (!uri) {
+    return;
+  }
+  await invoke('Main.openUri', uri);
+};
+
 const handleClickSessionDebug = async state => {
   await invoke('Main.openUri', `chat-debug://${state.selectedSessionId}`);
   return state;
@@ -4903,6 +5325,11 @@ const handleKeyDown = async (state, key, shiftKey) => {
   return handleSubmit(submitState);
 };
 
+const handleMessagesContextMenu = async state => {
+  await invoke('ContextMenu.show', 1234);
+  return state;
+};
+
 const handleModelChange = async (state, value) => {
   return {
     ...state,
@@ -5040,6 +5467,15 @@ const getSavedViewMode = savedState => {
   return viewMode;
 };
 
+const loadEmitStreamingFunctionCallEvents = async () => {
+  try {
+    const savedEmitStreamingFunctionCallEvents = await get('chatView.emitStreamingFunctionCallEvents');
+    return typeof savedEmitStreamingFunctionCallEvents === 'boolean' ? savedEmitStreamingFunctionCallEvents : false;
+  } catch {
+    return false;
+  }
+};
+
 const loadOpenApiApiKey = async () => {
   try {
     const savedOpenApiKey = await get('secrets.openApiKey');
@@ -5087,9 +5523,11 @@ const loadStreamingEnabled = async () => {
 const loadPreferences = async () => {
   const openApiApiKey = await loadOpenApiApiKey();
   const openRouterApiKey = await loadOpenRouterApiKey();
+  const emitStreamingFunctionCallEvents = await loadEmitStreamingFunctionCallEvents();
   const streamingEnabled = await loadStreamingEnabled();
   const passIncludeObfuscation = await loadPassIncludeObfuscation();
   return {
+    emitStreamingFunctionCallEvents,
     openApiApiKey,
     openRouterApiKey,
     passIncludeObfuscation,
@@ -5124,6 +5562,7 @@ const loadContent = async (state, savedState) => {
   const savedSelectedModelId = getSavedSelectedModelId(savedState);
   const savedViewMode = getSavedViewMode(savedState);
   const {
+    emitStreamingFunctionCallEvents,
     openApiApiKey,
     openRouterApiKey,
     passIncludeObfuscation,
@@ -5156,6 +5595,7 @@ const loadContent = async (state, savedState) => {
   return {
     ...state,
     chatListScrollTop,
+    emitStreamingFunctionCallEvents,
     initial: false,
     messagesScrollTop,
     openApiApiKey,
@@ -5232,6 +5672,34 @@ const getCss = (composerHeight, listItemHeight, chatMessageFontSize, chatMessage
   --ChatMessageFontSize: ${chatMessageFontSize}px;
   --ChatMessageLineHeight: ${chatMessageLineHeight}px;
   --ChatMessageFontFamily: ${chatMessageFontFamily};
+}
+
+.ChatToolCalls {
+  position: relative;
+  border: 1px solid var(--vscode-editorWidget-border);
+  border-radius: 4px;
+  margin-bottom: 8px;
+  padding: 10px 8px 6px;
+  background: var(--vscode-editorWidget-background);
+}
+
+.ChatToolCallsLabel {
+  position: absolute;
+  top: -8px;
+  left: 8px;
+  padding: 0 4px;
+  border-radius: 3px;
+  background: var(--vscode-editor-background);
+  color: var(--vscode-descriptionForeground);
+  font-size: 10px;
+  line-height: 14px;
+  text-transform: lowercase;
+  letter-spacing: 0.02em;
+}
+
+.ChatToolCallReadFileLink {
+  color: var(--vscode-textLink-foreground);
+  text-decoration: underline;
 }`;
 };
 
@@ -5287,6 +5755,7 @@ const ChatHeader = 'ChatHeader';
 const Button = 'Button';
 const ButtonPrimary = 'ButtonPrimary';
 const ButtonSecondary = 'ButtonSecondary';
+const FileIcon = 'FileIcon';
 const IconButton = 'IconButton';
 const InputBox = 'InputBox';
 const Label = 'Label';
@@ -5298,6 +5767,9 @@ const ChatListItemLabel = 'ChatListItemLabel';
 const Markdown = 'Markdown';
 const Message = 'Message';
 const ChatMessageContent = 'ChatMessageContent';
+const ChatToolCalls = 'ChatToolCalls';
+const ChatToolCallsLabel = 'ChatToolCallsLabel';
+const ChatToolCallReadFileLink = 'ChatToolCallReadFileLink';
 const ChatOrderedList = 'ChatOrderedList';
 const ChatOrderedListItem = 'ChatOrderedListItem';
 const MessageUser = 'MessageUser';
@@ -5327,6 +5799,8 @@ const HandleModelChange = 20;
 const HandleChatListScroll = 21;
 const HandleMessagesScroll = 22;
 const HandleClickSessionDebug = 23;
+const HandleClickReadFile = 24;
+const HandleMessagesContextMenu = 25;
 
 const getModelLabel = model => {
   if (model.provider === 'openRouter') {
@@ -5520,6 +5994,31 @@ const getChatHeaderDomDetailMode = selectedSessionTitle => {
   }, text(selectedSessionTitle), ...getChatHeaderActionsDom()];
 };
 
+const getMessageNodeDom = node => {
+  if (node.type === 'text') {
+    return [{
+      childCount: 1,
+      className: Markdown,
+      type: P
+    }, text(node.text)];
+  }
+  return [{
+    childCount: node.items.length,
+    className: ChatOrderedList,
+    type: Ol
+  }, ...node.items.flatMap(item => {
+    return [{
+      childCount: 1,
+      className: ChatOrderedListItem,
+      type: Li
+    }, text(item.text)];
+  })];
+};
+
+const getMessageContentDom = nodes => {
+  return nodes.flatMap(getMessageNodeDom);
+};
+
 const getMissingApiKeyDom = ({
   getApiKeyText,
   inputName,
@@ -5641,6 +6140,130 @@ const getToolCallArgumentPreview = rawArguments => {
   return rawArguments;
 };
 
+const RE_QUERY_OR_HASH = /[?#].*$/;
+const RE_TRAILING_SLASH = /\/$/;
+const getFileNameFromUri = uri => {
+  const stripped = uri.replace(RE_QUERY_OR_HASH, '').replace(RE_TRAILING_SLASH, '');
+  const slashIndex = Math.max(stripped.lastIndexOf('/'), stripped.lastIndexOf('\\\\'));
+  const fileName = slashIndex === -1 ? stripped : stripped.slice(slashIndex + 1);
+  return fileName || uri;
+};
+
+const getReadFileTarget = rawArguments => {
+  let parsed;
+  try {
+    parsed = JSON.parse(rawArguments);
+  } catch {
+    return undefined;
+  }
+  if (!parsed || typeof parsed !== 'object') {
+    return undefined;
+  }
+  const uri = Reflect.get(parsed, 'uri');
+  const path = Reflect.get(parsed, 'path');
+  const uriValue = typeof uri === 'string' ? uri : '';
+  const pathValue = typeof path === 'string' ? path : '';
+  const title = uriValue || pathValue;
+  if (!title) {
+    return undefined;
+  }
+  // `read_file` tool calls usually provide a relative `path`; pass it through so UI clicks can open the file.
+  const clickableUri = uriValue || pathValue;
+  return {
+    clickableUri,
+    title
+  };
+};
+
+const getToolCallStatusLabel$1 = toolCall => {
+  if (toolCall.status === 'not-found') {
+    return ' (not-found)';
+  }
+  if (toolCall.status === 'error') {
+    if (toolCall.errorMessage) {
+      return ` (error: ${toolCall.errorMessage})`;
+    }
+    return ' (error)';
+  }
+  return '';
+};
+
+const getToolCallReadFileVirtualDom = toolCall => {
+  const target = getReadFileTarget(toolCall.arguments);
+  if (!target) {
+    return [];
+  }
+  const fileName = getFileNameFromUri(target.title);
+  const toolNameLabel = `${toolCall.name} `;
+  const statusLabel = getToolCallStatusLabel$1(toolCall);
+  const fileNameClickableProps = target.clickableUri ? {
+    'data-uri': target.clickableUri,
+    onClick: HandleClickReadFile
+  } : {};
+  return [{
+    childCount: statusLabel ? 4 : 3,
+    className: ChatOrderedListItem,
+    title: target.title,
+    type: Li
+  }, {
+    childCount: 0,
+    className: FileIcon,
+    type: Div
+  }, text(toolNameLabel), {
+    childCount: 1,
+    className: ChatToolCallReadFileLink,
+    ...fileNameClickableProps,
+    type: Span
+  }, text(fileName), ...(statusLabel ? [text(statusLabel)] : [])];
+};
+
+const getToolCallStatusLabel = toolCall => {
+  if (toolCall.status === 'not-found') {
+    return ' (not-found)';
+  }
+  if (toolCall.status === 'error') {
+    if (toolCall.errorMessage) {
+      return ` (error: ${toolCall.errorMessage})`;
+    }
+    return ' (error)';
+  }
+  return '';
+};
+const getToolCallDom = toolCall => {
+  if (toolCall.name === 'read_file') {
+    const virtualDom = getToolCallReadFileVirtualDom(toolCall);
+    if (virtualDom.length > 0) {
+      return virtualDom;
+    }
+  }
+  const argumentPreview = getToolCallArgumentPreview(toolCall.arguments);
+  const label = `${toolCall.name} ${argumentPreview}${getToolCallStatusLabel(toolCall)}`;
+  return [{
+    childCount: 1,
+    className: ChatOrderedListItem,
+    type: Li
+  }, text(label)];
+};
+
+const getToolCallsDom = message => {
+  if (message.role !== 'assistant' || !message.toolCalls || message.toolCalls.length === 0) {
+    return [];
+  }
+  return [{
+    childCount: 2,
+    className: ChatToolCalls,
+    type: Div$1
+  }, {
+    childCount: 1,
+    className: ChatToolCallsLabel,
+    type: Div$1
+  }, text('tools'), {
+    childCount: message.toolCalls.length,
+    className: ChatOrderedList,
+    type: Ol$1
+  }, ...message.toolCalls.flatMap(getToolCallDom)];
+};
+
 const orderedListItemRegex = /^\s*\d+\.\s+(.*)$/;
 const parseMessageContent = rawMessage => {
   if (rawMessage === '') {
@@ -5698,43 +6321,7 @@ const parseMessageContent = rawMessage => {
     type: 'text'
   }] : nodes;
 };
-const getMessageContentDom = nodes => {
-  return nodes.flatMap(node => {
-    if (node.type === 'text') {
-      return [{
-        childCount: 1,
-        className: Markdown,
-        type: P
-      }, text(node.text)];
-    }
-    return [{
-      childCount: node.items.length,
-      className: ChatOrderedList,
-      type: Ol
-    }, ...node.items.flatMap(item => {
-      return [{
-        childCount: 1,
-        className: ChatOrderedListItem,
-        type: Li
-      }, text(item.text)];
-    })];
-  });
-};
 
-const getToolCallsDom = message => {
-  if (message.role !== 'assistant' || !message.toolCalls || message.toolCalls.length === 0) {
-    return [];
-  }
-  return message.toolCalls.flatMap(toolCall => {
-    const argumentPreview = getToolCallArgumentPreview(toolCall.arguments);
-    const label = `${toolCall.name} ${argumentPreview}`;
-    return [{
-      childCount: 1,
-      className: Markdown,
-      type: P
-    }, text(label)];
-  });
-};
 const getChatMessageDom = (message, openRouterApiKeyInput, openApiApiKeyInput = '', openRouterApiKeyState = 'idle') => {
   const roleClassName = message.role === 'user' ? MessageUser : MessageAssistant;
   const isOpenApiApiKeyMissingMessage = message.role === 'assistant' && message.text === openApiApiKeyRequiredMessage;
@@ -5744,7 +6331,8 @@ const getChatMessageDom = (message, openRouterApiKeyInput, openApiApiKeyInput =
   const messageIntermediate = parseMessageContent(message.text);
   const messageDom = getMessageContentDom(messageIntermediate);
   const toolCallsDom = getToolCallsDom(message);
-  const extraChildCount = isOpenApiApiKeyMissingMessage || isOpenRouterApiKeyMissingMessage || isOpenRouterRequestFailedMessage || isOpenRouterTooManyRequestsMessage ? messageIntermediate.length + 1 + toolCallsDom.length : messageIntermediate.length + toolCallsDom.length;
+  const toolCallsChildCount = toolCallsDom.length > 0 ? 1 : 0;
+  const extraChildCount = isOpenApiApiKeyMissingMessage || isOpenRouterApiKeyMissingMessage || isOpenRouterRequestFailedMessage || isOpenRouterTooManyRequestsMessage ? messageIntermediate.length + 1 + toolCallsChildCount : messageIntermediate.length + toolCallsChildCount;
   return [{
     childCount: 1,
     className: mergeClassNames(Message, roleClassName),
@@ -5753,7 +6341,7 @@ const getChatMessageDom = (message, openRouterApiKeyInput, openApiApiKeyInput =
     childCount: extraChildCount,
     className: ChatMessageContent,
     type: Div
-  }, ...messageDom, ...toolCallsDom, ...(isOpenApiApiKeyMissingMessage ? getMissingOpenApiApiKeyDom(openApiApiKeyInput) : []), ...(isOpenRouterApiKeyMissingMessage ? getMissingOpenRouterApiKeyDom(openRouterApiKeyInput, openRouterApiKeyState) : []), ...(isOpenRouterRequestFailedMessage ? getOpenRouterRequestFailedDom() : []), ...(isOpenRouterTooManyRequestsMessage ? getOpenRouterTooManyRequestsDom() : [])];
+  }, ...toolCallsDom, ...messageDom, ...(isOpenApiApiKeyMissingMessage ? getMissingOpenApiApiKeyDom(openApiApiKeyInput) : []), ...(isOpenRouterApiKeyMissingMessage ? getMissingOpenRouterApiKeyDom(openRouterApiKeyInput, openRouterApiKeyState) : []), ...(isOpenRouterRequestFailedMessage ? getOpenRouterRequestFailedDom() : []), ...(isOpenRouterTooManyRequestsMessage ? getOpenRouterTooManyRequestsDom() : [])];
 };
 
 const getEmptyMessagesDom = () => {
@@ -5771,6 +6359,7 @@ const getMessagesDom = (messages, openRouterApiKeyInput, openApiApiKeyInput = ''
   return [{
     childCount: messages.length,
     className: 'ChatMessages',
+    onContextMenu: HandleMessagesContextMenu,
     onScroll: HandleMessagesScroll,
     scrollTop: messagesScrollTop,
     type: Div
@@ -5985,6 +6574,9 @@ const renderEventListeners = () => {
   }, {
     name: HandleClick,
     params: ['handleClick', TargetName, 'event.target.dataset.id']
+  }, {
+    name: HandleClickReadFile,
+    params: ['handleClickReadFile', 'event.target.dataset.uri']
   }, {
     name: HandleClickDelete,
     params: ['handleClickDelete', 'event.target.dataset.id']
@@ -6018,6 +6610,10 @@ const renderEventListeners = () => {
   }, {
     name: HandleMessagesScroll,
     params: ['handleMessagesScroll', 'event.target.scrollTop']
+  }, {
+    name: HandleMessagesContextMenu,
+    params: ['handleMessagesContextMenu'],
+    preventDefault: true
   }, {
     name: HandleFocus,
     params: ['handleInputFocus', TargetName]
@@ -6061,30 +6657,22 @@ const saveState = state => {
   const {
     chatListScrollTop,
     composerValue,
-    height,
     messagesScrollTop,
     nextMessageId,
     renamingSessionId,
     selectedModelId,
     selectedSessionId,
-    viewMode,
-    width,
-    x,
-    y
+    viewMode
   } = state;
   return {
     chatListScrollTop,
     composerValue,
-    height,
     messagesScrollTop,
     nextMessageId,
     renamingSessionId,
     selectedModelId,
     selectedSessionId,
-    viewMode,
-    width,
-    x,
-    y
+    viewMode
   };
 };
 
@@ -6110,6 +6698,13 @@ const setChatList = state => {
   };
 };
 
+const setEmitStreamingFunctionCallEvents = (state, emitStreamingFunctionCallEvents) => {
+  return {
+    ...state,
+    emitStreamingFunctionCallEvents
+  };
+};
+
 const setStreamingEnabled = (state, streamingEnabled) => {
   return {
     ...state,
@@ -6148,11 +6743,13 @@ const commandMap = {
   'Chat.handleClickDelete': wrapCommand(handleClickDelete),
   'Chat.handleClickList': wrapCommand(handleClickList),
   'Chat.handleClickNew': wrapCommand(handleClickNew),
+  'Chat.handleClickReadFile': handleClickReadFile,
   'Chat.handleClickSessionDebug': wrapCommand(handleClickSessionDebug),
   'Chat.handleClickSettings': handleClickSettings,
   'Chat.handleInput': wrapCommand(handleInput),
   'Chat.handleInputFocus': wrapCommand(handleInputFocus),
   'Chat.handleKeyDown': wrapCommand(handleKeyDown),
+  'Chat.handleMessagesContextMenu': wrapCommand(handleMessagesContextMenu),
   'Chat.handleMessagesScroll': wrapCommand(handleMessagesScroll),
   'Chat.handleModelChange': wrapCommand(handleModelChange),
   'Chat.handleSubmit': wrapCommand(handleSubmit),
@@ -6171,6 +6768,7 @@ const commandMap = {
   'Chat.resize': wrapCommand(resize),
   'Chat.saveState': wrapGetter(saveState),
   'Chat.setChatList': wrapCommand(setChatList),
+  'Chat.setEmitStreamingFunctionCallEvents': wrapCommand(setEmitStreamingFunctionCallEvents),
   'Chat.setOpenRouterApiKey': wrapCommand(setOpenRouterApiKey),
   'Chat.setStreamingEnabled': wrapCommand(setStreamingEnabled),
   'Chat.terminate': terminate,