@lvce-editor/chat-view 3.6.0 → 3.8.0

package/dist/chatViewWorkerMain.js

@@ -1075,6 +1075,7 @@ const create$2 = rpcId => {
 };
 
 const {
+  invoke: invoke$2,
   set: set$3
 } = create$2(6002);
 
@@ -1525,6 +1526,7 @@ const createDefaultState = () => {
     tokensUsed: 0,
     uid: 0,
     usageOverviewEnabled: false,
+    useChatNetworkWorkerForRequests: false,
     useMockApi: false,
     viewMode: 'list',
     warningCount: 0,
@@ -2790,393 +2792,6 @@ const openRouterTooManyRequestsMessage = 'OpenRouter rate limit reached (429). P
 const openRouterRequestFailureReasons = ['ContentSecurityPolicyViolation: Check DevTools for details.', 'OpenRouter server offline: Check DevTools for details.', 'Check your internet connection.'];
 const openRouterTooManyRequestsReasons = ['Wait a short time and retry your request.', 'Reduce request frequency to avoid rate limits.', 'Use a different model if this one is saturated.'];
 
-const delay = async ms => {
-  await new Promise(resolve => setTimeout(resolve, ms));
-};
-
-const getMockAiResponse = async (userMessage, delayInMs) => {
-  await delay(delayInMs);
-  return `Mock AI response: I received "${userMessage}".`;
-};
-
-let queue = [];
-let waiters = [];
-let finished = false;
-let errorResult;
-const reset$1 = () => {
-  queue = [];
-  waiters = [];
-  finished = false;
-  errorResult = undefined;
-};
-const setHttpErrorResponse = (statusCode, body) => {
-  const rawError = body && typeof body === 'object' ? Reflect.get(body, 'error') : undefined;
-  const errorCode = rawError && typeof rawError === 'object' ? Reflect.get(rawError, 'code') : undefined;
-  const errorMessage = rawError && typeof rawError === 'object' ? Reflect.get(rawError, 'message') : undefined;
-  const errorType = rawError && typeof rawError === 'object' ? Reflect.get(rawError, 'type') : undefined;
-  errorResult = {
-    details: 'http-error',
-    ...(typeof errorCode === 'string' ? {
-      errorCode
-    } : {}),
-    ...(typeof errorMessage === 'string' ? {
-      errorMessage
-    } : {}),
-    ...(typeof errorType === 'string' ? {
-      errorType
-    } : {}),
-    statusCode,
-    type: 'error'
-  };
-};
-const takeErrorResponse = () => {
-  const error = errorResult;
-  errorResult = undefined;
-  return error;
-};
-const pushChunk = chunk => {
-  if (waiters.length > 0) {
-    const resolve = waiters.shift();
-    resolve?.(chunk);
-    return;
-  }
-  queue.push(chunk);
-};
-const finish = () => {
-  finished = true;
-  if (waiters.length === 0) {
-    return;
-  }
-  const activeWaiters = waiters;
-  waiters = [];
-  for (const resolve of activeWaiters) {
-    resolve(undefined);
-  }
-};
-const readNextChunk = async () => {
-  if (queue.length > 0) {
-    return queue.shift();
-  }
-  if (finished) {
-    return undefined;
-  }
-  const {
-    promise,
-    resolve
-  } = Promise.withResolvers();
-  waiters.push(resolve);
-  return promise;
-};
-
-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'
-  };
-};
-
-const activateByEvent = (event, assetDir, platform) => {
-  // @ts-ignore
-  return activateByEvent$1(event, assetDir, platform);
-};
-
-const executeProvider = async ({
-  assetDir,
-  event,
-  method,
-  noProviderFoundMessage,
-  params,
-  platform
-}) => {
-  await activateByEvent(event, assetDir, platform);
-  // @ts-ignore
-  const result = invoke$1(method, ...params);
-  return result;
-};
-
-const CommandExecute = 'ExtensionHostCommand.executeCommand';
-const FileSystemWriteFile = 'ExtensionHostFileSystem.writeFile';
-
-const normalizeLimitInfo = value => {
-  if (!value || typeof value !== 'object') {
-    return undefined;
-  }
-  const limitRemaining = Reflect.get(value, 'limitRemaining');
-  const limitReset = Reflect.get(value, 'limitReset');
-  const retryAfter = Reflect.get(value, 'retryAfter');
-  const usage = Reflect.get(value, 'usage');
-  const usageDaily = Reflect.get(value, 'usageDaily');
-  const normalized = {
-    ...(typeof limitRemaining === 'number' || limitRemaining === null ? {
-      limitRemaining
-    } : {}),
-    ...(typeof limitReset === 'string' || limitReset === null ? {
-      limitReset
-    } : {}),
-    ...(typeof retryAfter === 'string' || retryAfter === null ? {
-      retryAfter
-    } : {}),
-    ...(typeof usage === 'number' ? {
-      usage
-    } : {}),
-    ...(typeof usageDaily === 'number' ? {
-      usageDaily
-    } : {})
-  };
-  const hasDetails = typeof limitRemaining === 'number' || limitRemaining === null || typeof limitReset === 'string' || limitReset === null || typeof retryAfter === 'string' || retryAfter === null || typeof usage === 'number' || typeof usageDaily === 'number';
-  return hasDetails ? normalized : undefined;
-};
-
-const normalizeMockResult = value => {
-  if (typeof value === 'string') {
-    return {
-      text: value,
-      type: 'success'
-    };
-  }
-  if (!value || typeof value !== 'object') {
-    return {
-      details: 'request-failed',
-      type: 'error'
-    };
-  }
-  const type = Reflect.get(value, 'type');
-  if (type === 'success') {
-    const text = Reflect.get(value, 'text');
-    if (typeof text === 'string') {
-      return {
-        text,
-        type: 'success'
-      };
-    }
-    return {
-      details: 'request-failed',
-      type: 'error'
-    };
-  }
-  if (type === 'error') {
-    const details = Reflect.get(value, 'details');
-    if (details === 'request-failed' || details === 'too-many-requests' || details === 'http-error') {
-      const rawMessage = Reflect.get(value, 'rawMessage');
-      const statusCode = Reflect.get(value, 'statusCode');
-      const limitInfo = normalizeLimitInfo(Reflect.get(value, 'limitInfo'));
-      return {
-        details,
-        ...(limitInfo ? {
-          limitInfo
-        } : {}),
-        ...(typeof rawMessage === 'string' ? {
-          rawMessage
-        } : {}),
-        ...(typeof statusCode === 'number' ? {
-          statusCode
-        } : {}),
-        type: 'error'
-      };
-    }
-  }
-  const text = Reflect.get(value, 'text');
-  if (typeof text === 'string') {
-    return {
-      text,
-      type: 'success'
-    };
-  }
-  return {
-    details: 'request-failed',
-    type: 'error'
-  };
-};
-
-const getMockOpenRouterAssistantText = async (messages, modelId, openRouterApiBaseUrl, openRouterApiKey, mockApiCommandId, assetDir, platform) => {
-  if (!mockApiCommandId) {
-    return {
-      details: 'request-failed',
-      type: 'error'
-    };
-  }
-  try {
-    const result = await executeProvider({
-      assetDir,
-      event: `onCommand:${mockApiCommandId}`,
-      method: CommandExecute,
-      noProviderFoundMessage: 'No mock api command found',
-      params: [mockApiCommandId, {
-        messages,
-        modelId,
-        openRouterApiBaseUrl,
-        openRouterApiKey
-      }],
-      platform
-    });
-    return normalizeMockResult(result);
-  } catch {
-    return {
-      details: 'request-failed',
-      type: 'error'
-    };
-  }
-};
-
 const executeGetWorkspaceUriTool = async (_args, _options) => {
   try {
     const workspaceUri = await getWorkspacePath();
@@ -3307,6 +2922,25 @@ const executeRenderHtmlTool = async (args, _options) => {
   });
 };
 
