@lvce-editor/static-server 0.81.2 → 0.81.3

package/static/{7204a38 → 3bbdec0}/packages/chat-view/dist/chatViewWorkerMain.js

@@ -519,7 +519,7 @@ const register = commandMap => {
 const getCommand = key => {
   return commands[key];
 };
-const execute$1 = (command, ...args) => {
+const execute = (command, ...args) => {
   const fn = getCommand(command);
   if (!fn) {
     throw new CommandNotFoundError(command);
@@ -939,7 +939,7 @@ const logError = () => {
 };
 const handleMessage = event => {
   const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
-  const actualExecute = event?.target?.execute || execute$1;
+  const actualExecute = event?.target?.execute || execute;
   return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError, actualRequiresSocket);
 };
 
@@ -1118,18 +1118,18 @@ const create$2 = rpcId => {
 };
 
 const {
-  invoke: invoke$c,
+  invoke: invoke$a,
   set: set$e
 } = create$2(6010);
 const login = async options => {
-  return invoke$c('Auth.login', options);
+  return invoke$a('Auth.login', options);
 };
 const logout = async options => {
-  return invoke$c('Auth.logout', options);
+  return invoke$a('Auth.logout', options);
 };
 
 const {
-  invoke: invoke$b,
+  invoke: invoke$9,
   set: set$d
 } = create$2(6008);
 
@@ -1138,7 +1138,7 @@ const {
 } = create$2(6007);
 
 const {
-  invoke: invoke$a,
+  invoke: invoke$8,
   set: set$b
 } = create$2(6009);
 
@@ -1255,29 +1255,27 @@ const FocusChatInput = 8000;
 const FocusChatList = 8001;
 
 const {
-  invoke: invoke$9,
   set: set$a
 } = create$2(ChatNetworkWorker);
 
 const {
-  invoke: invoke$8,
+  invoke: invoke$7,
   set: set$9
 } = create$2(ChatStorageWorker);
 const appendEvent = async event => {
-  return invoke$8('ChatStorage.appendEvent', event);
+  return invoke$7('ChatStorage.appendEvent', event);
 };
 const clear = async () => {
-  return invoke$8('ChatStorage.clear');
+  return invoke$7('ChatStorage.clear');
 };
 const deleteSession$1 = async id => {
-  return invoke$8('ChatStorage.deleteSession', id);
+  return invoke$7('ChatStorage.deleteSession', id);
 };
 const getEvents = async sessionId => {
-  return invoke$8('ChatStorage.getEvents', sessionId);
+  return invoke$7('ChatStorage.getEvents', sessionId);
 };
 
 const {
-  invoke: invoke$7,
   set: set$8
 } = create$2(ChatToolWorker);
 
@@ -1364,9 +1362,6 @@ const sendMessagePortToIconThemeWorker$1 = async (port, rpcId) => {
   const command = 'IconTheme.handleMessagePort';
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToIconThemeWorker', port, command, rpcId);
 };
-const readFile = async uri => {
-  return invoke$1('FileSystem.readFile', uri);
-};
 const sendMessagePortToExtensionHostWorker$1 = async (port, rpcId = 0) => {
   const command = 'HandleMessagePort.handleMessagePort2';
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
@@ -2437,16 +2432,16 @@ const archive = () => {
   return i18nString(Archive);
 };
 const openApiApiKeyRequiredMessage = i18nString(OpenApiApiKeyRequiredMessage);
-const openApiRequestFailedMessage = i18nString(OpenApiRequestFailedMessage);
-const openApiRequestFailedOfflineMessage = i18nString(OpenApiRequestFailedOfflineMessage);
+i18nString(OpenApiRequestFailedMessage);
+i18nString(OpenApiRequestFailedOfflineMessage);
 const openRouterApiKeyRequiredMessage = i18nString(OpenRouterApiKeyRequiredMessage);
 const openRouterRequestFailedMessage = i18nString(OpenRouterRequestFailedMessage);
 const openRouterTooManyRequestsMessage = i18nString(OpenRouterTooManyRequestsMessage);
 const openRouterRequestFailureReasons = [i18nString(OpenRouterRequestFailureReasonContentSecurityPolicyViolation), i18nString(OpenRouterRequestFailureReasonServerOffline), i18nString(CheckYourInternetConnection)];
 const openRouterTooManyRequestsReasons = [i18nString(WaitAShortTimeAndRetryYourRequest), i18nString(ReduceRequestFrequencyToAvoidRateLimits), i18nString(UseADifferentModelIfThisOneIsSaturated)];
-const backendUrlRequiredMessage = i18nString(BackendUrlRequiredMessage);
-const backendAccessTokenRequiredMessage = i18nString(BackendAccessTokenRequiredMessage);
-const backendCompletionFailedMessage = i18nString(BackendCompletionFailedMessage);
+i18nString(BackendUrlRequiredMessage);
+i18nString(BackendAccessTokenRequiredMessage);
+i18nString(BackendCompletionFailedMessage);
 
 const defaultMaxToolCalls = 100;
 
@@ -2618,7 +2613,14 @@ const measureTextWidth = async (text, fontFamily, fontSize) => {
 };
 
 const defaultToolEnablement = {
-  run_in_terminal: false
+  close_preview: false,
+  glob: false,
+  open_preview: false,
+  render_html: false,
+  rg: false,
+  run_in_terminal: false,
+  spawn_subagent: false,
+  update_todo: false
 };
 const parseToolEnablement = value => {
   {
@@ -2638,19 +2640,6 @@ const validateToolEnablement = value => {
   }
   return toolEnablement;
 };
-const isToolEnabled = (toolEnablement, toolName) => {
-  if (!toolEnablement) {
-    return defaultToolEnablement[toolName] ?? true;
-  }
-  const enabled = toolEnablement[toolName];
-  if (typeof enabled === 'boolean') {
-    return enabled;
-  }
-  return defaultToolEnablement[toolName] ?? true;
-};
-const filterEnabledTools = (tools, toolEnablement) => {
-  return tools.filter(tool => isToolEnabled(toolEnablement, tool.function.name));
-};
 
 const createDefaultState = () => {
   const defaultProjectId = 'project-1';
@@ -2868,7 +2857,7 @@ const getSessionLastActiveTime = session => {
 };
 
 const getChatSession = async id => {
-  const session = await invoke$8('ChatStorage.getSession', id);
+  const session = await invoke$7('ChatStorage.getSession', id);
   if (!session) {
     return undefined;
   }
@@ -2925,7 +2914,7 @@ const saveChatSession = async session => {
     ...value,
     projectId: session.projectId
   } : value;
-  await invoke$8('ChatStorage.setSession', sessionValue);
+  await invoke$7('ChatStorage.setSession', sessionValue);
 };
 const saveChatSessionPreservingMessages = async (session, messages) => {
   if (messages) {
@@ -4482,13 +4471,13 @@ const selectProject = async (state, projectId) => {
 };
 
 const fileSchemeRegex = /^file:\/\//;
-const trailingSlashesRegex$4 = /\/+$/;
+const trailingSlashesRegex$1 = /\/+$/;
 const getProjectName = (uri, fallbackIndex) => {
   if (!uri) {
     return `Project ${fallbackIndex}`;
   }
   const withoutScheme = uri.replace(fileSchemeRegex, '');
-  const normalized = withoutScheme.replace(trailingSlashesRegex$4, '');
+  const normalized = withoutScheme.replace(trailingSlashesRegex$1, '');
   const lastSegment = normalized.split('/').pop();
   if (!lastSegment) {
     return `Project ${fallbackIndex}`;
@@ -4658,7 +4647,7 @@ const getLatestExecutablePlanMessage = (session, messages = session?.messages ||
   return undefined;
 };
 
-const getErrorMessage$1 = error => {
+const getErrorMessage = error => {
   if (error instanceof Error && error.message) {
     return error.message;
   }
@@ -4683,7 +4672,7 @@ const handleSubmit = async state => {
     await invoke$6('ChatModel.handleSubmit', state);
     return state;
   } catch (error) {
-    throw new Error(getErrorMessage$1(error), {
+    throw new Error(getErrorMessage(error), {
       cause: error
     });
   }
@@ -4711,9 +4700,9 @@ const handleClickImplementPlan = async state => {
   return handleSubmit(preparedState);
 };
 
-const trailingSlashesRegex$3 = /\/+$/;
+const trailingSlashesRegex = /\/+$/;
 const trimTrailingSlashes = value => {
-  return value.replace(trailingSlashesRegex$3, '');
+  return value.replace(trailingSlashesRegex, '');
 };
 
 const getBackendAuthUrl = (backendUrl, path) => {
@@ -4832,12 +4821,12 @@ const getBackendRefreshUrl = backendUrl => {
   return getBackendAuthUrl(backendUrl, '/auth/refresh');
 };
 
-const isObject$2 = value => {
+const isObject$1 = value => {
   return !!value && typeof value === 'object';
 };
 
 const isBackendAuthResponse = value => {
-  return isObject$2(value);
+  return isObject$1(value);
 };
 
 const getNumber = (value, fallback = 0) => {
@@ -4876,11 +4865,11 @@ const syncBackendAuth = async (backendUrl, useAuthWorker = false) => {
       return parseBackendAuthResponse(mockResponse);
     }
     if (useAuthWorker) {
-      return invoke$c('Auth.syncBackendAuth', backendUrl);
+      return invoke$a('Auth.syncBackendAuth', backendUrl);
     }
     const worker = true;
     if (worker) {
-      return invoke$c('Auth.syncBackendAuth', backendUrl);
+      return invoke$a('Auth.syncBackendAuth', backendUrl);
     }
     const response = await fetch(getBackendRefreshUrl(backendUrl), {
       credentials: 'include',
@@ -5158,3587 +5147,72 @@ const handleClickPrimaryControlsOverflow = async (state, eventX, eventY) => {
   return state;
 };
 
-const getAiResponse$1 = async options => {
-  return invoke$b('ChatCoordinator.getAiResponse', options);
-};
-
-const execute = async (name, rawArguments, options) => {
-  return invoke$7('ChatTool.execute', name, rawArguments, options);
-};
-const getTools = async () => {
-  return invoke$7('ChatTool.getTools');
-};
-
-const windowsAbsolutePathRegex = /^[a-zA-Z]:[\\/]/;
-const pathSeparatorRegex$1 = /[\\/]/;
-const isPathTraversalAttempt = path => {
-  if (!path) {
-    return false;
-  }
-  if (path.startsWith('/') || path.startsWith('\\')) {
-    return true;
-  }
-  if (path.startsWith('file://')) {
-    return true;
-  }
-  if (windowsAbsolutePathRegex.test(path)) {
-    return true;
-  }
-  const segments = path.split(pathSeparatorRegex$1);
-  return segments.includes('..');
-};
-
-const pathSeparatorRegex = /[\\/]/;
-const normalizeRelativePath = path => {
-  const segments = path.split(pathSeparatorRegex).filter(segment => segment && segment !== '.');
-  if (segments.length === 0) {
-    return '.';
-  }
-  return segments.join('/');
-};
-
-const stringifyToolOutput = output => {
-  if (typeof output === 'string') {
-    return output;
-  }
-  return JSON.stringify(output) ?? 'null';
+const update = async settings => {
+  await invoke$1('Preferences.update', settings);
 };
 
-const hasWriteFileLineCounts = value => {
-  const linesAdded = Reflect.get(value, 'linesAdded');
-  const linesDeleted = Reflect.get(value, 'linesDeleted');
-  return typeof linesAdded === 'number' || typeof linesDeleted === 'number';
-};
-const hasToolError = value => {
-  const error = Reflect.get(value, 'error');
-  return typeof error === 'string' && error.trim().length > 0;
-};
-const getTrackedToolExecutionValue = value => {
-  if (typeof value !== 'string') {
-    return value;
-  }
-  try {
-    return JSON.parse(value);
-  } catch {
-    return value;
-  }
-};
-const getStoredToolExecutionStatus = result => {
-  let parsed = result;
-  if (typeof result === 'string') {
-    try {
-      parsed = JSON.parse(result);
-    } catch {
-      return 'error';
-    }
-  }
-  if (!parsed || typeof parsed !== 'object') {
-    return 'error';
-  }
-  return hasToolError(parsed) ? 'error' : 'success';
-};
-const parseWriteFileArguments = rawArguments => {
-  let parsed = rawArguments;
-  if (typeof rawArguments === 'string') {
-    try {
-      parsed = JSON.parse(rawArguments);
-    } catch {
-      return undefined;
-    }
-  }
-  if (!parsed || typeof parsed !== 'object') {
-    return undefined;
-  }
-  const content = Reflect.get(parsed, 'content');
-  if (typeof content !== 'string') {
-    return undefined;
-  }
-  const uri = Reflect.get(parsed, 'uri');
-  if (typeof uri === 'string' && uri) {
-    return {
-      content,
-      target: uri
-    };
-  }
-  const path = Reflect.get(parsed, 'path');
-  if (typeof path !== 'string' || !path || isPathTraversalAttempt(path)) {
-    return undefined;
-  }
-  return {
-    content,
-    target: normalizeRelativePath(path)
-  };
-};
-const readFileIfExists = async target => {
-  try {
-    return await readFile(target);
-  } catch (error) {
-    const message = String(error);
-    if (message.includes('ENOENT') || message.includes('No such file') || message.includes('not found')) {
-      return undefined;
-    }
-    throw error;
-  }
-};
-const toLines = value => {
-  if (!value) {
-    return [];
-  }
-  const normalized = value.replaceAll('\r\n', '\n').replaceAll('\r', '\n');
-  const lines = normalized.split('\n');
-  if (lines.at(-1) === '') {
-    lines.pop();
-  }
-  return lines;
-};
-const getWriteFileLineCounts = (before, after) => {
-  if (before === after) {
-    return {
-      linesAdded: 0,
-      linesDeleted: 0
-    };
-  }
-  const beforeLines = toLines(before ?? '');
-  const afterLines = toLines(after);
-  const dp = Array.from({
-    length: afterLines.length + 1
-  }).fill(0);
-  for (const beforeLine of beforeLines) {
-    let previousDiagonal = 0;
-    for (let index = 1; index <= afterLines.length; index++) {
-      const current = dp[index];
-      if (beforeLine === afterLines[index - 1]) {
-        dp[index] = previousDiagonal + 1;
-      } else {
-        dp[index] = Math.max(dp[index], dp[index - 1]);
-      }
-      previousDiagonal = current;
-    }
-  }
-  const sharedLineCount = dp[afterLines.length];
-  return {
-    linesAdded: afterLines.length - sharedLineCount,
-    linesDeleted: beforeLines.length - sharedLineCount
-  };
-};
-const withWriteFileLineCounts = async (workerOutput, rawArguments) => {
-  if (!workerOutput || typeof workerOutput !== 'object' || hasWriteFileLineCounts(workerOutput) || hasToolError(workerOutput)) {
-    return workerOutput;
-  }
-  const parsedArguments = parseWriteFileArguments(rawArguments);
-  if (!parsedArguments) {
-    return workerOutput;
-  }
-  const previousContent = await readFileIfExists(parsedArguments.target);
-  return {
-    ...workerOutput,
-    ...getWriteFileLineCounts(previousContent, parsedArguments.content)
-  };
-};
-const executeChatTool = async (name, rawArguments, options) => {
-  if (!isToolEnabled(options.toolEnablement, name)) {
-    throw new Error(`Tool "${name}" is disabled in chat.toolEnablement preferences.`);
-  }
-  if (!options.useChatToolWorker) {
-    throw new Error('Chat tools must be executed in a web worker environment. Please set useChatToolWorker to true in the options.');
-  }
-  const executionOptions = {
-    assetDir: options.assetDir,
-    platform: options.platform,
-    ...(options.workspaceUri ? {
-      workspaceUri: options.workspaceUri
-    } : {})
-  };
-  const executionId = options.toolCallId || `${name}-${Date.now()}`;
-  const startedAt = new Date().toISOString();
-  if (options.sessionId) {
-    await appendChatViewEvent({
-      arguments: getTrackedToolExecutionValue(rawArguments),
-      id: executionId,
-      name,
-      options: executionOptions,
-      sessionId: options.sessionId,
-      time: startedAt,
-      timestamp: startedAt,
-      type: 'tool-execution-started'
+const setOpenApiApiKey = async (state, openApiApiKey, persist = true) => {
+  if (persist) {
+    await update({
+      'secrets.openApiKey': openApiApiKey
     });
   }
-  try {
-    const workerOutput = await execute(name, rawArguments, executionOptions);
-    const outputWithLineCounts = name === 'write_file' ? await withWriteFileLineCounts(workerOutput, rawArguments) : workerOutput;
-    const result = stringifyToolOutput(outputWithLineCounts);
-    if (options.sessionId) {
-      await appendChatViewEvent({
-        id: executionId,
-        name,
-        result: outputWithLineCounts,
-        sessionId: options.sessionId,
-        status: getStoredToolExecutionStatus(outputWithLineCounts),
-        timestamp: new Date().toISOString(),
-        type: 'tool-execution-finished'
-      });
-    }
-    return result;
-  } catch (error) {
-    const errorResult = {
-      error: error instanceof Error ? error.message : String(error)
-    };
-    if (options.sessionId) {
-      await appendChatViewEvent({
-        id: executionId,
-        name,
-        result: errorResult,
-        sessionId: options.sessionId,
-        status: 'error',
-        timestamp: new Date().toISOString(),
-        type: 'tool-execution-finished'
-      });
-    }
-    throw error;
-  }
-};
-
-const getAskQuestionTool = () => {
   return {
-    function: {
-      description: 'Ask the user a multiple-choice question in the chat UI. Use this when you need a user decision before continuing. Provide short answer options.',
-      name: 'ask_question',
-      parameters: {
-        additionalProperties: false,
-        properties: {
-          answers: {
-            description: 'List of answer options shown to the user.',
-            items: {
-              type: 'string'
-            },
-            type: 'array'
-          },
-          question: {
-            description: 'The question text shown to the user.',
-            type: 'string'
-          }
-        },
-        required: ['question', 'answers'],
-        type: 'object'
-      }
-    },
-    type: 'function'
+    ...state,
+    openApiApiKey,
+    openApiApiKeyInput: openApiApiKey
   };
 };
-const withQuestionTool = (tools, questionToolEnabled) => {
-  if (!questionToolEnabled) {
-    return tools;
-  }
-  for (const tool of tools) {
-    if (tool.function.name === 'ask_question') {
-      return tools;
-    }
-  }
-  return [...tools, getAskQuestionTool()];
-};
-const readOnlyToolNames = new Set(['get_workspace_uri', 'list_file', 'list_files', 'read_file']);
-const withAgentMode = (tools, agentMode) => {
-  if (agentMode === 'agent') {
-    return tools;
-  }
-  return tools.filter(tool => readOnlyToolNames.has(tool.function.name));
-};
-const getBasicChatTools = async (agentMode = defaultAgentMode, questionToolEnabled = false, toolEnablement) => {
-  const effectiveAgentMode = typeof agentMode === 'boolean' ? defaultAgentMode : agentMode;
-  const effectiveQuestionToolEnabled = typeof agentMode === 'boolean' ? agentMode : questionToolEnabled;
-  try {
-    return withAgentMode(filterEnabledTools(withQuestionTool(await getTools(), effectiveQuestionToolEnabled), toolEnablement), effectiveAgentMode);
-  } catch {
-    return withAgentMode(filterEnabledTools(withQuestionTool([], effectiveQuestionToolEnabled), toolEnablement), effectiveAgentMode);
-  }
-};
-
-const getBackendModelNotAllowedForFreePlanMessage = statusCode => {
-  if (typeof statusCode === 'number') {
-    return `Backend completion request failed (status ${statusCode}). The selected model is not available on the Free plan. Choose a lower-cost LVCE model such as Claude Haiku or GPT-5.4 Mini, or upgrade your plan and try again.`;
-  }
-  return 'Backend completion request failed. The selected model is not available on the Free plan. Choose a lower-cost LVCE model such as Claude Haiku or GPT-5.4 Mini, or upgrade your plan and try again.';
-};
-const getBackendHttpErrorDetails = (errorCode, errorMessage) => {
-  const trimmedErrorCode = errorCode?.trim();
-  const trimmedErrorMessage = errorMessage?.trim();
-  if (trimmedErrorCode && trimmedErrorMessage) {
-    return `Error code: ${trimmedErrorCode}. ${trimmedErrorMessage}`;
-  }
-  if (trimmedErrorCode) {
-    return `Error code: ${trimmedErrorCode}.`;
-  }
-  return trimmedErrorMessage;
-};
-const getBackendErrorMessage = errorResult => {
-  switch (errorResult.details) {
-    case 'http-error':
-      {
-        if (errorResult.errorCode === 'E_LVCE_MODEL_NOT_ALLOWED_FOR_FREE_PLAN') {
-          return getBackendModelNotAllowedForFreePlanMessage(errorResult.statusCode);
-        }
-        const details = getBackendHttpErrorDetails(errorResult.errorCode, errorResult.errorMessage);
-        if (typeof errorResult.statusCode === 'number') {
-          const prefix = `Backend completion request failed (status ${errorResult.statusCode}).`;
-          if (!details) {
-            return prefix;
-          }
-          return `${prefix} ${details}`;
-        }
-        if (details) {
-          return `Backend completion request failed. ${details}`;
-        }
-        return backendCompletionFailedMessage;
-      }
-    case 'invalid-response':
-      {
-        const errorMessage = errorResult.errorMessage?.trim();
-        if (errorMessage) {
-          return `Backend completion request failed. ${errorMessage}`;
-        }
-        return 'Backend completion request failed. Unexpected backend response format.';
-      }
-    case 'request-failed':
-      {
-        const errorMessage = errorResult.errorMessage?.trim();
-        if (errorMessage) {
-          return `Backend completion request failed. ${errorMessage}`;
-        }
-        return backendCompletionFailedMessage;
-      }
-  }
-};
-
-const getAttachmentTextPart = (attachment, type = 'input_text') => {
-  switch (attachment.displayType) {
-    case 'file':
-      return {
-        text: `Attached file "${attachment.name}" (${attachment.mimeType || 'application/octet-stream'}, ${attachment.size} bytes).`,
-        type
-      };
-    case 'image':
-      return {
-        text: `Attached image "${attachment.name}" could not be encoded for the AI request.`,
-        type
-      };
-    case 'invalid-image':
-      return {
-        text: `Attached file "${attachment.name}" could not be processed as a valid image.`,
-        type
-      };
-    case 'text-file':
-      return {
-        text: attachment.textContent ? `Attached text file "${attachment.name}" (${attachment.mimeType || 'text/plain'}):\n\n${attachment.textContent}` : `Attached text file "${attachment.name}" (${attachment.mimeType || 'text/plain'}).`,
-        type
-      };
-  }
-};
 
-const getTextPart = (text, type) => {
-  return {
-    text,
-    type
-  };
-};
-const getChatMessageOpenAiContent = message => {
-  const parts = [];
-  const textPartType = message.role === 'assistant' ? 'output_text' : 'input_text';
-  if (message.text) {
-    parts.push(getTextPart(message.text, textPartType));
-  }
-  for (const attachment of message.attachments ?? []) {
-    if (message.role === 'user' && attachment.displayType === 'image' && attachment.previewSrc) {
-      parts.push({
-        image_url: attachment.previewSrc,
-        type: 'input_image'
-      });
-      continue;
-    }
-    parts.push(getAttachmentTextPart(attachment, textPartType));
+const handleClickSaveOpenApiApiKey = async state => {
+  const {
+    openApiApiKeyInput
+  } = state;
+  const openApiApiKey = openApiApiKeyInput.trim();
+  if (!openApiApiKey) {
+    return state;
   }
-  return parts;
-};
-
-const getClientRequestIdHeader = () => {
-  return {
-    'x-client-request-id': crypto.randomUUID()
+  const optimisticState = {
+    ...state,
+    openApiApiKeyState: 'saving'
   };
-};
-
-const getMockAiResponse = async (userMessage, delayInMs) => {
-  if (delayInMs > 0) {
-    await delay(delayInMs);
-  }
-  return `Mock AI response: I received "${userMessage}".`;
-};
-
-let requests = [];
-const reset$2 = () => {
-  requests = [];
-};
-const capture = request => {
-  requests = [...requests, request];
-};
-const getAll = () => {
-  return requests;
-};
-
-const defaultRequestId = 'default';
-let streamStates = new Map();
-let preparedRequestIds = [];
-const createState = () => {
-  return {
-    errorResult: undefined,
-    finished: false,
-    queue: [],
-    waiters: []
-  };
-};
-const getOrCreateState = requestId => {
-  const existing = streamStates.get(requestId);
-  if (existing) {
-    return existing;
-  }
-  const state = createState();
-  streamStates.set(requestId, state);
-  return state;
-};
-const enqueuePreparedRequest = requestId => {
-  if (preparedRequestIds.includes(requestId)) {
-    return;
-  }
-  preparedRequestIds.push(requestId);
-};
-const reset$1 = (requestId = defaultRequestId) => {
-  if (requestId === defaultRequestId) {
-    streamStates = new Map();
-    preparedRequestIds = [];
-    streamStates.set(defaultRequestId, createState());
-    return;
-  }
-  streamStates.set(requestId, createState());
-  enqueuePreparedRequest(requestId);
-};
-const startRequest = () => {
-  const requestId = preparedRequestIds.shift() || defaultRequestId;
-  getOrCreateState(requestId);
-  return requestId;
-};
-const setHttpErrorResponse$1 = (statusCode, body, requestId = defaultRequestId) => {
-  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;
-  const state = getOrCreateState(requestId);
-  state.errorResult = {
-    details: 'http-error',
-    ...(typeof errorCode === 'string' ? {
-      errorCode
-    } : {}),
-    ...(typeof errorMessage === 'string' ? {
-      errorMessage
-    } : {}),
-    ...(typeof errorType === 'string' ? {
-      errorType
-    } : {}),
-    statusCode,
-    type: 'error'
-  };
-};
-const setRequestFailedResponse = (isOffline = false, requestId = defaultRequestId) => {
-  const state = getOrCreateState(requestId);
-  state.errorResult = {
-    details: 'request-failed',
-    ...(isOffline ? {
-      isOffline: true
-    } : {}),
-    type: 'error'
-  };
-};
-const takeErrorResponse$1 = (requestId = defaultRequestId) => {
-  const state = getOrCreateState(requestId);
-  const error = state.errorResult;
-  state.errorResult = undefined;
-  return error;
-};
-const pushChunk = (chunk, requestId = defaultRequestId) => {
-  const state = getOrCreateState(requestId);
-  if (state.waiters.length > 0) {
-    const resolve = state.waiters.shift();
-    resolve?.(chunk);
-    return;
-  }
-  state.queue.push(chunk);
-};
-const finish = (requestId = defaultRequestId) => {
-  const state = getOrCreateState(requestId);
-  state.finished = true;
-  if (state.waiters.length === 0) {
-    return;
-  }
-  const activeWaiters = [...state.waiters];
-  state.waiters.length = 0;
-  for (const resolve of activeWaiters) {
-    resolve(undefined);
-  }
-};
-const readNextChunk = async (requestId = defaultRequestId) => {
-  const state = getOrCreateState(requestId);
-  if (state.queue.length > 0) {
-    return state.queue.shift();
-  }
-  if (state.finished) {
-    return undefined;
-  }
-  const {
-    promise,
-    resolve
-  } = Promise.withResolvers();
-  state.waiters.push(resolve);
-  return promise;
-};
-
-/* cspell:ignore sonarjs */
-
-const lastRequestSummaryToken = '__MOCK_OPENAPI_LAST_REQUEST_SUMMARY__';
-const getLastRequestSummary = () => {
-  const requests = getAll();
-  const request = requests.at(-1);
-  if (!request || !request.payload || typeof request.payload !== 'object') {
-    return 'mock-request-summary images=0 text-files=0';
-  }
-  const input = Reflect.get(request.payload, 'input');
-  if (!Array.isArray(input) || input.length === 0) {
-    return 'mock-request-summary images=0 text-files=0';
-  }
-  let imageCount = 0;
-  let textFileCount = 0;
-  for (const item of input) {
-    if (!item || typeof item !== 'object') {
-      continue;
-    }
-    const content = Reflect.get(item, 'content');
-    if (!Array.isArray(content)) {
-      continue;
-    }
-    for (const part of content) {
-      if (!part || typeof part !== 'object') {
-        continue;
-      }
-      const type = Reflect.get(part, 'type');
-      if (type === 'input_image') {
-        imageCount++;
-        continue;
-      }
-      if (type !== 'input_text') {
-        continue;
-      }
-      const text = Reflect.get(part, 'text');
-      if (typeof text === 'string' && text.startsWith('Attached text file "')) {
-        textFileCount++;
-      }
-    }
-  }
-  return `mock-request-summary images=${imageCount} text-files=${textFileCount}`;
-};
-const getResponseFunctionCalls$1 = value => {
-  if (!value || typeof value !== 'object') {
-    return [];
-  }
-  const output = Reflect.get(value, 'output');
-  if (!Array.isArray(output)) {
-    return [];
-  }
-  const responseFunctionCalls = [];
-  for (const item of output) {
-    if (!item || typeof item !== 'object') {
-      continue;
-    }
-    if (Reflect.get(item, 'type') !== 'function_call') {
-      continue;
-    }
-    const callId = Reflect.get(item, 'call_id');
-    const name = Reflect.get(item, 'name');
-    const rawArguments = Reflect.get(item, 'arguments');
-    if (typeof callId !== 'string' || typeof name !== 'string') {
-      continue;
-    }
-    responseFunctionCalls.push({
-      arguments: typeof rawArguments === 'string' ? rawArguments : '',
-      callId,
-      name
-    });
-  }
-  return responseFunctionCalls;
-};
-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, requestId) => {
-  const error = takeErrorResponse$1(requestId);
-  if (error) {
-    return error;
-  }
-  let text = '';
-  let remainder = '';
-  let toolCallAccumulator = {};
-  let responseFunctionCalls = [];
-  let responseId;
-  let requestDone = false;
-  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') {
-      const response = Reflect.get(parsed, 'response');
-      responseFunctionCalls = getResponseFunctionCalls$1(response);
-      const parsedResponseId = response && typeof response === 'object' ? Reflect.get(response, 'id') : undefined;
-      if (typeof parsedResponseId === 'string' && parsedResponseId) {
-        responseId = parsedResponseId;
-      }
-      requestDone = true;
-      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]') {
-        requestDone = true;
-        await notifyFinished();
-        break;
-      }
-      let parsed;
-      try {
-        parsed = JSON.parse(line);
-      } catch {
-        continue;
-      }
-      await handleParsedSseEvent(parsed);
-      if (requestDone) {
-        break;
-      }
-    }
-  };
-  while (!requestDone) {
-    const chunk = await readNextChunk(requestId);
-    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);
-        if (requestDone) {
-          break;
-        }
-      }
-      continue;
-    }
-    const resolvedChunk = chunk === lastRequestSummaryToken ? getLastRequestSummary() : chunk;
-    text += resolvedChunk;
-    if (stream && onTextChunk) {
-      await onTextChunk(resolvedChunk);
-    }
-  }
-  if (!requestDone && remainder) {
-    const dataLines = parseSseDataLines(remainder);
-    await consumeSseDataLines(dataLines);
-  }
-  await notifyFinished();
-  return {
-    ...(responseId ? {
-      responseId
-    } : {}),
-    responseFunctionCalls,
-    text,
-    type: 'success'
-  };
-};
-
-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 requestFailedResult = {
-  details: 'request-failed',
-  type: 'error'
-};
-const getSuccessResult = text => {
-  return {
-    text,
-    type: 'success'
-  };
-};
-const getErrorResult = (value, details) => {
-  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 normalizeMockResult = value => {
-  if (typeof value === 'string') {
-    return getSuccessResult(value);
-  }
-  if (!value || typeof value !== 'object') {
-    return requestFailedResult;
-  }
-  const type = Reflect.get(value, 'type');
-  if (type === 'success') {
-    const text = Reflect.get(value, 'text');
-    if (typeof text === 'string') {
-      return getSuccessResult(text);
-    }
-    return requestFailedResult;
-  }
-  if (type === 'error') {
-    const details = Reflect.get(value, 'details');
-    if (details === 'request-failed' || details === 'too-many-requests' || details === 'http-error') {
-      return getErrorResult(value, details);
-    }
-  }
-  const text = Reflect.get(value, 'text');
-  if (typeof text === 'string') {
-    return getSuccessResult(text);
-  }
-  return requestFailedResult;
-};
-
-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$9('ChatNetwork.makeApiRequest', options);
-};
-const makeStreamingApiRequest = async options => {
-  return invoke$9('ChatNetwork.makeStreamingApiRequest', options);
-};
-
-const getNumericCount = parsed => {
-  const count = Reflect.get(parsed, 'count');
-  if (typeof count === 'number' && Number.isFinite(count)) {
-    return count;
-  }
-  const matchCount = Reflect.get(parsed, 'matchCount');
-  if (typeof matchCount === 'number' && Number.isFinite(matchCount)) {
-    return matchCount;
-  }
-  return undefined;
-};
-const getArrayCount = parsed => {
-  const matches = Reflect.get(parsed, 'matches');
-  if (Array.isArray(matches)) {
-    return matches.length;
-  }
-  const files = Reflect.get(parsed, 'files');
-  if (Array.isArray(files)) {
-    return files.length;
-  }
-  const results = Reflect.get(parsed, 'results');
-  if (Array.isArray(results)) {
-    return results.length;
-  }
-  return undefined;
-};
-const getGlobMatchCount = result => {
-  if (!result) {
-    return undefined;
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(result);
-  } catch {
-    return undefined;
-  }
-  if (Array.isArray(parsed)) {
-    return parsed.length;
-  }
-  if (!parsed || typeof parsed !== 'object') {
-    return undefined;
-  }
-  return getNumericCount(parsed) ?? getArrayCount(parsed);
-};
-
-const getTextContent = content => {
-  if (typeof content === 'string') {
-    return content;
-  }
-  if (!Array.isArray(content)) {
-    return '';
-  }
-  const textParts = [];
-  for (const part of content) {
-    if (!part || typeof part !== 'object') {
-      continue;
-    }
-    const maybeType = Reflect.get(part, 'type');
-    const maybeText = Reflect.get(part, 'text');
-    if (maybeType === 'text' && typeof maybeText === 'string') {
-      textParts.push(maybeText);
-    }
-  }
-  return textParts.join('\n');
-};
-
-/* cspell:ignore sonarjs */
-
-const errorPrefixRegex = /^Error:\s*/;
-const notFoundErrorRegex = /not[\s_-]?found|enoent/i;
-const getOpenAiTools = tools => {
-  return tools.map(tool => {
-    if (!tool || typeof tool !== 'object') {
-      return tool;
-    }
-    const type = Reflect.get(tool, 'type');
-    const toolFunction = Reflect.get(tool, 'function');
-    if (type !== 'function' || !toolFunction || typeof toolFunction !== 'object') {
-      return tool;
-    }
-    const name = Reflect.get(toolFunction, 'name');
-    const description = Reflect.get(toolFunction, 'description');
-    const parameters = Reflect.get(toolFunction, 'parameters');
-    return {
-      ...(typeof description === 'string' ? {
-        description
-      } : {}),
-      ...(typeof name === 'string' ? {
-        name
-      } : {}),
-      ...(parameters && typeof parameters === 'object' ? {
-        parameters
-      } : {}),
-      type: 'function'
-    };
-  });
-};
-const getOpenAiParams = (input, modelId, stream, includeObfuscation, tools, webSearchEnabled, maxToolCalls, systemPrompt = '', previousResponseId, reasoningEffort, supportsReasoningEffort = false) => {
-  const openAiTools = getOpenAiTools(tools);
-  return {
-    input,
-    ...(systemPrompt ? {
-      instructions: systemPrompt
-    } : {}),
-    model: modelId,
-    ...(stream ? {
-      stream: true,
-      ...(includeObfuscation ? {} : {
-        stream_options: {
-          include_obfuscation: false
-        }
-      })
-    } : {}),
-    ...(previousResponseId ? {
-      previous_response_id: previousResponseId
-    } : {}),
-    ...(reasoningEffort && supportsReasoningEffort ? {
-      reasoning: {
-        effort: reasoningEffort
-      }
-    } : {}),
-    max_tool_calls: maxToolCalls,
-    tool_choice: 'auto',
-    tools: webSearchEnabled ? [...openAiTools, {
-      type: 'web_search'
-    }] : openAiTools
-  };
-};
-const getStreamChunkText = content => {
-  if (typeof content === 'string') {
-    return content;
-  }
-  if (!Array.isArray(content)) {
-    return '';
-  }
-  return content.map(part => {
-    if (!part || typeof part !== 'object') {
-      return '';
-    }
-    const text = Reflect.get(part, 'text');
-    return typeof text === 'string' ? text : '';
-  }).join('');
-};
-const getShortToolErrorMessage = error => {
-  const trimmed = error.trim().replace(errorPrefixRegex, '');
-  const firstLine = trimmed.split('\n')[0];
-  if (firstLine.length <= 80) {
-    return firstLine;
-  }
-  return `${firstLine.slice(0, 77)}...`;
-};
-const getStreamingToolCallStatus = value => {
-  if (value === 'in_progress') {
-    return 'in-progress';
-  }
-  if (value === 'cancelled' || value === 'canceled') {
-    return 'canceled';
-  }
-  if (value === 'failed' || value === 'error') {
-    return 'error';
-  }
-  return undefined;
-};
-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 rawStack = Reflect.get(parsed, 'errorStack') ?? Reflect.get(parsed, 'stack');
-  const errorStack = typeof rawStack === 'string' && rawStack.trim() ? rawStack : undefined;
-  const errorMessage = getShortToolErrorMessage(rawError);
-  if (notFoundErrorRegex.test(errorMessage)) {
-    return {
-      errorMessage,
-      ...(errorStack ? {
-        errorStack
-      } : {}),
-      status: 'not-found'
-    };
-  }
-  return {
-    ...(errorStack ? {
-      errorStack
-    } : {}),
-    errorMessage,
-    status: 'error'
-  };
-};
-const getToolCallResult = (name, content) => {
-  if (name === 'write_file') {
-    let parsed;
-    try {
-      parsed = JSON.parse(content);
-    } catch {
-      return undefined;
-    }
-    if (!parsed || typeof parsed !== 'object') {
-      return undefined;
-    }
-    const linesAdded = Reflect.get(parsed, 'addedLines') ?? Reflect.get(parsed, 'linesAdded');
-    const linesDeleted = Reflect.get(parsed, 'removedLines') ?? Reflect.get(parsed, 'linesDeleted');
-    if (typeof linesAdded !== 'number' && typeof linesDeleted !== 'number') {
-      return undefined;
-    }
-    return content;
-  }
-  if (name === 'glob') {
-    return getGlobMatchCount(content) === undefined ? undefined : content;
-  }
-  if (name !== 'getWorkspaceUri') {
-    return undefined;
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(content);
-  } catch {
-    return undefined;
-  }
-  if (!parsed || typeof parsed !== 'object') {
-    return undefined;
-  }
-  const workspaceUri = Reflect.get(parsed, 'workspaceUri');
-  if (typeof workspaceUri !== 'string' || !workspaceUri) {
-    return undefined;
-  }
-  return workspaceUri;
-};
-const getResponseOutputText = parsed => {
-  if (!parsed || typeof parsed !== 'object') {
-    return '';
-  }
-  const outputText = Reflect.get(parsed, 'output_text');
-  if (typeof outputText === 'string') {
-    return outputText;
-  }
-  const output = Reflect.get(parsed, 'output');
-  if (!Array.isArray(output)) {
-    return '';
-  }
-  const chunks = [];
-  for (const outputItem of output) {
-    if (!outputItem || typeof outputItem !== 'object') {
-      continue;
-    }
-    const itemType = Reflect.get(outputItem, 'type');
-    if (itemType !== 'message') {
-      continue;
-    }
-    const content = Reflect.get(outputItem, 'content');
-    if (!Array.isArray(content)) {
-      continue;
-    }
-    for (const part of content) {
-      if (!part || typeof part !== 'object') {
-        continue;
-      }
-      const partType = Reflect.get(part, 'type');
-      const text = Reflect.get(part, 'text');
-      if ((partType === 'output_text' || partType === 'text') && typeof text === 'string') {
-        chunks.push(text);
-      }
-    }
-  }
-  return chunks.join('');
-};
-const getResponseFunctionCalls = parsed => {
-  if (!parsed || typeof parsed !== 'object') {
-    return [];
-  }
-  const output = Reflect.get(parsed, 'output');
-  if (!Array.isArray(output)) {
-    return [];
-  }
-  const calls = [];
-  for (const outputItem of output) {
-    if (!outputItem || typeof outputItem !== 'object') {
-      continue;
-    }
-    const itemType = Reflect.get(outputItem, 'type');
-    if (itemType !== 'function_call') {
-      continue;
-    }
-    const callId = Reflect.get(outputItem, 'call_id');
-    const name = Reflect.get(outputItem, 'name');
-    const rawArguments = Reflect.get(outputItem, 'arguments');
-    if (typeof callId !== 'string' || typeof name !== 'string') {
-      continue;
-    }
-    calls.push({
-      arguments: typeof rawArguments === 'string' ? rawArguments : '',
-      callId,
-      name
-    });
-  }
-  return calls;
-};
-const parseSseEvent = 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 updateToolCallAccumulator = (accumulator, chunk) => {
-  let changed = false;
-  const nextAccumulator = {
-    ...accumulator
-  };
-  for (const item of chunk) {
-    if (!item || typeof item !== 'object') {
-      continue;
-    }
-    const index = Reflect.get(item, 'index');
-    if (typeof index !== 'number') {
-      continue;
-    }
-    const current = nextAccumulator[index] || {
-      arguments: '',
-      name: ''
-    };
-    const id = Reflect.get(item, 'id');
-    const toolFunction = Reflect.get(item, 'function');
-    let {
-      name
-    } = current;
-    let args = current.arguments;
-    if (toolFunction && typeof toolFunction === 'object') {
-      const deltaName = Reflect.get(toolFunction, 'name');
-      const deltaArguments = Reflect.get(toolFunction, 'arguments');
-      if (typeof deltaName === 'string' && deltaName) {
-        name = deltaName;
-      }
-      if (typeof deltaArguments === 'string') {
-        args += deltaArguments;
-      }
-    }
-    const next = {
-      arguments: args,
-      ...(typeof id === 'string' ? {
-        id
-      } : current.id ? {
-        id: current.id
-      } : {}),
-      name
-    };
-    if (JSON.stringify(next) !== JSON.stringify(current)) {
-      nextAccumulator[index] = next;
-      changed = true;
-    }
-  }
-  if (!changed) {
-    return undefined;
-  }
-  const toolCalls = Object.entries(nextAccumulator).toSorted((a, b) => Number(a[0]) - Number(b[0])).map(entry => entry[1]).filter(toolCall => !!toolCall.name);
-  return {
-    nextAccumulator,
-    toolCalls
-  };
-};
-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',
-      type: 'error'
-    };
-  }
-  const reader = response.body.getReader();
-  const decoder = new TextDecoder();
-  let remainder = '';
-  let text = '';
-  let done = false;
-  let toolCallAccumulator = {};
-  let responseId;
-  let completedResponseFunctionCalls = [];
-  const emitToolCallAccumulator = async () => {
-    if (!onToolCallsChunk) {
-      return;
-    }
-    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;
-    }
-    await onToolCallsChunk(toolCalls);
-  };
-  const handleParsedStreamEvent = async parsed => {
-    if (onDataEvent) {
-      await onDataEvent(parsed);
-    }
-    if (!parsed || typeof parsed !== 'object') {
-      return;
-    }
-    const eventType = Reflect.get(parsed, 'type');
-    if (eventType === 'response.completed') {
-      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') {
-      const delta = Reflect.get(parsed, 'delta');
-      if (typeof delta !== 'string' || !delta) {
-        return;
-      }
-      text += delta;
-      if (onTextChunk) {
-        await onTextChunk(delta);
-      }
-      return;
-    }
-    if (eventType === 'response.output_item.added') {
-      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 rawStatus = Reflect.get(item, 'status');
-      const status = getStreamingToolCallStatus(rawStatus);
-      const next = {
-        arguments: typeof rawArguments === 'string' ? rawArguments : '',
-        ...(typeof callId === 'string' ? {
-          id: callId
-        } : {}),
-        name: typeof name === 'string' ? name : '',
-        ...(status ? {
-          status
-        } : {})
-      };
-      toolCallAccumulator = {
-        ...toolCallAccumulator,
-        [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 rawStatus = Reflect.get(item, 'status');
-      const status = getStreamingToolCallStatus(rawStatus);
-      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,
-          ...(status ? {
-            status
-          } : current.status ? {
-            status: current.status
-          } : {})
-        }
-      };
-      await emitToolCallAccumulator();
-      return;
-    }
-    if (eventType === 'response.function_call_arguments.delta' || eventType === 'response.function_call_arguments.done') {
-      const toolCallKey = getStreamingToolCallKey(parsed);
-      if (!toolCallKey) {
-        return;
-      }
-      const current = toolCallAccumulator[toolCallKey] || {
-        arguments: '',
-        name: ''
-      };
-      const name = Reflect.get(parsed, 'name');
-      const callId = Reflect.get(parsed, 'call_id');
-      const delta = Reflect.get(parsed, 'delta');
-      const rawArguments = Reflect.get(parsed, 'arguments');
-      const next = {
-        arguments: typeof rawArguments === 'string' ? rawArguments : 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,
-        [toolCallKey]: next
-      };
-      await emitToolCallAccumulator();
-      return;
-    }
-    const choices = Reflect.get(parsed, 'choices');
-    if (!Array.isArray(choices)) {
-      return;
-    }
-    const firstChoice = choices[0];
-    if (!firstChoice || typeof firstChoice !== 'object') {
-      return;
-    }
-    const delta = Reflect.get(firstChoice, 'delta');
-    if (!delta || typeof delta !== 'object') {
-      return;
-    }
-    const toolCalls = Reflect.get(delta, 'tool_calls');
-    const updatedToolCallResult = Array.isArray(toolCalls) ? updateToolCallAccumulator(toolCallAccumulator, toolCalls) : undefined;
-    if (updatedToolCallResult) {
-      toolCallAccumulator = updatedToolCallResult.nextAccumulator;
-    }
-    if (updatedToolCallResult && onToolCallsChunk) {
-      await onToolCallsChunk(updatedToolCallResult.toolCalls);
-    }
-    const content = Reflect.get(delta, 'content');
-    const chunkText = getStreamChunkText(content);
-    if (!chunkText) {
-      return;
-    }
-    text += chunkText;
-    if (onTextChunk) {
-      await onTextChunk(chunkText);
-    }
-  };
-  while (!done) {
-    const {
-      done: streamDone,
-      value
-    } = await reader.read();
-    if (streamDone) {
-      done = true;
-    } else if (value) {
-      remainder += decoder.decode(value, {
-        stream: true
-      });
-    }
-    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 = parseSseEvent(rawEvent);
-      if (dataLines.length === 0) {
-        continue;
-      }
-      for (const line of dataLines) {
-        if (line === '[DONE]') {
-          done = true;
-          break;
-        }
-        let parsed;
-        try {
-          parsed = JSON.parse(line);
-        } catch {
-          continue;
-        }
-        await handleParsedStreamEvent(parsed);
-      }
-    }
-  }
-  if (remainder) {
-    const dataLines = parseSseEvent(remainder);
-    for (const line of dataLines) {
-      if (line === '[DONE]') {
-        continue;
-      }
-      let parsed;
-      try {
-        parsed = JSON.parse(line);
-      } catch {
-        continue;
-      }
-      await handleParsedStreamEvent(parsed);
-    }
-  }
-  const responseFunctionCalls = completedResponseFunctionCalls.length > 0 ? completedResponseFunctionCalls : getResponseFunctionCallsFromStreamingAccumulator(toolCallAccumulator);
-  return {
-    ...(responseId ? {
-      responseId
-    } : {}),
-    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 getOpenApiErrorDetailsFromResponseText = responseText => {
-  let parsed;
-  try {
-    parsed = JSON.parse(responseText);
-  } 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 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({
-    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-    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 {
-    agentMode = defaultAgentMode,
-    includeObfuscation = false,
-    maxToolCalls = defaultMaxToolCalls,
-    onDataEvent,
-    onEventStreamFinished,
-    onTextChunk,
-    onToolCallsChunk,
-    questionToolEnabled = false,
-    reasoningEffort,
-    sessionId,
-    stream,
-    supportsReasoningEffort = false,
-    systemPrompt = '',
-    toolEnablement,
-    useChatNetworkWorkerForRequests = false,
-    useChatToolWorker = true,
-    webSearchEnabled = false,
-    workspaceUri = ''
-  } = options ?? {
-    stream: false
-  };
-  const openAiInput = messages.map(message => ({
-    content: getChatMessageOpenAiContent(message),
-    role: message.role
-  }));
-  const tools = await getBasicChatTools(agentMode, questionToolEnabled, toolEnablement);
-  const safeMaxToolCalls = Math.max(1, maxToolCalls);
-  const maxToolIterations = safeMaxToolCalls - 1;
-  let previousResponseId;
-  for (let i = 0; i <= maxToolIterations; i++) {
-    const postBody = getOpenAiParams(openAiInput, modelId, stream, includeObfuscation, tools, webSearchEnabled, safeMaxToolCalls, systemPrompt, previousResponseId, reasoningEffort, supportsReasoningEffort);
-    if (stream) {
-      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;
-      }
-      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,
-            ...(sessionId ? {
-              sessionId
-            } : {}),
-            toolCallId: toolCall.callId,
-            ...(toolEnablement ? {
-              toolEnablement
-            } : {}),
-            useChatToolWorker,
-            workspaceUri
-          });
-          const executionStatus = getToolCallExecutionStatus(content);
-          const toolCallResult = getToolCallResult(toolCall.name, content);
-          executedToolCalls.push({
-            arguments: toolCall.arguments,
-            ...(executionStatus.errorStack ? {
-              errorStack: executionStatus.errorStack
-            } : {}),
-            ...(executionStatus.errorMessage ? {
-              errorMessage: executionStatus.errorMessage
-            } : {}),
-            ...(executionStatus.errorStack ? {
-              errorStack: executionStatus.errorStack
-            } : {}),
-            id: toolCall.callId,
-            name: toolCall.name,
-            ...(toolCallResult ? {
-              result: toolCallResult
-            } : {}),
-            ...(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;
-    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 {
-        text: '',
-        type: 'success'
-      };
-    }
-    const parsedResponseId = Reflect.get(parsed, 'id');
-    if (typeof parsedResponseId === 'string' && parsedResponseId) {
-      previousResponseId = parsedResponseId;
-    }
-    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,
-          ...(sessionId ? {
-            sessionId
-          } : {}),
-          toolCallId: toolCall.callId,
-          ...(toolEnablement ? {
-            toolEnablement
-          } : {}),
-          useChatToolWorker,
-          workspaceUri
-        });
-        const executionStatus = getToolCallExecutionStatus(content);
-        const toolCallResult = getToolCallResult(toolCall.name, content);
-        executedToolCalls.push({
-          arguments: toolCall.arguments,
-          ...(executionStatus.errorStack ? {
-            errorStack: executionStatus.errorStack
-          } : {}),
-          ...(executionStatus.errorMessage ? {
-            errorMessage: executionStatus.errorMessage
-          } : {}),
-          ...(executionStatus.errorStack ? {
-            errorStack: executionStatus.errorStack
-          } : {}),
-          id: toolCall.callId,
-          name: toolCall.name,
-          ...(toolCallResult ? {
-            result: toolCallResult
-          } : {}),
-          ...(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);
-    if (outputText) {
-      return {
-        text: outputText,
-        type: 'success'
-      };
-    }
-    const choices = Reflect.get(parsed, 'choices');
-    if (Array.isArray(choices)) {
-      const firstChoice = choices[0];
-      if (!firstChoice || typeof firstChoice !== 'object') {
-        return {
-          text: '',
-          type: 'success'
-        };
-      }
-      const message = Reflect.get(firstChoice, 'message');
-      if (!message || typeof message !== 'object') {
-        return {
-          text: '',
-          type: 'success'
-        };
-      }
-      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;
-          }
-          const id = Reflect.get(toolCall, 'id');
-          const toolFunction = Reflect.get(toolCall, 'function');
-          if (typeof id !== 'string' || !toolFunction || typeof toolFunction !== 'object') {
-            continue;
-          }
-          const name = Reflect.get(toolFunction, 'name');
-          const rawArguments = Reflect.get(toolFunction, 'arguments');
-          const content = typeof name === 'string' ? await executeChatTool(name, rawArguments, {
-            assetDir,
-            platform,
-            ...(sessionId ? {
-              sessionId
-            } : {}),
-            toolCallId: id,
-            useChatToolWorker,
-            workspaceUri
-          }) : '{}';
-          if (typeof name === 'string') {
-            const executionStatus = getToolCallExecutionStatus(content);
-            const toolCallResult = getToolCallResult(name, content);
-            executedToolCalls.push({
-              arguments: typeof rawArguments === 'string' ? rawArguments : '',
-              ...(executionStatus.errorStack ? {
-                errorStack: executionStatus.errorStack
-              } : {}),
-              ...(executionStatus.errorMessage ? {
-                errorMessage: executionStatus.errorMessage
-              } : {}),
-              ...(executionStatus.errorStack ? {
-                errorStack: executionStatus.errorStack
-              } : {}),
-              id,
-              name,
-              ...(toolCallResult ? {
-                result: toolCallResult
-              } : {}),
-              ...(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');
-      return {
-        text: getTextContent(content),
-        type: 'success'
-      };
-    }
-    return {
-      text: '',
-      type: 'success'
-    };
-  }
-  return {
-    details: 'tool-iterations-exhausted',
-    iterationLimit: safeMaxToolCalls,
-    type: 'error'
-  };
-};
-
-/* cspell:ignore sonarjs */
-
-const imageRegex = /\b(?:image|vision|multimodal)\b/i;
-const unsupportedRegex = /\bdoes(?:\s+not|n't)\s+support|not\s+support(?:ed)?|unsupported\b/i;
-const isOffline = () => {
-  if (!globalThis.navigator) {
-    return false;
-  }
-  return globalThis.navigator.onLine === false;
-};
-const isImageNotSupportedError = errorResult => {
-  const haystack = [errorResult.errorCode, errorResult.errorMessage, errorResult.errorType].filter(Boolean).join(' ');
-  return imageRegex.test(haystack) && unsupportedRegex.test(haystack);
-};
-const getImageNotSupportedMessage = modelName => {
-  const subject = modelName ? `${modelName} does not support image attachments.` : 'This model does not support image attachments.';
-  return `${subject} Choose a vision-capable model like GPT-4o Mini or GPT-4o, or remove the image and try again.`;
-};
-const getOpenApiErrorMessage = errorResult => {
-  switch (errorResult.details) {
-    case 'http-error':
-      {
-        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 (isImageNotSupportedError(errorResult)) {
-          return getImageNotSupportedMessage();
-        }
-        if (errorResult.statusCode === 429) {
-          let prefix = 'OpenAI rate limit exceeded (429)';
-          if (hasErrorCode) {
-            prefix = `OpenAI rate limit exceeded (429: ${errorResult.errorCode})`;
-          }
-          if (hasErrorType) {
-            prefix += ` [${errorResult.errorType}]`;
-          }
-          prefix += '.';
-          if (!errorMessage) {
-            return prefix;
-          }
-          return `${prefix} ${errorMessage}`;
-        }
-        if (typeof errorResult.statusCode === 'number') {
-          let prefix = `OpenAI request failed (status ${errorResult.statusCode})`;
-          if (hasErrorCode) {
-            prefix += `: ${errorResult.errorCode}`;
-          }
-          if (hasErrorType) {
-            prefix += ` [${errorResult.errorType}]`;
-          }
-          prefix += '.';
-          if (!errorMessage) {
-            return prefix;
-          }
-          return `${prefix} ${errorMessage}`;
-        }
-        if (errorMessage) {
-          return `OpenAI request failed. ${errorMessage}`;
-        }
-        return openApiRequestFailedMessage;
-      }
-    case 'request-failed':
-      if (errorResult.isOffline || isOffline()) {
-        return openApiRequestFailedOfflineMessage;
-      }
-      return openApiRequestFailedMessage;
-    case 'tool-iterations-exhausted':
-      {
-        const rounds = typeof errorResult.iterationLimit === 'number' ? errorResult.iterationLimit : defaultMaxToolCalls;
-        return `OpenAI request ended after ${rounds} tool-call rounds without a final assistant response. This usually means the model got stuck in a tool loop. Please try rephrasing your request, reducing scope, or switching to a different model.`;
-      }
-  }
-};
-
-const getOpenApiModelId = selectedModelId => {
-  const openApiPrefix = 'openapi/';
-  const openAiPrefix = 'openai/';
-  const normalizedModelId = selectedModelId.toLowerCase();
-  if (normalizedModelId.startsWith(openApiPrefix)) {
-    return selectedModelId.slice(openApiPrefix.length);
-  }
-  if (normalizedModelId.startsWith(openAiPrefix)) {
-    return selectedModelId.slice(openAiPrefix.length);
-  }
-  return selectedModelId;
-};
-
-const trailingSlashesRegex$2 = /\/+$/;
-const getOpenRouterApiEndpoint = openRouterApiBaseUrl => {
-  const trimmedBaseUrl = openRouterApiBaseUrl.replace(trailingSlashesRegex$2, '');
-  return `${trimmedBaseUrl}/chat/completions`;
-};
-
-const trailingSlashesRegex$1 = /\/+$/;
-const getOpenRouterKeyEndpoint = openRouterApiBaseUrl => {
-  const trimmedBaseUrl = openRouterApiBaseUrl.replace(trailingSlashesRegex$1, '');
-  return `${trimmedBaseUrl}/auth/key`;
-};
-
-/* cspell:ignore sonarjs */
-
-const getOpenRouterRaw429Message = async response => {
-  let parsed;
-  try {
-    parsed = await response.json();
-  } catch {
-    return undefined;
-  }
-  if (!parsed || typeof parsed !== 'object') {
-    return undefined;
-  }
-  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 getOpenRouterRaw429MessageFromText = responseText => {
-  let parsed;
-  try {
-    parsed = JSON.parse(responseText);
-  } catch {
-    return undefined;
-  }
-  if (!parsed || typeof parsed !== 'object') {
-    return undefined;
-  }
-  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;
-  }
-  const data = Reflect.get(parsed, 'data');
-  if (!data || typeof data !== 'object') {
-    return undefined;
-  }
-  const limitRemaining = Reflect.get(data, 'limit_remaining');
-  const limitReset = Reflect.get(data, 'limit_reset');
-  const usage = Reflect.get(data, 'usage');
-  const usageDaily = Reflect.get(data, 'usage_daily');
-  const normalizedLimitInfo = {
-    ...(typeof limitRemaining === 'number' || limitRemaining === null ? {
-      limitRemaining
-    } : {}),
-    ...(typeof limitReset === 'string' || limitReset === null ? {
-      limitReset
-    } : {}),
-    ...(typeof usage === 'number' ? {
-      usage
-    } : {}),
-    ...(typeof usageDaily === 'number' ? {
-      usageDaily
-    } : {})
-  };
-  const hasLimitInfo = normalizedLimitInfo.limitRemaining !== undefined || normalizedLimitInfo.limitReset !== undefined || normalizedLimitInfo.usage !== undefined || normalizedLimitInfo.usageDaily !== undefined;
-  if (!hasLimitInfo) {
-    return undefined;
-  }
-  return normalizedLimitInfo;
-};
-const getOpenRouterAssistantText = async (messages, modelId, openRouterApiKey, openRouterApiBaseUrl, assetDir, platform, useChatNetworkWorkerForRequests = false, useChatToolWorker = true, questionToolEnabled = false, systemPrompt = '', workspaceUri = '', agentMode = defaultAgentMode, toolEnablement, sessionId) => {
-  const effectiveAgentMode = typeof agentMode === 'boolean' ? defaultAgentMode : agentMode;
-  const completionMessages = [...(systemPrompt ? [{
-    content: systemPrompt,
-    role: 'system'
-  }] : []), ...messages.map(message => ({
-    content: message.text,
-    role: message.role
-  }))];
-  const tools = await getBasicChatTools(effectiveAgentMode, questionToolEnabled, toolEnablement);
-  const maxToolIterations = 4;
-  for (let i = 0; i <= maxToolIterations; i++) {
-    let parsed;
-    if (useChatNetworkWorkerForRequests) {
-      const requestResult = await makeApiRequest({
-        headers: {
-          Authorization: `Bearer ${openRouterApiKey}`,
-          'Content-Type': 'application/json',
-          ...getClientRequestIdHeader()
-        },
-        method: 'POST',
-        postBody: {
-          messages: completionMessages,
-          model: modelId,
-          tool_choice: 'auto',
-          tools
-        },
-        url: getOpenRouterApiEndpoint(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: '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'
-        };
-      }
-    }
-    if (!parsed || typeof parsed !== 'object') {
-      return {
-        text: '',
-        type: 'success'
-      };
-    }
-    const choices = Reflect.get(parsed, 'choices');
-    if (!Array.isArray(choices)) {
-      return {
-        text: '',
-        type: 'success'
-      };
-    }
-    const firstChoice = choices[0];
-    if (!firstChoice || typeof firstChoice !== 'object') {
-      return {
-        text: '',
-        type: 'success'
-      };
-    }
-    const message = Reflect.get(firstChoice, 'message');
-    if (!message || typeof message !== 'object') {
-      return {
-        text: '',
-        type: 'success'
-      };
-    }
-    const toolCalls = Reflect.get(message, 'tool_calls');
-    if (Array.isArray(toolCalls) && toolCalls.length > 0) {
-      completionMessages.push(message);
-      for (const toolCall of toolCalls) {
-        if (!toolCall || typeof toolCall !== 'object') {
-          continue;
-        }
-        const id = Reflect.get(toolCall, 'id');
-        const toolFunction = Reflect.get(toolCall, 'function');
-        if (typeof id !== 'string' || !toolFunction || typeof toolFunction !== 'object') {
-          continue;
-        }
-        const name = Reflect.get(toolFunction, 'name');
-        const rawArguments = Reflect.get(toolFunction, 'arguments');
-        const content = typeof name === 'string' ? await executeChatTool(name, rawArguments, {
-          assetDir,
-          platform,
-          ...(sessionId ? {
-            sessionId
-          } : {}),
-          toolCallId: id,
-          ...(toolEnablement ? {
-            toolEnablement
-          } : {}),
-          useChatToolWorker,
-          workspaceUri
-        }) : '{}';
-        completionMessages.push({
-          content,
-          role: 'tool',
-          tool_call_id: id
-        });
-      }
-      continue;
-    }
-    const content = Reflect.get(message, 'content');
-    return {
-      text: getTextContent(content),
-      type: 'success'
-    };
-  }
-  return {
-    details: 'request-failed',
-    type: 'error'
-  };
-};
-
-const getOpenRouterTooManyRequestsMessage = errorResult => {
-  const details = [];
-  if (errorResult.rawMessage) {
-    details.push(errorResult.rawMessage);
-  }
-  const {
-    limitInfo
-  } = errorResult;
-  if (limitInfo) {
-    if (limitInfo.retryAfter) {
-      details.push(`Retry after: ${limitInfo.retryAfter}.`);
-    }
-    if (limitInfo.limitReset) {
-      details.push(`Limit resets: ${limitInfo.limitReset}.`);
-    }
-    if (limitInfo.limitRemaining === null) {
-      details.push('Credits remaining: unlimited.');
-    } else if (typeof limitInfo.limitRemaining === 'number') {
-      details.push(`Credits remaining: ${limitInfo.limitRemaining}.`);
-    }
-    if (typeof limitInfo.usageDaily === 'number') {
-      details.push(`Credits used today (UTC): ${limitInfo.usageDaily}.`);
-    }
-    if (typeof limitInfo.usage === 'number') {
-      details.push(`Credits used (all time): ${limitInfo.usage}.`);
-    }
-  }
-  if (details.length === 0) {
-    return openRouterTooManyRequestsMessage;
-  }
-  return `${openRouterTooManyRequestsMessage} ${details.join(' ')}`;
-};
-
-const getOpenRouterErrorMessage = errorResult => {
-  switch (errorResult.details) {
-    case 'http-error':
-    case 'request-failed':
-      return openRouterRequestFailedMessage;
-    case 'too-many-requests':
-      return getOpenRouterTooManyRequestsMessage(errorResult);
-  }
-};
-
-// cspell:ignore openrouter
-const getOpenRouterModelId = selectedModelId => {
-  const openRouterPrefix = 'openrouter/';
-  if (selectedModelId.toLowerCase().startsWith(openRouterPrefix)) {
-    return selectedModelId.slice(openRouterPrefix.length);
-  }
-  return selectedModelId;
-};
-
-const isOpenApiModel = (selectedModelId, models) => {
-  const selectedModel = models.find(model => model.id === selectedModelId);
-  const normalizedProvider = selectedModel?.provider?.toLowerCase();
-  if (normalizedProvider === 'openapi' || normalizedProvider === 'openai' || normalizedProvider === 'open-ai') {
-    return true;
-  }
-  const normalizedModelId = selectedModelId.toLowerCase();
-  return normalizedModelId.startsWith('openapi/') || normalizedModelId.startsWith('openai/');
-};
-
-// cspell:ignore openrouter
-
-const isOpenRouterModel = (selectedModelId, models) => {
-  const selectedModel = models.find(model => model.id === selectedModelId);
-  const normalizedProvider = selectedModel?.provider?.toLowerCase();
-  if (normalizedProvider === 'openrouter' || normalizedProvider === 'open-router') {
-    return true;
-  }
-  return selectedModelId.toLowerCase().startsWith('openrouter/');
-};
-
-let errorResponse;
-let successResponse;
-const setHttpErrorResponse = (statusCode, body) => {
-  errorResponse = {
-    body,
-    statusCode,
-    type: 'http-error'
-  };
-};
-const setResponse = body => {
-  successResponse = {
-    body,
-    type: 'success'
-  };
-};
-const takeErrorResponse = () => {
-  const response = errorResponse;
-  errorResponse = undefined;
-  return response;
-};
-const takeResponse = () => {
-  const response = successResponse;
-  successResponse = undefined;
-  return response;
-};
-
-/* cspell:ignore sonarjs */
-
-const trailingSlashesRegex = /\/+$/;
-const shouldUseBackendResponses = (backendUrl, authAccessToken) => {
-  return !!backendUrl && !!authAccessToken;
-};
-const getBackendResponsesEndpoint = backendUrl => {
-  const trimmedBackendUrl = backendUrl.replace(trailingSlashesRegex, '');
-  return `${trimmedBackendUrl}/v1/responses`;
-};
-const hasImageAttachments = messages => {
-  return messages.some(message => message.attachments?.some(attachment => attachment.displayType === 'image'));
-};
-const isObject$1 = value => {
-  return !!value && typeof value === 'object';
-};
-const getBackendErrorMessageFromBody = body => {
-  if (!isObject$1(body)) {
-    return undefined;
-  }
-  const directMessage = Reflect.get(body, 'message');
-  if (typeof directMessage === 'string' && directMessage) {
-    return directMessage;
-  }
-  const directError = Reflect.get(body, 'error');
-  if (typeof directError === 'string' && directError) {
-    return directError;
-  }
-  if (!isObject$1(directError)) {
-    return undefined;
-  }
-  const nestedMessage = Reflect.get(directError, 'message');
-  if (typeof nestedMessage === 'string' && nestedMessage) {
-    return nestedMessage;
-  }
-  return undefined;
-};
-const getBackendErrorCodeFromBody = body => {
-  if (!isObject$1(body)) {
-    return undefined;
-  }
-  const directCode = Reflect.get(body, 'code');
-  if (typeof directCode === 'string' && directCode) {
-    return directCode;
-  }
-  const directError = Reflect.get(body, 'error');
-  if (!isObject$1(directError)) {
-    return undefined;
-  }
-  const nestedCode = Reflect.get(directError, 'code');
-  if (typeof nestedCode === 'string' && nestedCode) {
-    return nestedCode;
-  }
-  return undefined;
-};
-const getBackendStatusCodeFromBody = body => {
-  if (!isObject$1(body)) {
-    return undefined;
-  }
-  const statusCode = Reflect.get(body, 'statusCode');
-  if (typeof statusCode === 'number') {
-    return statusCode;
-  }
-  return undefined;
-};
-const getBackendResponseId = body => {
-  if (!isObject$1(body)) {
-    return undefined;
-  }
-  const id = Reflect.get(body, 'id');
-  return typeof id === 'string' && id ? id : undefined;
-};
-const getBackendResponseStatus = body => {
-  if (!isObject$1(body)) {
-    return undefined;
-  }
-  const status = Reflect.get(body, 'status');
-  return typeof status === 'string' && status ? status : undefined;
-};
-const getBackendIncompleteMessage = body => {
-  if (!isObject$1(body)) {
-    return undefined;
-  }
-  const incompleteDetails = Reflect.get(body, 'incomplete_details');
-  if (!isObject$1(incompleteDetails)) {
-    return undefined;
-  }
-  const reason = Reflect.get(incompleteDetails, 'reason');
-  if (typeof reason === 'string' && reason) {
-    return `Backend response was incomplete (${reason}).`;
-  }
-  return undefined;
-};
-const getBackendResponseFunctionCalls = body => {
-  if (!isObject$1(body)) {
-    return [];
-  }
-  const output = Reflect.get(body, 'output');
-  if (!Array.isArray(output)) {
-    return [];
-  }
-  const calls = [];
-  for (const outputItem of output) {
-    if (!isObject$1(outputItem)) {
-      continue;
-    }
-    if (Reflect.get(outputItem, 'type') !== 'function_call') {
-      continue;
-    }
-    const callId = Reflect.get(outputItem, 'call_id');
-    const name = Reflect.get(outputItem, 'name');
-    const rawArguments = Reflect.get(outputItem, 'arguments');
-    if (typeof callId !== 'string' || !callId || typeof name !== 'string' || !name) {
-      continue;
-    }
-    calls.push({
-      arguments: typeof rawArguments === 'string' ? rawArguments : '',
-      callId,
-      name
-    });
-  }
-  return calls;
-};
-const getErrorMessage = error => {
-  if (error instanceof Error) {
-    return error.message;
-  }
-  return typeof error === 'string' && error ? error : undefined;
-};
-const getBackendInvalidResponseDetails = body => {
-  const errorMessage = getBackendErrorMessageFromBody(body);
-  if (errorMessage) {
-    return errorMessage;
-  }
-  const incompleteMessage = getBackendIncompleteMessage(body);
-  if (incompleteMessage) {
-    return incompleteMessage;
-  }
-  const status = getBackendResponseStatus(body);
-  if (status && status !== 'completed') {
-    return `Backend response status was "${status}".`;
-  }
-  if (isObject$1(body) && Array.isArray(Reflect.get(body, 'output'))) {
-    return 'Unexpected backend response format: no assistant text or tool calls were returned.';
-  }
-  return 'Unexpected backend response format.';
-};
-const toExecutedToolCall = (toolCall, content) => {
-  const executionStatus = getToolCallExecutionStatus(content);
-  const toolCallResult = getToolCallResult(toolCall.name, content);
-  return {
-    arguments: toolCall.arguments,
-    ...(executionStatus.errorMessage ? {
-      errorMessage: executionStatus.errorMessage
-    } : {}),
-    ...(executionStatus.errorStack ? {
-      errorStack: executionStatus.errorStack
-    } : {}),
-    id: toolCall.callId,
-    name: toolCall.name,
-    ...(toolCallResult ? {
-      result: toolCallResult
-    } : {}),
-    ...(executionStatus.status ? {
-      status: executionStatus.status
-    } : {})
-  };
-};
-const getBackendResponseOutputText = body => {
-  if (!isObject$1(body)) {
-    return '';
-  }
-  const outputText = Reflect.get(body, 'output_text');
-  if (typeof outputText === 'string' && outputText) {
-    return outputText;
-  }
-  const text = Reflect.get(body, 'text');
-  if (typeof text === 'string' && text) {
-    return text;
-  }
-  const message = Reflect.get(body, 'message');
-  if (isObject$1(message)) {
-    const content = Reflect.get(message, 'content');
-    if (typeof content === 'string' && content) {
-      return content;
-    }
-  }
-  const choices = Reflect.get(body, 'choices');
-  if (Array.isArray(choices)) {
-    const firstChoice = choices[0];
-    if (isObject$1(firstChoice)) {
-      const firstMessage = Reflect.get(firstChoice, 'message');
-      if (isObject$1(firstMessage)) {
-        const content = Reflect.get(firstMessage, 'content');
-        if (typeof content === 'string' && content) {
-          return content;
-        }
-      }
-    }
-  }
-  const output = Reflect.get(body, 'output');
-  if (!Array.isArray(output)) {
-    return '';
-  }
-  const chunks = [];
-  for (const outputItem of output) {
-    if (!isObject$1(outputItem)) {
-      continue;
-    }
-    if (Reflect.get(outputItem, 'type') !== 'message') {
-      continue;
-    }
-    const content = Reflect.get(outputItem, 'content');
-    if (!Array.isArray(content)) {
-      continue;
-    }
-    for (const part of content) {
-      if (!isObject$1(part)) {
-        continue;
-      }
-      const type = Reflect.get(part, 'type');
-      const text = Reflect.get(part, 'text');
-      if ((type === 'output_text' || type === 'text') && typeof text === 'string' && text) {
-        chunks.push(text);
-      }
-    }
-  }
-  return chunks.join('');
-};
-const getBackendResponsesBody = (input, modelId, systemPrompt, tools, maxToolCalls, webSearchEnabled, previousResponseId, reasoningEffort, supportsReasoningEffort = false) => {
-  return getOpenAiParams(input, modelId, false, false, tools, webSearchEnabled, maxToolCalls, systemPrompt, previousResponseId, reasoningEffort, supportsReasoningEffort);
-};
-const getBackendAssistantText = async ({
-  agentMode = defaultAgentMode,
-  assetDir,
-  authAccessToken,
-  backendUrl,
-  maxToolCalls = defaultMaxToolCalls,
-  messages,
-  modelId,
-  onToolCallsChunk,
-  platform,
-  questionToolEnabled = false,
-  reasoningEffort,
-  sessionId,
-  supportsReasoningEffort = false,
-  systemPrompt,
-  toolEnablement,
-  useChatToolWorker,
-  webSearchEnabled = false,
-  workspaceUri
-}) => {
-  const mockError = takeErrorResponse();
-  if (mockError) {
-    const errorCode = getBackendErrorCodeFromBody(mockError.body);
-    const errorMessage = getBackendErrorMessageFromBody(mockError.body);
-    return getBackendErrorMessage({
-      details: 'http-error',
-      ...(errorCode ? {
-        errorCode
-      } : {}),
-      ...(typeof mockError.statusCode === 'number' ? {
-        statusCode: mockError.statusCode
-      } : {}),
-      ...(errorMessage ? {
-        errorMessage
-      } : {})
-    });
-  }
-  const mockResponse = takeResponse();
-  const tools = await getBasicChatTools(agentMode, questionToolEnabled, toolEnablement);
-  const input = messages.map(message => ({
-    content: getChatMessageOpenAiContent(message),
-    role: message.role
-  }));
-  let previousResponseId;
-  const maxToolIterations = Math.max(0, maxToolCalls - 1);
-  for (let index = 0; index <= maxToolIterations; index++) {
-    let json;
-    if (index === 0 && mockResponse) {
-      json = mockResponse.body;
-    } else {
-      let response;
-      try {
-        response = await fetch(getBackendResponsesEndpoint(backendUrl), {
-          body: JSON.stringify(getBackendResponsesBody(input, modelId, systemPrompt, tools, maxToolCalls, webSearchEnabled, previousResponseId, reasoningEffort, supportsReasoningEffort)),
-          headers: {
-            Authorization: `Bearer ${authAccessToken}`,
-            'Content-Type': 'application/json',
-            ...getClientRequestIdHeader()
-          },
-          method: 'POST'
-        });
-      } catch (error) {
-        const errorMessage = getErrorMessage(error);
-        return getBackendErrorMessage({
-          details: 'request-failed',
-          ...(errorMessage ? {
-            errorMessage
-          } : {})
-        });
-      }
-      if (!response.ok) {
-        const payload = await response.json().catch(() => undefined);
-        const errorCode = getBackendErrorCodeFromBody(payload);
-        const errorMessage = getBackendErrorMessageFromBody(payload);
-        const statusCode = response.status || getBackendStatusCodeFromBody(payload);
-        return getBackendErrorMessage({
-          details: 'http-error',
-          ...(errorCode ? {
-            errorCode
-          } : {}),
-          ...(typeof statusCode === 'number' ? {
-            statusCode
-          } : {}),
-          ...(errorMessage ? {
-            errorMessage
-          } : {})
-        });
-      }
-      try {
-        json = await response.json();
-      } catch {
-        return getBackendErrorMessage({
-          details: 'invalid-response',
-          errorMessage: 'Backend returned invalid JSON.'
-        });
-      }
-    }
-    const responseFunctionCalls = getBackendResponseFunctionCalls(json);
-    if (responseFunctionCalls.length > 0) {
-      const responseId = getBackendResponseId(json);
-      if (!responseId) {
-        return getBackendErrorMessage({
-          details: 'invalid-response',
-          errorMessage: 'Unexpected backend response format: tool calls were returned without a response id.'
-        });
-      }
-      previousResponseId = responseId;
-      input.length = 0;
-      const executedToolCalls = [];
-      for (const toolCall of responseFunctionCalls) {
-        const content = await executeChatTool(toolCall.name, toolCall.arguments, {
-          assetDir,
-          platform,
-          ...(sessionId ? {
-            sessionId
-          } : {}),
-          toolCallId: toolCall.callId,
-          ...(toolEnablement ? {
-            toolEnablement
-          } : {}),
-          useChatToolWorker,
-          ...(workspaceUri ? {
-            workspaceUri
-          } : {})
-        });
-        executedToolCalls.push(toExecutedToolCall(toolCall, content));
-        input.push({
-          call_id: toolCall.callId,
-          output: content,
-          type: 'function_call_output'
-        });
-      }
-      if (onToolCallsChunk && executedToolCalls.length > 0) {
-        await onToolCallsChunk(executedToolCalls);
-      }
-      continue;
-    }
-    const content = getBackendResponseOutputText(json);
-    if (content) {
-      return content;
-    }
-    return getBackendErrorMessage({
-      details: 'invalid-response',
-      errorMessage: getBackendInvalidResponseDetails(json)
-    });
-  }
-  return getBackendErrorMessage({
-    details: 'invalid-response',
-    errorMessage: `Backend request ended after ${maxToolCalls} tool-call rounds without a final assistant response. This usually means the model got stuck in a tool loop.`
-  });
-};
-const getAiResponse = async ({
-  agentMode = defaultAgentMode,
-  assetDir,
-  authAccessToken,
-  backendUrl = '',
-  maxToolCalls = defaultMaxToolCalls,
-  messageId,
-  messages,
-  mockAiResponseDelay = 800,
-  mockApiCommandId,
-  models,
-  nextMessageId,
-  onDataEvent,
-  onEventStreamFinished,
-  onMockOpenApiRequestCaptured,
-  onTextChunk,
-  onToolCallsChunk,
-  openApiApiBaseUrl,
-  openApiApiKey,
-  openRouterApiBaseUrl,
-  openRouterApiKey,
-  passIncludeObfuscation = false,
-  platform,
-  questionToolEnabled = false,
-  reasoningEffort,
-  selectedModelId,
-  sessionId,
-  streamingEnabled = true,
-  systemPrompt = '',
-  toolEnablement,
-  useChatCoordinatorWorker = false,
-  useChatNetworkWorkerForRequests = false,
-  useChatToolWorker = true,
-  useMockApi,
-  useOwnBackend = false,
-  userText,
-  webSearchEnabled = false,
-  workspaceUri
-}) => {
-  useChatCoordinatorWorker = false; // TODO enable this
-  const authToken = authAccessToken || '';
-  const backendEnabled = shouldUseBackendResponses(backendUrl, authToken);
-  if (useChatCoordinatorWorker && !backendEnabled) {
-    try {
-      const result = await getAiResponse$1({
-        agentMode,
-        assetDir,
-        ...(messageId ? {
-          messageId
-        } : {}),
-        maxToolCalls,
-        messages,
-        mockAiResponseDelay,
-        mockApiCommandId,
-        models,
-        nextMessageId,
-        openApiApiBaseUrl,
-        openApiApiKey,
-        openRouterApiBaseUrl,
-        openRouterApiKey,
-        passIncludeObfuscation,
-        platform,
-        questionToolEnabled,
-        ...(reasoningEffort ? {
-          reasoningEffort
-        } : {}),
-        selectedModelId,
-        streamingEnabled,
-        systemPrompt,
-        ...(toolEnablement ? {
-          toolEnablement
-        } : {}),
-        useChatNetworkWorkerForRequests,
-        useChatToolWorker,
-        useMockApi,
-        userText,
-        webSearchEnabled: agentMode === 'plan' ? false : webSearchEnabled,
-        ...(workspaceUri ? {
-          workspaceUri
-        } : {})
-      });
-      if (streamingEnabled) {
-        if (onTextChunk) {
-          await onTextChunk(result.text);
-        }
-        if (onEventStreamFinished) {
-          await onEventStreamFinished();
-        }
-      }
-      return result;
-    } catch {
-      // Fall back to the local implementation if coordinator worker RPC is unavailable.
-    }
-  }
-  let text = '';
-  const usesOpenApiModel = isOpenApiModel(selectedModelId, models);
-  const usesOpenRouterModel = isOpenRouterModel(selectedModelId, models);
-  const selectedModel = models.find(model => model.id === selectedModelId);
-  const supportsImages = selectedModel?.supportsImages ?? false;
-  const supportsReasoningEffort = selectedModel?.supportsReasoningEffort ?? false;
-  const safeMaxToolCalls = Math.max(1, maxToolCalls);
-  if (hasImageAttachments(messages) && !supportsImages) {
-    text = getImageNotSupportedMessage(selectedModel?.name);
-  }
-  if (!text && (backendEnabled || useOwnBackend)) {
-    if (!backendUrl) {
-      text = backendUrlRequiredMessage;
-    } else if (authToken) {
-      text = await getBackendAssistantText({
-        agentMode,
-        assetDir,
-        authAccessToken: authToken,
-        backendUrl,
-        maxToolCalls: safeMaxToolCalls,
-        messages,
-        modelId: getOpenApiModelId(selectedModelId),
-        onToolCallsChunk,
-        platform,
-        questionToolEnabled,
-        reasoningEffort,
-        supportsReasoningEffort,
-        systemPrompt,
-        toolEnablement,
-        useChatToolWorker,
-        webSearchEnabled: agentMode === 'plan' ? false : webSearchEnabled,
-        ...(sessionId ? {
-          sessionId
-        } : {}),
-        ...(workspaceUri ? {
-          workspaceUri
-        } : {})
-      });
-    } else {
-      text = backendAccessTokenRequiredMessage;
-    }
-  }
-  if (!text && usesOpenApiModel) {
-    if (useMockApi) {
-      const openAiInput = messages.map(message => ({
-        content: getChatMessageOpenAiContent(message),
-        role: message.role
-      }));
-      const modelId = getOpenApiModelId(selectedModelId);
-      const headers = {
-        Authorization: `Bearer ${openApiApiKey}`,
-        'Content-Type': 'application/json',
-        ...getClientRequestIdHeader()
-      };
-      const maxToolIterations = safeMaxToolCalls - 1;
-      const mockRequestId = startRequest();
-      let previousResponseId;
-      for (let i = 0; i <= maxToolIterations; i++) {
-        const tools1 = await getBasicChatTools(agentMode, questionToolEnabled, toolEnablement);
-        const request = {
-          headers,
-          method: 'POST',
-          payload: getOpenAiParams(openAiInput, modelId, streamingEnabled, passIncludeObfuscation, tools1, agentMode === 'plan' ? false : webSearchEnabled, safeMaxToolCalls, systemPrompt, previousResponseId, reasoningEffort, supportsReasoningEffort),
-          url: getOpenApiApiEndpoint(openApiApiBaseUrl)
-        };
-        capture(request);
-        if (onMockOpenApiRequestCaptured) {
-          await Promise.resolve(onMockOpenApiRequestCaptured(request));
-        }
-        const result = await getMockOpenApiAssistantText(streamingEnabled, onTextChunk, onToolCallsChunk, onDataEvent, onEventStreamFinished, mockRequestId);
-        if (result.type !== 'success') {
-          text = getOpenApiErrorMessage(result);
-          break;
-        }
-        text = result.text;
-        if (result.responseId) {
-          previousResponseId = result.responseId;
-        }
-        if (result.responseFunctionCalls.length === 0) {
-          break;
-        }
-        openAiInput.length = 0;
-        const executedToolCalls = [];
-        for (const toolCall of result.responseFunctionCalls) {
-          const content = await executeChatTool(toolCall.name, toolCall.arguments, {
-            assetDir,
-            platform,
-            ...(sessionId ? {
-              sessionId
-            } : {}),
-            toolCallId: toolCall.callId,
-            ...(toolEnablement ? {
-              toolEnablement
-            } : {}),
-            useChatToolWorker,
-            ...(workspaceUri ? {
-              workspaceUri
-            } : {})
-          });
-          const executionStatus = getToolCallExecutionStatus(content);
-          const toolCallResult = getToolCallResult(toolCall.name, content);
-          executedToolCalls.push({
-            arguments: toolCall.arguments,
-            ...(executionStatus.errorStack ? {
-              errorStack: executionStatus.errorStack
-            } : {}),
-            ...(executionStatus.errorMessage ? {
-              errorMessage: executionStatus.errorMessage
-            } : {}),
-            id: toolCall.callId,
-            name: toolCall.name,
-            ...(toolCallResult ? {
-              result: toolCallResult
-            } : {}),
-            ...(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);
-        }
-      }
-    } else if (openApiApiKey) {
-      const result = await getOpenApiAssistantText(messages, getOpenApiModelId(selectedModelId), openApiApiKey, openApiApiBaseUrl, assetDir, platform, {
-        agentMode,
-        includeObfuscation: passIncludeObfuscation,
-        maxToolCalls: safeMaxToolCalls,
-        ...(onDataEvent ? {
-          onDataEvent
-        } : {}),
-        ...(onEventStreamFinished ? {
-          onEventStreamFinished
-        } : {}),
-        ...(onTextChunk ? {
-          onTextChunk
-        } : {}),
-        ...(onToolCallsChunk ? {
-          onToolCallsChunk
-        } : {}),
-        questionToolEnabled,
-        ...(reasoningEffort ? {
-          reasoningEffort
-        } : {}),
-        ...(sessionId ? {
-          sessionId
-        } : {}),
-        stream: streamingEnabled,
-        supportsReasoningEffort,
-        systemPrompt,
-        ...(toolEnablement ? {
-          toolEnablement
-        } : {}),
-        useChatNetworkWorkerForRequests,
-        useChatToolWorker,
-        webSearchEnabled: agentMode === 'plan' ? false : webSearchEnabled,
-        ...(workspaceUri ? {
-          workspaceUri
-        } : {})
-      });
-      if (result.type === 'success') {
-        const {
-          text: assistantText
-        } = result;
-        text = assistantText;
-      } else {
-        text = getOpenApiErrorMessage(result);
-      }
-    } else {
-      text = openApiApiKeyRequiredMessage;
-    }
-  } else if (!text && usesOpenRouterModel) {
-    const modelId = getOpenRouterModelId(selectedModelId);
-    if (useMockApi) {
-      const result = await getMockOpenRouterAssistantText(messages, modelId, openRouterApiBaseUrl, openRouterApiKey, mockApiCommandId, assetDir, platform);
-      if (result.type === 'success') {
-        const {
-          text: assistantText
-        } = result;
-        text = assistantText;
-      } else {
-        text = getOpenRouterErrorMessage(result);
-      }
-    } else if (openRouterApiKey) {
-      const result = await getOpenRouterAssistantText(messages, modelId, openRouterApiKey, openRouterApiBaseUrl, assetDir, platform, useChatNetworkWorkerForRequests, useChatToolWorker, questionToolEnabled, systemPrompt, workspaceUri, agentMode, toolEnablement, sessionId);
-      if (result.type === 'success') {
-        const {
-          text: assistantText
-        } = result;
-        text = assistantText;
-      } else {
-        text = getOpenRouterErrorMessage(result);
-      }
-    } else {
-      text = openRouterApiKeyRequiredMessage;
-    }
-  }
-  if (!text && !usesOpenApiModel && !usesOpenRouterModel) {
-    text = await getMockAiResponse(userText, mockAiResponseDelay);
-  }
-  const assistantTime = new Date().toLocaleTimeString([], {
-    hour: '2-digit',
-    minute: '2-digit'
-  });
-  const message = {
-    id: messageId || crypto.randomUUID(),
-    role: 'assistant',
-    text,
-    time: assistantTime
-  };
-  return message;
-};
-
-const parseMessageContents = async rawMessages => {
-  return invoke$a('ChatMessageParsing.parseMessageContents', rawMessages);
-};
-
-const emptyMessageContent = [{
-  children: [{
-    text: '',
-    type: 'text'
-  }],
-  type: 'text'
-}];
-const getPlainTextMessageContent = text => {
-  return [{
-    children: [{
-      text,
-      type: 'text'
-    }],
-    type: 'text'
-  }];
-};
-const getParsedMessageContent = (parsedMessages, messageId) => {
-  const parsedMessage = parsedMessages.find(item => item.id === messageId);
-  return parsedMessage?.parsedContent;
-};
-const setParsedMessageContent = (parsedMessages, messageId, text, parsedContent) => {
-  const index = parsedMessages.findIndex(item => item.id === messageId);
-  if (index === -1) {
-    return [...parsedMessages, {
-      id: messageId,
-      parsedContent,
-      text
-    }];
-  }
-  const existingItem = parsedMessages[index];
-  if (existingItem.text === text && existingItem.parsedContent === parsedContent) {
-    return parsedMessages;
-  }
-  return [...parsedMessages.slice(0, index), {
-    ...existingItem,
-    parsedContent,
-    text
-  }, ...parsedMessages.slice(index + 1)];
-};
-const parseAndStoreMessageContent = async (parsedMessages, message) => {
-  return parseAndStoreMessagesContentInWorker(parsedMessages, [message]);
-};
-const parseAndStoreMessagesContent = async (parsedMessages, messages) => {
-  return parseAndStoreMessagesContentInWorker(parsedMessages, messages);
-};
-const getMessagesNeedingParsing = (parsedMessages, messages) => {
-  return messages.filter(message => {
-    const existingParsedMessage = parsedMessages.find(item => item.id === message.id);
-    return !existingParsedMessage || existingParsedMessage.text !== message.text;
-  });
-};
-const parseAndStoreMessagesContentInWorker = async (parsedMessages, messages) => {
-  const messagesNeedingParsing = getMessagesNeedingParsing(parsedMessages, messages);
-  if (messagesNeedingParsing.length === 0) {
-    return parsedMessages;
-  }
-  let parsedContents;
-  try {
-    parsedContents = await parseMessageContents(messagesNeedingParsing.map(message => message.text));
-  } catch {
-    parsedContents = messagesNeedingParsing.map(message => getPlainTextMessageContent(message.text));
-  }
-  let nextParsedMessages = parsedMessages;
-  for (const [index, message] of messagesNeedingParsing.entries()) {
-    const parsedContent = message.text === '' ? emptyMessageContent : parsedContents[index];
-    nextParsedMessages = setParsedMessageContent(nextParsedMessages, message.id, message.text, parsedContent);
-  }
-  return nextParsedMessages;
-};
-const getEmptyMessageContent = () => {
-  return emptyMessageContent;
-};
-
-const update = async settings => {
-  await invoke$1('Preferences.update', settings);
-};
-
-const setOpenApiApiKey = async (state, openApiApiKey, persist = true) => {
-  if (persist) {
-    await update({
-      'secrets.openApiKey': openApiApiKey
-    });
-  }
-  return {
-    ...state,
-    openApiApiKey,
-    openApiApiKeyInput: openApiApiKey
-  };
-};
-
-const handleClickSaveOpenApiApiKey = async state => {
-  const {
-    openApiApiKeyInput
-  } = state;
-  const openApiApiKey = openApiApiKeyInput.trim();
-  if (!openApiApiKey) {
-    return state;
-  }
-  const optimisticState = {
-    ...state,
-    openApiApiKeyState: 'saving'
-  };
-  set(state.uid, state, optimisticState);
-  await invoke$1('Chat.rerender');
-  const persistedState = await setOpenApiApiKey(optimisticState, openApiApiKey);
-  const updatedState = {
-    ...persistedState,
-    openApiApiKeyState: 'idle'
-  };
-  const session = updatedState.sessions.find(item => item.id === updatedState.selectedSessionId);
-  if (!session) {
-    return updatedState;
-  }
-  const selectedMessages = updatedState.messages.length > 0 ? updatedState.messages : session.messages;
-  const lastMessage = selectedMessages.at(-1);
-  const shouldRetryOpenApi = lastMessage?.role === 'assistant' && lastMessage.text === openApiApiKeyRequiredMessage;
-  if (!shouldRetryOpenApi) {
-    return updatedState;
-  }
-  const previousUserMessage = selectedMessages.toReversed().find(item => item.role === 'user');
-  if (!previousUserMessage) {
-    return updatedState;
-  }
-  const retryMessages = selectedMessages.slice(0, -1);
-  const assistantMessage = await getAiResponse({
-    agentMode: updatedState.agentMode,
-    assetDir: updatedState.assetDir,
-    maxToolCalls: updatedState.maxToolCalls,
-    messages: retryMessages,
-    mockAiResponseDelay: updatedState.mockAiResponseDelay,
-    mockApiCommandId: updatedState.mockApiCommandId,
-    models: updatedState.models,
-    nextMessageId: updatedState.nextMessageId,
-    openApiApiBaseUrl: updatedState.openApiApiBaseUrl,
-    openApiApiKey: updatedState.openApiApiKey,
-    openRouterApiBaseUrl: updatedState.openRouterApiBaseUrl,
-    openRouterApiKey: updatedState.openRouterApiKey,
-    platform: updatedState.platform,
-    selectedModelId: updatedState.selectedModelId,
-    streamingEnabled: updatedState.streamingEnabled,
-    systemPrompt: updatedState.systemPrompt,
-    useChatCoordinatorWorker: updatedState.useChatCoordinatorWorker,
-    useChatNetworkWorkerForRequests: updatedState.useChatNetworkWorkerForRequests,
-    useMockApi: updatedState.useMockApi,
-    useOwnBackend: updatedState.useOwnBackend,
-    userText: previousUserMessage.text
-  });
-  const parsedMessages = await parseAndStoreMessageContent(updatedState.parsedMessages, assistantMessage);
-  const messages = [...selectedMessages.slice(0, -1), assistantMessage];
-  const updatedSession = {
-    ...session,
-    messages,
-    status: 'finished'
-  };
-  const updatedSessionSummary = {
-    ...session,
-    messages: [],
-    status: 'finished'
-  };
-  await saveChatSessionPreservingMessages(updatedSession, messages);
-  const updatedSessions = updatedState.sessions.map(item => {
-    if (item.id !== updatedState.selectedSessionId) {
-      return item;
-    }
-    return updatedSessionSummary;
-  });
-  return {
-    ...updatedState,
-    messages,
-    nextMessageId: updatedState.nextMessageId + 1,
-    openApiApiKeyState: 'idle',
-    parsedMessages,
-    sessions: updatedSessions
-  };
-};
-
-const setOpenRouterApiKey = async (state, openRouterApiKey, persist = true) => {
-  if (persist) {
-    await update({
-      'secrets.openRouterApiKey': openRouterApiKey
-    });
-  }
-  return {
-    ...state,
-    openRouterApiKey,
-    openRouterApiKeyInput: openRouterApiKey
-  };
-};
-
-const handleClickSaveOpenRouterApiKey = async state => {
-  const {
-    openRouterApiKeyInput
-  } = state;
-  const openRouterApiKey = openRouterApiKeyInput.trim();
-  if (!openRouterApiKey) {
-    return state;
-  }
-  const optimisticState = {
-    ...state,
-    openRouterApiKeyState: 'saving'
-  };
-  set(state.uid, state, optimisticState);
-  await invoke$1('Chat.rerender');
-  const persistedState = await setOpenRouterApiKey(optimisticState, openRouterApiKey);
-  const updatedState = {
-    ...persistedState,
-    openRouterApiKeyState: 'idle'
+  set(state.uid, state, optimisticState);
+  await invoke$1('Chat.rerender');
+  const persistedState = await setOpenApiApiKey(optimisticState, openApiApiKey);
+  const updatedState = {
+    ...persistedState,
+    openApiApiKeyState: 'idle'
   };
   const session = updatedState.sessions.find(item => item.id === updatedState.selectedSessionId);
   if (!session) {
-    return updatedState;
-  }
-  const selectedMessages = updatedState.messages.length > 0 ? updatedState.messages : session.messages;
-  const lastMessage = selectedMessages.at(-1);
-  const shouldRetryOpenRouter = lastMessage?.role === 'assistant' && lastMessage.text === openRouterApiKeyRequiredMessage;
-  if (!shouldRetryOpenRouter) {
-    return updatedState;
-  }
-  const previousUserMessage = selectedMessages.toReversed().find(item => item.role === 'user');
-  if (!previousUserMessage) {
-    return updatedState;
-  }
-  const retryMessages = selectedMessages.slice(0, -1);
-  const assistantMessage = await getAiResponse({
-    agentMode: updatedState.agentMode,
-    assetDir: updatedState.assetDir,
-    maxToolCalls: updatedState.maxToolCalls,
-    messages: retryMessages,
-    mockAiResponseDelay: updatedState.mockAiResponseDelay,
-    mockApiCommandId: updatedState.mockApiCommandId,
-    models: updatedState.models,
-    nextMessageId: updatedState.nextMessageId,
-    openApiApiBaseUrl: updatedState.openApiApiBaseUrl,
-    openApiApiKey: updatedState.openApiApiKey,
-    openRouterApiBaseUrl: updatedState.openRouterApiBaseUrl,
-    openRouterApiKey,
-    platform: updatedState.platform,
-    selectedModelId: updatedState.selectedModelId,
-    systemPrompt: updatedState.systemPrompt,
-    useChatCoordinatorWorker: updatedState.useChatCoordinatorWorker,
-    useChatNetworkWorkerForRequests: updatedState.useChatNetworkWorkerForRequests,
-    useMockApi: updatedState.useMockApi,
-    useOwnBackend: updatedState.useOwnBackend,
-    userText: previousUserMessage.text
-  });
-  const parsedMessages = await parseAndStoreMessageContent(updatedState.parsedMessages, assistantMessage);
-  const messages = [...selectedMessages.slice(0, -1), assistantMessage];
-  const updatedSession = {
-    ...session,
-    messages,
-    status: 'finished'
-  };
-  const updatedSessionSummary = {
-    ...session,
-    messages: [],
-    status: 'finished'
-  };
-  await saveChatSessionPreservingMessages(updatedSession, messages);
-  const updatedSessions = updatedState.sessions.map(item => {
-    if (item.id !== updatedState.selectedSessionId) {
-      return item;
-    }
-    return updatedSessionSummary;
-  });
-  return {
-    ...updatedState,
-    messages,
-    nextMessageId: updatedState.nextMessageId + 1,
-    openRouterApiKeyState: 'idle',
-    parsedMessages,
-    sessions: updatedSessions
-  };
+    return updatedState;
+  }
+  const selectedMessages = updatedState.messages.length > 0 ? updatedState.messages : session.messages;
+  const lastMessage = selectedMessages.at(-1);
+  const shouldRetryOpenApi = lastMessage?.role === 'assistant' && lastMessage.text === openApiApiKeyRequiredMessage;
+  if (!shouldRetryOpenApi) {
+    return updatedState;
+  }
+  const previousUserMessage = selectedMessages.toReversed().find(item => item.role === 'user');
+  if (!previousUserMessage) {
+    return updatedState;
+  }
+
+  // @ts-ignore
+  selectedMessages.slice(0, -1);
+
+  // TODO ask view-model to do it
+  return state;
+};
+
+const handleClickSaveOpenRouterApiKey = async state => {
+  const {
+    openRouterApiKeyInput
+  } = state;
+  // TODO ask worker to do it
+  // @ts-ignore
+  openRouterApiKeyInput.trim();
+  return state;
 };
 
 const handleClickSend = async state => {
@@ -8964,6 +5438,83 @@ const openRunModePicker = state => {
   };
 };
 
+const parseMessageContents = async rawMessages => {
+  return invoke$8('ChatMessageParsing.parseMessageContents', rawMessages);
+};
+
+const emptyMessageContent = [{
+  children: [{
+    text: '',
+    type: 'text'
+  }],
+  type: 'text'
+}];
+const getPlainTextMessageContent = text => {
+  return [{
+    children: [{
+      text,
+      type: 'text'
+    }],
+    type: 'text'
+  }];
+};
+const getParsedMessageContent = (parsedMessages, messageId) => {
+  const parsedMessage = parsedMessages.find(item => item.id === messageId);
+  return parsedMessage?.parsedContent;
+};
+const setParsedMessageContent = (parsedMessages, messageId, text, parsedContent) => {
+  const index = parsedMessages.findIndex(item => item.id === messageId);
+  if (index === -1) {
+    return [...parsedMessages, {
+      id: messageId,
+      parsedContent,
+      text
+    }];
+  }
+  const existingItem = parsedMessages[index];
+  if (existingItem.text === text && existingItem.parsedContent === parsedContent) {
+    return parsedMessages;
+  }
+  return [...parsedMessages.slice(0, index), {
+    ...existingItem,
+    parsedContent,
+    text
+  }, ...parsedMessages.slice(index + 1)];
+};
+const parseAndStoreMessageContent = async (parsedMessages, message) => {
+  return parseAndStoreMessagesContentInWorker(parsedMessages, [message]);
+};
+const parseAndStoreMessagesContent = async (parsedMessages, messages) => {
+  return parseAndStoreMessagesContentInWorker(parsedMessages, messages);
+};
+const getMessagesNeedingParsing = (parsedMessages, messages) => {
+  return messages.filter(message => {
+    const existingParsedMessage = parsedMessages.find(item => item.id === message.id);
+    return !existingParsedMessage || existingParsedMessage.text !== message.text;
+  });
+};
+const parseAndStoreMessagesContentInWorker = async (parsedMessages, messages) => {
+  const messagesNeedingParsing = getMessagesNeedingParsing(parsedMessages, messages);
+  if (messagesNeedingParsing.length === 0) {
+    return parsedMessages;
+  }
+  let parsedContents;
+  try {
+    parsedContents = await parseMessageContents(messagesNeedingParsing.map(message => message.text));
+  } catch {
+    parsedContents = messagesNeedingParsing.map(message => getPlainTextMessageContent(message.text));
+  }
+  let nextParsedMessages = parsedMessages;
+  for (const [index, message] of messagesNeedingParsing.entries()) {
+    const parsedContent = message.text === '' ? emptyMessageContent : parsedContents[index];
+    nextParsedMessages = setParsedMessageContent(nextParsedMessages, message.id, message.text, parsedContent);
+  }
+  return nextParsedMessages;
+};
+const getEmptyMessageContent = () => {
+  return emptyMessageContent;
+};
+
 const selectSession = async (state, id) => {
   const {
     lastNormalViewMode,
@@ -10170,17 +6721,23 @@ const mockBackendAuthResponse = (state, payload) => {
 };
 
 const mockBackendSetHttpErrorResponse = (state, statusCode, body) => {
-  setHttpErrorResponse(statusCode, body);
-  void invoke$b('ChatCoordinator.mockBackendSetHttpErrorResponse', statusCode, body);
+  void invoke$9('ChatCoordinator.mockBackendSetHttpErrorResponse', statusCode, body);
   return state;
 };
 
 const mockBackendSetResponse = (state, body) => {
-  setResponse(body);
-  void invoke$b('ChatCoordinator.mockBackendSetResponse', body);
+  void invoke$9('ChatCoordinator.mockBackendSetResponse', body);
   return state;
 };
 
+let requests = [];
+const reset$2 = () => {
+  requests = [];
+};
+const getAll = () => {
+  return requests;
+};
+
 const mockOpenApiRequestGetAll = _state => {
   return getAll();
 };
@@ -10190,8 +6747,97 @@ const mockOpenApiRequestReset = state => {
   return state;
 };
 
+const defaultRequestId = 'default';
+let streamStates = new Map();
+let preparedRequestIds = [];
+const createState = () => {
+  return {
+    errorResult: undefined,
+    finished: false,
+    queue: [],
+    waiters: []
+  };
+};
+const getOrCreateState = requestId => {
+  const existing = streamStates.get(requestId);
+  if (existing) {
+    return existing;
+  }
+  const state = createState();
+  streamStates.set(requestId, state);
+  return state;
+};
+const enqueuePreparedRequest = requestId => {
+  if (preparedRequestIds.includes(requestId)) {
+    return;
+  }
+  preparedRequestIds.push(requestId);
+};
+const reset$1 = (requestId = defaultRequestId) => {
+  if (requestId === defaultRequestId) {
+    streamStates = new Map();
+    preparedRequestIds = [];
+    streamStates.set(defaultRequestId, createState());
+    return;
+  }
+  streamStates.set(requestId, createState());
+  enqueuePreparedRequest(requestId);
+};
+const setHttpErrorResponse = (statusCode, body, requestId = defaultRequestId) => {
+  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;
+  const state = getOrCreateState(requestId);
+  state.errorResult = {
+    details: 'http-error',
+    ...(typeof errorCode === 'string' ? {
+      errorCode
+    } : {}),
+    ...(typeof errorMessage === 'string' ? {
+      errorMessage
+    } : {}),
+    ...(typeof errorType === 'string' ? {
+      errorType
+    } : {}),
+    statusCode,
+    type: 'error'
+  };
+};
+const setRequestFailedResponse = (isOffline = false, requestId = defaultRequestId) => {
+  const state = getOrCreateState(requestId);
+  state.errorResult = {
+    details: 'request-failed',
+    ...(isOffline ? {
+      isOffline: true
+    } : {}),
+    type: 'error'
+  };
+};
+const pushChunk = (chunk, requestId = defaultRequestId) => {
+  const state = getOrCreateState(requestId);
+  if (state.waiters.length > 0) {
+    const resolve = state.waiters.shift();
+    resolve?.(chunk);
+    return;
+  }
+  state.queue.push(chunk);
+};
+const finish = (requestId = defaultRequestId) => {
+  const state = getOrCreateState(requestId);
+  state.finished = true;
+  if (state.waiters.length === 0) {
+    return;
+  }
+  const activeWaiters = [...state.waiters];
+  state.waiters.length = 0;
+  for (const resolve of activeWaiters) {
+    resolve(undefined);
+  }
+};
+
 const mockOpenApiSetHttpErrorResponse = (state, statusCode, body) => {
-  setHttpErrorResponse$1(statusCode, body);
+  setHttpErrorResponse(statusCode, body);
   return state;
 };
 
@@ -10203,7 +6849,7 @@ const mockOpenApiSetRequestFailedResponse = (state, isOffline = false) => {
 const mockOpenApiStreamFinish = async (state, requestId) => {
   finish(requestId);
   if (!requestId) {
-    await invoke$b('ChatCoordinator.mockOpenApiStreamFinish');
+    await invoke$9('ChatCoordinator.mockOpenApiStreamFinish');
   }
   return state;
 };
@@ -10214,14 +6860,14 @@ const mockOpenApiStreamPushChunk = async (state, chunkOrRequestId, chunk) => {
     return state;
   }
   pushChunk(chunkOrRequestId);
-  await invoke$b('ChatCoordinator.mockOpenApiStreamPushChunk', chunkOrRequestId);
+  await invoke$9('ChatCoordinator.mockOpenApiStreamPushChunk', chunkOrRequestId);
   return state;
 };
 
 const mockOpenApiStreamReset = async (state, requestId) => {
   reset$1(requestId);
   if (!requestId) {
-    await invoke$b('ChatCoordinator.mockOpenApiStreamReset');
+    await invoke$9('ChatCoordinator.mockOpenApiStreamReset');
   }
   return state;
 };
@@ -10367,7 +7013,7 @@ const pasteInput = async state => {
 };
 
 const registerMockResponse = async (state, mockResponse) => {
-  await invoke$b('ChatCoordinator.registerMockResponse', mockResponse);
+  await invoke$9('ChatCoordinator.registerMockResponse', mockResponse);
   return state;
 };
 
@@ -12623,6 +9269,51 @@ const getToolCallGetWorkspaceUriVirtualDom = toolCall => {
   }), ...(statusLabel ? [text(statusLabel)] : [])];
 };
 
+const getNumericCount = parsed => {
+  const count = Reflect.get(parsed, 'count');
+  if (typeof count === 'number' && Number.isFinite(count)) {
+    return count;
+  }
+  const matchCount = Reflect.get(parsed, 'matchCount');
+  if (typeof matchCount === 'number' && Number.isFinite(matchCount)) {
+    return matchCount;
+  }
+  return undefined;
+};
+const getArrayCount = parsed => {
+  const matches = Reflect.get(parsed, 'matches');
+  if (Array.isArray(matches)) {
+    return matches.length;
+  }
+  const files = Reflect.get(parsed, 'files');
+  if (Array.isArray(files)) {
+    return files.length;
+  }
+  const results = Reflect.get(parsed, 'results');
+  if (Array.isArray(results)) {
+    return results.length;
+  }
+  return undefined;
+};
+const getGlobMatchCount = result => {
+  if (!result) {
+    return undefined;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(result);
+  } catch {
+    return undefined;
+  }
+  if (Array.isArray(parsed)) {
+    return parsed.length;
+  }
+  if (!parsed || typeof parsed !== 'object') {
+    return undefined;
+  }
+  return getNumericCount(parsed) ?? getArrayCount(parsed);
+};
+
 const getGlobPatternLabel = toolCall => {
   if (toolCall.name !== 'glob') {
     return '';
@@ -15197,6 +11888,19 @@ const setNowForTest = (state, value) => {
   return state;
 };
 
+const setOpenRouterApiKey = async (state, openRouterApiKey, persist = true) => {
+  if (persist) {
+    await update({
+      'secrets.openRouterApiKey': openRouterApiKey
+    });
+  }
+  return {
+    ...state,
+    openRouterApiKey,
+    openRouterApiKeyInput: openRouterApiKey
+  };
+};
+
 const setQuestionToolEnabled = (state, questionToolEnabled) => {
   return {
     ...state,