@lvce-editor/static-server 0.77.0 → 0.77.2

package/static/a3ab23c/packages/chat-coordinator-worker/dist/chatCoordinatorWorkerMain.js

@@ -0,0 +1,3551 @@
+const isMessagePort = value => {
+  return value && value instanceof MessagePort;
+};
+const isMessagePortMain = value => {
+  return value && value.constructor && value.constructor.name === 'MessagePortMain';
+};
+const isOffscreenCanvas = value => {
+  return typeof OffscreenCanvas !== 'undefined' && value instanceof OffscreenCanvas;
+};
+const isInstanceOf = (value, constructorName) => {
+  return value?.constructor?.name === constructorName;
+};
+const isSocket = value => {
+  return isInstanceOf(value, 'Socket');
+};
+const transferrables = [isMessagePort, isMessagePortMain, isOffscreenCanvas, isSocket];
+const isTransferrable = value => {
+  for (const fn of transferrables) {
+    if (fn(value)) {
+      return true;
+    }
+  }
+  return false;
+};
+const walkValue = (value, transferrables, isTransferrable) => {
+  if (!value) {
+    return;
+  }
+  if (isTransferrable(value)) {
+    transferrables.push(value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      walkValue(item, transferrables, isTransferrable);
+    }
+    return;
+  }
+  if (typeof value === 'object') {
+    for (const property of Object.values(value)) {
+      walkValue(property, transferrables, isTransferrable);
+    }
+    return;
+  }
+};
+const getTransferrables = value => {
+  const transferrables = [];
+  walkValue(value, transferrables, isTransferrable);
+  return transferrables;
+};
+const attachEvents = that => {
+  const handleMessage = (...args) => {
+    const data = that.getData(...args);
+    that.dispatchEvent(new MessageEvent('message', {
+      data
+    }));
+  };
+  that.onMessage(handleMessage);
+  const handleClose = event => {
+    that.dispatchEvent(new Event('close'));
+  };
+  that.onClose(handleClose);
+};
+class Ipc extends EventTarget {
+  constructor(rawIpc) {
+    super();
+    this._rawIpc = rawIpc;
+    attachEvents(this);
+  }
+}
+const readyMessage = 'ready';
+const getData$2 = event => {
+  return event.data;
+};
+const listen$8 = ({
+  port
+}) => {
+  return port;
+};
+const signal$9 = port => {
+  port.postMessage(readyMessage);
+};
+class IpcChildWithMessagePort extends Ipc {
+  getData(event) {
+    return getData$2(event);
+  }
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const transfer = getTransferrables(message);
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    // ignore
+  }
+  onClose(callback) {
+    // ignore
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+    this._rawIpc.start();
+  }
+}
+const wrap$g = port => {
+  return new IpcChildWithMessagePort(port);
+};
+const IpcChildWithMessagePort$1 = {
+  __proto__: null,
+  listen: listen$8,
+  signal: signal$9,
+  wrap: wrap$g
+};
+const listen$7 = () => {
+  // @ts-ignore
+  if (typeof WorkerGlobalScope === 'undefined') {
+    throw new TypeError('module is not in web worker scope');
+  }
+  return globalThis;
+};
+const signal$8 = global => {
+  global.postMessage(readyMessage);
+};
+class IpcChildWithModuleWorker extends Ipc {
+  getData(event) {
+    return getData$2(event);
+  }
+  send(message) {
+    // @ts-ignore
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const transfer = getTransferrables(message);
+    // @ts-ignore
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    // ignore
+  }
+  onClose(callback) {
+    // ignore
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+  }
+}
+const wrap$f = global => {
+  return new IpcChildWithModuleWorker(global);
+};
+const IpcChildWithModuleWorker$1 = {
+  __proto__: null,
+  listen: listen$7,
+  signal: signal$8,
+  wrap: wrap$f
+};
+
+class CommandNotFoundError extends Error {
+  constructor(command) {
+    super(`Command not found ${command}`);
+    this.name = 'CommandNotFoundError';
+  }
+}
+const commands = Object.create(null);
+const register = commandMap => {
+  Object.assign(commands, commandMap);
+};
+const getCommand = key => {
+  return commands[key];
+};
+const execute = (command, ...args) => {
+  const fn = getCommand(command);
+  if (!fn) {
+    throw new CommandNotFoundError(command);
+  }
+  return fn(...args);
+};
+
+const Two$1 = '2.0';
+const callbacks = Object.create(null);
+const get$1 = id => {
+  return callbacks[id];
+};
+const remove$1 = id => {
+  delete callbacks[id];
+};
+class JsonRpcError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'JsonRpcError';
+  }
+}
+const NewLine = '\n';
+const DomException = 'DOMException';
+const ReferenceError$1 = 'ReferenceError';
+const SyntaxError$1 = 'SyntaxError';
+const TypeError$1 = 'TypeError';
+const getErrorConstructor = (message, type) => {
+  if (type) {
+    switch (type) {
+      case DomException:
+        return DOMException;
+      case ReferenceError$1:
+        return ReferenceError;
+      case SyntaxError$1:
+        return SyntaxError;
+      case TypeError$1:
+        return TypeError;
+      default:
+        return Error;
+    }
+  }
+  if (message.startsWith('TypeError: ')) {
+    return TypeError;
+  }
+  if (message.startsWith('SyntaxError: ')) {
+    return SyntaxError;
+  }
+  if (message.startsWith('ReferenceError: ')) {
+    return ReferenceError;
+  }
+  return Error;
+};
+const constructError = (message, type, name) => {
+  const ErrorConstructor = getErrorConstructor(message, type);
+  if (ErrorConstructor === DOMException && name) {
+    return new ErrorConstructor(message, name);
+  }
+  if (ErrorConstructor === Error) {
+    const error = new Error(message);
+    if (name && name !== 'VError') {
+      error.name = name;
+    }
+    return error;
+  }
+  return new ErrorConstructor(message);
+};
+const joinLines = lines => {
+  return lines.join(NewLine);
+};
+const splitLines = lines => {
+  return lines.split(NewLine);
+};
+const getCurrentStack = () => {
+  const stackLinesToSkip = 3;
+  const currentStack = joinLines(splitLines(new Error().stack || '').slice(stackLinesToSkip));
+  return currentStack;
+};
+const getNewLineIndex = (string, startIndex = undefined) => {
+  return string.indexOf(NewLine, startIndex);
+};
+const getParentStack = error => {
+  let parentStack = error.stack || error.data || error.message || '';
+  if (parentStack.startsWith('    at')) {
+    parentStack = error.message + NewLine + parentStack;
+  }
+  return parentStack;
+};
+const MethodNotFound = -32601;
+const Custom = -32001;
+const restoreJsonRpcError = error => {
+  const currentStack = getCurrentStack();
+  if (error && error instanceof Error) {
+    if (typeof error.stack === 'string') {
+      error.stack = error.stack + NewLine + currentStack;
+    }
+    return error;
+  }
+  if (error && error.code && error.code === MethodNotFound) {
+    const restoredError = new JsonRpcError(error.message);
+    const parentStack = getParentStack(error);
+    restoredError.stack = parentStack + NewLine + currentStack;
+    return restoredError;
+  }
+  if (error && error.message) {
+    const restoredError = constructError(error.message, error.type, error.name);
+    if (error.data) {
+      if (error.data.stack && error.data.type && error.message) {
+        restoredError.stack = error.data.type + ': ' + error.message + NewLine + error.data.stack + NewLine + currentStack;
+      } else if (error.data.stack) {
+        restoredError.stack = error.data.stack;
+      }
+      if (error.data.codeFrame) {
+        // @ts-ignore
+        restoredError.codeFrame = error.data.codeFrame;
+      }
+      if (error.data.code) {
+        // @ts-ignore
+        restoredError.code = error.data.code;
+      }
+      if (error.data.type) {
+        // @ts-ignore
+        restoredError.name = error.data.type;
+      }
+    } else {
+      if (error.stack) {
+        const lowerStack = restoredError.stack || '';
+        // @ts-ignore
+        const indexNewLine = getNewLineIndex(lowerStack);
+        const parentStack = getParentStack(error);
+        // @ts-ignore
+        restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
+      }
+      if (error.codeFrame) {
+        // @ts-ignore
+        restoredError.codeFrame = error.codeFrame;
+      }
+    }
+    return restoredError;
+  }
+  if (typeof error === 'string') {
+    return new Error(`JsonRpc Error: ${error}`);
+  }
+  return new Error(`JsonRpc Error: ${error}`);
+};
+const unwrapJsonRpcResult = responseMessage => {
+  if ('error' in responseMessage) {
+    const restoredError = restoreJsonRpcError(responseMessage.error);
+    throw restoredError;
+  }
+  if ('result' in responseMessage) {
+    return responseMessage.result;
+  }
+  throw new JsonRpcError('unexpected response message');
+};
+const warn = (...args) => {
+  console.warn(...args);
+};
+const resolve = (id, response) => {
+  const fn = get$1(id);
+  if (!fn) {
+    console.log(response);
+    warn(`callback ${id} may already be disposed`);
+    return;
+  }
+  fn(response);
+  remove$1(id);
+};
+const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
+const getErrorType = prettyError => {
+  if (prettyError && prettyError.type) {
+    return prettyError.type;
+  }
+  if (prettyError && prettyError.constructor && prettyError.constructor.name) {
+    return prettyError.constructor.name;
+  }
+  return undefined;
+};
+const isAlreadyStack = line => {
+  return line.trim().startsWith('at ');
+};
+const getStack = prettyError => {
+  const stackString = prettyError.stack || '';
+  const newLineIndex = stackString.indexOf('\n');
+  if (newLineIndex !== -1 && !isAlreadyStack(stackString.slice(0, newLineIndex))) {
+    return stackString.slice(newLineIndex + 1);
+  }
+  return stackString;
+};
+const getErrorProperty = (error, prettyError) => {
+  if (error && error.code === E_COMMAND_NOT_FOUND) {
+    return {
+      code: MethodNotFound,
+      data: error.stack,
+      message: error.message
+    };
+  }
+  return {
+    code: Custom,
+    data: {
+      code: prettyError.code,
+      codeFrame: prettyError.codeFrame,
+      name: prettyError.name,
+      stack: getStack(prettyError),
+      type: getErrorType(prettyError)
+    },
+    message: prettyError.message
+  };
+};
+const create$1$1 = (id, error) => {
+  return {
+    error,
+    id,
+    jsonrpc: Two$1
+  };
+};
+const getErrorResponse = (id, error, preparePrettyError, logError) => {
+  const prettyError = preparePrettyError(error);
+  logError(error, prettyError);
+  const errorProperty = getErrorProperty(error, prettyError);
+  return create$1$1(id, errorProperty);
+};
+const create$6 = (message, result) => {
+  return {
+    id: message.id,
+    jsonrpc: Two$1,
+    result: result ?? null
+  };
+};
+const getSuccessResponse = (message, result) => {
+  const resultProperty = result ?? null;
+  return create$6(message, resultProperty);
+};
+const getErrorResponseSimple = (id, error) => {
+  return {
+    error: {
+      code: Custom,
+      data: error,
+      // @ts-ignore
+      message: error.message
+    },
+    id,
+    jsonrpc: Two$1
+  };
+};
+const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
+  try {
+    const result = requiresSocket(message.method) ? await execute(message.method, ipc, ...message.params) : await execute(message.method, ...message.params);
+    return getSuccessResponse(message, result);
+  } catch (error) {
+    if (ipc.canUseSimpleErrorResponse) {
+      return getErrorResponseSimple(message.id, error);
+    }
+    return getErrorResponse(message.id, error, preparePrettyError, logError);
+  }
+};
+const defaultPreparePrettyError = error => {
+  return error;
+};
+const defaultLogError = () => {
+  // ignore
+};
+const defaultRequiresSocket = () => {
+  return false;
+};
+const defaultResolve = resolve;
+
+// TODO maybe remove this in v6 or v7, only accept options object to simplify the code
+const normalizeParams = args => {
+  if (args.length === 1) {
+    const options = args[0];
+    return {
+      execute: options.execute,
+      ipc: options.ipc,
+      logError: options.logError || defaultLogError,
+      message: options.message,
+      preparePrettyError: options.preparePrettyError || defaultPreparePrettyError,
+      requiresSocket: options.requiresSocket || defaultRequiresSocket,
+      resolve: options.resolve || defaultResolve
+    };
+  }
+  return {
+    execute: args[2],
+    ipc: args[0],
+    logError: args[5],
+    message: args[1],
+    preparePrettyError: args[4],
+    requiresSocket: args[6],
+    resolve: args[3]
+  };
+};
+const handleJsonRpcMessage = async (...args) => {
+  const options = normalizeParams(args);
+  const {
+    execute,
+    ipc,
+    logError,
+    message,
+    preparePrettyError,
+    requiresSocket,
+    resolve
+  } = options;
+  if ('id' in message) {
+    if ('method' in message) {
+      const response = await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
+      try {
+        ipc.send(response);
+      } catch (error) {
+        const errorResponse = getErrorResponse(message.id, error, preparePrettyError, logError);
+        ipc.send(errorResponse);
+      }
+      return;
+    }
+    resolve(message.id, message);
+    return;
+  }
+  if ('method' in message) {
+    await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
+    return;
+  }
+  throw new JsonRpcError('unexpected message');
+};
+
+const Two = '2.0';
+
+const create$5 = (method, params) => {
+  return {
+    jsonrpc: Two,
+    method,
+    params
+  };
+};
+
+const create$4 = (id, method, params) => {
+  const message = {
+    id,
+    jsonrpc: Two,
+    method,
+    params
+  };
+  return message;
+};
+
+let id = 0;
+const create$3 = () => {
+  return ++id;
+};
+
+const registerPromise = map => {
+  const id = create$3();
+  const {
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  map[id] = resolve;
+  return {
+    id,
+    promise
+  };
+};
+
+const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer) => {
+  const {
+    id,
+    promise
+  } = registerPromise(callbacks);
+  const message = create$4(id, method, params);
+  if (useSendAndTransfer && ipc.sendAndTransfer) {
+    ipc.sendAndTransfer(message);
+  } else {
+    ipc.send(message);
+  }
+  const responseMessage = await promise;
+  return unwrapJsonRpcResult(responseMessage);
+};
+const createRpc = ipc => {
+  const callbacks = Object.create(null);
+  ipc._resolve = (id, response) => {
+    const fn = callbacks[id];
+    if (!fn) {
+      console.warn(`callback ${id} may already be disposed`);
+      return;
+    }
+    fn(response);
+    delete callbacks[id];
+  };
+  const rpc = {
+    async dispose() {
+      await ipc?.dispose();
+    },
+    invoke(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, false);
+    },
+    invokeAndTransfer(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, true);
+    },
+    // @ts-ignore
+    ipc,
+    /**
+     * @deprecated
+     */
+    send(method, ...params) {
+      const message = create$5(method, params);
+      ipc.send(message);
+    }
+  };
+  return rpc;
+};
+
+const requiresSocket = () => {
+  return false;
+};
+const preparePrettyError = error => {
+  return error;
+};
+const logError = () => {
+  // handled by renderer worker
+};
+const handleMessage = event => {
+  const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
+  const actualExecute = event?.target?.execute || execute;
+  return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError, actualRequiresSocket);
+};
+
+const handleIpc = ipc => {
+  if ('addEventListener' in ipc) {
+    ipc.addEventListener('message', handleMessage);
+  } else if ('on' in ipc) {
+    // deprecated
+    ipc.on('message', handleMessage);
+  }
+};
+
+const listen$1 = async (module, options) => {
+  const rawIpc = await module.listen(options);
+  if (module.signal) {
+    module.signal(rawIpc);
+  }
+  const ipc = module.wrap(rawIpc);
+  return ipc;
+};
+
+const create$2 = async ({
+  commandMap,
+  messagePort
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const ipc = await listen$1(IpcChildWithMessagePort$1, {
+    port: messagePort
+  });
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  return rpc;
+};
+
+const create$1 = async ({
+  commandMap
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const ipc = await listen$1(IpcChildWithModuleWorker$1);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  return rpc;
+};
+
+const sessions = [];
+const subscriberQueues = new Map();
+const subscriberWaiters = new Map();
+const activeRunBySessionId = new Map();
+const runById = new Map();
+const cancelledRunIds = new Set();
+const runPromises = new Map();
+const clone = value => {
+  return structuredClone(value);
+};
+const getSessionIndex = sessionId => {
+  return sessions.findIndex(session => session.id === sessionId);
+};
+const emitEvent = event => {
+  for (const queue of subscriberQueues.values()) {
+    queue.push(clone(event));
+  }
+  for (const [subscriberId, waiters] of subscriberWaiters) {
+    const queue = subscriberQueues.get(subscriberId);
+    if (!queue || queue.length === 0) {
+      continue;
+    }
+    const callbacks = [...waiters];
+    waiters.length = 0;
+    for (const callback of callbacks) {
+      callback();
+    }
+  }
+};
+const createMessage = (role, text) => {
+  return {
+    id: crypto.randomUUID(),
+    role,
+    text,
+    time: new Date().toLocaleTimeString([], {
+      hour: '2-digit',
+      minute: '2-digit'
+    })
+  };
+};
+const updateMessage = (sessionId, messageId, text, inProgress) => {
+  const index = getSessionIndex(sessionId);
+  if (index === -1) {
+    return undefined;
+  }
+  const session = sessions[index];
+  const nextMessages = session.messages.map(message => {
+    if (message.id !== messageId) {
+      return message;
+    }
+    return {
+      ...message,
+      inProgress,
+      text
+    };
+  });
+  const updatedMessage = nextMessages.find(message => message.id === messageId);
+  if (!updatedMessage) {
+    return undefined;
+  }
+  sessions[index] = {
+    ...session,
+    messages: nextMessages
+  };
+  return updatedMessage;
+};
+const appendMessage = (sessionId, message) => {
+  const index = getSessionIndex(sessionId);
+  if (index === -1) {
+    return false;
+  }
+  const session = sessions[index];
+  sessions[index] = {
+    ...session,
+    messages: [...session.messages, message]
+  };
+  return true;
+};
+const getChunks = text => {
+  const tokens = text.split(' ');
+  return tokens.map((token, index) => {
+    if (index === tokens.length - 1) {
+      return token;
+    }
+    return `${token} `;
+  });
+};
+const finalizeRun = (runId, sessionId) => {
+  activeRunBySessionId.delete(sessionId);
+  runById.delete(runId);
+  cancelledRunIds.delete(runId);
+  runPromises.delete(runId);
+};
+const processRun = async (runId, sessionId, assistantMessageId, prompt) => {
+  const baseText = `Coordinator pipeline placeholder response for: ${prompt}`;
+  const chunks = getChunks(baseText);
+  let currentText = '';
+  for (const chunk of chunks) {
+    if (cancelledRunIds.has(runId)) {
+      const cancelledMessage = updateMessage(sessionId, assistantMessageId, currentText, false);
+      if (cancelledMessage) {
+        emitEvent({
+          message: clone(cancelledMessage),
+          runId,
+          sessionId,
+          type: 'message-updated'
+        });
+      }
+      emitEvent({
+        runId,
+        sessionId,
+        type: 'run-cancelled'
+      });
+      finalizeRun(runId, sessionId);
+      return;
+    }
+    currentText += chunk;
+    const updatedMessage = updateMessage(sessionId, assistantMessageId, currentText, true);
+    if (updatedMessage) {
+      emitEvent({
+        message: clone(updatedMessage),
+        runId,
+        sessionId,
+        type: 'message-updated'
+      });
+    }
+    await Promise.resolve();
+  }
+  const doneMessage = updateMessage(sessionId, assistantMessageId, currentText, false);
+  if (doneMessage) {
+    emitEvent({
+      message: clone(doneMessage),
+      runId,
+      sessionId,
+      type: 'message-updated'
+    });
+  }
+  emitEvent({
+    runId,
+    sessionId,
+    type: 'run-finished'
+  });
+  finalizeRun(runId, sessionId);
+};
+const listSessions$1 = () => {
+  return sessions.map(session => ({
+    id: session.id,
+    messageCount: session.messages.length,
+    title: session.title
+  }));
+};
+const getSession$1 = sessionId => {
+  const session = sessions.find(item => item.id === sessionId);
+  if (!session) {
+    return undefined;
+  }
+  return clone(session);
+};
+const createSession$1 = (title = `Chat ${sessions.length + 1}`) => {
+  const session = {
+    id: crypto.randomUUID(),
+    messages: [],
+    title
+  };
+  sessions.push(session);
+  emitEvent({
+    session,
+    type: 'session-created'
+  });
+  return clone(session);
+};
+const deleteSession$1 = sessionId => {
+  const index = getSessionIndex(sessionId);
+  if (index === -1) {
+    return false;
+  }
+  sessions.splice(index, 1);
+  emitEvent({
+    sessionId,
+    type: 'session-deleted'
+  });
+  return true;
+};
+const submit$1 = options => {
+  const text = options.text.trim();
+  if (!text) {
+    return {
+      message: 'Prompt is empty.',
+      type: 'error'
+    };
+  }
+  let session = options.sessionId ? sessions.find(item => item.id === options.sessionId) : undefined;
+  if (!session) {
+    session = createSession$1();
+  }
+  if (activeRunBySessionId.has(session.id)) {
+    return {
+      message: 'Session already has an active run.',
+      type: 'error'
+    };
+  }
+  const userMessage = createMessage('user', text);
+  const assistantMessage = {
+    ...createMessage('assistant', ''),
+    inProgress: true
+  };
+  appendMessage(session.id, userMessage);
+  appendMessage(session.id, assistantMessage);
+  const updatedSession = getSession$1(session.id);
+  if (updatedSession) {
+    emitEvent({
+      session: updatedSession,
+      type: 'session-updated'
+    });
+  }
+  emitEvent({
+    message: clone(userMessage),
+    sessionId: session.id,
+    type: 'message-appended'
+  });
+  emitEvent({
+    message: clone(assistantMessage),
+    sessionId: session.id,
+    type: 'message-appended'
+  });
+  const runId = crypto.randomUUID();
+  activeRunBySessionId.set(session.id, runId);
+  runById.set(runId, {
+    assistantMessageId: assistantMessage.id,
+    sessionId: session.id
+  });
+  emitEvent({
+    assistantMessageId: assistantMessage.id,
+    runId,
+    sessionId: session.id,
+    type: 'run-started'
+  });
+  const runPromise = processRun(runId, session.id, assistantMessage.id, text);
+  runPromises.set(runId, runPromise);
+  return {
+    assistantMessageId: assistantMessage.id,
+    runId,
+    sessionId: session.id,
+    type: 'success',
+    userMessageId: userMessage.id
+  };
+};
+const cancelRun$1 = runId => {
+  if (!runById.has(runId)) {
+    return false;
+  }
+  cancelledRunIds.add(runId);
+  return true;
+};
+const subscribe$1 = subscriberId => {
+  if (subscriberQueues.has(subscriberId)) {
+    return;
+  }
+  subscriberQueues.set(subscriberId, []);
+  subscriberWaiters.set(subscriberId, []);
+};
+const unsubscribe$1 = subscriberId => {
+  subscriberQueues.delete(subscriberId);
+  subscriberWaiters.delete(subscriberId);
+};
+const consumeEvents$1 = subscriberId => {
+  const queue = subscriberQueues.get(subscriberId);
+  if (!queue) {
+    return [];
+  }
+  const events = [...queue];
+  queue.length = 0;
+  return events;
+};
+const waitForEvents$1 = async (subscriberId, timeout = 1000) => {
+  const queue = subscriberQueues.get(subscriberId);
+  if (!queue) {
+    return [];
+  }
+  if (queue.length > 0) {
+    return consumeEvents$1(subscriberId);
+  }
+  await new Promise(resolve => {
+    const waiters = subscriberWaiters.get(subscriberId);
+    if (!waiters) {
+      resolve();
+      return;
+    }
+    waiters.push(resolve);
+    setTimeout(resolve, timeout);
+  });
+  return consumeEvents$1(subscriberId);
+};
+
+const createSession = async title => {
+  return createSession$1(title);
+};
+const listSessions = async () => {
+  return listSessions$1();
+};
+const getSession = async sessionId => {
+  return getSession$1(sessionId);
+};
+const deleteSession = async sessionId => {
+  return deleteSession$1(sessionId);
+};
+const submit = async options => {
+  return submit$1(options);
+};
+const cancelRun = async runId => {
+  return cancelRun$1(runId);
+};
+const subscribe = async subscriberId => {
+  subscribe$1(subscriberId);
+};
+const unsubscribe = async subscriberId => {
+  unsubscribe$1(subscriberId);
+};
+const consumeEvents = async subscriberId => {
+  return consumeEvents$1(subscriberId);
+};
+const waitForEvents = async (subscriberId, timeout) => {
+  return waitForEvents$1(subscriberId, timeout);
+};
+
+const createMockRpc = ({
+  commandMap
+}) => {
+  const invocations = [];
+  const invoke = (method, ...params) => {
+    invocations.push([method, ...params]);
+    const command = commandMap[method];
+    if (!command) {
+      throw new Error(`command ${method} not found`);
+    }
+    return command(...params);
+  };
+  const mockRpc = {
+    invocations,
+    invoke,
+    invokeAndTransfer: invoke
+  };
+  return mockRpc;
+};
+
+const rpcs = Object.create(null);
+const set = (id, rpc) => {
+  rpcs[id] = rpc;
+};
+const get = id => {
+  return rpcs[id];
+};
+const remove = id => {
+  delete rpcs[id];
+};
+
+/* eslint-disable  @typescript-eslint/explicit-function-return-type */
+const create = rpcId => {
+  return {
+    async dispose() {
+      const rpc = get(rpcId);
+      await rpc.dispose();
+    },
+    // @ts-ignore
+    invoke(method, ...params) {
+      const rpc = get(rpcId);
+      // @ts-ignore
+      return rpc.invoke(method, ...params);
+    },
+    // @ts-ignore
+    invokeAndTransfer(method, ...params) {
+      const rpc = get(rpcId);
+      // @ts-ignore
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    registerMockRpc(commandMap) {
+      const mockRpc = createMockRpc({
+        commandMap
+      });
+      set(rpcId, mockRpc);
+      // @ts-ignore
+      mockRpc[Symbol.dispose] = () => {
+        remove(rpcId);
+      };
+      // @ts-ignore
+      return mockRpc;
+    },
+    set(rpc) {
+      set(rpcId, rpc);
+    }
+  };
+};
+
+const ChatNetworkWorker = 6002;
+const ExtensionHostWorker = 44;
+const RendererWorker = 1;
+
+const {
+  invoke: invoke$2} = create(ChatNetworkWorker);
+
+const {
+  invoke: invoke$1} = create(ExtensionHostWorker);
+
+const {
+  invoke} = create(RendererWorker);
+const readFile = async uri => {
+  return invoke('FileSystem.readFile', uri);
+};
+const writeFile = async (uri, text) => {
+  await invoke('FileSystem.writeFile', uri, text);
+};
+const activateByEvent$1 = (event, assetDir, platform) => {
+  return invoke('ExtensionHostManagement.activateByEvent', event, assetDir, platform);
+};
+const getWorkspacePath = () => {
+  return invoke('Workspace.getPath');
+};
+
+const getToolErrorPayload = error => {
+  const rawStack = error && typeof error === 'object' ? Reflect.get(error, 'stack') : undefined;
+  return {
+    error: String(error),
+    ...(typeof rawStack === 'string' && rawStack.trim() ? {
+      errorStack: rawStack,
+      stack: rawStack
+    } : {})
+  };
+};
+
+const executeGetWorkspaceUriTool = async (_args, _options) => {
+  try {
+    const workspaceUri = await getWorkspacePath();
+    return JSON.stringify({
+      workspaceUri
+    });
+  } catch (error) {
+    return JSON.stringify(getToolErrorPayload(error));
+  }
+};
+
+const isAbsoluteUri$1 = value => {
+  return /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(value);
+};
+const executeListFilesTool = async (args, _options) => {
+  const uri = typeof args.uri === 'string' ? args.uri : '';
+  if (!uri || !isAbsoluteUri$1(uri)) {
+    return JSON.stringify({
+      error: 'Invalid argument: uri must be an absolute URI.'
+    });
+  }
+  try {
+    const entries = await invoke('FileSystem.readDirWithFileTypes', uri);
+    return JSON.stringify({
+      entries,
+      uri
+    });
+  } catch (error) {
+    return JSON.stringify({
+      ...getToolErrorPayload(error),
+      uri
+    });
+  }
+};
+
+const isPathTraversalAttempt = path => {
+  if (!path) {
+    return false;
+  }
+  if (path.startsWith('/') || path.startsWith('\\')) {
+    return true;
+  }
+  if (path.startsWith('file://')) {
+    return true;
+  }
+  if (/^[a-zA-Z]:[\\/]/.test(path)) {
+    return true;
+  }
+  const segments = path.split(/[\\/]/);
+  return segments.includes('..');
+};
+
+const normalizeRelativePath = path => {
+  const segments = path.split(/[\\/]/).filter(segment => segment && segment !== '.');
+  if (segments.length === 0) {
+    return '.';
+  }
+  return segments.join('/');
+};
+
+const isAbsoluteUri = value => {
+  return /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(value);
+};
+const executeReadFileTool = async (args, _options) => {
+  const uri = typeof args.uri === 'string' ? args.uri : '';
+  if (uri) {
+    if (!isAbsoluteUri(uri)) {
+      return JSON.stringify({
+        error: 'Invalid argument: uri must be an absolute URI.'
+      });
+    }
+    try {
+      const content = await readFile(uri);
+      return JSON.stringify({
+        content,
+        uri
+      });
+    } catch (error) {
+      return JSON.stringify({
+        ...getToolErrorPayload(error),
+        uri
+      });
+    }
+  }
+  const filePath = typeof args.path === 'string' ? args.path : '';
+  if (!filePath || isPathTraversalAttempt(filePath)) {
+    return JSON.stringify({
+      error: 'Access denied: path must be relative and stay within the open workspace folder.'
+    });
+  }
+  const normalizedPath = normalizeRelativePath(filePath);
+  try {
+    const content = await readFile(normalizedPath);
+    return JSON.stringify({
+      content,
+      path: normalizedPath
+    });
+  } catch (error) {
+    return JSON.stringify({
+      ...getToolErrorPayload(error),
+      path: normalizedPath
+    });
+  }
+};
+
+const maxPayloadLength = 40_000;
+const executeRenderHtmlTool = async (args, _options) => {
+  const html = typeof args.html === 'string' ? args.html : '';
+  const css = typeof args.css === 'string' ? args.css : '';
+  const title = typeof args.title === 'string' ? args.title : '';
+  if (!html) {
+    return JSON.stringify({
+      error: 'Missing required argument: html'
+    });
+  }
+  if (html.length > maxPayloadLength || css.length > maxPayloadLength) {
+    return JSON.stringify({
+      error: 'Payload too large: keep html/css under 40,000 characters each.'
+    });
+  }
+  return JSON.stringify({
+    css,
+    html,
+    ok: true,
+    title
+  });
+};
+
+const executeWriteFileTool = async (args, _options) => {
+  const filePath = typeof args.path === 'string' ? args.path : '';
+  const content = typeof args.content === 'string' ? args.content : '';
+  if (!filePath || isPathTraversalAttempt(filePath)) {
+    return JSON.stringify({
+      error: 'Access denied: path must be relative and stay within the open workspace folder.'
+    });
+  }
+  const normalizedPath = normalizeRelativePath(filePath);
+  try {
+    await writeFile(normalizedPath, content);
+    return JSON.stringify({
+      ok: true,
+      path: normalizedPath
+    });
+  } catch (error) {
+    return JSON.stringify({
+      ...getToolErrorPayload(error),
+      path: normalizedPath
+    });
+  }
+};
+
+const parseToolArguments = rawArguments => {
+  if (typeof rawArguments !== 'string') {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(rawArguments);
+    if (!parsed || typeof parsed !== 'object') {
+      return {};
+    }
+    return parsed;
+  } catch {
+    return {};
+  }
+};
+
+const executeChatTool = async (name, rawArguments, options) => {
+  const args = parseToolArguments(rawArguments);
+  if (name === 'read_file') {
+    return executeReadFileTool(args);
+  }
+  if (name === 'write_file') {
+    return executeWriteFileTool(args);
+  }
+  if (name === 'list_files') {
+    return executeListFilesTool(args);
+  }
+  if (name === 'getWorkspaceUri') {
+    return executeGetWorkspaceUriTool();
+  }
+  if (name === 'render_html') {
+    return executeRenderHtmlTool(args);
+  }
+  return JSON.stringify({
+    error: `Unknown tool: ${name}`
+  });
+};
+
+const getReadFileTool = () => {
+  return {
+    function: {
+      description: 'Read UTF-8 text content from a file inside the currently open workspace folder. Only pass an absolute URI.',
+      name: 'read_file',
+      parameters: {
+        additionalProperties: false,
+        properties: {
+          uri: {
+            description: 'Absolute file URI within the workspace (for example: file:///workspace/src/index.ts).',
+            type: 'string'
+          }
+        },
+        required: ['uri'],
+        type: 'object'
+      }
+    },
+    type: 'function'
+  };
+};
+const getWriteFileTool = () => {
+  return {
+    function: {
+      description: 'Write UTF-8 text content to a file inside the currently open workspace folder.',
+      name: 'write_file',
+      parameters: {
+        additionalProperties: false,
+        properties: {
+          content: {
+            description: 'New UTF-8 text content to write to the file.',
+            type: 'string'
+          },
+          path: {
+            description: 'Relative file path within the workspace (for example: src/index.ts).',
+            type: 'string'
+          }
+        },
+        required: ['path', 'content'],
+        type: 'object'
+      }
+    },
+    type: 'function'
+  };
+};
+const getListFilesTool = () => {
+  return {
+    function: {
+      description: 'List direct children (files and folders) for a folder URI inside the currently open workspace folder. Only pass an absolute URI.',
+      name: 'list_files',
+      parameters: {
+        additionalProperties: false,
+        properties: {
+          uri: {
+            description: 'Absolute folder URI within the workspace (for example: file:///workspace/src).',
+            type: 'string'
+          }
+        },
+        required: ['uri'],
+        type: 'object'
+      }
+    },
+    type: 'function'
+  };
+};
+const getGetWorkspaceUriTool = () => {
+  return {
+    function: {
+      description: 'Get the URI of the currently open workspace folder.',
+      name: 'getWorkspaceUri',
+      parameters: {
+        additionalProperties: false,
+        properties: {},
+        type: 'object'
+      }
+    },
+    type: 'function'
+  };
+};
+const getRenderHtmlTool = () => {
+  return {
+    function: {
+      description: 'Render custom HTML and optional CSS directly in the chat tool call list using native chat UI rendering. Use this for structured cards, tables, and small dashboards. After calling this tool, do not repeat the same HTML, data table, or long content again as plain text unless the user explicitly asks for a text-only version.',
+      name: 'render_html',
+      parameters: {
+        additionalProperties: false,
+        properties: {
+          css: {
+            description: 'Optional CSS string applied inside the preview document.',
+            type: 'string'
+          },
+          html: {
+            description: 'HTML string to render in the preview document.',
+            type: 'string'
+          },
+          title: {
+            description: 'Optional short title for the preview.',
+            type: 'string'
+          }
+        },
+        required: ['html'],
+        type: 'object'
+      }
+    },
+    type: 'function'
+  };
+};
+const getBasicChatTools = () => {
+  return [getReadFileTool(), getWriteFileTool(), getListFilesTool(), getGetWorkspaceUriTool(), getRenderHtmlTool()];
+};
+
+const openApiApiKeyRequiredMessage = 'OpenAI API key is not configured. Enter your OpenAI API key below and click Save.';
+const openApiRequestFailedMessage = 'OpenAI request failed.';
+const openApiRequestFailedOfflineMessage = 'OpenAI request failed because you are offline. Please check your internet connection.';
+const openRouterApiKeyRequiredMessage = 'OpenRouter API key is not configured. Enter your OpenRouter API key below and click Save.';
+const openRouterRequestFailedMessage = 'OpenRouter request failed. Possible reasons:';
+const openRouterTooManyRequestsMessage = 'OpenRouter rate limit reached (429). Please try again soon. Helpful tips:';
+
+const getClientRequestIdHeader = () => {
+  return {
+    'x-client-request-id': crypto.randomUUID()
+  };
+};
+
+const delay = async ms => {
+  await new Promise(resolve => setTimeout(resolve, ms));
+};
+
+const getMockAiResponse = async (userMessage, delayInMs) => {
+  await delay(delayInMs);
+  return `Mock AI response: I received "${userMessage}".`;
+};
+
+let queue = [];
+let waiters = [];
+let finished = false;
+let errorResult;
+const reset$1 = () => {
+  queue = [];
+  waiters = [];
+  finished = false;
+  errorResult = undefined;
+};
+const setHttpErrorResponse = (statusCode, body) => {
+  const rawError = body && typeof body === 'object' ? Reflect.get(body, 'error') : undefined;
+  const errorCode = rawError && typeof rawError === 'object' ? Reflect.get(rawError, 'code') : undefined;
+  const errorMessage = rawError && typeof rawError === 'object' ? Reflect.get(rawError, 'message') : undefined;
+  const errorType = rawError && typeof rawError === 'object' ? Reflect.get(rawError, 'type') : undefined;
+  errorResult = {
+    details: 'http-error',
+    ...(typeof errorCode === 'string' ? {
+      errorCode
+    } : {}),
+    ...(typeof errorMessage === 'string' ? {
+      errorMessage
+    } : {}),
+    ...(typeof errorType === 'string' ? {
+      errorType
+    } : {}),
+    statusCode,
+    type: 'error'
+  };
+};
+const takeErrorResponse = () => {
+  const error = errorResult;
+  errorResult = undefined;
+  return error;
+};
+const pushChunk = chunk => {
+  if (waiters.length > 0) {
+    const resolve = waiters.shift();
+    resolve?.(chunk);
+    return;
+  }
+  queue.push(chunk);
+};
+const finish = () => {
+  finished = true;
+  if (waiters.length === 0) {
+    return;
+  }
+  const activeWaiters = waiters;
+  waiters = [];
+  for (const resolve of activeWaiters) {
+    resolve(undefined);
+  }
+};
+const readNextChunk = async () => {
+  if (queue.length > 0) {
+    return queue.shift();
+  }
+  if (finished) {
+    return undefined;
+  }
+  const {
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  waiters.push(resolve);
+  return promise;
+};
+
+const 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) => {
+  const error = takeErrorResponse();
+  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();
+    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;
+    }
+    text += chunk;
+    if (stream && onTextChunk) {
+      await onTextChunk(chunk);
+    }
+  }
+  if (!requestDone && remainder) {
+    const dataLines = parseSseDataLines(remainder);
+    await consumeSseDataLines(dataLines);
+  }
+  await notifyFinished();
+  return {
+    ...(responseId ? {
+      responseId
+    } : {}),
+    responseFunctionCalls,
+    text,
+    type: 'success'
+  };
+};
+
+const activateByEvent = (event, assetDir, platform) => {
+  // @ts-ignore
+  return activateByEvent$1(event, assetDir, platform);
+};
+
+const executeProvider = async ({
+  assetDir,
+  event,
+  method,
+  noProviderFoundMessage,
+  params,
+  platform
+}) => {
+  await activateByEvent(event, assetDir, platform);
+  // @ts-ignore
+  const result = invoke$1(method, ...params);
+  return result;
+};
+
+const CommandExecute = 'ExtensionHostCommand.executeCommand';
+
+const normalizeLimitInfo = value => {
+  if (!value || typeof value !== 'object') {
+    return undefined;
+  }
+  const limitRemaining = Reflect.get(value, 'limitRemaining');
+  const limitReset = Reflect.get(value, 'limitReset');
+  const retryAfter = Reflect.get(value, 'retryAfter');
+  const usage = Reflect.get(value, 'usage');
+  const usageDaily = Reflect.get(value, 'usageDaily');
+  const normalized = {
+    ...(typeof limitRemaining === 'number' || limitRemaining === null ? {
+      limitRemaining
+    } : {}),
+    ...(typeof limitReset === 'string' || limitReset === null ? {
+      limitReset
+    } : {}),
+    ...(typeof retryAfter === 'string' || retryAfter === null ? {
+      retryAfter
+    } : {}),
+    ...(typeof usage === 'number' ? {
+      usage
+    } : {}),
+    ...(typeof usageDaily === 'number' ? {
+      usageDaily
+    } : {})
+  };
+  const hasDetails = typeof limitRemaining === 'number' || limitRemaining === null || typeof limitReset === 'string' || limitReset === null || typeof retryAfter === 'string' || retryAfter === null || typeof usage === 'number' || typeof usageDaily === 'number';
+  return hasDetails ? normalized : undefined;
+};
+
+const normalizeMockResult = value => {
+  if (typeof value === 'string') {
+    return {
+      text: value,
+      type: 'success'
+    };
+  }
+  if (!value || typeof value !== 'object') {
+    return {
+      details: 'request-failed',
+      type: 'error'
+    };
+  }
+  const type = Reflect.get(value, 'type');
+  if (type === 'success') {
+    const text = Reflect.get(value, 'text');
+    if (typeof text === 'string') {
+      return {
+        text,
+        type: 'success'
+      };
+    }
+    return {
+      details: 'request-failed',
+      type: 'error'
+    };
+  }
+  if (type === 'error') {
+    const details = Reflect.get(value, 'details');
+    if (details === 'request-failed' || details === 'too-many-requests' || details === 'http-error') {
+      const rawMessage = Reflect.get(value, 'rawMessage');
+      const statusCode = Reflect.get(value, 'statusCode');
+      const limitInfo = normalizeLimitInfo(Reflect.get(value, 'limitInfo'));
+      return {
+        details,
+        ...(limitInfo ? {
+          limitInfo
+        } : {}),
+        ...(typeof rawMessage === 'string' ? {
+          rawMessage
+        } : {}),
+        ...(typeof statusCode === 'number' ? {
+          statusCode
+        } : {}),
+        type: 'error'
+      };
+    }
+  }
+  const text = Reflect.get(value, 'text');
+  if (typeof text === 'string') {
+    return {
+      text,
+      type: 'success'
+    };
+  }
+  return {
+    details: 'request-failed',
+    type: 'error'
+  };
+};
+
+const getMockOpenRouterAssistantText = async (messages, modelId, openRouterApiBaseUrl, openRouterApiKey, mockApiCommandId, assetDir, platform) => {
+  if (!mockApiCommandId) {
+    return {
+      details: 'request-failed',
+      type: 'error'
+    };
+  }
+  try {
+    const result = await executeProvider({
+      assetDir,
+      event: `onCommand:${mockApiCommandId}`,
+      method: CommandExecute,
+      noProviderFoundMessage: 'No mock api command found',
+      params: [mockApiCommandId, {
+        messages,
+        modelId,
+        openRouterApiBaseUrl,
+        openRouterApiKey
+      }],
+      platform
+    });
+    return normalizeMockResult(result);
+  } catch {
+    return {
+      details: 'request-failed',
+      type: 'error'
+    };
+  }
+};
+
+const getOpenApiApiEndpoint = openApiApiBaseUrl => {
+  return `${openApiApiBaseUrl}/responses`;
+};
+
+const makeApiRequest = async options => {
+  return invoke$2('ChatNetwork.makeApiRequest', options);
+};
+const makeStreamingApiRequest = async options => {
+  return invoke$2('ChatNetwork.makeStreamingApiRequest', options);
+};
+
+const getTextContent = content => {
+  if (typeof content === 'string') {
+    return content;
+  }
+  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');
+};
+
+/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
+
+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, previousResponseId) => {
+  const openAiTools = getOpenAiTools(tools);
+  return {
+    input,
+    model: modelId,
+    ...(stream ? {
+      stream: true,
+      ...(includeObfuscation ? {} : {
+        stream_options: {
+          include_obfuscation: false
+        }
+      })
+    } : {}),
+    ...(previousResponseId ? {
+      previous_response_id: previousResponseId
+    } : {}),
+    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(/^Error:\s*/, '');
+  const firstLine = trimmed.split('\n')[0];
+  if (firstLine.length <= 80) {
+    return firstLine;
+  }
+  return `${firstLine.slice(0, 77)}...`;
+};
+const getToolCallExecutionStatus = content => {
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    return {
+      errorMessage: 'Invalid tool output',
+      status: 'error'
+    };
+  }
+  if (!parsed || typeof parsed !== 'object') {
+    return {
+      errorMessage: 'Invalid tool output',
+      status: 'error'
+    };
+  }
+  const rawError = Reflect.get(parsed, 'error');
+  if (typeof rawError !== 'string' || !rawError.trim()) {
+    return {
+      status: 'success'
+    };
+  }
+  const rawStack = Reflect.get(parsed, 'errorStack') ?? Reflect.get(parsed, 'stack');
+  const errorStack = typeof rawStack === 'string' && rawStack.trim() ? rawStack : undefined;
+  const errorMessage = getShortToolErrorMessage(rawError);
+  if (/not[\s_-]?found|enoent/i.test(errorMessage)) {
+    return {
+      ...(errorStack ? {
+        errorStack
+      } : {}),
+      status: 'not-found'
+    };
+  }
+  return {
+    ...(errorStack ? {
+      errorStack
+    } : {}),
+    errorMessage,
+    status: 'error'
+  };
+};
+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 next = {
+        arguments: typeof rawArguments === 'string' ? rawArguments : '',
+        ...(typeof callId === 'string' ? {
+          id: callId
+        } : {}),
+        name: typeof name === 'string' ? name : ''
+      };
+      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 current = toolCallAccumulator[toolCallKey] || {
+        arguments: '',
+        name: ''
+      };
+      toolCallAccumulator = {
+        ...toolCallAccumulator,
+        [toolCallKey]: {
+          arguments: typeof rawArguments === 'string' ? rawArguments : current.arguments,
+          ...(typeof callId === 'string' ? {
+            id: callId
+          } : current.id ? {
+            id: current.id
+          } : {}),
+          name: typeof name === 'string' && name ? name : current.name
+        }
+      };
+      await emitToolCallAccumulator();
+      return;
+    }
+    if (eventType === 'response.function_call_arguments.delta' || eventType === 'response.function_call_arguments.done') {
+      const 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({
+    start(controller) {
+      for (const chunk of chunks) {
+        controller.enqueue(new TextEncoder().encode(chunk));
+      }
+      controller.close();
+    }
+  });
+  return {
+    body: stream
+  };
+};
+const getOpenApiAssistantText = async (messages, modelId, openApiApiKey, openApiApiBaseUrl, assetDir, platform, options) => {
+  const {
+    includeObfuscation = false,
+    onDataEvent,
+    onEventStreamFinished,
+    onTextChunk,
+    onToolCallsChunk,
+    stream,
+    useChatNetworkWorkerForRequests = false,
+    webSearchEnabled = false
+  } = options ?? {
+    stream: false
+  };
+  const openAiInput = messages.map(message => ({
+    content: message.text,
+    role: message.role
+  }));
+  const tools = getBasicChatTools();
+  const maxToolIterations = 4;
+  let previousResponseId;
+  for (let i = 0; i <= maxToolIterations; i++) {
+    const postBody = getOpenAiParams(openAiInput, modelId, stream, includeObfuscation, tools, webSearchEnabled, previousResponseId);
+    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);
+          const executionStatus = getToolCallExecutionStatus(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,
+            ...(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);
+        const executionStatus = getToolCallExecutionStatus(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,
+          ...(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) : '{}';
+          if (typeof name === 'string') {
+            const executionStatus = getToolCallExecutionStatus(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,
+              ...(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: 'request-failed',
+    type: 'error'
+  };
+};
+
+const isOffline = () => {
+  if (!globalThis.navigator) {
+    return false;
+  }
+  return globalThis.navigator.onLine === false;
+};
+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 (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 (isOffline()) {
+        return openApiRequestFailedOfflineMessage;
+      }
+      return openApiRequestFailedMessage;
+  }
+};
+
+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 getOpenRouterApiEndpoint = openRouterApiBaseUrl => {
+  const trimmedBaseUrl = openRouterApiBaseUrl.replace(/\/+$/, '');
+  return `${trimmedBaseUrl}/chat/completions`;
+};
+
+const getOpenRouterKeyEndpoint = openRouterApiBaseUrl => {
+  const trimmedBaseUrl = openRouterApiBaseUrl.replace(/\/+$/, '');
+  return `${trimmedBaseUrl}/auth/key`;
+};
+
+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) => {
+  const completionMessages = messages.map(message => ({
+    content: message.text,
+    role: message.role
+  }));
+  const tools = getBasicChatTools();
+  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) : '{}';
+        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 requests = [];
+const reset = () => {
+  requests = [];
+};
+const capture = request => {
+  requests = [...requests, request];
+};
+const getAll = () => {
+  return requests;
+};
+
+/* eslint-disable prefer-destructuring */
+
+const getAiResponse = async ({
+  assetDir,
+  messageId,
+  messages,
+  mockAiResponseDelay = 800,
+  mockApiCommandId,
+  models,
+  onDataEvent,
+  onEventStreamFinished,
+  onTextChunk,
+  onToolCallsChunk,
+  openApiApiBaseUrl,
+  openApiApiKey,
+  openRouterApiBaseUrl,
+  openRouterApiKey,
+  passIncludeObfuscation = false,
+  platform,
+  selectedModelId,
+  streamingEnabled = true,
+  useChatNetworkWorkerForRequests = false,
+  useMockApi,
+  userText,
+  webSearchEnabled = false
+}) => {
+  let text = '';
+  const usesOpenApiModel = isOpenApiModel(selectedModelId, models);
+  const usesOpenRouterModel = isOpenRouterModel(selectedModelId, models);
+  if (usesOpenApiModel) {
+    if (useMockApi) {
+      const openAiInput = messages.map(message => ({
+        content: message.text,
+        role: message.role
+      }));
+      const modelId = getOpenApiModelId(selectedModelId);
+      const headers = {
+        Authorization: `Bearer ${openApiApiKey}`,
+        'Content-Type': 'application/json',
+        ...getClientRequestIdHeader()
+      };
+      const maxToolIterations = 4;
+      let previousResponseId;
+      for (let i = 0; i <= maxToolIterations; i++) {
+        capture({
+          headers,
+          method: 'POST',
+          payload: getOpenAiParams(openAiInput, modelId, streamingEnabled, passIncludeObfuscation, getBasicChatTools(), webSearchEnabled, previousResponseId),
+          url: getOpenApiApiEndpoint(openApiApiBaseUrl)
+        });
+        const result = await getMockOpenApiAssistantText(streamingEnabled, onTextChunk, onToolCallsChunk, onDataEvent, onEventStreamFinished);
+        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;
+        for (const toolCall of result.responseFunctionCalls) {
+          const content = await executeChatTool(toolCall.name, toolCall.arguments);
+          openAiInput.push({
+            call_id: toolCall.callId,
+            output: content,
+            type: 'function_call_output'
+          });
+        }
+      }
+    } else if (openApiApiKey) {
+      const result = await getOpenApiAssistantText(messages, getOpenApiModelId(selectedModelId), openApiApiKey, openApiApiBaseUrl, assetDir, platform, {
+        includeObfuscation: passIncludeObfuscation,
+        ...(onDataEvent ? {
+          onDataEvent
+        } : {}),
+        ...(onEventStreamFinished ? {
+          onEventStreamFinished
+        } : {}),
+        ...(onTextChunk ? {
+          onTextChunk
+        } : {}),
+        ...(onToolCallsChunk ? {
+          onToolCallsChunk
+        } : {}),
+        stream: streamingEnabled,
+        useChatNetworkWorkerForRequests,
+        webSearchEnabled
+      });
+      if (result.type === 'success') {
+        const {
+          text: assistantText
+        } = result;
+        text = assistantText;
+      } else {
+        text = getOpenApiErrorMessage(result);
+      }
+    } else {
+      text = openApiApiKeyRequiredMessage;
+    }
+  } else if (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);
+      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 isDefaultSessionTitle = title => {
+  return /^Chat \d+$/.test(title);
+};
+
+const sanitizeGeneratedTitle = value => {
+  return value.replace(/^title:\s*/i, '').replaceAll(/^['"`\s]+|['"`\s]+$/g, '').replaceAll(/\s+/g, ' ').trim().slice(0, 80);
+};
+
+const getTimeString = () => {
+  return new Date().toLocaleTimeString([], {
+    hour: '2-digit',
+    minute: '2-digit'
+  });
+};
+const getAiSessionTitle = async (state, userText, assistantText) => {
+  const {
+    models,
+    openApiApiBaseUrl,
+    openApiApiKey,
+    openRouterApiBaseUrl,
+    openRouterApiKey,
+    selectedModelId,
+    useMockApi
+  } = state;
+  if (useMockApi) {
+    return '';
+  }
+  const usesOpenApiModel = isOpenApiModel(selectedModelId, models);
+  const usesOpenRouterModel = isOpenRouterModel(selectedModelId, models);
+  if (usesOpenApiModel && !openApiApiKey) {
+    return '';
+  }
+  if (usesOpenRouterModel && !openRouterApiKey) {
+    return '';
+  }
+  if (!usesOpenApiModel && !usesOpenRouterModel) {
+    return '';
+  }
+  const titlePrompt = `Create a concise title (max 6 words) for this conversation. Respond only with the title, no punctuation at the end.
+User: ${userText}
+Assistant: ${assistantText}`;
+  const promptMessage = {
+    id: crypto.randomUUID(),
+    role: 'user',
+    text: titlePrompt,
+    time: getTimeString()
+  };
+  const titleResponse = await getAiResponse({
+    assetDir: state.assetDir,
+    messages: [promptMessage],
+    mockAiResponseDelay: state.mockAiResponseDelay,
+    mockApiCommandId: state.mockApiCommandId,
+    models,
+    openApiApiBaseUrl,
+    openApiApiKey,
+    openRouterApiBaseUrl,
+    openRouterApiKey,
+    passIncludeObfuscation: state.passIncludeObfuscation,
+    platform: state.platform,
+    selectedModelId,
+    streamingEnabled: false,
+    useChatNetworkWorkerForRequests: state.useChatNetworkWorkerForRequests,
+    useMockApi,
+    userText: titlePrompt,
+    webSearchEnabled: false
+  });
+  const title = sanitizeGeneratedTitle(titleResponse.text);
+  return title && !isDefaultSessionTitle(title) ? title : '';
+};
+
+const handleMessagePort = async port => {
+  await create$2({
+    commandMap: commandMap,
+    messagePort: port
+  });
+};
+
+const mockOpenApiRequestGetAll = () => {
+  return getAll();
+};
+
+const mockOpenApiRequestReset = () => {
+  reset();
+};
+
+const mockOpenApiSetHttpErrorResponse = (statusCode, body) => {
+  setHttpErrorResponse(statusCode, body);
+};
+
+const mockOpenApiStreamFinish = () => {
+  finish();
+};
+
+const mockOpenApiStreamPushChunk = chunk => {
+  pushChunk(chunk);
+};
+
+const mockOpenApiStreamReset = () => {
+  reset$1();
+};
+
+const commandMap = {
+  'ChatCoordinator.cancelRun': cancelRun,
+  'ChatCoordinator.consumeEvents': consumeEvents,
+  'ChatCoordinator.createSession': createSession,
+  'ChatCoordinator.deleteSession': deleteSession,
+  'ChatCoordinator.getAiResponse': getAiResponse,
+  'ChatCoordinator.getAiSessionTitle': getAiSessionTitle,
+  'ChatCoordinator.getSession': getSession,
+  'ChatCoordinator.listSessions': listSessions,
+  'ChatCoordinator.mockOpenApiRequestGetAll': mockOpenApiRequestGetAll,
+  'ChatCoordinator.mockOpenApiRequestReset': mockOpenApiRequestReset,
+  'ChatCoordinator.mockOpenApiSetHttpErrorResponse': mockOpenApiSetHttpErrorResponse,
+  'ChatCoordinator.mockOpenApiStreamFinish': mockOpenApiStreamFinish,
+  'ChatCoordinator.mockOpenApiStreamPushChunk': mockOpenApiStreamPushChunk,
+  'ChatCoordinator.mockOpenApiStreamReset': mockOpenApiStreamReset,
+  'ChatCoordinator.submit': submit,
+  'ChatCoordinator.subscribe': subscribe,
+  'ChatCoordinator.unsubscribe': unsubscribe,
+  'ChatCoordinator.waitForEvents': waitForEvents,
+  'HandleMessagePort.handleMessagePort': handleMessagePort
+};
+
+const listen = async () => {
+  await create$1({
+    commandMap: commandMap
+  });
+};
+
+const main = async () => {
+  await listen();
+};
+
+main();