+const activateByEvent = (event, assetDir, platform) => {
+  // @ts-ignore
+  return activateByEvent$1(event, assetDir, platform);
+};
+
+const executeProvider = async ({
+  assetDir,
+  event,
+  method,
+  noProviderFoundMessage,
+  params,
+  platform
+}) => {
+  await activateByEvent(event, assetDir, platform);
+  // @ts-ignore
+  const result = invoke$1(method, ...params);
+  return result;
+};
+
 const OnFileSystem = 'onFileSystem';
 
 const executeFileSystemCommand = async (method, params, options) => {
@@ -3320,6 +2954,9 @@ const executeFileSystemCommand = async (method, params, options) => {
   });
 };
 
+const CommandExecute = 'ExtensionHostCommand.executeCommand';
+const FileSystemWriteFile = 'ExtensionHostFileSystem.writeFile';
+
 const executeWriteFileTool = async (args, options) => {
   const filePath = typeof args.path === 'string' ? args.path : '';
   const content = typeof args.content === 'string' ? args.content : '';
@@ -3379,17 +3016,61 @@ const executeChatTool = async (name, rawArguments, options) => {
     error: `Unknown tool: ${name}`
   });
 };
-
-const getReadFileTool = () => {
+
+const getReadFileTool = () => {
+  return {
+    function: {
+      description: 'Read UTF-8 text content from a file inside the currently open workspace folder. Only pass an absolute URI.',
+      name: 'read_file',
+      parameters: {
+        additionalProperties: false,
+        properties: {
+          uri: {
+            description: 'Absolute file URI within the workspace (for example: file:///workspace/src/index.ts).',
+            type: 'string'
+          }
+        },
+        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',
+      parameters: {
+        additionalProperties: false,
+        properties: {
+          content: {
+            description: 'New UTF-8 text content to write to the file.',
+            type: 'string'
+          },
+          path: {
+            description: 'Relative file path within the workspace (for example: src/index.ts).',
+            type: 'string'
+          }
+        },
+        required: ['path', 'content'],
+        type: 'object'
+      }
+    },
+    type: 'function'
+  };
+};
+const getListFilesTool = () => {
   return {
     function: {
-      description: 'Read UTF-8 text content from a file inside the currently open workspace folder. Only pass an absolute URI.',
-      name: 'read_file',
+      description: '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: {
           uri: {
-            description: 'Absolute file URI within the workspace (for example: file:///workspace/src/index.ts).',
+            description: 'Absolute folder URI within the workspace (for example: file:///workspace/src).',
             type: 'string'
           }
         },
@@ -3400,106 +3081,434 @@ const getReadFileTool = () => {
     type: 'function'
   };
 };
-const getWriteFileTool = () => {
+const getGetWorkspaceUriTool = () => {
   return {
     function: {
-      description: 'Write UTF-8 text content to a file inside the currently open workspace folder.',
-      name: 'write_file',
+      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: {
-          content: {
-            description: 'New UTF-8 text content to write to the file.',
+          css: {
+            description: 'Optional CSS string applied inside the preview document.',
             type: 'string'
           },
-          path: {
-            description: 'Relative file path within the workspace (for example: src/index.ts).',
+          html: {
+            description: 'HTML string to render in the preview document.',
+            type: 'string'
+          },
+          title: {
+            description: 'Optional short title for the preview.',
             type: 'string'
           }
         },
-        required: ['path', 'content'],
+        required: ['html'],
         type: 'object'
       }
     },
     type: 'function'
   };
-};
-const getListFilesTool = () => {
-  return {
-    function: {
-      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: {
-          uri: {
-            description: 'Absolute folder URI within the workspace (for example: file:///workspace/src).',
-            type: 'string'
-          }
-        },
-        required: ['uri'],
-        type: 'object'
+};
+const getBasicChatTools = () => {
+  return [getReadFileTool(), getWriteFileTool(), getListFilesTool(), getGetWorkspaceUriTool(), getRenderHtmlTool()];
+};
+
+const getClientRequestIdHeader = () => {
+  return {
+    'x-client-request-id': crypto.randomUUID()
+  };
+};
+
+const delay = async ms => {
+  await new Promise(resolve => setTimeout(resolve, ms));
+};
+
+const getMockAiResponse = async (userMessage, delayInMs) => {
+  await delay(delayInMs);
+  return `Mock AI response: I received "${userMessage}".`;
+};
+
+let queue = [];
+let waiters = [];
+let finished = false;
+let errorResult;
+const reset$2 = () => {
+  queue = [];
+  waiters = [];
+  finished = false;
+  errorResult = undefined;
+};
+const setHttpErrorResponse = (statusCode, body) => {
+  const rawError = body && typeof body === 'object' ? Reflect.get(body, 'error') : undefined;
+  const errorCode = rawError && typeof rawError === 'object' ? Reflect.get(rawError, 'code') : undefined;
+  const errorMessage = rawError && typeof rawError === 'object' ? Reflect.get(rawError, 'message') : undefined;
+  const errorType = rawError && typeof rawError === 'object' ? Reflect.get(rawError, 'type') : undefined;
+  errorResult = {
+    details: 'http-error',
+    ...(typeof errorCode === 'string' ? {
+      errorCode
+    } : {}),
+    ...(typeof errorMessage === 'string' ? {
+      errorMessage
+    } : {}),
+    ...(typeof errorType === 'string' ? {
+      errorType
+    } : {}),
+    statusCode,
+    type: 'error'
+  };
+};
+const takeErrorResponse = () => {
+  const error = errorResult;
+  errorResult = undefined;
+  return error;
+};
+const pushChunk = chunk => {
+  if (waiters.length > 0) {
+    const resolve = waiters.shift();
+    resolve?.(chunk);
+    return;
+  }
+  queue.push(chunk);
+};
+const finish = () => {
+  finished = true;
+  if (waiters.length === 0) {
+    return;
+  }
+  const activeWaiters = waiters;
+  waiters = [];
+  for (const resolve of activeWaiters) {
+    resolve(undefined);
+  }
+};
+const readNextChunk = async () => {
+  if (queue.length > 0) {
+    return queue.shift();
+  }
+  if (finished) {
+    return undefined;
+  }
+  const {
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  waiters.push(resolve);
+  return promise;
+};
+
+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;
       }
-    },
-    type: 'function'
-  };
-};
-const getGetWorkspaceUriTool = () => {
-  return {
-    function: {
-      description: 'Get the URI of the currently open workspace folder.',
-      name: 'getWorkspaceUri',
-      parameters: {
-        additionalProperties: false,
-        properties: {},
-        type: 'object'
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        continue;
       }
-    },
-    type: 'function'
+      await handleParsedSseEvent(parsed);
+    }
   };
-};
-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'
+  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);
       }
-    },
-    type: 'function'
+      continue;
+    }
+    text += chunk;
+    if (stream && onTextChunk) {
+      await onTextChunk(chunk);
+    }
+  }
+  if (remainder) {
+    const dataLines = parseSseDataLines(remainder);
+    await consumeSseDataLines(dataLines);
+  }
+  await notifyFinished();
+  return {
+    text,
+    type: 'success'
   };
 };
