@lvce-editor/static-server 0.75.11 → 0.75.13

package/static/{c86dcc9 → 5da550e}/packages/chat-view/dist/chatViewWorkerMain.js

@@ -1027,7 +1027,7 @@ const createMockRpc = ({
 };
 
 const rpcs = Object.create(null);
-const set$3 = (id, rpc) => {
+const set$4 = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get$2 = id => {
@@ -1060,7 +1060,7 @@ const create$2 = rpcId => {
       const mockRpc = createMockRpc({
         commandMap
       });
-      set$3(rpcId, mockRpc);
+      set$4(rpcId, mockRpc);
       // @ts-ignore
       mockRpc[Symbol.dispose] = () => {
         remove(rpcId);
@@ -1069,11 +1069,17 @@ const create$2 = rpcId => {
       return mockRpc;
     },
     set(rpc) {
-      set$3(rpcId, rpc);
+      set$4(rpcId, rpc);
     }
   };
 };
 
+const {
+  set: set$3
+} = create$2(6002);
+
+const Div$1 = 4;
+
 const ClientX = 'event.clientX';
 const ClientY = 'event.clientY';
 const Key = 'event.key';
@@ -1310,6 +1316,9 @@ const chats = () => {
 const newChat = () => {
   return i18nString('New Chat');
 };
+const debug = () => {
+  return i18nString('Debug');
+};
 const backToChats = () => {
   return i18nString('Back to chats');
 };
@@ -1471,6 +1480,7 @@ const createDefaultState = () => {
     listItemHeight: 40,
     maxComposerRows: 5,
     messagesScrollTop: 0,
+    mockAiResponseDelay: 800,
     mockApiCommandId: '',
     models: getDefaultModels(),
     nextMessageId: 1,
@@ -2006,7 +2016,7 @@ const now$1 = () => {
   return new Date().toISOString();
 };
 const isSameMessage$1 = (a, b) => {
-  return a.id === b.id && a.inProgress === b.inProgress && a.role === b.role && a.text === b.text && a.time === b.time;
+  return a.id === b.id && a.inProgress === b.inProgress && a.role === b.role && a.text === b.text && a.time === b.time && JSON.stringify(a.toolCalls || []) === JSON.stringify(b.toolCalls || []);
 };
 const canAppendMessages$1 = (previousMessages, nextMessages) => {
   if (nextMessages.length < previousMessages.length) {
@@ -2078,6 +2088,7 @@ const getMutationEvents$1 = (previous, next) => {
           text: nextMessage.text,
           time: nextMessage.time,
           timestamp,
+          toolCalls: nextMessage.toolCalls,
           type: 'chat-message-updated'
         });
       }
@@ -2130,9 +2141,14 @@ const replaySession$1 = (id, summary, events) => {
         }
         return {
           ...message,
-          inProgress: event.inProgress,
+          ...(event.inProgress === undefined ? {} : {
+            inProgress: event.inProgress
+          }),
           text: event.text,
-          time: event.time
+          time: event.time,
+          ...(event.toolCalls === undefined ? {} : {
+            toolCalls: event.toolCalls
+          })
         };
       });
       continue;
@@ -2311,7 +2327,7 @@ const now = () => {
   return new Date().toISOString();
 };
 const isSameMessage = (a, b) => {
-  return a.id === b.id && a.inProgress === b.inProgress && a.role === b.role && a.text === b.text && a.time === b.time;
+  return a.id === b.id && a.inProgress === b.inProgress && a.role === b.role && a.text === b.text && a.time === b.time && JSON.stringify(a.toolCalls || []) === JSON.stringify(b.toolCalls || []);
 };
 const canAppendMessages = (previousMessages, nextMessages) => {
   if (nextMessages.length < previousMessages.length) {
@@ -2383,6 +2399,7 @@ const getMutationEvents = (previous, next) => {
           text: nextMessage.text,
           time: nextMessage.time,
           timestamp,
+          toolCalls: nextMessage.toolCalls,
           type: 'chat-message-updated'
         });
       }
@@ -2429,9 +2446,14 @@ const replaySession = (id, title, events) => {
         }
         return {
           ...message,
-          inProgress: event.inProgress,
+          ...(event.inProgress === undefined ? {} : {
+            inProgress: event.inProgress
+          }),
           text: event.text,
-          time: event.time
+          time: event.time,
+          ...(event.toolCalls === undefined ? {} : {
+            toolCalls: event.toolCalls
+          })
         };
       });
       continue;
@@ -2645,18 +2667,45 @@ const delay = async ms => {
   await new Promise(resolve => setTimeout(resolve, ms));
 };
 
-const getMockAiResponse = async userMessage => {
-  await delay(800);
+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) {
@@ -2684,23 +2733,174 @@ const readNextChunk = async () => {
   if (finished) {
     return undefined;
   }
-  return new Promise(resolve => {
-    waiters.push(resolve);
-  });
+  const {
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  waiters.push(resolve);
+  return promise;
 };
 
-const getMockOpenApiAssistantText = async (stream, onTextChunk) => {
+const parseSseDataLines = eventChunk => {
+  const lines = eventChunk.split('\n');
+  const dataLines = [];
+  for (const line of lines) {
+    if (!line.startsWith('data:')) {
+      continue;
+    }
+    dataLines.push(line.slice(5).trimStart());
+  }
+  return dataLines;
+};
+const emitToolCalls = async (toolCallAccumulator, onToolCallsChunk) => {
+  if (!onToolCallsChunk) {
+    return;
+  }
+  const toolCalls = Object.entries(toolCallAccumulator).toSorted((a, b) => Number(a[0]) - Number(b[0])).map(entry => entry[1]).filter(toolCall => !!toolCall.name);
+  if (toolCalls.length === 0) {
+    return;
+  }
+  await onToolCallsChunk(toolCalls);
+};
+const getMockOpenApiAssistantText = async (stream, onTextChunk, onToolCallsChunk, onDataEvent, onEventStreamFinished) => {
+  const error = takeErrorResponse();
+  if (error) {
+    return error;
+  }
   let text = '';
+  let remainder = '';
+  let toolCallAccumulator = {};
+  let finishedNotified = false;
+  const notifyFinished = async () => {
+    if (finishedNotified) {
+      return;
+    }
+    finishedNotified = true;
+    if (onEventStreamFinished) {
+      await onEventStreamFinished();
+    }
+  };
+  const handleParsedSseEvent = async parsed => {
+    if (onDataEvent) {
+      await onDataEvent(parsed);
+    }
+    if (!parsed || typeof parsed !== 'object') {
+      return;
+    }
+    const eventType = Reflect.get(parsed, 'type');
+    if (eventType === 'response.completed') {
+      await notifyFinished();
+      return;
+    }
+    if (eventType === 'response.output_text.delta') {
+      const delta = Reflect.get(parsed, 'delta');
+      if (typeof delta !== 'string' || !delta) {
+        return;
+      }
+      text += delta;
+      if (stream && onTextChunk) {
+        await onTextChunk(delta);
+      }
+      return;
+    }
+    if (eventType === 'response.output_item.added') {
+      const outputIndex = Reflect.get(parsed, 'output_index');
+      const item = Reflect.get(parsed, 'item');
+      if (typeof outputIndex !== 'number' || !item || typeof item !== 'object') {
+        return;
+      }
+      if (Reflect.get(item, 'type') !== 'function_call') {
+        return;
+      }
+      const name = Reflect.get(item, 'name');
+      const argumentsValue = Reflect.get(item, 'arguments');
+      const callId = Reflect.get(item, 'call_id');
+      toolCallAccumulator = {
+        ...toolCallAccumulator,
+        [outputIndex]: {
+          arguments: typeof argumentsValue === 'string' ? argumentsValue : '',
+          ...(typeof callId === 'string' ? {
+            id: callId
+          } : {}),
+          name: typeof name === 'string' ? name : ''
+        }
+      };
+      await emitToolCalls(toolCallAccumulator, onToolCallsChunk);
+      return;
+    }
+    if (eventType === 'response.function_call_arguments.delta' || eventType === 'response.function_call_arguments.done') {
+      const outputIndex = Reflect.get(parsed, 'output_index');
+      if (typeof outputIndex !== 'number') {
+        return;
+      }
+      const current = toolCallAccumulator[outputIndex] || {
+        arguments: '',
+        name: ''
+      };
+      const delta = Reflect.get(parsed, 'delta');
+      const argumentsValue = Reflect.get(parsed, 'arguments');
+      const name = Reflect.get(parsed, 'name');
+      const callId = Reflect.get(parsed, 'call_id');
+      const next = {
+        arguments: typeof argumentsValue === 'string' ? argumentsValue : typeof delta === 'string' ? `${current.arguments}${delta}` : current.arguments,
+        ...(typeof callId === 'string' ? {
+          id: callId
+        } : current.id ? {
+          id: current.id
+        } : {}),
+        name: typeof name === 'string' && name ? name : current.name
+      };
+      toolCallAccumulator = {
+        ...toolCallAccumulator,
+        [outputIndex]: next
+      };
+      await emitToolCalls(toolCallAccumulator, onToolCallsChunk);
+    }
+  };
+  const consumeSseDataLines = async dataLines => {
+    for (const line of dataLines) {
+      if (line === '[DONE]') {
+        await notifyFinished();
+        continue;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      await handleParsedSseEvent(parsed);
+    }
+  };
   while (true) {
     const chunk = await readNextChunk();
     if (typeof chunk !== 'string') {
       break;
     }
+    if (chunk.startsWith('data:')) {
+      remainder += chunk;
+      while (true) {
+        const separatorIndex = remainder.indexOf('\n\n');
+        if (separatorIndex === -1) {
+          break;
+        }
+        const rawEvent = remainder.slice(0, separatorIndex);
+        remainder = remainder.slice(separatorIndex + 2);
+        const dataLines = parseSseDataLines(rawEvent);
+        await consumeSseDataLines(dataLines);
+      }
+      continue;
+    }
     text += chunk;
     if (stream && onTextChunk) {
       await onTextChunk(chunk);
     }
   }
+  if (remainder) {
+    const dataLines = parseSseDataLines(remainder);
+    await consumeSseDataLines(dataLines);
+  }
+  await notifyFinished();
   return {
     text,
     type: 'success'
@@ -2739,13 +2939,23 @@ const normalizeLimitInfo = value => {
   const usage = Reflect.get(value, 'usage');
   const usageDaily = Reflect.get(value, 'usageDaily');
   const normalized = {
-    limitRemaining: typeof limitRemaining === 'number' || limitRemaining === null ? limitRemaining : undefined,
-    limitReset: typeof limitReset === 'string' || limitReset === null ? limitReset : undefined,
-    retryAfter: typeof retryAfter === 'string' || retryAfter === null ? retryAfter : undefined,
-    usage: typeof usage === 'number' ? usage : undefined,
-    usageDaily: typeof usageDaily === 'number' ? usageDaily : undefined
+    ...(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 = normalized.limitRemaining !== undefined || normalized.limitReset !== undefined || normalized.retryAfter !== undefined || normalized.usage !== undefined || normalized.usageDaily !== undefined;
+  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;
 };
 
@@ -2781,11 +2991,18 @@ const normalizeMockResult = value => {
     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: normalizeLimitInfo(Reflect.get(value, 'limitInfo')),
-        rawMessage: typeof rawMessage === 'string' ? rawMessage : undefined,
-        statusCode: typeof statusCode === 'number' ? statusCode : undefined,
+        ...(limitInfo ? {
+          limitInfo
+        } : {}),
+        ...(typeof rawMessage === 'string' ? {
+          rawMessage
+        } : {}),
+        ...(typeof statusCode === 'number' ? {
+          statusCode
+        } : {}),
         type: 'error'
       };
     }
@@ -3016,11 +3233,8 @@ const getClientRequestIdHeader = () => {
   };
 };
 
-const getOpenApiApiEndpoint = (openApiApiBaseUrl, stream) => {
-  if (stream) {
-    return `${openApiApiBaseUrl}/chat/completions?stream=true`;
-  }
-  return `${openApiApiBaseUrl}/chat/completions`;
+const getOpenApiApiEndpoint = openApiApiBaseUrl => {
+  return `${openApiApiBaseUrl}/responses`;
 };
 
 const getTextContent = content => {
@@ -3044,18 +3258,50 @@ const getTextContent = content => {
   return textParts.join('\n');
 };
 
-const getOpenAiParams = (completionMessages, modelId, stream, includeObfuscation, tools) => {
+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, previousResponseId) => {
   return {
-    messages: completionMessages,
+    input,
     model: modelId,
     ...(stream ? {
-      stream: true
+      stream: true,
+      ...(includeObfuscation ? {} : {
+        stream_options: {
+          include_obfuscation: false
+        }
+      })
     } : {}),
-    ...(includeObfuscation ? {
-      include_obfuscation: true
+    ...(previousResponseId ? {
+      previous_response_id: previousResponseId
     } : {}),
     tool_choice: 'auto',
-    tools
+    tools: getOpenAiTools(tools)
   };
 };
 const getStreamChunkText = content => {
@@ -3073,6 +3319,75 @@ const getStreamChunkText = content => {
     return typeof text === 'string' ? text : '';
   }).join('');
 };
+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 = [];
@@ -3084,7 +3399,63 @@ const parseSseEvent = eventChunk => {
   }
   return dataLines;
 };
-const parseOpenApiStream = async (response, onTextChunk) => {
+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 parseOpenApiStream = async (response, onTextChunk, onToolCallsChunk, onDataEvent, onEventStreamFinished) => {
   if (!response.body) {
     return {
       details: 'request-failed',
@@ -3096,6 +3467,136 @@ const parseOpenApiStream = async (response, onTextChunk) => {
   let remainder = '';
   let text = '';
   let done = false;
+  let finishedNotified = false;
+  let toolCallAccumulator = {};
+  const notifyFinished = async () => {
+    if (finishedNotified) {
+      return;
+    }
+    finishedNotified = true;
+    if (onEventStreamFinished) {
+      await onEventStreamFinished();
+    }
+  };
+  const emitToolCallAccumulator = async () => {
+    if (!onToolCallsChunk) {
+      return;
+    }
+    const toolCalls = Object.entries(toolCallAccumulator).toSorted((a, b) => Number(a[0]) - Number(b[0])).map(entry => entry[1]).filter(toolCall => !!toolCall.name);
+    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') {
+      await notifyFinished();
+      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 outputIndex = Reflect.get(parsed, 'output_index');
+      const item = Reflect.get(parsed, 'item');
+      if (typeof outputIndex !== 'number' || !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,
+        [outputIndex]: next
+      };
+      await emitToolCallAccumulator();
+      return;
+    }
+    if (eventType === 'response.function_call_arguments.delta' || eventType === 'response.function_call_arguments.done') {
+      const outputIndex = Reflect.get(parsed, 'output_index');
+      if (typeof outputIndex !== 'number') {
+        return;
+      }
+      const current = toolCallAccumulator[outputIndex] || {
+        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,
+        [outputIndex]: 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,
@@ -3121,6 +3622,7 @@ const parseOpenApiStream = async (response, onTextChunk) => {
       }
       for (const line of dataLines) {
         if (line === '[DONE]') {
+          await notifyFinished();
           done = true;
           break;
         }
@@ -3130,30 +3632,7 @@ const parseOpenApiStream = async (response, onTextChunk) => {
         } catch {
           continue;
         }
-        if (!parsed || typeof parsed !== 'object') {
-          continue;
-        }
-        const choices = Reflect.get(parsed, 'choices');
-        if (!Array.isArray(choices)) {
-          continue;
-        }
-        const firstChoice = choices[0];
-        if (!firstChoice || typeof firstChoice !== 'object') {
-          continue;
-        }
-        const delta = Reflect.get(firstChoice, 'delta');
-        if (!delta || typeof delta !== 'object') {
-          continue;
-        }
-        const content = Reflect.get(delta, 'content');
-        const chunkText = getStreamChunkText(content);
-        if (!chunkText) {
-          continue;
-        }
-        text += chunkText;
-        if (onTextChunk) {
-          await onTextChunk(chunkText);
-        }
+        await handleParsedStreamEvent(parsed);
       }
     }
   }
@@ -3161,6 +3640,7 @@ const parseOpenApiStream = async (response, onTextChunk) => {
     const dataLines = parseSseEvent(remainder);
     for (const line of dataLines) {
       if (line === '[DONE]') {
+        await notifyFinished();
         continue;
       }
       let parsed;
@@ -3169,32 +3649,10 @@ const parseOpenApiStream = async (response, onTextChunk) => {
       } catch {
         continue;
       }
-      if (!parsed || typeof parsed !== 'object') {
-        continue;
-      }
-      const choices = Reflect.get(parsed, 'choices');
-      if (!Array.isArray(choices)) {
-        continue;
-      }
-      const firstChoice = choices[0];
-      if (!firstChoice || typeof firstChoice !== 'object') {
-        continue;
-      }
-      const delta = Reflect.get(firstChoice, 'delta');
-      if (!delta || typeof delta !== 'object') {
-        continue;
-      }
-      const content = Reflect.get(delta, 'content');
-      const chunkText = getStreamChunkText(content);
-      if (!chunkText) {
-        continue;
-      }
-      text += chunkText;
-      if (onTextChunk) {
-        await onTextChunk(chunkText);
-      }
+      await handleParsedStreamEvent(parsed);
     }
   }
+  await notifyFinished();
   return {
     text,
     type: 'success'
@@ -3218,30 +3676,40 @@ const getOpenApiErrorDetails = async response => {
   const errorMessage = Reflect.get(error, 'message');
   const errorType = Reflect.get(error, 'type');
   return {
-    errorCode: typeof errorCode === 'string' ? errorCode : undefined,
-    errorMessage: typeof errorMessage === 'string' ? errorMessage : undefined,
-    errorType: typeof errorType === 'string' ? errorType : undefined
+    ...(typeof errorCode === 'string' ? {
+      errorCode
+    } : {}),
+    ...(typeof errorMessage === 'string' ? {
+      errorMessage
+    } : {}),
+    ...(typeof errorType === 'string' ? {
+      errorType
+    } : {})
   };
 };
 const getOpenApiAssistantText = async (messages, modelId, openApiApiKey, openApiApiBaseUrl, assetDir, platform, options) => {
   const {
     includeObfuscation = false,
+    onDataEvent,
+    onEventStreamFinished,
     onTextChunk,
+    onToolCallsChunk,
     stream
   } = options ?? {
     stream: false
   };
-  const completionMessages = messages.map(message => ({
+  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++) {
     let response;
     try {
-      response = await fetch(getOpenApiApiEndpoint(openApiApiBaseUrl, stream), {
-        body: JSON.stringify(getOpenAiParams(completionMessages, modelId, stream, includeObfuscation, tools)),
+      response = await fetch(getOpenApiApiEndpoint(openApiApiBaseUrl), {
+        body: JSON.stringify(getOpenAiParams(openAiInput, modelId, stream, includeObfuscation, tools, previousResponseId)),
         headers: {
           Authorization: `Bearer ${openApiApiKey}`,
           'Content-Type': 'application/json',
@@ -3263,15 +3731,21 @@ const getOpenApiAssistantText = async (messages, modelId, openApiApiKey, openApi
       } = await getOpenApiErrorDetails(response);
       return {
         details: 'http-error',
-        errorCode,
-        errorMessage,
-        errorType,
+        ...(errorCode ? {
+          errorCode
+        } : {}),
+        ...(errorMessage ? {
+          errorMessage
+        } : {}),
+        ...(errorType ? {
+          errorType
+        } : {}),
         statusCode: response.status,
         type: 'error'
       };
     }
     if (stream) {
-      return parseOpenApiStream(response, onTextChunk);
+      return parseOpenApiStream(response, onTextChunk, onToolCallsChunk, onDataEvent, onEventStreamFinished);
     }
     let parsed;
     try {
@@ -3288,56 +3762,83 @@ const getOpenApiAssistantText = async (messages, modelId, openApiApiKey, openApi
         type: 'success'
       };
     }
-    const choices = Reflect.get(parsed, 'choices');
-    if (!Array.isArray(choices)) {
-      return {
-        text: '',
-        type: 'success'
-      };
+    const parsedResponseId = Reflect.get(parsed, 'id');
+    if (typeof parsedResponseId === 'string' && parsedResponseId) {
+      previousResponseId = parsedResponseId;
     }
-    const firstChoice = choices[0];
-    if (!firstChoice || typeof firstChoice !== 'object') {
-      return {
-        text: '',
-        type: 'success'
-      };
+    const responseFunctionCalls = getResponseFunctionCalls(parsed);
+    if (responseFunctionCalls.length > 0) {
+      openAiInput.length = 0;
+      for (const toolCall of responseFunctionCalls) {
+        const content = await executeChatTool(toolCall.name, toolCall.arguments, {
+          assetDir,
+          platform
+        });
+        openAiInput.push({
+          call_id: toolCall.callId,
+          output: content,
+          type: 'function_call_output'
+        });
+      }
+      continue;
     }
-    const message = Reflect.get(firstChoice, 'message');
-    if (!message || typeof message !== 'object') {
+    const outputText = getResponseOutputText(parsed);
+    if (outputText) {
       return {
-        text: '',
+        text: outputText,
         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 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;
+        for (const toolCall of toolCalls) {
+          if (!toolCall || typeof toolCall !== 'object') {
+            continue;
+          }
+          const id = Reflect.get(toolCall, 'id');
+          const toolFunction = Reflect.get(toolCall, 'function');
+          if (typeof id !== 'string' || !toolFunction || typeof toolFunction !== 'object') {
+            continue;
+          }
+          const name = Reflect.get(toolFunction, 'name');
+          const rawArguments = Reflect.get(toolFunction, 'arguments');
+          const content = typeof name === 'string' ? await executeChatTool(name, rawArguments, {
+            assetDir,
+            platform
+          }) : '{}';
+          openAiInput.push({
+            call_id: id,
+            output: content,
+            type: 'function_call_output'
+          });
         }
-        const name = Reflect.get(toolFunction, 'name');
-        const rawArguments = Reflect.get(toolFunction, 'arguments');
-        const content = typeof name === 'string' ? await executeChatTool(name, rawArguments, {
-          assetDir,
-          platform
-        }) : '{}';
-        completionMessages.push({
-          content,
-          role: 'tool',
-          tool_call_id: id
-        });
+        continue;
       }
-      continue;
+      const content = Reflect.get(message, 'content');
+      return {
+        text: getTextContent(content),
+        type: 'success'
+      };
     }
-    const content = Reflect.get(message, 'content');
     return {
-      text: getTextContent(content),
+      text: '',
       type: 'success'
     };
   }
@@ -3473,10 +3974,18 @@ const getOpenRouterLimitInfo = async (openRouterApiKey, openRouterApiBaseUrl) =>
   const usage = Reflect.get(data, 'usage');
   const usageDaily = Reflect.get(data, 'usage_daily');
   const normalizedLimitInfo = {
-    limitRemaining: typeof limitRemaining === 'number' || limitRemaining === null ? limitRemaining : undefined,
-    limitReset: typeof limitReset === 'string' || limitReset === null ? limitReset : undefined,
-    usage: typeof usage === 'number' ? usage : undefined,
-    usageDaily: typeof usageDaily === 'number' ? usageDaily : undefined
+    ...(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) {
@@ -3521,11 +4030,17 @@ const getOpenRouterAssistantText = async (messages, modelId, openRouterApiKey, o
         const limitInfo = await getOpenRouterLimitInfo(openRouterApiKey, openRouterApiBaseUrl);
         return {
           details: 'too-many-requests',
-          limitInfo: limitInfo || retryAfter ? {
-            ...limitInfo,
-            retryAfter
-          } : undefined,
-          rawMessage,
+          ...(limitInfo || retryAfter ? {
+            limitInfo: {
+              ...limitInfo,
+              ...(retryAfter ? {
+                retryAfter
+              } : {})
+            }
+          } : {}),
+          ...(rawMessage ? {
+            rawMessage
+          } : {}),
           statusCode: 429,
           type: 'error'
         };
@@ -3685,11 +4200,15 @@ const isOpenRouterModel = (selectedModelId, models) => {
 
 const getAiResponse = async ({
   assetDir,
+  messageId,
   messages,
+  mockAiResponseDelay = 800,
   mockApiCommandId,
   models,
-  nextMessageId,
+  onDataEvent,
+  onEventStreamFinished,
   onTextChunk,
+  onToolCallsChunk,
   openApiApiBaseUrl,
   openApiApiKey,
   openRouterApiBaseUrl,
@@ -3706,7 +4225,7 @@ const getAiResponse = async ({
   const usesOpenRouterModel = isOpenRouterModel(selectedModelId, models);
   if (usesOpenApiModel) {
     if (useMockApi) {
-      const result = await getMockOpenApiAssistantText(streamingEnabled, onTextChunk);
+      const result = await getMockOpenApiAssistantText(streamingEnabled, onTextChunk, onToolCallsChunk, onDataEvent, onEventStreamFinished);
       if (result.type === 'success') {
         const {
           text: assistantText
@@ -3718,7 +4237,18 @@ const getAiResponse = async ({
     } else if (openApiApiKey) {
       const result = await getOpenApiAssistantText(messages, getOpenApiModelId(selectedModelId), openApiApiKey, openApiApiBaseUrl, assetDir, platform, {
         includeObfuscation: passIncludeObfuscation,
-        onTextChunk,
+        ...(onDataEvent ? {
+          onDataEvent
+        } : {}),
+        ...(onEventStreamFinished ? {
+          onEventStreamFinished
+        } : {}),
+        ...(onTextChunk ? {
+          onTextChunk
+        } : {}),
+        ...(onToolCallsChunk ? {
+          onToolCallsChunk
+        } : {}),
         stream: streamingEnabled
       });
       if (result.type === 'success') {
@@ -3759,14 +4289,14 @@ const getAiResponse = async ({
     }
   }
   if (!text && !usesOpenApiModel && !usesOpenRouterModel) {
-    text = await getMockAiResponse(userText);
+    text = await getMockAiResponse(userText, mockAiResponseDelay);
   }
   const assistantTime = new Date().toLocaleTimeString([], {
     hour: '2-digit',
     minute: '2-digit'
   });
   return {
-    id: `message-${nextMessageId}`,
+    id: messageId || crypto.randomUUID(),
     role: 'assistant',
     text,
     time: assistantTime
@@ -3819,9 +4349,9 @@ const handleClickSaveOpenApiApiKey = async state => {
   const assistantMessage = await getAiResponse({
     assetDir: updatedState.assetDir,
     messages: retryMessages,
+    mockAiResponseDelay: updatedState.mockAiResponseDelay,
     mockApiCommandId: updatedState.mockApiCommandId,
     models: updatedState.models,
-    nextMessageId: updatedState.nextMessageId,
     openApiApiBaseUrl: updatedState.openApiApiBaseUrl,
     openApiApiKey: updatedState.openApiApiKey,
     openRouterApiBaseUrl: updatedState.openRouterApiBaseUrl,
@@ -3899,9 +4429,9 @@ const handleClickSaveOpenRouterApiKey = async state => {
   const assistantMessage = await getAiResponse({
     assetDir: updatedState.assetDir,
     messages: retryMessages,
+    mockAiResponseDelay: updatedState.mockAiResponseDelay,
     mockApiCommandId: updatedState.mockApiCommandId,
     models: updatedState.models,
-    nextMessageId: updatedState.nextMessageId,
     openApiApiBaseUrl: updatedState.openApiApiBaseUrl,
     openApiApiKey: updatedState.openApiApiKey,
     openRouterApiBaseUrl: updatedState.openRouterApiBaseUrl,
@@ -3958,6 +4488,25 @@ const updateMessageTextInSelectedSession = (sessions, selectedSessionId, message
     };
   });
 };
+const updateMessageToolCallsInSelectedSession = (sessions, selectedSessionId, messageId, toolCalls) => {
+  return sessions.map(session => {
+    if (session.id !== selectedSessionId) {
+      return session;
+    }
+    return {
+      ...session,
+      messages: session.messages.map(message => {
+        if (message.id !== messageId) {
+          return message;
+        }
+        return {
+          ...message,
+          toolCalls
+        };
+      })
+    };
+  });
+};
 const handleTextChunkFunction = async (uid, assistantMessageId, chunk, handleTextChunkState) => {
   const selectedSession = handleTextChunkState.latestState.sessions.find(session => session.id === handleTextChunkState.latestState.selectedSessionId);
   if (!selectedSession) {
@@ -3973,13 +4522,6 @@ const handleTextChunkFunction = async (uid, assistantMessageId, chunk, handleTex
       previousState: handleTextChunkState.previousState
     };
   }
-  await appendChatViewEvent({
-    content: chunk,
-    messageId: assistantMessageId,
-    sessionId: handleTextChunkState.latestState.selectedSessionId,
-    timestamp: new Date().toISOString(),
-    type: 'handle-response-chunk'
-  });
   const updatedText = assistantMessage.text + chunk;
   const updatedSessions = updateMessageTextInSelectedSession(handleTextChunkState.latestState.sessions, handleTextChunkState.latestState.selectedSessionId, assistantMessageId, updatedText, true);
   const nextState = {
@@ -3994,6 +4536,34 @@ const handleTextChunkFunction = async (uid, assistantMessageId, chunk, handleTex
     previousState: nextState
   };
 };
+const handleToolCallsChunkFunction = async (uid, assistantMessageId, toolCalls, handleTextChunkState) => {
+  const selectedSession = handleTextChunkState.latestState.sessions.find(session => session.id === handleTextChunkState.latestState.selectedSessionId);
+  if (!selectedSession) {
+    return {
+      latestState: handleTextChunkState.latestState,
+      previousState: handleTextChunkState.previousState
+    };
+  }
+  const assistantMessage = selectedSession.messages.find(message => message.id === assistantMessageId);
+  if (!assistantMessage) {
+    return {
+      latestState: handleTextChunkState.latestState,
+      previousState: handleTextChunkState.previousState
+    };
+  }
+  const updatedSessions = updateMessageToolCallsInSelectedSession(handleTextChunkState.latestState.sessions, handleTextChunkState.latestState.selectedSessionId, assistantMessageId, toolCalls);
+  const nextState = {
+    ...handleTextChunkState.latestState,
+    sessions: updatedSessions
+  };
+  set(uid, handleTextChunkState.previousState, nextState);
+  // @ts-ignore
+  await invoke('Chat.rerender');
+  return {
+    latestState: nextState,
+    previousState: nextState
+  };
+};
 
 const appendMessageToSelectedSession = (sessions, selectedSessionId, message) => {
   return sessions.map(session => {
@@ -4010,6 +4580,7 @@ const handleSubmit = async state => {
   const {
     assetDir,
     composerValue,
+    mockAiResponseDelay,
     mockApiCommandId,
     models,
     nextMessageId,
@@ -4034,13 +4605,14 @@ const handleSubmit = async state => {
     hour: '2-digit',
     minute: '2-digit'
   });
+  const userMessageId = crypto.randomUUID();
   const userMessage = {
-    id: `message-${nextMessageId}`,
+    id: userMessageId,
     role: 'user',
     text: userText,
     time: userTime
   };
-  const assistantMessageId = `message-${nextMessageId + 1}`;
+  const assistantMessageId = crypto.randomUUID();
   const assistantTime = new Date().toLocaleTimeString([], {
     hour: '2-digit',
     minute: '2-digit'
@@ -4127,11 +4699,33 @@ const handleSubmit = async state => {
   } : undefined;
   const assistantMessage = await getAiResponse({
     assetDir,
+    messageId: assistantMessageId,
     messages,
+    mockAiResponseDelay,
     mockApiCommandId,
     models,
-    nextMessageId: optimisticState.nextMessageId,
-    onTextChunk: handleTextChunkFunctionRef,
+    onDataEvent: async value => {
+      await appendChatViewEvent({
+        sessionId: optimisticState.selectedSessionId,
+        timestamp: new Date().toISOString(),
+        type: 'sse-response-part',
+        value
+      });
+    },
+    onEventStreamFinished: async () => {
+      await appendChatViewEvent({
+        sessionId: optimisticState.selectedSessionId,
+        timestamp: new Date().toISOString(),
+        type: 'event-stream-finished',
+        value: '[DONE]'
+      });
+    },
+    ...(handleTextChunkFunctionRef ? {
+      onTextChunk: handleTextChunkFunctionRef
+    } : {}),
+    onToolCallsChunk: async toolCalls => {
+      handleTextChunkState = await handleToolCallsChunkFunction(state.uid, assistantMessageId, toolCalls, handleTextChunkState);
+    },
     openApiApiBaseUrl,
     openApiApiKey,
     openRouterApiBaseUrl,
@@ -4177,6 +4771,7 @@ const Send = 'send';
 const Back = 'back';
 const Model = 'model';
 const CreateSession = 'create-session';
+const SessionDebug = 'session-debug';
 const Settings = 'settings';
 const CloseChat = 'close-chat';
 const SessionDelete = 'SessionDelete';
@@ -4321,6 +4916,11 @@ const handleClickNew = async state => {
   return createSession(state);
 };
 
+const handleClickSessionDebug = async state => {
+  await invoke('Main.openUri', `chat-debug://${state.selectedSessionId}`);
+  return state;
+};
+
 const handleClickSettings = async () => {
   // TODO
   await invoke('Main.openUri', 'app://settings.json');
@@ -4377,7 +4977,7 @@ const handleInputFocus = async (state, name) => {
       focused: true
     };
   }
-  if (name === CreateSession || name === Settings || name === CloseChat || name === Back) {
+  if (name === CreateSession || name === SessionDebug || name === Settings || name === CloseChat || name === Back) {
     return {
       ...state,
       focus: 'header',
@@ -4643,13 +5243,6 @@ const loadPreferences = async () => {
   };
 };
 
-const toSummarySession = session => {
-  return {
-    id: session.id,
-    messages: [],
-    title: session.title
-  };
-};
 const loadSelectedSessionMessages = async (sessions, selectedSessionId) => {
   if (!selectedSessionId) {
     return sessions;
@@ -4665,6 +5258,14 @@ const loadSelectedSessionMessages = async (sessions, selectedSessionId) => {
     return loadedSession;
   });
 };
+
+const toSummarySession = session => {
+  return {
+    id: session.id,
+    messages: [],
+    title: session.title
+  };
+};
 const loadContent = async (state, savedState) => {
   const savedSelectedModelId = getSavedSelectedModelId(savedState);
   const savedViewMode = getSavedViewMode(savedState);
@@ -4716,6 +5317,11 @@ const loadContent = async (state, savedState) => {
   };
 };
 
+const mockOpenApiSetHttpErrorResponse = (state, statusCode, body) => {
+  setHttpErrorResponse(statusCode, body);
+  return state;
+};
+
 const mockOpenApiStreamFinish = state => {
   finish();
   return state;
@@ -4866,6 +5472,7 @@ const HandleSubmit = 19;
 const HandleModelChange = 20;
 const HandleChatListScroll = 21;
 const HandleMessagesScroll = 22;
+const HandleClickSessionDebug = 23;
 
 const getModelLabel = model => {
   if (model.provider === 'openRouter') {
@@ -4887,6 +5494,18 @@ const getModelOptionDOm = (model, selectedModelId) => {
   }, text(getModelLabel(model))];
 };
 
+const getChatSelectVirtualDom = (models, selectedModelId) => {
+  const modelOptions = models.flatMap(model => getModelOptionDOm(model, selectedModelId));
+  return [{
+    childCount: models.length,
+    className: Select,
+    name: Model,
+    onInput: HandleModelChange,
+    type: Select$1,
+    value: selectedModelId
+  }, ...modelOptions];
+};
+
 const getSendButtonClassName = isSendDisabled => {
   return isSendDisabled ? `${IconButton} ${SendButtonDisabled}` : `${IconButton}`;
 };
@@ -4946,7 +5565,6 @@ const getUsageOverviewDom = (tokensUsed, tokensMax) => {
 
 const getChatSendAreaDom = (composerValue, models, selectedModelId, usageOverviewEnabled, tokensUsed, tokensMax, composerHeight = 28, composerFontSize = 13, composerFontFamily = 'system-ui', composerLineHeight = 20) => {
   const isSendDisabled = composerValue.trim() === '';
-  const modelOptions = models.flatMap(model => getModelOptionDOm(model, selectedModelId));
   return [{
     childCount: 1,
     className: ChatSendArea,
@@ -4962,21 +5580,13 @@ const getChatSendAreaDom = (composerValue, models, selectedModelId, usageOvervie
     onFocus: HandleFocus,
     onInput: HandleInput,
     placeholder: composePlaceholder(),
-    // style: `height:${composerHeight}px;font-size:${composerFontSize}px;font-family:${composerFontFamily};line-height:${composerLineHeight}px;`,
     type: TextArea,
     value: composerValue
   }, {
     childCount: usageOverviewEnabled ? 3 : 2,
     className: ChatSendAreaBottom,
     type: Div
-  }, {
-    childCount: models.length,
-    className: Select,
-    name: Model,
-    onInput: HandleModelChange,
-    type: Select$1,
-    value: selectedModelId
-  }, ...modelOptions, ...(usageOverviewEnabled ? getUsageOverviewDom(tokensUsed, tokensMax) : []), ...getSendButtonDom(isSendDisabled)];
+  }, ...getChatSelectVirtualDom(models, selectedModelId), ...(usageOverviewEnabled ? getUsageOverviewDom(tokensUsed, tokensMax) : []), ...getSendButtonDom(isSendDisabled)];
 };
 
 const getBackButtonVirtualDom = () => {
@@ -5013,6 +5623,11 @@ const getHeaderActionVirtualDom = item => {
 
 const getChatHeaderActionsDom = () => {
   const items = [{
+    icon: 'MaskIcon MaskIconDebugPause',
+    name: SessionDebug,
+    onClick: HandleClickSessionDebug,
+    title: debug()
+  }, {
     icon: 'MaskIcon MaskIconAdd',
     name: CreateSession,
     onClick: HandleClickNew,
@@ -5130,6 +5745,7 @@ const getOpenRouterRequestFailedDom = () => {
     }, text(reason)];
   })];
 };
+
 const getOpenRouterTooManyRequestsDom = () => {
   return [{
     childCount: openRouterTooManyRequestsReasons.length,
@@ -5143,13 +5759,146 @@ const getOpenRouterTooManyRequestsDom = () => {
     }, text(reason)];
   })];
 };
+
+const getToolCallArgumentPreview = rawArguments => {
+  if (!rawArguments.trim()) {
+    return '""';
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(rawArguments);
+  } catch {
+    return rawArguments;
+  }
+  if (!parsed || typeof parsed !== 'object') {
+    return rawArguments;
+  }
+  const path = Reflect.get(parsed, 'path');
+  if (typeof path === 'string') {
+    return `"${path}"`;
+  }
+  const keys = Object.keys(parsed);
+  if (keys.length === 1) {
+    const value = Reflect.get(parsed, keys[0]);
+    if (typeof value === 'string') {
+      return `"${value}"`;
+    }
+  }
+  return rawArguments;
+};
+
+const getToolCallDom = toolCall => {
+  const argumentPreview = getToolCallArgumentPreview(toolCall.arguments);
+  const label = `${toolCall.name} ${argumentPreview}`;
+  return [{
+    childCount: 1,
+    className: Markdown,
+    type: P
+  }, text(label)];
+};
+
+const getToolCallsDom = message => {
+  if (message.role !== 'assistant' || !message.toolCalls || message.toolCalls.length === 0) {
+    return [];
+  }
+  return [{
+    childCount: message.toolCalls.length,
+    className: 'ToolCallsContainer',
+    type: Div$1
+  }, ...message.toolCalls.flatMap(getToolCallDom)];
+};
+
+const orderedListItemRegex = /^\s*\d+\.\s+(.*)$/;
+const parseMessageContent = rawMessage => {
+  if (rawMessage === '') {
+    return [{
+      text: '',
+      type: 'text'
+    }];
+  }
+  const lines = rawMessage.split(/\r?\n/);
+  const nodes = [];
+  let paragraphLines = [];
+  let listItems = [];
+  const flushParagraph = () => {
+    if (paragraphLines.length === 0) {
+      return;
+    }
+    nodes.push({
+      text: paragraphLines.join('\n'),
+      type: 'text'
+    });
+    paragraphLines = [];
+  };
+  const flushList = () => {
+    if (listItems.length === 0) {
+      return;
+    }
+    nodes.push({
+      items: listItems,
+      type: 'list'
+    });
+    listItems = [];
+  };
+  for (const line of lines) {
+    if (!line.trim()) {
+      flushList();
+      flushParagraph();
+      continue;
+    }
+    const match = line.match(orderedListItemRegex);
+    if (match) {
+      flushParagraph();
+      listItems.push({
+        text: match[1],
+        type: 'list-item'
+      });
+      continue;
+    }
+    flushList();
+    paragraphLines.push(line);
+  }
+  flushList();
+  flushParagraph();
+  return nodes.length === 0 ? [{
+    text: '',
+    type: 'text'
+  }] : nodes;
+};
+const getMessageContentDom = nodes => {
+  return nodes.flatMap(node => {
+    if (node.type === 'text') {
+      return [{
+        childCount: 1,
+        className: Markdown,
+        type: P
+      }, text(node.text)];
+    }
+    return [{
+      childCount: node.items.length,
+      className: ChatOrderedList,
+      type: Ol
+    }, ...node.items.flatMap(item => {
+      return [{
+        childCount: 1,
+        className: ChatOrderedListItem,
+        type: Li
+      }, text(item.text)];
+    })];
+  });
+};
+
 const getChatMessageDom = (message, openRouterApiKeyInput, openApiApiKeyInput = '', openRouterApiKeyState = 'idle') => {
   const roleClassName = message.role === 'user' ? MessageUser : MessageAssistant;
   const isOpenApiApiKeyMissingMessage = message.role === 'assistant' && message.text === openApiApiKeyRequiredMessage;
   const isOpenRouterApiKeyMissingMessage = message.role === 'assistant' && message.text === openRouterApiKeyRequiredMessage;
   const isOpenRouterRequestFailedMessage = message.role === 'assistant' && message.text === openRouterRequestFailedMessage;
   const isOpenRouterTooManyRequestsMessage = message.role === 'assistant' && message.text.startsWith(openRouterTooManyRequestsMessage);
-  const extraChildCount = isOpenApiApiKeyMissingMessage || isOpenRouterApiKeyMissingMessage || isOpenRouterRequestFailedMessage || isOpenRouterTooManyRequestsMessage ? 2 : 1;
+  const messageIntermediate = parseMessageContent(message.text);
+  const messageDom = getMessageContentDom(messageIntermediate);
+  const toolCallsDom = getToolCallsDom(message);
+  const toolCallsChildCount = toolCallsDom.length > 0 ? 1 : 0;
+  const extraChildCount = isOpenApiApiKeyMissingMessage || isOpenRouterApiKeyMissingMessage || isOpenRouterRequestFailedMessage || isOpenRouterTooManyRequestsMessage ? messageIntermediate.length + 1 + toolCallsChildCount : messageIntermediate.length + toolCallsChildCount;
   return [{
     childCount: 1,
     className: mergeClassNames(Message, roleClassName),
@@ -5158,11 +5907,7 @@ const getChatMessageDom = (message, openRouterApiKeyInput, openApiApiKeyInput =
     childCount: extraChildCount,
     className: ChatMessageContent,
     type: Div
-  }, {
-    childCount: 1,
-    className: Markdown,
-    type: P
-  }, text(message.text), ...(isOpenApiApiKeyMissingMessage ? getMissingOpenApiApiKeyDom(openApiApiKeyInput) : []), ...(isOpenRouterApiKeyMissingMessage ? getMissingOpenRouterApiKeyDom(openRouterApiKeyInput, openRouterApiKeyState) : []), ...(isOpenRouterRequestFailedMessage ? getOpenRouterRequestFailedDom() : []), ...(isOpenRouterTooManyRequestsMessage ? getOpenRouterTooManyRequestsDom() : [])];
+  }, ...messageDom, ...toolCallsDom, ...(isOpenApiApiKeyMissingMessage ? getMissingOpenApiApiKeyDom(openApiApiKeyInput) : []), ...(isOpenRouterApiKeyMissingMessage ? getMissingOpenRouterApiKeyDom(openRouterApiKeyInput, openRouterApiKeyState) : []), ...(isOpenRouterRequestFailedMessage ? getOpenRouterRequestFailedDom() : []), ...(isOpenRouterTooManyRequestsMessage ? getOpenRouterTooManyRequestsDom() : [])];
 };
 
 const getEmptyMessagesDom = () => {
@@ -5280,7 +6025,7 @@ const getChatModeUnsupportedVirtualDom = () => {
   }, text(unknownViewMode())];
 };
 
-const getChatVirtualDom = (sessions, selectedSessionId, composerValue, openRouterApiKeyInput, viewMode, models, selectedModelId, usageOverviewEnabled, tokensUsed, tokensMax, openApiApiKeyInput = '', openRouterApiKeyState = 'idle', composerHeight = 28, composerFontSize = 13, composerFontFamily = 'system-ui', composerLineHeight = 20, chatListScrollTop = 0, messagesScrollTop = 0) => {
+const getChatVirtualDom = (sessions, selectedSessionId, composerValue, openRouterApiKeyInput, viewMode, models, selectedModelId, usageOverviewEnabled, tokensUsed, tokensMax, openApiApiKeyInput, openRouterApiKeyState, composerHeight, composerFontSize, composerFontFamily, composerLineHeight, chatListScrollTop, messagesScrollTop) => {
   switch (viewMode) {
     case 'detail':
       return getChatModeDetailVirtualDom(sessions, selectedSessionId, composerValue, openRouterApiKeyInput, openApiApiKeyInput, models, selectedModelId, usageOverviewEnabled, tokensUsed, tokensMax, openRouterApiKeyState, composerHeight, composerFontSize, composerFontFamily, composerLineHeight, messagesScrollTop);
@@ -5406,6 +6151,9 @@ const renderEventListeners = () => {
   }, {
     name: HandleClickNew,
     params: ['handleClickNew']
+  }, {
+    name: HandleClickSessionDebug,
+    params: ['handleClickSessionDebug']
   }, {
     name: HandleClickBack,
     params: ['handleClickBack']
@@ -5446,6 +6194,7 @@ const reset = async state => {
     ...state,
     composerHeight: getMinComposerHeightForState(state),
     composerValue: '',
+    mockAiResponseDelay: 0,
     openRouterApiKey: '',
     selectedModelId: 'test',
     selectedSessionId: '',
@@ -5553,6 +6302,7 @@ const commandMap = {
   'Chat.handleClickDelete': wrapCommand(handleClickDelete),
   'Chat.handleClickList': wrapCommand(handleClickList),
   'Chat.handleClickNew': wrapCommand(handleClickNew),
+  'Chat.handleClickSessionDebug': wrapCommand(handleClickSessionDebug),
   'Chat.handleClickSettings': handleClickSettings,
   'Chat.handleInput': wrapCommand(handleInput),
   'Chat.handleInputFocus': wrapCommand(handleInputFocus),
@@ -5563,6 +6313,7 @@ const commandMap = {
   'Chat.initialize': initialize,
   'Chat.loadContent': wrapCommand(loadContent),
   'Chat.loadContent2': wrapCommand(loadContent),
+  'Chat.mockOpenApiSetHttpErrorResponse': wrapCommand(mockOpenApiSetHttpErrorResponse),
   'Chat.mockOpenApiStreamFinish': wrapCommand(mockOpenApiStreamFinish),
   'Chat.mockOpenApiStreamPushChunk': wrapCommand(mockOpenApiStreamPushChunk),
   'Chat.mockOpenApiStreamReset': wrapCommand(mockOpenApiStreamReset),
@@ -5588,7 +6339,7 @@ const initializeChatNetworkWorker = async () => {
     commandMap: {},
     send
   });
-  return rpc;
+  set$3(rpc);
 };
 
 const listen = async () => {