-const getBasicChatTools = () => {
-  return [getReadFileTool(), getWriteFileTool(), getListFilesTool(), getGetWorkspaceUriTool(), getRenderHtmlTool()];
+
+const normalizeLimitInfo = value => {
+  if (!value || typeof value !== 'object') {
+    return undefined;
+  }
+  const limitRemaining = Reflect.get(value, 'limitRemaining');
+  const limitReset = Reflect.get(value, 'limitReset');
+  const retryAfter = Reflect.get(value, 'retryAfter');
+  const usage = Reflect.get(value, 'usage');
+  const usageDaily = Reflect.get(value, 'usageDaily');
+  const normalized = {
+    ...(typeof limitRemaining === 'number' || limitRemaining === null ? {
+      limitRemaining
+    } : {}),
+    ...(typeof limitReset === 'string' || limitReset === null ? {
+      limitReset
+    } : {}),
+    ...(typeof retryAfter === 'string' || retryAfter === null ? {
+      retryAfter
+    } : {}),
+    ...(typeof usage === 'number' ? {
+      usage
+    } : {}),
+    ...(typeof usageDaily === 'number' ? {
+      usageDaily
+    } : {})
+  };
+  const hasDetails = typeof limitRemaining === 'number' || limitRemaining === null || typeof limitReset === 'string' || limitReset === null || typeof retryAfter === 'string' || retryAfter === null || typeof usage === 'number' || typeof usageDaily === 'number';
+  return hasDetails ? normalized : undefined;
 };
 
-const getClientRequestIdHeader = () => {
+const normalizeMockResult = value => {
+  if (typeof value === 'string') {
+    return {
+      text: value,
+      type: 'success'
+    };
+  }
+  if (!value || typeof value !== 'object') {
+    return {
+      details: 'request-failed',
+      type: 'error'
+    };
+  }
+  const type = Reflect.get(value, 'type');
+  if (type === 'success') {
+    const text = Reflect.get(value, 'text');
+    if (typeof text === 'string') {
+      return {
+        text,
+        type: 'success'
+      };
+    }
+    return {
+      details: 'request-failed',
+      type: 'error'
+    };
+  }
+  if (type === 'error') {
+    const details = Reflect.get(value, 'details');
+    if (details === 'request-failed' || details === 'too-many-requests' || details === 'http-error') {
+      const rawMessage = Reflect.get(value, 'rawMessage');
+      const statusCode = Reflect.get(value, 'statusCode');
+      const limitInfo = normalizeLimitInfo(Reflect.get(value, 'limitInfo'));
+      return {
+        details,
+        ...(limitInfo ? {
+          limitInfo
+        } : {}),
+        ...(typeof rawMessage === 'string' ? {
+          rawMessage
+        } : {}),
+        ...(typeof statusCode === 'number' ? {
+          statusCode
+        } : {}),
+        type: 'error'
+      };
+    }
+  }
+  const text = Reflect.get(value, 'text');
+  if (typeof text === 'string') {
+    return {
+      text,
+      type: 'success'
+    };
+  }
   return {
-    'x-client-request-id': crypto.randomUUID()
+    details: 'request-failed',
+    type: 'error'
   };
 };
 
+const getMockOpenRouterAssistantText = async (messages, modelId, openRouterApiBaseUrl, openRouterApiKey, mockApiCommandId, assetDir, platform) => {
+  if (!mockApiCommandId) {
+    return {
+      details: 'request-failed',
+      type: 'error'
+    };
+  }
+  try {
+    const result = await executeProvider({
+      assetDir,
+      event: `onCommand:${mockApiCommandId}`,
+      method: CommandExecute,
+      noProviderFoundMessage: 'No mock api command found',
+      params: [mockApiCommandId, {
+        messages,
+        modelId,
+        openRouterApiBaseUrl,
+        openRouterApiKey
+      }],
+      platform
+    });
+    return normalizeMockResult(result);
+  } catch {
+    return {
+      details: 'request-failed',
+      type: 'error'
+    };
+  }
+};
+
 const getOpenApiApiEndpoint = openApiApiBaseUrl => {
   return `${openApiApiBaseUrl}/responses`;
 };
 
+const makeApiRequest = async options => {
+  return invoke$2('ChatNetwork.makeApiRequest', options);
+};
+const makeStreamingApiRequest = async options => {
+  return invoke$2('ChatNetwork.makeStreamingApiRequest', options);
+};
+
 const getTextContent = content => {
   if (typeof content === 'string') {
     return content;
@@ -3521,6 +3530,8 @@ const getTextContent = content => {
   return textParts.join('\n');
 };
 
+/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
+
 const getOpenAiTools = tools => {
   return tools.map(tool => {
     if (!tool || typeof tool !== 'object') {
@@ -4028,15 +4039,44 @@ const parseOpenApiStream = async (response, onTextChunk, onToolCallsChunk, onDat
     ...(responseId ? {
       responseId
     } : {}),
-    responseFunctionCalls,
-    text,
-    type: 'success'
+    responseFunctionCalls,
+    text,
+    type: 'success'
+  };
+};
+const getOpenApiErrorDetails = async response => {
+  let parsed;
+  try {
+    parsed = await response.json();
+  } catch {
+    return {};
+  }
+  if (!parsed || typeof parsed !== 'object') {
+    return {};
+  }
+  const error = Reflect.get(parsed, 'error');
+  if (!error || typeof error !== 'object') {
+    return {};
+  }
+  const errorCode = Reflect.get(error, 'code');
+  const errorMessage = Reflect.get(error, 'message');
+  const errorType = Reflect.get(error, 'type');
+  return {
+    ...(typeof errorCode === 'string' ? {
+      errorCode
+    } : {}),
+    ...(typeof errorMessage === 'string' ? {
+      errorMessage
+    } : {}),
+    ...(typeof errorType === 'string' ? {
+      errorType
+    } : {})
   };
 };
-const getOpenApiErrorDetails = async response => {
+const getOpenApiErrorDetailsFromResponseText = responseText => {
   let parsed;
   try {
-    parsed = await response.json();
+    parsed = JSON.parse(responseText);
   } catch {
     return {};
   }
@@ -4062,6 +4102,23 @@ const getOpenApiErrorDetails = async response => {
     } : {})
   };
 };
+const getResponseFromSseEvents = events => {
+  const chunks = events.map(event => {
+    const data = typeof event === 'string' ? event : JSON.stringify(event);
+    return `data: ${data}\n\n`;
+  });
+  const stream = new ReadableStream({
+    start(controller) {
+      for (const chunk of chunks) {
+        controller.enqueue(new TextEncoder().encode(chunk));
+      }
+      controller.close();
+    }
+  });
+  return {
+    body: stream
+  };
+};
 const getOpenApiAssistantText = async (messages, modelId, openApiApiKey, openApiApiBaseUrl, assetDir, platform, options) => {
   const {
     includeObfuscation = false,
@@ -4070,6 +4127,7 @@ const getOpenApiAssistantText = async (messages, modelId, openApiApiKey, openApi
     onTextChunk,
     onToolCallsChunk,
     stream,
+    useChatNetworkWorkerForRequests = false,
     webSearchEnabled = false
   } = options ?? {
     stream: false
@@ -4082,46 +4140,89 @@ const getOpenApiAssistantText = async (messages, modelId, openApiApiKey, openApi
   const maxToolIterations = 4;
   let previousResponseId;
   for (let i = 0; i <= maxToolIterations; i++) {
-    let response;
-    try {
-      response = await fetch(getOpenApiApiEndpoint(openApiApiBaseUrl), {
-        body: JSON.stringify(getOpenAiParams(openAiInput, modelId, stream, includeObfuscation, tools, webSearchEnabled, previousResponseId)),
-        headers: {
-          Authorization: `Bearer ${openApiApiKey}`,
-          'Content-Type': 'application/json',
-          ...getClientRequestIdHeader()
-        },
-        method: 'POST'
-      });
-    } catch {
-      return {
-        details: 'request-failed',
-        type: 'error'
-      };
-    }
-    if (!response.ok) {
-      const {
-        errorCode,
-        errorMessage,
-        errorType
-      } = await getOpenApiErrorDetails(response);
-      return {
-        details: 'http-error',
-        ...(errorCode ? {
-          errorCode
-        } : {}),
-        ...(errorMessage ? {
-          errorMessage
-        } : {}),
-        ...(errorType ? {
-          errorType
-        } : {}),
-        statusCode: response.status,
-        type: 'error'
-      };
-    }
+    const postBody = getOpenAiParams(openAiInput, modelId, stream, includeObfuscation, tools, webSearchEnabled, previousResponseId);
     if (stream) {
-      const streamResult = await parseOpenApiStream(response, onTextChunk, onToolCallsChunk, onDataEvent);
+      const streamResult = useChatNetworkWorkerForRequests ? await (async () => {
+        const requestResult = await makeStreamingApiRequest({
+          headers: {
+            Authorization: `Bearer ${openApiApiKey}`,
+            'Content-Type': 'application/json',
+            ...getClientRequestIdHeader()
+          },
+          method: 'POST',
+          postBody,
+          url: getOpenApiApiEndpoint(openApiApiBaseUrl)
+        });
+        if (requestResult.type === 'error') {
+          if (requestResult.statusCode === 0) {
+            return {
+              details: 'request-failed',
+              type: 'error'
+            };
+          }
+          const {
+            errorCode,
+            errorMessage,
+            errorType
+          } = getOpenApiErrorDetailsFromResponseText(requestResult.response);
+          return {
+            details: 'http-error',
+            ...(errorCode ? {
+              errorCode
+            } : {}),
+            ...(errorMessage ? {
+              errorMessage
+            } : {}),
+            ...(errorType ? {
+              errorType
+            } : {}),
+            statusCode: requestResult.statusCode,
+            type: 'error'
+          };
+        }
+        const response = getResponseFromSseEvents(requestResult.body);
+        return parseOpenApiStream(response, onTextChunk, onToolCallsChunk, onDataEvent);
+      })() : await (async () => {
+        let response;
+        try {
+          response = await fetch(getOpenApiApiEndpoint(openApiApiBaseUrl), {
+            body: JSON.stringify(postBody),
+            headers: {
+              Authorization: `Bearer ${openApiApiKey}`,
+              'Content-Type': 'application/json',
+              ...getClientRequestIdHeader()
+            },
+            method: 'POST'
+          });
+        } catch {
+          return {
+            details: 'request-failed',
+            type: 'error'
+          };
+        }
+        if (!response.ok) {
+          const {
+            errorCode,
+            errorMessage,
+            errorType
+          } = await getOpenApiErrorDetails(response);
+          return {
+            details: 'http-error',
+            ...(errorCode ? {
+              errorCode
+            } : {}),
+            ...(errorMessage ? {
+              errorMessage
+            } : {}),
+            ...(errorType ? {
+              errorType
+            } : {}),
+            statusCode: response.status,
+            type: 'error'
+          };
+        }
+        return parseOpenApiStream(response, onTextChunk, onToolCallsChunk, onDataEvent);
+      })();
       if (streamResult.type !== 'success') {
         return streamResult;
       }
@@ -4168,13 +4269,92 @@ const getOpenApiAssistantText = async (messages, modelId, openApiApiKey, openApi
       };
     }
     let parsed;
-    try {
-      parsed = await response.json();
-    } catch {
-      return {
-        details: 'request-failed',
-        type: 'error'
-      };
+    if (useChatNetworkWorkerForRequests) {
+      const requestResult = await makeApiRequest({
+        headers: {
+          Authorization: `Bearer ${openApiApiKey}`,
+          'Content-Type': 'application/json',
+          ...getClientRequestIdHeader()
+        },
+        method: 'POST',
+        postBody,
+        url: getOpenApiApiEndpoint(openApiApiBaseUrl)
+      });
+      if (requestResult.type === 'error') {
+        if (requestResult.statusCode === 0) {
+          return {
+            details: 'request-failed',
+            type: 'error'
+          };
+        }
+        const {
+          errorCode,
+          errorMessage,
+          errorType
+        } = getOpenApiErrorDetailsFromResponseText(requestResult.response);
+        return {
+          details: 'http-error',
+          ...(errorCode ? {
+            errorCode
+          } : {}),
+          ...(errorMessage ? {
+            errorMessage
+          } : {}),
+          ...(errorType ? {
+            errorType
+          } : {}),
+          statusCode: requestResult.statusCode,
+          type: 'error'
+        };
+      }
+      parsed = requestResult.body;
+    } else {
+      let response;
+      try {
+        response = await fetch(getOpenApiApiEndpoint(openApiApiBaseUrl), {
+          body: JSON.stringify(postBody),
+          headers: {
+            Authorization: `Bearer ${openApiApiKey}`,
+            'Content-Type': 'application/json',
+            ...getClientRequestIdHeader()
+          },
+          method: 'POST'
+        });
+      } catch {
+        return {
+          details: 'request-failed',
+          type: 'error'
+        };
+      }
+      if (!response.ok) {
+        const {
+          errorCode,
+          errorMessage,
+          errorType
+        } = await getOpenApiErrorDetails(response);
+        return {
+          details: 'http-error',
+          ...(errorCode ? {
+            errorCode
+          } : {}),
+          ...(errorMessage ? {
+            errorMessage
+          } : {}),
+          ...(errorType ? {
+            errorType
+          } : {}),
+          statusCode: response.status,
+          type: 'error'
+        };
+      }
+      try {
+        parsed = await response.json();
+      } catch {
+        return {
+          details: 'request-failed',
+          type: 'error'
+        };
+      }
     }
     if (!parsed || typeof parsed !== 'object') {
       return {
@@ -4409,28 +4589,67 @@ const getOpenRouterRaw429Message = async response => {
   }
   return raw;
 };
-const getOpenRouterLimitInfo = async (openRouterApiKey, openRouterApiBaseUrl) => {
-  let response;
+const getOpenRouterRaw429MessageFromText = responseText => {
+  let parsed;
   try {
-    response = await fetch(getOpenRouterKeyEndpoint(openRouterApiBaseUrl), {
-      headers: {
-        Authorization: `Bearer ${openRouterApiKey}`,
-        ...getClientRequestIdHeader()
-      },
-      method: 'GET'
-    });
+    parsed = JSON.parse(responseText);
   } catch {
     return undefined;
   }
-  if (!response.ok) {
+  if (!parsed || typeof parsed !== 'object') {
     return undefined;
   }
-  let parsed;
-  try {
-    parsed = await response.json();
-  } catch {
+  const error = Reflect.get(parsed, 'error');
+  if (!error || typeof error !== 'object') {
+    return undefined;
+  }
+  const metadata = Reflect.get(error, 'metadata');
+  if (!metadata || typeof metadata !== 'object') {
+    return undefined;
+  }
+  const raw = Reflect.get(metadata, 'raw');
+  if (typeof raw !== 'string' || !raw) {
     return undefined;
   }
+  return raw;
+};
+const getOpenRouterLimitInfo = async (openRouterApiKey, openRouterApiBaseUrl, useChatNetworkWorkerForRequests) => {
+  let parsed;
+  if (useChatNetworkWorkerForRequests) {
+    const result = await makeApiRequest({
+      headers: {
+        Authorization: `Bearer ${openRouterApiKey}`,
+        ...getClientRequestIdHeader()
+      },
+      method: 'GET',
+      url: getOpenRouterKeyEndpoint(openRouterApiBaseUrl)
+    });
+    if (result.type === 'error') {
+      return undefined;
+    }
+    parsed = result.body;
+  } else {
+    let response;
+    try {
+      response = await fetch(getOpenRouterKeyEndpoint(openRouterApiBaseUrl), {
+        headers: {
+          Authorization: `Bearer ${openRouterApiKey}`,
+          ...getClientRequestIdHeader()
+        },
+        method: 'GET'
+      });
+    } catch {
+      return undefined;
+    }
+    if (!response.ok) {
+      return undefined;
+    }
+    try {
+      parsed = await response.json();
+    } catch {
+      return undefined;
+    }
+  }
   if (!parsed || typeof parsed !== 'object') {
     return undefined;
   }
@@ -4462,7 +4681,7 @@ const getOpenRouterLimitInfo = async (openRouterApiKey, openRouterApiBaseUrl) =>
   }
   return normalizedLimitInfo;
 };
-const getOpenRouterAssistantText = async (messages, modelId, openRouterApiKey, openRouterApiBaseUrl, assetDir, platform) => {
+const getOpenRouterAssistantText = async (messages, modelId, openRouterApiKey, openRouterApiBaseUrl, assetDir, platform, useChatNetworkWorkerForRequests = false) => {
   const completionMessages = messages.map(message => ({
     content: message.text,
     role: message.role
@@ -4470,64 +4689,111 @@ const getOpenRouterAssistantText = async (messages, modelId, openRouterApiKey, o
   const tools = getBasicChatTools();
   const maxToolIterations = 4;
   for (let i = 0; i <= maxToolIterations; i++) {
-    let response;
-    try {
-      response = await fetch(getOpenRouterApiEndpoint(openRouterApiBaseUrl), {
-        body: JSON.stringify({
-          messages: completionMessages,
-          model: modelId,
-          tool_choice: 'auto',
-          tools
-        }),
+    let parsed;
+    if (useChatNetworkWorkerForRequests) {
+      const requestResult = await makeApiRequest({
         headers: {
           Authorization: `Bearer ${openRouterApiKey}`,
           'Content-Type': 'application/json',
           ...getClientRequestIdHeader()
         },
-        method: 'POST'
+        method: 'POST',
+        postBody: {
+          messages: completionMessages,
+          model: modelId,
+          tool_choice: 'auto',
+          tools
+        },
+        url: getOpenRouterApiEndpoint(openRouterApiBaseUrl)
       });
-    } catch {
-      return {
-        details: 'request-failed',
-        type: 'error'
-      };
-    }
-    if (!response.ok) {
-      if (response.status === 429) {
-        const retryAfter = response.headers?.get?.('retry-after') ?? null;
-        const rawMessage = await getOpenRouterRaw429Message(response);
-        const limitInfo = await getOpenRouterLimitInfo(openRouterApiKey, openRouterApiBaseUrl);
+      if (requestResult.type === 'error') {
+        if (requestResult.statusCode === 429) {
+          const retryAfter = requestResult.headers?.['retry-after'] ?? null;
+          const rawMessage = getOpenRouterRaw429MessageFromText(requestResult.response);
+          const limitInfo = await getOpenRouterLimitInfo(openRouterApiKey, openRouterApiBaseUrl, useChatNetworkWorkerForRequests);
+          return {
+            details: 'too-many-requests',
+            ...(limitInfo || retryAfter ? {
+              limitInfo: {
+                ...limitInfo,
+                ...(retryAfter ? {
+                  retryAfter
+                } : {})
+              }
+            } : {}),
+            ...(rawMessage ? {
+              rawMessage
+            } : {}),
+            statusCode: 429,
+            type: 'error'
+          };
+        }
         return {
-          details: 'too-many-requests',
-          ...(limitInfo || retryAfter ? {
-            limitInfo: {
-              ...limitInfo,
-              ...(retryAfter ? {
-                retryAfter
-              } : {})
-            }
-          } : {}),
-          ...(rawMessage ? {
-            rawMessage
-          } : {}),
-          statusCode: 429,
+          details: 'http-error',
+          statusCode: requestResult.statusCode,
+          type: 'error'
+        };
+      }
+      parsed = requestResult.body;
+    } else {
+      let response;
+      try {
+        response = await fetch(getOpenRouterApiEndpoint(openRouterApiBaseUrl), {
+          body: JSON.stringify({
+            messages: completionMessages,
+            model: modelId,
+            tool_choice: 'auto',
+            tools
+          }),
+          headers: {
+            Authorization: `Bearer ${openRouterApiKey}`,
+            'Content-Type': 'application/json',
+            ...getClientRequestIdHeader()
+          },
+          method: 'POST'
+        });
+      } catch {
+        return {
+          details: 'request-failed',
+          type: 'error'
+        };
+      }
+      if (!response.ok) {
+        if (response.status === 429) {
+          const retryAfter = response.headers?.get?.('retry-after') ?? null;
+          const rawMessage = await getOpenRouterRaw429Message(response);
+          const limitInfo = await getOpenRouterLimitInfo(openRouterApiKey, openRouterApiBaseUrl, useChatNetworkWorkerForRequests);
+          return {
+            details: 'too-many-requests',
+            ...(limitInfo || retryAfter ? {
+              limitInfo: {
+                ...limitInfo,
+                ...(retryAfter ? {
+                  retryAfter
+                } : {})
+              }
+            } : {}),
+            ...(rawMessage ? {
+              rawMessage
+            } : {}),
+            statusCode: 429,
+            type: 'error'
+          };
+        }
+        return {
+          details: 'http-error',
+          statusCode: response.status,
+          type: 'error'
+        };
+      }
+      try {
+        parsed = await response.json();
+      } catch {
+        return {
+          details: 'request-failed',
           type: 'error'
         };
       }
-      return {
-        details: 'http-error',
-        statusCode: response.status,
-        type: 'error'
-      };
-    }
-    let parsed;
-    try {
-      parsed = await response.json();
-    } catch {
-      return {
-        details: 'request-failed',
-        type: 'error'
-      };
     }
     if (!parsed || typeof parsed !== 'object') {
       return {
@@ -4667,6 +4933,17 @@ const isOpenRouterModel = (selectedModelId, models) => {
   return selectedModelId.toLowerCase().startsWith('openrouter/');
 };
 
+let requests = [];
+const reset$1 = () => {
+  requests = [];
+};
+const capture = request => {
+  requests = [...requests, request];
+};
+const getAll = () => {
+  return requests;
+};
+
 const getAiResponse = async ({
   assetDir,
   messageId,
@@ -4686,6 +4963,7 @@ const getAiResponse = async ({
   platform,
   selectedModelId,
   streamingEnabled = true,
+  useChatNetworkWorkerForRequests = false,
   useMockApi,
   userText,
   webSearchEnabled = false
@@ -4695,6 +4973,22 @@ const getAiResponse = async ({
   const usesOpenRouterModel = isOpenRouterModel(selectedModelId, models);
   if (usesOpenApiModel) {
     if (useMockApi) {
+      const openAiInput = messages.map(message => ({
+        content: message.text,
+        role: message.role
+      }));
+      const modelId = getOpenApiModelId(selectedModelId);
+      const headers = {
+        Authorization: `Bearer ${openApiApiKey}`,
+        'Content-Type': 'application/json',
+        ...getClientRequestIdHeader()
+      };
+      capture({
+        headers,
+        method: 'POST',
+        payload: getOpenAiParams(openAiInput, modelId, streamingEnabled, passIncludeObfuscation, getBasicChatTools(), webSearchEnabled),
+        url: getOpenApiApiEndpoint(openApiApiBaseUrl)
+      });
       const result = await getMockOpenApiAssistantText(streamingEnabled, onTextChunk, onToolCallsChunk, onDataEvent, onEventStreamFinished);
       if (result.type === 'success') {
         const {
@@ -4720,6 +5014,7 @@ const getAiResponse = async ({
           onToolCallsChunk
         } : {}),
         stream: streamingEnabled,
+        useChatNetworkWorkerForRequests,
         webSearchEnabled
       });
       if (result.type === 'success') {
@@ -4746,7 +5041,7 @@ const getAiResponse = async ({
         text = getOpenRouterErrorMessage(result);
       }
     } else if (openRouterApiKey) {
-      const result = await getOpenRouterAssistantText(messages, modelId, openRouterApiKey, openRouterApiBaseUrl, assetDir, platform);
+      const result = await getOpenRouterAssistantText(messages, modelId, openRouterApiKey, openRouterApiBaseUrl, assetDir, platform, useChatNetworkWorkerForRequests);
       if (result.type === 'success') {
         const {
           text: assistantText
@@ -4830,6 +5125,7 @@ const handleClickSaveOpenApiApiKey = async state => {
     platform: updatedState.platform,
     selectedModelId: updatedState.selectedModelId,
     streamingEnabled: updatedState.streamingEnabled,
+    useChatNetworkWorkerForRequests: updatedState.useChatNetworkWorkerForRequests,
     useMockApi: updatedState.useMockApi,
     userText: previousUserMessage.text
   });
@@ -4910,6 +5206,7 @@ const handleClickSaveOpenRouterApiKey = async state => {
     openRouterApiKey,
     platform: updatedState.platform,
     selectedModelId: updatedState.selectedModelId,
+    useChatNetworkWorkerForRequests: updatedState.useChatNetworkWorkerForRequests,
     useMockApi: updatedState.useMockApi,
     userText: previousUserMessage.text
   });
@@ -5286,6 +5583,7 @@ Assistant: ${assistantText}`;
     platform: state.platform,
     selectedModelId,
     streamingEnabled: false,
+    useChatNetworkWorkerForRequests: state.useChatNetworkWorkerForRequests,
     useMockApi,
     userText: titlePrompt,
     webSearchEnabled: false
@@ -5313,6 +5611,7 @@ const handleSubmit = async state => {
     selectedSessionId,
     sessions,
     streamingEnabled,
+    useChatNetworkWorkerForRequests,
     useMockApi,
     viewMode,
     webSearchEnabled
@@ -5465,6 +5764,7 @@ const handleSubmit = async state => {
     platform,
     selectedModelId,
     streamingEnabled,
+    useChatNetworkWorkerForRequests,
     useMockApi,
     userText,
     webSearchEnabled
@@ -6105,8 +6405,17 @@ const loadStreamingEnabled = async () => {
   }
 };
 
+const loadUseChatNetworkWorkerForRequests = async () => {
+  try {
+    const savedUseChatNetworkWorkerForRequests = await get('chatView.useChatNetworkWorkerForRequests');
+    return typeof savedUseChatNetworkWorkerForRequests === 'boolean' ? savedUseChatNetworkWorkerForRequests : false;
+  } catch {
+    return false;
+  }
+};
+
 const loadPreferences = async () => {
-  const [aiSessionTitleGenerationEnabled, composerDropEnabled, openApiApiKey, openRouterApiKey, emitStreamingFunctionCallEvents, streamingEnabled, passIncludeObfuscation] = await Promise.all([loadAiSessionTitleGenerationEnabled(), loadComposerDropEnabled(), loadOpenApiApiKey(), loadOpenRouterApiKey(), loadEmitStreamingFunctionCallEvents(), loadStreamingEnabled(), loadPassIncludeObfuscation()]);
+  const [aiSessionTitleGenerationEnabled, composerDropEnabled, openApiApiKey, openRouterApiKey, emitStreamingFunctionCallEvents, streamingEnabled, passIncludeObfuscation, useChatNetworkWorkerForRequests] = await Promise.all([loadAiSessionTitleGenerationEnabled(), loadComposerDropEnabled(), loadOpenApiApiKey(), loadOpenRouterApiKey(), loadEmitStreamingFunctionCallEvents(), loadStreamingEnabled(), loadPassIncludeObfuscation(), loadUseChatNetworkWorkerForRequests()]);
   return {
     aiSessionTitleGenerationEnabled,
     composerDropEnabled,
@@ -6114,7 +6423,8 @@ const loadPreferences = async () => {
     openApiApiKey,
     openRouterApiKey,
     passIncludeObfuscation,
-    streamingEnabled
+    streamingEnabled,
+    useChatNetworkWorkerForRequests
   };
 };
 
@@ -6151,7 +6461,8 @@ const loadContent = async (state, savedState) => {
     openApiApiKey,
     openRouterApiKey,
     passIncludeObfuscation,
-    streamingEnabled
+    streamingEnabled,
+    useChatNetworkWorkerForRequests
   } = await loadPreferences();
   const legacySavedSessions = getSavedSessions(savedState);
   const storedSessions = await listChatSessions();
@@ -6195,10 +6506,20 @@ const loadContent = async (state, savedState) => {
     selectedSessionId,
     sessions,
     streamingEnabled,
+    useChatNetworkWorkerForRequests,
     viewMode
   };
 };
 
+const mockOpenApiRequestGetAll = _state => {
+  return getAll();
+};
+
+const mockOpenApiRequestReset = state => {
+  reset$1();
+  return state;
+};
+
 const mockOpenApiSetHttpErrorResponse = (state, statusCode, body) => {
   setHttpErrorResponse(statusCode, body);
   return state;
@@ -6215,7 +6536,7 @@ const mockOpenApiStreamPushChunk = (state, chunk) => {
 };
 
 const mockOpenApiStreamReset = state => {
-  reset$1();
+  reset$2();
   return state;
 };
 
@@ -6254,7 +6575,7 @@ const openMockSession = async (state, mockSessionId, mockChatMessages) => {
 };
 
 const registerMockResponse = (state, mockResponse) => {
-  reset$1();
+  reset$2();
   pushChunk(mockResponse.text);
   finish();
   return state;
@@ -7936,6 +8257,18 @@ const setStreamingEnabled = (state, streamingEnabled) => {
   };
 };
 
+const setUseChatNetworkWorkerForRequests = async (state, useChatNetworkWorkerForRequests, persist = true) => {
+  if (persist) {
+    await update({
+      'chatView.useChatNetworkWorkerForRequests': useChatNetworkWorkerForRequests
+    });
+  }
+  return {
+    ...state,
+    useChatNetworkWorkerForRequests
+  };
+};
+
 const defaultMockApiCommandId = 'ChatE2e.mockApi';
 const useMockApi = (state, value, mockApiCommandId = defaultMockApiCommandId) => {
   if (!value) {
@@ -7985,6 +8318,8 @@ const commandMap = {
   'Chat.initialize': initialize,
   'Chat.loadContent': wrapCommand(loadContent),
   'Chat.loadContent2': wrapCommand(loadContent),
+  'Chat.mockOpenApiRequestGetAll': wrapGetter(mockOpenApiRequestGetAll),
+  'Chat.mockOpenApiRequestReset': wrapCommand(mockOpenApiRequestReset),
   'Chat.mockOpenApiSetHttpErrorResponse': wrapCommand(mockOpenApiSetHttpErrorResponse),
   'Chat.mockOpenApiStreamFinish': wrapCommand(mockOpenApiStreamFinish),
   'Chat.mockOpenApiStreamPushChunk': wrapCommand(mockOpenApiStreamPushChunk),
@@ -8001,6 +8336,7 @@ const commandMap = {
   'Chat.setEmitStreamingFunctionCallEvents': wrapCommand(setEmitStreamingFunctionCallEvents),
   'Chat.setOpenRouterApiKey': wrapCommand(setOpenRouterApiKey),
   'Chat.setStreamingEnabled': wrapCommand(setStreamingEnabled),
+  'Chat.setUseChatNetworkWorkerForRequests': wrapCommand(setUseChatNetworkWorkerForRequests),
   'Chat.terminate': terminate,
   'Chat.useMockApi': wrapCommand(useMockApi)
 };