@hef2024/llmasaservice-ui 0.24.2 → 0.24.4

package/dist/index.mjs

@@ -652,6 +652,302 @@ var ThinkingBlock = ({
   );
 };
 
+// src/mcpAuth.ts
+function normalizeMcpHeaders(value) {
+  const normalized = {};
+  if (!value) return normalized;
+  for (const [key, raw] of Object.entries(value)) {
+    if (typeof raw !== "string") continue;
+    const trimmedValue = raw.trim();
+    if (!trimmedValue) continue;
+    normalized[key] = trimmedValue;
+  }
+  return normalized;
+}
+
+// src/toolArgsParser.ts
+var TOOL_ARGS_CANDIDATE_PARSE_DEPTH = 3;
+var isPlainObject = (value) => {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+var stripMarkdownCodeFence = (input) => {
+  const trimmed = input.trim();
+  if (!trimmed.startsWith("```")) return trimmed;
+  const withoutStart = trimmed.replace(/^```[a-zA-Z0-9_-]*\s*/u, "");
+  return withoutStart.replace(/```$/u, "").trim();
+};
+var stripOuterQuotes = (input) => {
+  const trimmed = input.trim();
+  if (trimmed.length < 2) return trimmed;
+  const first = trimmed[0];
+  const last = trimmed[trimmed.length - 1];
+  if (first === '"' && last === '"' || first === "'" && last === "'") {
+    return trimmed.slice(1, -1).trim();
+  }
+  return trimmed;
+};
+var normalizeSmartQuotes = (input) => {
+  return input.replace(/[“”]/gu, '"').replace(/[‘’]/gu, "'");
+};
+var convertSingleQuotedStrings = (input) => {
+  let output = "";
+  let inSingle = false;
+  let inDouble = false;
+  let escaped = false;
+  for (let index = 0; index < input.length; index += 1) {
+    const char = input[index];
+    if (inSingle) {
+      if (escaped) {
+        output += char === '"' ? '\\"' : char;
+        escaped = false;
+        continue;
+      }
+      if (char === "\\") {
+        output += "\\";
+        escaped = true;
+        continue;
+      }
+      if (char === "'") {
+        output += '"';
+        inSingle = false;
+        continue;
+      }
+      output += char === '"' ? '\\"' : char;
+      continue;
+    }
+    if (inDouble) {
+      output += char;
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (char === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (char === '"') {
+        inDouble = false;
+      }
+      continue;
+    }
+    if (char === "'") {
+      output += '"';
+      inSingle = true;
+      continue;
+    }
+    if (char === '"') {
+      output += '"';
+      inDouble = true;
+      continue;
+    }
+    output += char;
+  }
+  return output;
+};
+var quoteBareObjectKeys = (input) => {
+  return input.replace(
+    /([{,]\s*)([A-Za-z_$][A-Za-z0-9_$-]*)(\s*:)/gu,
+    '$1"$2"$3'
+  );
+};
+var stripTrailingCommas = (input) => {
+  return input.replace(/,\s*([}\]])/gu, "$1");
+};
+var normalizeEscapesOutsideStrings = (input) => {
+  let output = "";
+  let inDouble = false;
+  let inSingle = false;
+  let escaped = false;
+  for (let index = 0; index < input.length; index += 1) {
+    const char = input[index];
+    const next = index + 1 < input.length ? input[index + 1] : "";
+    if (inDouble || inSingle) {
+      output += char;
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (char === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (inDouble && char === '"') {
+        inDouble = false;
+      } else if (inSingle && char === "'") {
+        inSingle = false;
+      }
+      continue;
+    }
+    if (char === '"') {
+      inDouble = true;
+      output += char;
+      continue;
+    }
+    if (char === "'") {
+      inSingle = true;
+      output += char;
+      continue;
+    }
+    if (char === "\\") {
+      if (next === "n") {
+        output += "\n";
+        index += 1;
+        continue;
+      }
+      if (next === "r") {
+        output += "\r";
+        index += 1;
+        continue;
+      }
+      if (next === "t") {
+        output += "	";
+        index += 1;
+        continue;
+      }
+      if (next === '"') {
+        output += '"';
+        index += 1;
+        continue;
+      }
+      if (next === "'") {
+        output += "'";
+        index += 1;
+        continue;
+      }
+      if (next === "\\") {
+        output += "\\";
+        index += 1;
+        continue;
+      }
+    }
+    output += char;
+  }
+  return output;
+};
+var normalizeJsLikeJson = (input) => {
+  const normalizedQuotes = normalizeSmartQuotes(input);
+  const normalizedSingleQuotes = convertSingleQuotedStrings(normalizedQuotes);
+  const withQuotedKeys = quoteBareObjectKeys(normalizedSingleQuotes);
+  return stripTrailingCommas(withQuotedKeys);
+};
+var extractFirstJsonObject = (input) => {
+  const start = input.indexOf("{");
+  if (start === -1) return null;
+  let depth = 0;
+  let inString = false;
+  let quoteChar = "";
+  let escaped = false;
+  for (let index = start; index < input.length; index += 1) {
+    const char = input[index];
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (char === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (char === quoteChar) {
+        inString = false;
+        quoteChar = "";
+      }
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      inString = true;
+      quoteChar = char;
+      continue;
+    }
+    if (char === "{") {
+      depth += 1;
+      continue;
+    }
+    if (char === "}") {
+      depth -= 1;
+      if (depth === 0) {
+        return input.slice(start, index + 1);
+      }
+    }
+  }
+  return null;
+};
+var parseMaybeNestedJson = (input) => {
+  let current = input;
+  for (let depth = 0; depth < TOOL_ARGS_CANDIDATE_PARSE_DEPTH; depth += 1) {
+    if (typeof current !== "string") {
+      return current;
+    }
+    const trimmed = current.trim();
+    if (!trimmed) {
+      return {};
+    }
+    current = JSON.parse(trimmed);
+  }
+  return current;
+};
+var addCandidate = (candidates, value) => {
+  if (typeof value !== "string") return;
+  const trimmed = value.trim();
+  if (!trimmed) return;
+  candidates.add(trimmed);
+};
+var buildProgressiveQuoteUnescapes = (input, rounds = 4) => {
+  const values = [];
+  let current = input;
+  for (let round = 0; round < rounds; round += 1) {
+    const next = current.replace(/\\"/gu, '"');
+    if (next === current) {
+      break;
+    }
+    values.push(next);
+    current = next;
+  }
+  return values;
+};
+var parseToolArguments = (rawArgs) => {
+  if (isPlainObject(rawArgs)) {
+    return rawArgs;
+  }
+  if (typeof rawArgs !== "string") {
+    return {};
+  }
+  const base = rawArgs.trim();
+  if (!base) {
+    return {};
+  }
+  const codeFenceStripped = stripMarkdownCodeFence(base);
+  const extracted = extractFirstJsonObject(codeFenceStripped);
+  const candidates = /* @__PURE__ */ new Set();
+  addCandidate(candidates, base);
+  addCandidate(candidates, codeFenceStripped);
+  addCandidate(candidates, stripOuterQuotes(codeFenceStripped));
+  buildProgressiveQuoteUnescapes(base).forEach((candidate) => addCandidate(candidates, candidate));
+  buildProgressiveQuoteUnescapes(codeFenceStripped).forEach(
+    (candidate) => addCandidate(candidates, candidate)
+  );
+  addCandidate(candidates, extracted);
+  buildProgressiveQuoteUnescapes(extracted || "").forEach(
+    (candidate) => addCandidate(candidates, candidate)
+  );
+  addCandidate(candidates, normalizeJsLikeJson(codeFenceStripped));
+  addCandidate(candidates, extracted ? normalizeJsLikeJson(extracted) : null);
+  Array.from(candidates).forEach((candidate) => {
+    addCandidate(candidates, normalizeEscapesOutsideStrings(candidate));
+  });
+  for (const candidate of candidates) {
+    try {
+      const parsed = parseMaybeNestedJson(candidate);
+      if (isPlainObject(parsed)) {
+        return parsed;
+      }
+    } catch (e) {
+      continue;
+    }
+  }
+  return null;
+};
+
 // src/ChatPanel.tsx
 var ChatPanel = ({
   project_id,
@@ -697,7 +993,8 @@ var ChatPanel = ({
   customerEmailCaptureMode = "HIDE",
   customerEmailCapturePlaceholder = "Please enter your email...",
   mcpServers,
-  progressiveActions = true
+  progressiveActions = true,
+  resolveMcpAuthHeaders
 }) => {
   var _a;
   const isEmailAddress = (email) => {
@@ -1023,6 +1320,44 @@ var ChatPanel = ({
   const [toolList, setToolList] = useState5([]);
   const [toolsLoading, setToolsLoading] = useState5(false);
   const [toolsFetchError, setToolsFetchError] = useState5(false);
+  const buildMcpRequestHeaders = useCallback(
+    (_0) => __async(void 0, [_0], function* ({
+      phase,
+      mcpServer,
+      toolName,
+      toolArgs
+    }) {
+      const merged = {};
+      const baseAccessToken = typeof mcpServer.accessToken === "string" ? mcpServer.accessToken.trim() : "";
+      if (baseAccessToken) {
+        merged["x-mcp-access-token"] = baseAccessToken;
+      }
+      if (project_id) {
+        merged["x-project-id"] = project_id;
+      }
+      if (!resolveMcpAuthHeaders) return merged;
+      try {
+        const resolved = yield resolveMcpAuthHeaders({
+          phase,
+          mcpServer,
+          projectId: project_id,
+          customer: currentCustomer,
+          toolName,
+          toolArgs
+        });
+        return __spreadValues(__spreadValues({}, merged), normalizeMcpHeaders(
+          resolved
+        ));
+      } catch (error2) {
+        console.error(
+          `Failed to resolve MCP auth headers for ${phase} request:`,
+          error2
+        );
+        return merged;
+      }
+    }),
+    [project_id, currentCustomer, resolveMcpAuthHeaders]
+  );
   useEffect6(() => {
     const fetchAndSetTools = () => __async(void 0, null, function* () {
       if (!mcpServers || mcpServers.length === 0) {
@@ -1039,7 +1374,13 @@ var ChatPanel = ({
             m.url
           )}`;
           try {
-            const response2 = yield fetch(urlToFetch);
+            const requestHeaders = yield buildMcpRequestHeaders({
+              phase: "list",
+              mcpServer: m
+            });
+            const response2 = yield fetch(urlToFetch, {
+              headers: requestHeaders
+            });
             if (!response2.ok) {
               console.error(
                 `Error fetching tools from ${m.url}: ${response2.status} ${response2.statusText}`
@@ -1055,7 +1396,7 @@ var ChatPanel = ({
               return toolsFromServer.map((tool) => __spreadProps(__spreadValues({}, tool), {
                 url: m.url,
                 accessToken: m.accessToken || "",
-                headers: {}
+                headers: requestHeaders
               }));
             } else {
               return [];
@@ -1084,7 +1425,7 @@ var ChatPanel = ({
       }
     });
     fetchAndSetTools();
-  }, [mcpServers, publicAPIUrl]);
+  }, [mcpServers, publicAPIUrl, buildMcpRequestHeaders]);
   const llmResult = useLLM({
     project_id,
     customer: currentCustomer,
@@ -1449,19 +1790,19 @@ var ChatPanel = ({
     []
   );
   const anthropic_toolAction = {
-    pattern: '\\{"type":"tool_use","id":"([^"]+)","name":"([^"]+)","input":(\\{[\\s\\S]+?\\}),"service":"([^"]+)"\\}',
+    pattern: '\\{"type":"tool_use","id":"([^"]+)","name":"([^"]+)","input":(\\{[\\s\\S]*?\\}),"service":"([^"]+)"\\}',
     type: "markdown",
     markdown: "<br />*Tool use requested: $2*",
     actionType: "tool"
   };
   const openAI_toolAction = {
-    pattern: '\\{"id":"([^"]+)","type":"function","function":\\{"name":"([^"]+)","arguments":"((?:\\\\.|[^"\\\\])*)"\\},"service":"([^"]+)"\\}',
+    pattern: '\\{"id":"([^"]+)","type":"function","function":\\{"name":"([^"]+)","arguments":"([\\s\\S]*?)"\\},"service":"([^"]+)"\\}',
     type: "markdown",
     markdown: "<br />*Tool use requested: $2*",
     actionType: "tool"
   };
   const google_toolAction = {
-    pattern: '^\\{\\s*"(functionCall)"\\s*:\\s*\\{\\s*"name"\\s*:\\s*"([^"]+)"\\s*,\\s*"args"\\s*:\\s*(\\{[\\s\\S]+?\\})\\s*\\}(?:\\s*,\\s*"thoughtSignature"\\s*:\\s*"[^"]*")?\\s*,\\s*"service"\\s*:\\s*"([^"]+)"\\s*\\}$',
+    pattern: '^\\{\\s*"(functionCall)"\\s*:\\s*\\{\\s*"name"\\s*:\\s*"([^"]+)"\\s*,\\s*"args"\\s*:\\s*(\\{[\\s\\S]*?\\})\\s*\\}(?:\\s*,\\s*"thoughtSignature"\\s*:\\s*"[^"]*")?\\s*,\\s*"service"\\s*:\\s*"([^"]+)"\\s*\\}$',
     type: "markdown",
     markdown: "<br />*Tool use requested: $2*",
     actionType: "tool"
@@ -1603,114 +1944,125 @@ var ChatPanel = ({
           ]
         }
       ];
-      const toolCallsMessage = {
-        role: "assistant",
-        content: [],
-        tool_calls: []
-      };
-      const toolCallsPromises = toolsToProcess.map((req) => __async(void 0, null, function* () {
-        if (!req) return null;
-        try {
+      const parsedToolCalls = yield Promise.all(
+        toolsToProcess.map((req, index) => __async(void 0, null, function* () {
+          var _a2, _b, _c, _d, _e, _f;
+          if (!req) return null;
+          let parsedToolCall = null;
+          try {
+            parsedToolCall = JSON.parse(req.match);
+          } catch (error2) {
+            console.error("Failed to parse tool call:", error2);
+          }
+          const toolName = req.groups[1] || req.toolName || (typeof (parsedToolCall == null ? void 0 : parsedToolCall.name) === "string" ? parsedToolCall.name : "") || (typeof ((_a2 = parsedToolCall == null ? void 0 : parsedToolCall.function) == null ? void 0 : _a2.name) === "string" ? parsedToolCall.function.name : "");
+          if (!toolName) return null;
+          const rawCallId = req.groups[0] || (parsedToolCall == null ? void 0 : parsedToolCall.id) || (parsedToolCall == null ? void 0 : parsedToolCall.tool_call_id) || `${toolName}-${index + 1}`;
+          const callId = typeof rawCallId === "string" && rawCallId.trim().length > 0 && rawCallId !== "functionCall" ? rawCallId : `${toolName}-${index + 1}`;
+          let args = {};
+          const rawArgs = (_f = (_e = (_c = (_b = req.groups[2]) != null ? _b : parsedToolCall == null ? void 0 : parsedToolCall.input) != null ? _c : parsedToolCall == null ? void 0 : parsedToolCall.args) != null ? _e : (_d = parsedToolCall == null ? void 0 : parsedToolCall.function) == null ? void 0 : _d.arguments) != null ? _f : "{}";
+          const parsedArgs = parseToolArguments(rawArgs);
+          if (!parsedArgs) {
+            console.error("Failed to parse tool arguments", {
+              toolName,
+              callId,
+              rawArgsPreview: typeof rawArgs === "string" ? rawArgs.slice(0, 500) : JSON.stringify(rawArgs).slice(0, 500)
+            });
+            return null;
+          }
+          args = parsedArgs;
+          const serviceTag = typeof req.groups[3] === "string" && req.groups[3] || typeof (parsedToolCall == null ? void 0 : parsedToolCall.service) === "string" && parsedToolCall.service || "";
           return {
             req,
-            parsedToolCall: JSON.parse(req.match)
+            toolName,
+            callId,
+            args,
+            serviceTag
           };
-        } catch (e) {
-          console.error("Failed to parse tool call:", e);
-          return null;
-        }
+        }))
+      );
+      const toolCallBatch = parsedToolCalls.filter(Boolean);
+      const finalToolCalls = toolCallBatch.map((toolCall) => ({
+        id: toolCall.callId,
+        type: "tool_use",
+        name: toolCall.toolName,
+        input: toolCall.args,
+        service: toolCall.serviceTag
       }));
-      const parsedToolCalls = yield Promise.all(toolCallsPromises);
-      parsedToolCalls.forEach((item) => {
-        if (item && item.parsedToolCall) {
-          toolCallsMessage.tool_calls.push(item.parsedToolCall);
-        }
-      });
-      newMessages.push(toolCallsMessage);
-      const finalToolCalls = toolCallsMessage.tool_calls;
-      const toolResponsePromises = parsedToolCalls.map((item) => __async(void 0, null, function* () {
-        var _a2;
-        if (!item || !item.req) return null;
-        const req = item.req;
-        const mcpTool = toolList.find((tool) => tool.name === req.toolName);
+      const toolResponsePromises = toolCallBatch.map((toolCall) => __async(void 0, null, function* () {
+        var _a2, _b, _c;
+        const mcpTool = toolList.find((tool) => tool.name === toolCall.toolName);
         if (!mcpTool) {
-          console.error(`Tool ${req.toolName} not found in tool list`);
-          return null;
+          console.error(`Tool ${toolCall.toolName} not found in tool list`);
+          return {
+            tool_call_id: toolCall.callId,
+            tool_name: toolCall.toolName,
+            result: `Tool ${toolCall.toolName} not found in current tool list.`,
+            isError: true
+          };
         }
         try {
-          let args;
-          try {
-            args = JSON.parse(req.groups[2]);
-          } catch (e) {
-            try {
-              args = JSON.parse(req.groups[2].replace(/\\"/g, '"'));
-            } catch (err) {
-              console.error("Failed to parse tool arguments:", err);
-              return null;
-            }
-          }
           const body = {
-            tool: req.groups[1],
-            args
+            tool: toolCall.toolName,
+            args: toolCall.args
           };
           const result = yield fetch(
             `${publicAPIUrl}/tools/${encodeURIComponent(mcpTool.url)}`,
             {
               method: "POST",
-              headers: {
-                "Content-Type": "application/json",
-                "x-mcp-access-token": mcpTool.accessToken && mcpTool.accessToken !== "" ? mcpTool.accessToken : "",
-                "x-project-id": project_id
-              },
+              headers: __spreadValues({
+                "Content-Type": "application/json"
+              }, yield buildMcpRequestHeaders({
+                phase: "call",
+                mcpServer: mcpTool,
+                toolName: toolCall.toolName,
+                toolArgs: toolCall.args
+              })),
               body: JSON.stringify(body)
             }
           );
           if (!result.ok) {
             console.error(
-              `Error calling tool ${req.toolName}: ${result.status} ${result.statusText}`
+              `Error calling tool ${toolCall.toolName}: ${result.status} ${result.statusText}`
             );
             const errorBody = yield result.text();
             console.error(`Error body: ${errorBody}`);
-            return null;
+            return {
+              tool_call_id: toolCall.callId,
+              tool_name: toolCall.toolName,
+              result: `HTTP ${result.status} ${result.statusText}: ${errorBody || "Tool call failed"}`,
+              isError: true
+            };
           }
           let resultData;
           try {
             resultData = yield result.json();
           } catch (jsonError) {
             console.error(
-              `Error parsing JSON response for tool ${req.toolName}:`,
+              `Error parsing JSON response for tool ${toolCall.toolName}:`,
               jsonError
             );
-            try {
-              const textBody = yield result.text();
-              console.error("Response body (text):", textBody);
-            } catch (textError) {
-              console.error(
-                "Failed to read response body as text either:",
-                textError
-              );
-            }
-            return null;
-          }
-          if (resultData && resultData.content && resultData.content.length > 0) {
-            const textResult = (_a2 = resultData.content[0]) == null ? void 0 : _a2.text;
             return {
-              role: "tool",
-              content: [
-                {
-                  type: "text",
-                  text: textResult
-                }
-              ],
-              tool_call_id: req.groups[0]
+              tool_call_id: toolCall.callId,
+              tool_name: toolCall.toolName,
+              result: "Tool returned a non-JSON response.",
+              isError: true
             };
-          } else {
-            console.error(`No content returned from tool ${req.toolName}`);
-            return null;
           }
+          const textResult = (_c = (_b = (_a2 = resultData == null ? void 0 : resultData.content) == null ? void 0 : _a2[0]) == null ? void 0 : _b.text) != null ? _c : (resultData == null ? void 0 : resultData.result) ? JSON.stringify(resultData.result) : JSON.stringify(resultData);
+          return {
+            tool_call_id: toolCall.callId,
+            tool_name: toolCall.toolName,
+            result: textResult || "",
+            isError: (resultData == null ? void 0 : resultData.isError) === true
+          };
         } catch (error2) {
-          console.error(`Error processing tool ${req.toolName}:`, error2);
-          return null;
+          console.error(`Error processing tool ${toolCall.toolName}:`, error2);
+          return {
+            tool_call_id: toolCall.callId,
+            tool_name: toolCall.toolName,
+            result: error2 instanceof Error ? error2.message : `Unhandled error calling ${toolCall.toolName}`,
+            isError: true
+          };
         }
       }));
       const toolResponses = yield Promise.all(toolResponsePromises);
@@ -1732,11 +2084,49 @@ var ChatPanel = ({
           });
         });
       }
-      finalToolResponses.forEach((response2) => {
-        if (response2) {
-          newMessages.push(response2);
-        }
-      });
+      const toReplayText = (value, maxLength = 2e3) => {
+        const raw = typeof value === "string" ? value : (() => {
+          try {
+            return JSON.stringify(value);
+          } catch (_error) {
+            return String(value != null ? value : "");
+          }
+        })();
+        const normalized = String(raw != null ? raw : "").replace(/\s+/g, " ").trim();
+        if (normalized.length <= maxLength) return normalized;
+        return `${normalized.slice(0, maxLength - 3)}...`;
+      };
+      if (toolCallBatch.length > 0) {
+        const replayLines = toolCallBatch.map((toolCall, index) => {
+          var _a2;
+          const matchedResponse = finalToolResponses.find(
+            (response2) => (response2 == null ? void 0 : response2.tool_call_id) === toolCall.callId
+          ) || finalToolResponses[index];
+          const status = (matchedResponse == null ? void 0 : matchedResponse.isError) ? "error" : "ok";
+          const resultText = toReplayText((_a2 = matchedResponse == null ? void 0 : matchedResponse.result) != null ? _a2 : "No result returned");
+          return [
+            `Tool: ${toolCall.toolName}`,
+            `Call ID: ${toolCall.callId}`,
+            `Status: ${status}`,
+            `Args: ${toReplayText(toolCall.args, 600)}`,
+            `Result: ${resultText}`
+          ].join("\n");
+        });
+        newMessages.push({
+          role: "user",
+          content: [
+            {
+              type: "text",
+              text: [
+                "Tool execution summary for the previous request:",
+                ...replayLines,
+                "Continue the same assistant response from exactly where you paused using these tool results.",
+                "If this response is using meta tags, keep the same format (<thinking>, <reasoning>, <searching>) in the continuation."
+              ].join("\n\n")
+            }
+          ]
+        });
+      }
       send(
         "",
         newMessages,
@@ -3518,7 +3908,8 @@ var AgentPanel = ({
   //ragQueryLimit = 10,
   //ragRankLimit = 5,
   initialHistory = {},
-  hideRagContextInPrompt = true
+  hideRagContextInPrompt = true,
+  resolveMcpAuthHeaders
 }) => {
   var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u;
   const searchParams = new URLSearchParams(location.search);
@@ -3656,7 +4047,8 @@ var AgentPanel = ({
       createConversationOnFirstChat: (_s = agentData == null ? void 0 : agentData.createConversationOnFirstChat) != null ? _s : true,
       customerEmailCaptureMode: (_t = agentData == null ? void 0 : agentData.customerEmailCaptureMode) != null ? _t : "HIDE",
       customerEmailCapturePlaceholder: (_u = agentData == null ? void 0 : agentData.customerEmailCapturePlaceholder) != null ? _u : "Please enter your email...",
-      mcpServers: mcpData
+      mcpServers: mcpData,
+      resolveMcpAuthHeaders
     })
   ));
 };
@@ -3733,18 +4125,731 @@ var ToolInfoModal2 = ({
 var ToolInfoModal_default2 = ToolInfoModal2;
 
 // src/AIChatPanel.tsx
+var areToolRequestListsEqual = (a, b) => {
+  if (a.length !== b.length) return false;
+  for (let index = 0; index < a.length; index += 1) {
+    const left = a[index];
+    const right = b[index];
+    if (!left || !right) return false;
+    if (left.callId !== right.callId) return false;
+    if (left.toolName !== right.toolName) return false;
+    if (left.serviceTag !== right.serviceTag) return false;
+    if (left.match !== right.match) return false;
+    if (left.start !== right.start || left.end !== right.end) return false;
+  }
+  return true;
+};
+var mergeContinuationResponseText = (baseText, continuationText) => {
+  const base = typeof baseText === "string" ? baseText : "";
+  const continuation = typeof continuationText === "string" ? continuationText : "";
+  if (!base) return continuation;
+  if (!continuation) return base;
+  if (base.includes(continuation)) {
+    return base;
+  }
+  const maxOverlap = Math.min(base.length, continuation.length);
+  for (let overlap = maxOverlap; overlap > 0; overlap -= 1) {
+    if (base.slice(-overlap) === continuation.slice(0, overlap)) {
+      return `${base}${continuation.slice(overlap)}`;
+    }
+  }
+  return `${base}
+
+${continuation}`;
+};
+var INLINE_TOOL_MARKER_PREFIX = "[[AI_TOOL_CALL:";
+var INLINE_TOOL_MARKER_SUFFIX = "]]";
+var INLINE_TOOL_MARKER_REGEX = /\[\[AI_TOOL_CALL:([^|\]]+)\|([^\]]+)\]\]/g;
+var INLINE_THINKING_MARKER_PREFIX = "[[AI_THINK_BLOCK:";
+var INLINE_THINKING_MARKER_SUFFIX = "]]";
+var INLINE_THINKING_MARKER_REGEX = /\[\[AI_THINK_BLOCK:([^|\]]+)\|([^\]]+)\]\]/g;
+var MAX_TOOL_CONTINUATIONS_PER_TURN = 20;
+var MAX_TOOL_REPLAY_PAYLOAD_CHARS = 75e4;
+var MAX_TRACE_SUMMARY_CHARS = 1800;
+var MAX_TRACE_REASONING_BLOCKS = 4;
+var MAX_TRACE_TOOL_LINES = 6;
+var MAX_TRACE_ITEM_CHARS = 220;
+var MAX_TRACE_LINE_CHARS = 420;
+var hasInlineRuntimeMarkers = (value) => {
+  const source = typeof value === "string" ? value : "";
+  return source.includes(INLINE_TOOL_MARKER_PREFIX) || source.includes(INLINE_THINKING_MARKER_PREFIX);
+};
+var toNonEmptyLines = (value) => String(value || "").split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+var isBoundarySubsetByLines = (existingLines, incomingLines) => {
+  if (incomingLines.length === 0 || existingLines.length === 0) return false;
+  if (incomingLines.length >= existingLines.length) return false;
+  const prefixMatch = incomingLines.every((line, index) => existingLines[index] === line);
+  if (prefixMatch) return true;
+  const suffixStart = existingLines.length - incomingLines.length;
+  return incomingLines.every((line, index) => existingLines[suffixStart + index] === line);
+};
+var shouldPreserveBoundaryDroppedStreamText = (existingContent, incomingContent) => {
+  const existing = String(existingContent || "").trim();
+  const incoming = String(incomingContent || "").trim();
+  if (!existing) return false;
+  if (!incoming) return true;
+  if (incoming === existing) return false;
+  if (!hasInlineRuntimeMarkers(existing)) return false;
+  if (existing.includes(incoming)) {
+    return true;
+  }
+  const existingLines = toNonEmptyLines(existing);
+  const incomingLines = toNonEmptyLines(incoming);
+  return isBoundarySubsetByLines(existingLines, incomingLines);
+};
+var isObjectRecord = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+var stringifyToolArgs = (value) => {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value != null ? value : {});
+  } catch (_error) {
+    return "{}";
+  }
+};
+var truncateTraceText = (value, maxChars) => {
+  const text = String(value || "").trim();
+  if (!text) return "";
+  if (text.length <= maxChars) return text;
+  return `${text.slice(0, Math.max(0, maxChars - 1)).trimEnd()}\u2026`;
+};
+var normalizeTraceText = (value) => {
+  if (value === null || value === void 0) return "";
+  const raw = typeof value === "string" ? value : (() => {
+    try {
+      return JSON.stringify(value);
+    } catch (_error) {
+      return String(value);
+    }
+  })();
+  return String(raw || "").replace(/\s+/g, " ").trim();
+};
+var toTraceObjectArray = (value) => {
+  if (!Array.isArray(value)) return [];
+  return value.filter((item) => isObjectRecord(item));
+};
+var getTraceStatusLabel = (response) => {
+  if (!response) return "pending";
+  if (response.isError === true || response.error === true) return "error";
+  return "ok";
+};
+var buildCompactTraceSummary = ({
+  reasoningBlocks,
+  toolCalls,
+  toolResponses
+}) => {
+  const sections = [];
+  const normalizedReasoning = (Array.isArray(reasoningBlocks) ? reasoningBlocks : []).filter((block) => !!block && typeof block.content === "string" && block.content.trim().length > 0).slice(-MAX_TRACE_REASONING_BLOCKS).map((block) => {
+    const content = truncateTraceText(normalizeTraceText(block.content), MAX_TRACE_ITEM_CHARS);
+    if (!content) return "";
+    const type = typeof block.type === "string" ? block.type : "thinking";
+    return `- ${type}: ${content}`;
+  }).filter(Boolean);
+  if (normalizedReasoning.length > 0) {
+    sections.push(["reasoning:", ...normalizedReasoning].join("\n"));
+  }
+  const calls = toTraceObjectArray(toolCalls).slice(-MAX_TRACE_TOOL_LINES);
+  const responses = toTraceObjectArray(toolResponses);
+  if (calls.length > 0) {
+    const responsesByCallId = /* @__PURE__ */ new Map();
+    responses.forEach((response) => {
+      const key = typeof response.tool_call_id === "string" ? response.tool_call_id.trim() : "";
+      if (!key || responsesByCallId.has(key)) return;
+      responsesByCallId.set(key, response);
+    });
+    const responseOffset = Math.max(0, responses.length - calls.length);
+    const toolLines = calls.map((call, index) => {
+      var _a, _b, _c, _d, _e, _f;
+      const toolName = typeof call.name === "string" ? call.name.trim() : typeof call.tool_name === "string" ? call.tool_name.trim() : "tool";
+      const callId = typeof call.id === "string" ? call.id.trim() : typeof call.tool_call_id === "string" ? call.tool_call_id.trim() : "";
+      const response = (callId ? responsesByCallId.get(callId) : void 0) || responses[responseOffset + index] || responses[index];
+      const status = getTraceStatusLabel(response);
+      const rawArgs = (_c = (_b = (_a = call.input) != null ? _a : call.args) != null ? _b : call.arguments) != null ? _c : {};
+      const parsedArgs = parseToolArguments(rawArgs);
+      const normalizedArgs = truncateTraceText(
+        normalizeTraceText(parsedArgs != null ? parsedArgs : isObjectRecord(rawArgs) ? rawArgs : rawArgs || {}),
+        MAX_TRACE_ITEM_CHARS
+      );
+      const normalizedResult = truncateTraceText(
+        normalizeTraceText((_f = (_e = (_d = response == null ? void 0 : response.result) != null ? _d : response == null ? void 0 : response.content) != null ? _e : response == null ? void 0 : response.error) != null ? _f : ""),
+        MAX_TRACE_ITEM_CHARS
+      );
+      const base = callId ? `- ${toolName} (${callId}) ${status}` : `- ${toolName} ${status}`;
+      const withArgs = normalizedArgs ? `${base} args=${normalizedArgs}` : base;
+      const withResult = normalizedResult ? `${withArgs} result=${normalizedResult}` : withArgs;
+      return truncateTraceText(withResult, MAX_TRACE_LINE_CHARS);
+    }).filter(Boolean);
+    if (toolLines.length > 0) {
+      sections.push(["tools:", ...toolLines].join("\n"));
+    }
+  }
+  if (sections.length === 0) return "";
+  return truncateTraceText(["TRACE SUMMARY (compact)", ...sections].join("\n"), MAX_TRACE_SUMMARY_CHARS);
+};
+var findPreviousNonWhitespaceChar = (text, startIndex) => {
+  for (let index = startIndex; index >= 0; index -= 1) {
+    const char = text[index];
+    if (typeof char !== "string") continue;
+    if (!/\s/.test(char)) {
+      return char;
+    }
+  }
+  return null;
+};
+var findNextNonWhitespaceChar = (text, startIndex) => {
+  for (let index = startIndex; index < text.length; index += 1) {
+    const char = text[index];
+    if (typeof char !== "string") continue;
+    if (!/\s/.test(char)) {
+      return char;
+    }
+  }
+  return null;
+};
+var isStandaloneToolObjectSegment = (text, openIndex, closeIndex) => {
+  const lineStart = text.lastIndexOf("\n", openIndex - 1) + 1;
+  const lineEndRaw = text.indexOf("\n", closeIndex + 1);
+  const lineEnd = lineEndRaw === -1 ? text.length : lineEndRaw;
+  const linePrefix = text.slice(lineStart, openIndex);
+  const lineSuffix = text.slice(closeIndex + 1, lineEnd);
+  const startsLine = linePrefix.trim().length === 0;
+  const endsLine = lineSuffix.trim().length === 0;
+  const prevChar = findPreviousNonWhitespaceChar(text, openIndex - 1);
+  const nextChar = findNextNonWhitespaceChar(text, closeIndex + 1);
+  const prevDelimited = prevChar !== null && ["{", "}", "[", "]", ","].includes(prevChar);
+  const nextDelimited = nextChar !== null && ["{", "}", "[", "]", ","].includes(nextChar);
+  const prefixWindow = text.slice(Math.max(0, openIndex - 64), openIndex);
+  const hasLabelPrefix = /(?:^|[\r\n])\s*[A-Za-z][A-Za-z0-9 _-]{0,30}:\s*$/.test(prefixWindow);
+  if (hasLabelPrefix) return false;
+  return (startsLine || prevDelimited) && (endsLine || nextDelimited);
+};
+var extractTopLevelJsonObjectSegments = (source) => {
+  const text = typeof source === "string" ? source : "";
+  if (!text) return [];
+  const segments = [];
+  let cursor = 0;
+  while (cursor < text.length) {
+    const openIndex = text.indexOf("{", cursor);
+    if (openIndex === -1) break;
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    let closeIndex = -1;
+    for (let index = openIndex; index < text.length; index += 1) {
+      const char = text[index];
+      if (inString) {
+        if (escaped) {
+          escaped = false;
+          continue;
+        }
+        if (char === "\\") {
+          escaped = true;
+          continue;
+        }
+        if (char === '"') {
+          inString = false;
+        }
+        continue;
+      }
+      if (char === '"') {
+        inString = true;
+        continue;
+      }
+      if (char === "{") {
+        depth += 1;
+        continue;
+      }
+      if (char === "}") {
+        depth -= 1;
+        if (depth === 0) {
+          closeIndex = index;
+          break;
+        }
+        if (depth < 0) {
+          break;
+        }
+      }
+    }
+    if (closeIndex === -1) {
+      cursor = openIndex + 1;
+      continue;
+    }
+    const raw = text.slice(openIndex, closeIndex + 1);
+    try {
+      const value = JSON.parse(raw);
+      if (isObjectRecord(value) && isStandaloneToolObjectSegment(text, openIndex, closeIndex)) {
+        segments.push({
+          start: openIndex,
+          end: closeIndex + 1,
+          raw,
+          value
+        });
+      }
+    } catch (_error) {
+    }
+    cursor = closeIndex + 1;
+  }
+  return segments;
+};
+var resolveToolRequestFromSegment = (segment, fallbackIndex) => {
+  var _a, _b, _c;
+  const record = segment.value;
+  const serviceTag = typeof record.service === "string" ? record.service : "";
+  const rawId = typeof record.id === "string" ? record.id.trim() : "";
+  if (record.type === "tool_use" && typeof record.name === "string") {
+    const toolName = String(record.name).trim();
+    if (!toolName) return null;
+    const callId = rawId || `${toolName}-${fallbackIndex + 1}`;
+    return {
+      match: segment.raw,
+      groups: [callId, toolName, stringifyToolArgs((_a = record.input) != null ? _a : {}), serviceTag],
+      toolName,
+      callId,
+      serviceTag,
+      start: segment.start,
+      end: segment.end
+    };
+  }
+  if (record.type === "function" && isObjectRecord(record.function)) {
+    const functionRecord = record.function;
+    const toolName = typeof functionRecord.name === "string" ? functionRecord.name.trim() : "";
+    if (!toolName) return null;
+    const callId = rawId || `${toolName}-${fallbackIndex + 1}`;
+    return {
+      match: segment.raw,
+      groups: [callId, toolName, stringifyToolArgs((_b = functionRecord.arguments) != null ? _b : {}), serviceTag],
+      toolName,
+      callId,
+      serviceTag,
+      start: segment.start,
+      end: segment.end
+    };
+  }
+  if (isObjectRecord(record.functionCall) && typeof record.functionCall.name === "string") {
+    const functionCall = record.functionCall;
+    const toolName = String(functionCall.name).trim();
+    if (!toolName) return null;
+    const callId = rawId || `${toolName}-${fallbackIndex + 1}`;
+    return {
+      match: segment.raw,
+      groups: [callId, toolName, stringifyToolArgs((_c = functionCall.args) != null ? _c : {}), serviceTag],
+      toolName,
+      callId,
+      serviceTag,
+      start: segment.start,
+      end: segment.end
+    };
+  }
+  return null;
+};
+var extractBalancedObjectCandidate = (input) => {
+  const text = typeof input === "string" ? input : "";
+  const start = text.indexOf("{");
+  if (start === -1) return null;
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let index = start; index < text.length; index += 1) {
+    const char = text[index];
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (char === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (char === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+      continue;
+    }
+    if (char === "{") {
+      depth += 1;
+      continue;
+    }
+    if (char === "}") {
+      depth -= 1;
+      if (depth === 0) {
+        return text.slice(start, index + 1);
+      }
+    }
+  }
+  return null;
+};
+var extractLineLevelFallbackToolRequests = (source, existing) => {
+  const text = typeof source === "string" ? source : "";
+  if (!text) return [];
+  const takenRanges = existing.map((request) => ({
+    start: request.start,
+    end: request.end
+  }));
+  const overlapsExisting = (start, end) => takenRanges.some((range) => start < range.end && end > range.start);
+  const requests = [];
+  let offset = 0;
+  const lines = text.split("\n");
+  const normalizeStandaloneToolJsonLine = (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) return null;
+    let normalized = trimmed;
+    const first = normalized[0];
+    const last = normalized[normalized.length - 1];
+    const hasSymmetricQuote = normalized.length >= 2 && (first === "'" && last === "'" || first === '"' && last === '"' || first === "`" && last === "`");
+    if (hasSymmetricQuote) {
+      const inner = normalized.slice(1, -1).trim();
+      if (first === '"') {
+        try {
+          const decoded = JSON.parse(normalized);
+          if (typeof decoded === "string") {
+            normalized = decoded.trim();
+          } else {
+            normalized = inner;
+          }
+        } catch (_error) {
+          normalized = inner;
+        }
+      } else {
+        normalized = inner;
+      }
+    }
+    const extractedCandidate = extractBalancedObjectCandidate(normalized);
+    if (extractedCandidate) {
+      normalized = extractedCandidate.trim();
+    }
+    if (!normalized.startsWith("{")) return null;
+    if (!normalized.includes('"type"')) return null;
+    return normalized;
+  };
+  const extractBalancedObjectAfterField = (input, fieldName) => {
+    const fieldRegex = new RegExp(`"${fieldName}"\\s*:\\s*`, "i");
+    const fieldMatch = fieldRegex.exec(input);
+    if (!fieldMatch) return null;
+    const startIndex = input.indexOf("{", fieldMatch.index + fieldMatch[0].length);
+    if (startIndex === -1) return null;
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let index = startIndex; index < input.length; index += 1) {
+      const char = input[index];
+      if (inString) {
+        if (escaped) {
+          escaped = false;
+          continue;
+        }
+        if (char === "\\") {
+          escaped = true;
+          continue;
+        }
+        if (char === '"') {
+          inString = false;
+        }
+        continue;
+      }
+      if (char === '"') {
+        inString = true;
+        continue;
+      }
+      if (char === "{") {
+        depth += 1;
+        continue;
+      }
+      if (char === "}") {
+        depth -= 1;
+        if (depth === 0) {
+          return input.slice(startIndex, index + 1);
+        }
+      }
+    }
+    return null;
+  };
+  lines.forEach((line, index) => {
+    var _a, _b, _c, _d, _e, _f;
+    const lineStart = offset;
+    const lineEnd = lineStart + line.length;
+    offset = lineEnd + (index < lines.length - 1 ? 1 : 0);
+    const normalized = normalizeStandaloneToolJsonLine(line);
+    if (!normalized) return;
+    if (!(normalized.includes('"tool_use"') || normalized.includes('"function"'))) return;
+    if (/(^|[\r\n])\s*[A-Za-z][A-Za-z0-9 _-]{0,30}:\s*\{/.test(line)) return;
+    if (overlapsExisting(lineStart, lineEnd)) return;
+    try {
+      const parsedLine = JSON.parse(normalized);
+      if (isObjectRecord(parsedLine)) {
+        const type2 = typeof parsedLine.type === "string" ? parsedLine.type.trim().toLowerCase() : "";
+        if (type2 === "tool_use") {
+          const toolName2 = typeof parsedLine.name === "string" ? parsedLine.name.trim() : "";
+          if (!toolName2) return;
+          const callId2 = typeof parsedLine.id === "string" && parsedLine.id.trim().length > 0 ? parsedLine.id.trim() : `tool-call-${index + 1}`;
+          const serviceTag = typeof parsedLine.service === "string" ? parsedLine.service : "";
+          const parsedArgs2 = parseToolArguments((_a = parsedLine.input) != null ? _a : {});
+          if (!parsedArgs2) return;
+          requests.push({
+            match: line,
+            groups: [callId2, toolName2, stringifyToolArgs(parsedArgs2), serviceTag],
+            toolName: toolName2,
+            callId: callId2,
+            serviceTag,
+            start: lineStart,
+            end: lineEnd
+          });
+          return;
+        }
+        if (type2 === "function" && isObjectRecord(parsedLine.function)) {
+          const functionRecord = parsedLine.function;
+          const toolName2 = typeof functionRecord.name === "string" ? functionRecord.name.trim() : "";
+          if (!toolName2) return;
+          const callId2 = typeof parsedLine.id === "string" && parsedLine.id.trim().length > 0 ? parsedLine.id.trim() : `tool-call-${index + 1}`;
+          const serviceTag = typeof parsedLine.service === "string" ? parsedLine.service : "";
+          const parsedArgs2 = parseToolArguments((_b = functionRecord.arguments) != null ? _b : {});
+          if (!parsedArgs2) return;
+          requests.push({
+            match: line,
+            groups: [callId2, toolName2, stringifyToolArgs(parsedArgs2), serviceTag],
+            toolName: toolName2,
+            callId: callId2,
+            serviceTag,
+            start: lineStart,
+            end: lineEnd
+          });
+          return;
+        }
+      }
+    } catch (_error) {
+    }
+    const typeMatch = normalized.match(/"type"\s*:\s*"([^"]+)"/i);
+    const type = (_c = typeMatch == null ? void 0 : typeMatch[1]) == null ? void 0 : _c.trim().toLowerCase();
+    if (type !== "tool_use" && type !== "function") return;
+    const idMatch = normalized.match(/"id"\s*:\s*"([^"]+)"/i);
+    const callId = ((_d = idMatch == null ? void 0 : idMatch[1]) == null ? void 0 : _d.trim()) || `tool-call-${index + 1}`;
+    let toolName = "";
+    let argsRaw = "{}";
+    if (type === "tool_use") {
+      const nameMatch = normalized.match(/"name"\s*:\s*"([^"]+)"/i);
+      toolName = ((_e = nameMatch == null ? void 0 : nameMatch[1]) == null ? void 0 : _e.trim()) || "";
+      const inputObject = extractBalancedObjectAfterField(normalized, "input");
+      if (inputObject) {
+        argsRaw = inputObject;
+      }
+    } else {
+      const fnNameMatch = normalized.match(/"function"\s*:\s*\{[\s\S]*?"name"\s*:\s*"([^"]+)"/i);
+      toolName = ((_f = fnNameMatch == null ? void 0 : fnNameMatch[1]) == null ? void 0 : _f.trim()) || "";
+      const argumentsObject = extractBalancedObjectAfterField(normalized, "arguments");
+      if (argumentsObject) {
+        argsRaw = argumentsObject;
+      } else {
+        const argsStringMatch = normalized.match(/"arguments"\s*:\s*"([\s\S]*?)"(?:\s*,|\s*})/i);
+        if (argsStringMatch == null ? void 0 : argsStringMatch[1]) {
+          const rawArgs = argsStringMatch[1];
+          try {
+            argsRaw = JSON.parse(`"${rawArgs}"`);
+          } catch (_error) {
+            argsRaw = rawArgs;
+          }
+        }
+      }
+    }
+    if (!toolName) return;
+    const parsedArgs = parseToolArguments(argsRaw);
+    if (!parsedArgs) return;
+    requests.push({
+      match: line,
+      groups: [callId, toolName, stringifyToolArgs(parsedArgs), ""],
+      toolName,
+      callId,
+      serviceTag: "",
+      start: lineStart,
+      end: lineEnd
+    });
+  });
+  return requests;
+};
+var stripStandaloneRawToolJsonLines = (source) => {
+  const text = typeof source === "string" ? source : "";
+  if (!text) return text;
+  const normalizeStandaloneToolJsonLine = (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) return null;
+    let normalized = trimmed;
+    const first = normalized[0];
+    const last = normalized[normalized.length - 1];
+    const hasSymmetricQuote = normalized.length >= 2 && (first === "'" && last === "'" || first === '"' && last === '"' || first === "`" && last === "`");
+    if (hasSymmetricQuote) {
+      const inner = normalized.slice(1, -1).trim();
+      if (first === '"') {
+        try {
+          const decoded = JSON.parse(normalized);
+          if (typeof decoded === "string") {
+            normalized = decoded.trim();
+          } else {
+            normalized = inner;
+          }
+        } catch (_error) {
+          normalized = inner;
+        }
+      } else {
+        normalized = inner;
+      }
+    }
+    const extractedCandidate = extractBalancedObjectCandidate(normalized);
+    if (extractedCandidate) {
+      normalized = extractedCandidate.trim();
+    }
+    if (!normalized.startsWith("{") || !normalized.endsWith("}")) return null;
+    return normalized;
+  };
+  const lines = text.split("\n");
+  let removedAny = false;
+  const kept = lines.filter((line) => {
+    const normalized = normalizeStandaloneToolJsonLine(line);
+    if (!normalized) return true;
+    const hasToolType = /"type"\s*:\s*"(tool_use|function)"/i.test(normalized);
+    if (!hasToolType) return true;
+    const hasName = /"name"\s*:\s*"[^"]+"/i.test(normalized);
+    const hasFunctionName = /"function"\s*:\s*\{[\s\S]*?"name"\s*:\s*"[^"]+"/i.test(normalized);
+    if (!hasName && !hasFunctionName) return true;
+    removedAny = true;
+    return false;
+  });
+  if (!removedAny) return text;
+  return kept.join("\n").replace(/\n{3,}/g, "\n\n");
+};
+var extractToolRequestMatchesFromText = (rawResponse) => {
+  const requests = [];
+  const segments = extractTopLevelJsonObjectSegments(rawResponse);
+  segments.forEach((segment, segmentIndex) => {
+    const parsed = resolveToolRequestFromSegment(segment, segmentIndex);
+    if (!parsed) return;
+    requests.push(parsed);
+  });
+  const fallbackRequests = extractLineLevelFallbackToolRequests(rawResponse, requests);
+  fallbackRequests.forEach((request) => {
+    requests.push(request);
+  });
+  if (requests.length === 0) return [];
+  requests.sort((a, b) => a.start - b.start);
+  const seenSignatures = /* @__PURE__ */ new Set();
+  const deduped = requests.filter((request) => {
+    const signature = `${String(request.toolName || "").trim().toLowerCase()}::${String(
+      request.callId || ""
+    ).trim().toLowerCase()}::${request.start}`;
+    if (seenSignatures.has(signature)) return false;
+    seenSignatures.add(signature);
+    return true;
+  });
+  deduped.sort((a, b) => a.start - b.start);
+  return deduped;
+};
+var hashInlineMarkerValue = (value) => {
+  let hash = 5381;
+  const input = String(value || "");
+  for (let index = 0; index < input.length; index += 1) {
+    hash = (hash << 5) + hash ^ input.charCodeAt(index);
+  }
+  return (hash >>> 0).toString(36);
+};
+var getThinkingBlockSignature = (type, content) => {
+  const normalizedContent = String(content || "").trim();
+  return `${type}-${hashInlineMarkerValue(normalizedContent)}-${normalizedContent.length}`;
+};
+var buildThinkingBlockMarker = (type, signature) => {
+  const normalizedType = String(type || "thinking").trim();
+  const normalizedSignature = String(signature || "").trim() || `${normalizedType}-block`;
+  return `${INLINE_THINKING_MARKER_PREFIX}${encodeURIComponent(normalizedType)}|${encodeURIComponent(
+    normalizedSignature
+  )}${INLINE_THINKING_MARKER_SUFFIX}`;
+};
+var buildInlineToolMarker = (toolName, callId) => {
+  const normalizedToolName = String(toolName || "").trim() || "tool";
+  const normalizedCallId = String(callId || "").trim() || `${normalizedToolName}-call`;
+  return `${INLINE_TOOL_MARKER_PREFIX}${encodeURIComponent(normalizedToolName)}|${encodeURIComponent(
+    normalizedCallId
+  )}${INLINE_TOOL_MARKER_SUFFIX}`;
+};
+var parseInlineToolMarkers = (text) => {
+  const source = typeof text === "string" ? text : "";
+  if (!source) return { parts: [""], markers: [] };
+  const parts = [];
+  const markers = [];
+  let lastIndex = 0;
+  INLINE_TOOL_MARKER_REGEX.lastIndex = 0;
+  let match;
+  while ((match = INLINE_TOOL_MARKER_REGEX.exec(source)) !== null) {
+    parts.push(source.slice(lastIndex, match.index));
+    const encodedToolName = match[1] || "";
+    const encodedCallId = match[2] || "";
+    let toolName = encodedToolName;
+    let callId = encodedCallId;
+    try {
+      toolName = decodeURIComponent(encodedToolName);
+    } catch (_error) {
+      toolName = encodedToolName;
+    }
+    try {
+      callId = decodeURIComponent(encodedCallId);
+    } catch (_error) {
+      callId = encodedCallId;
+    }
+    markers.push({
+      toolName: String(toolName || "").trim() || "tool",
+      callId: String(callId || "").trim() || "call"
+    });
+    lastIndex = match.index + match[0].length;
+  }
+  parts.push(source.slice(lastIndex));
+  return { parts, markers };
+};
+var parseInlineThinkingMarkers = (text) => {
+  const source = typeof text === "string" ? text : "";
+  if (!source) return { parts: [""], markers: [] };
+  const parts = [];
+  const markers = [];
+  let lastIndex = 0;
+  INLINE_THINKING_MARKER_REGEX.lastIndex = 0;
+  let match;
+  while ((match = INLINE_THINKING_MARKER_REGEX.exec(source)) !== null) {
+    parts.push(source.slice(lastIndex, match.index));
+    const encodedType = match[1] || "";
+    const encodedSignature = match[2] || "";
+    let rawType = encodedType;
+    let signature = encodedSignature;
+    try {
+      rawType = decodeURIComponent(encodedType);
+    } catch (_error) {
+      rawType = encodedType;
+    }
+    try {
+      signature = decodeURIComponent(encodedSignature);
+    } catch (_error) {
+      signature = encodedSignature;
+    }
+    const normalizedType = String(rawType || "").trim().toLowerCase();
+    const type = normalizedType === "reasoning" ? "reasoning" : normalizedType === "searching" ? "searching" : "thinking";
+    markers.push({
+      type,
+      signature: String(signature || "").trim()
+    });
+    lastIndex = match.index + match[0].length;
+  }
+  parts.push(source.slice(lastIndex));
+  return { parts, markers };
+};
 var ArrowUpIcon = () => /* @__PURE__ */ React14.createElement("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", className: "ai-chat-icon-sm" }, /* @__PURE__ */ React14.createElement("path", { d: "M12 19V5M5 12l7-7 7 7" }));
 var StopIcon = () => /* @__PURE__ */ React14.createElement("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "currentColor", className: "ai-chat-icon" }, /* @__PURE__ */ React14.createElement("rect", { x: "6", y: "6", width: "12", height: "12", rx: "2" }));
 var ChevronDownIcon = () => /* @__PURE__ */ React14.createElement("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", className: "ai-chat-icon-sm" }, /* @__PURE__ */ React14.createElement("path", { d: "m6 9 6 6 6-6" }));
 var ChevronUpIcon = () => /* @__PURE__ */ React14.createElement("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", className: "ai-chat-icon-sm" }, /* @__PURE__ */ React14.createElement("path", { d: "m18 15-6-6-6 6" }));
 var AgentIcon = () => /* @__PURE__ */ React14.createElement("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", className: "ai-chat-icon-sm" }, /* @__PURE__ */ React14.createElement("path", { d: "M12 8V4H8" }), /* @__PURE__ */ React14.createElement("rect", { width: "16", height: "12", x: "4", y: "8", rx: "2" }), /* @__PURE__ */ React14.createElement("path", { d: "M2 14h2" }), /* @__PURE__ */ React14.createElement("path", { d: "M20 14h2" }), /* @__PURE__ */ React14.createElement("path", { d: "M15 13v2" }), /* @__PURE__ */ React14.createElement("path", { d: "M9 13v2" }));
+var ToolIcon = () => /* @__PURE__ */ React14.createElement("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", className: "ai-chat-icon-sm" }, /* @__PURE__ */ React14.createElement("path", { d: "M14.7 6.3a4 4 0 0 0-5.4 5.4l-6 6a2 2 0 0 0 2.8 2.8l6-6a4 4 0 0 0 5.4-5.4l-2.1 2.1-3.3-3.3 2.6-1.6Z" }));
 var CheckIcon = () => /* @__PURE__ */ React14.createElement("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", className: "ai-chat-icon-sm" }, /* @__PURE__ */ React14.createElement("polyline", { points: "20 6 9 17 4 12" }));
 var LLMAsAServiceLogo = () => /* @__PURE__ */ React14.createElement("svg", { width: "16", height: "16", viewBox: "0 0 72 72", fill: "none", xmlns: "http://www.w3.org/2000/svg" }, /* @__PURE__ */ React14.createElement("ellipse", { cx: "14.0868", cy: "59.2146", rx: "7.8261", ry: "7.7854", fill: "#2487D8" }), /* @__PURE__ */ React14.createElement("ellipse", { cx: "24.9013", cy: "43.0776", rx: "6.11858", ry: "6.08676", fill: "#2487D8" }), /* @__PURE__ */ React14.createElement("ellipse", { cx: "45.391", cy: "43.0776", rx: "6.11858", ry: "6.08676", fill: "#2487D8" }), /* @__PURE__ */ React14.createElement("ellipse", { cx: "65.8813", cy: "43.0776", rx: "6.11858", ry: "6.08676", fill: "#2487D8" }), /* @__PURE__ */ React14.createElement("ellipse", { cx: "35.1461", cy: "26.5327", rx: "4.41103", ry: "4.3878", fill: "#2487D8" }), /* @__PURE__ */ React14.createElement("ellipse", { cx: "55.6364", cy: "26.5327", rx: "4.41103", ry: "4.3878", fill: "#2487D8" }), /* @__PURE__ */ React14.createElement("ellipse", { cx: "45.391", cy: "10.3959", rx: "2.70351", ry: "2.68919", fill: "#2487D8" }));
 var AlertCircleIcon = () => /* @__PURE__ */ React14.createElement("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", className: "ai-chat-icon-sm" }, /* @__PURE__ */ React14.createElement("circle", { cx: "12", cy: "12", r: "10" }), /* @__PURE__ */ React14.createElement("line", { x1: "12", x2: "12", y1: "8", y2: "12" }), /* @__PURE__ */ React14.createElement("line", { x1: "12", x2: "12.01", y1: "16", y2: "16" }));
 var CloseIcon = () => /* @__PURE__ */ React14.createElement("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", className: "ai-chat-icon-sm" }, /* @__PURE__ */ React14.createElement("line", { x1: "18", x2: "6", y1: "6", y2: "18" }), /* @__PURE__ */ React14.createElement("line", { x1: "6", x2: "18", y1: "6", y2: "18" }));
 var ChatInput = React14.memo(({
   placeholder,
-  idle,
+  isBusy,
   onSubmit,
   onStop,
   agentOptions,
@@ -3777,14 +4882,14 @@ var ChatInput = React14.memo(({
   }, []);
   const handleSubmit = useCallback2(() => {
     const trimmed = inputValue.trim();
-    if (trimmed && idle) {
+    if (trimmed && !isBusy) {
       onSubmit(trimmed);
       setInputValue("");
       if (textareaRef.current) {
         textareaRef.current.style.height = "auto";
       }
     }
-  }, [inputValue, idle, onSubmit]);
+  }, [inputValue, isBusy, onSubmit]);
   useEffect8(() => {
     const handleClickOutside = (event) => {
       if (containerRef.current && !containerRef.current.contains(event.target)) {
@@ -3820,9 +4925,6 @@ var ChatInput = React14.memo(({
   const hasRawData2 = (section) => {
     return typeof section.rawData === "string";
   };
-  const hasStructuredData = (section) => {
-    return typeof section.data === "object" && section.data !== null;
-  };
   const estimateSectionTokens2 = (section) => {
     var _a;
     if (typeof section.tokens === "number") {
@@ -3833,32 +4935,6 @@ var ChatInput = React14.memo(({
     }
     return Math.ceil(JSON.stringify((_a = section.data) != null ? _a : {}).length / 4);
   };
-  const detectFormat = (section) => {
-    if (section.format) {
-      return section.format;
-    }
-    if (!hasRawData2(section)) {
-      return "json";
-    }
-    const raw = section.rawData.trim();
-    if (raw.startsWith("{") || raw.startsWith("[")) return "json";
-    if (raw.includes("# ") || raw.includes("```")) return "markdown";
-    return "text";
-  };
-  const formatBadge = (format) => {
-    if (format === "toon") return "TOON";
-    if (format === "markdown") return "MD";
-    if (format === "text") return "TEXT";
-    return "JSON";
-  };
-  const [detailViewModeBySection, setDetailViewModeBySection] = useState7({});
-  const getVisibleDetailMode = (section) => {
-    var _a;
-    if (hasRawData2(section)) {
-      return (_a = detailViewModeBySection[section.id]) != null ? _a : "raw";
-    }
-    return "structured";
-  };
   const getStructuredContent = (section) => {
     var _a;
     return JSON.stringify((_a = section.data) != null ? _a : {}, null, 2);
@@ -3950,10 +5026,10 @@ var ChatInput = React14.memo(({
           className: `ai-chat-context-popover__progress-bar ${isOverLimit ? "ai-chat-context-popover__progress-bar--warning" : ""}`,
           style: { width: `${Math.min(tokenPercentage, 100)}%` }
         }
-      ))), /* @__PURE__ */ React14.createElement("div", { className: "ai-chat-context-popover__sections" }, contextSections.map((section) => /* @__PURE__ */ React14.createElement(
+      ))), /* @__PURE__ */ React14.createElement("div", { className: "ai-chat-context-popover__sections" }, contextSections.map((section, index) => /* @__PURE__ */ React14.createElement(
         "div",
         {
-          key: section.id,
+          key: `${section.id}-${index}`,
           className: `ai-chat-context-popover__section-item ${enableContextDetailView ? "ai-chat-context-popover__section-item--clickable" : ""}`,
           onClick: () => {
             if (enableContextDetailView) {
@@ -3964,7 +5040,6 @@ var ChatInput = React14.memo(({
         },
         /* @__PURE__ */ React14.createElement("span", { className: "ai-chat-context-popover__section-icon" }, "\u{1F4C4}"),
         /* @__PURE__ */ React14.createElement("span", { className: "ai-chat-context-popover__section-title" }, section.title),
-        /* @__PURE__ */ React14.createElement("span", { className: "ai-chat-context-popover__section-format" }, formatBadge(detectFormat(section))),
         /* @__PURE__ */ React14.createElement("span", { className: "ai-chat-context-popover__section-tokens" }, estimateSectionTokens2(section))
       ))), enableContextDetailView && /* @__PURE__ */ React14.createElement(
         "button",
@@ -4006,15 +5081,13 @@ var ChatInput = React14.memo(({
           className: `ai-chat-context-popover__progress-bar ${isOverLimit ? "ai-chat-context-popover__progress-bar--warning" : ""}`,
           style: { width: `${Math.min(tokenPercentage, 100)}%` }
         }
-      ))), /* @__PURE__ */ React14.createElement("div", { className: "ai-chat-context-popover__detail-sections" }, contextSections.map((section) => {
+      ))), /* @__PURE__ */ React14.createElement("div", { className: "ai-chat-context-popover__detail-sections" }, contextSections.map((section, index) => {
         const isRawSection = hasRawData2(section);
-        const hasBothViews = isRawSection && hasStructuredData(section);
-        const visibleMode = getVisibleDetailMode(section);
         const isEnabled = !disabledSectionIds.has(section.id);
         return /* @__PURE__ */ React14.createElement(
           "details",
           {
-            key: section.id,
+            key: `${section.id}-${index}`,
             className: `ai-chat-context-popover__detail-section ${!isEnabled ? "ai-chat-context-popover__detail-section--disabled" : ""}`,
             open: expandedSectionId === section.id
           },
@@ -4040,43 +5113,18 @@ var ChatInput = React14.memo(({
               }
             ),
             /* @__PURE__ */ React14.createElement("span", { className: "ai-chat-context-toggle__slider" })
-          )), /* @__PURE__ */ React14.createElement("span", { className: "ai-chat-context-popover__detail-section-meta" }, /* @__PURE__ */ React14.createElement("code", null, `{{${section.id}}}`), /* @__PURE__ */ React14.createElement("span", null, formatBadge(detectFormat(section))), /* @__PURE__ */ React14.createElement("span", null, "~", estimateSectionTokens2(section)))),
-          hasBothViews && /* @__PURE__ */ React14.createElement("div", { className: "ai-chat-context-popover__detail-view-toggle" }, /* @__PURE__ */ React14.createElement(
-            "button",
-            {
-              type: "button",
-              className: `ai-chat-context-popover__detail-view-button ${visibleMode === "raw" ? "active" : ""}`,
-              onClick: (e) => {
-                e.preventDefault();
-                e.stopPropagation();
-                setDetailViewModeBySection((prev) => __spreadProps(__spreadValues({}, prev), { [section.id]: "raw" }));
-              }
-            },
-            "Raw"
-          ), /* @__PURE__ */ React14.createElement(
-            "button",
-            {
-              type: "button",
-              className: `ai-chat-context-popover__detail-view-button ${visibleMode === "structured" ? "active" : ""}`,
-              onClick: (e) => {
-                e.preventDefault();
-                e.stopPropagation();
-                setDetailViewModeBySection((prev) => __spreadProps(__spreadValues({}, prev), { [section.id]: "structured" }));
-              }
-            },
-            "Structured"
-          )),
-          /* @__PURE__ */ React14.createElement("pre", { className: "ai-chat-context-popover__detail-content" }, /* @__PURE__ */ React14.createElement("code", null, visibleMode === "raw" && isRawSection ? section.rawData : getStructuredContent(section)))
+          )), /* @__PURE__ */ React14.createElement("span", { className: "ai-chat-context-popover__detail-section-meta" }, /* @__PURE__ */ React14.createElement("code", null, `{{${section.id}}}`), /* @__PURE__ */ React14.createElement("span", null, "~", estimateSectionTokens2(section)))),
+          /* @__PURE__ */ React14.createElement("pre", { className: "ai-chat-context-popover__detail-content" }, /* @__PURE__ */ React14.createElement("code", null, isRawSection ? section.rawData : getStructuredContent(section)))
         );
       })))
     )), /* @__PURE__ */ React14.createElement(
       "button",
       {
-        className: `ai-chat-send-button ${idle && !inputValue.trim() ? "ai-chat-send-button--disabled" : ""} ${!idle ? "ai-chat-send-button--stop" : ""}`,
-        onClick: () => idle ? handleSubmit() : onStop(),
-        disabled: idle && !inputValue.trim()
+        className: `ai-chat-send-button ${!isBusy && !inputValue.trim() ? "ai-chat-send-button--disabled" : ""} ${isBusy ? "ai-chat-send-button--stop" : ""}`,
+        onClick: () => isBusy ? onStop() : handleSubmit(),
+        disabled: !isBusy && !inputValue.trim()
       },
-      idle ? /* @__PURE__ */ React14.createElement(ArrowUpIcon, null) : /* @__PURE__ */ React14.createElement(StopIcon, null)
+      isBusy ? /* @__PURE__ */ React14.createElement(StopIcon, null) : /* @__PURE__ */ React14.createElement(ArrowUpIcon, null)
     )),
     agentOptions.length > 0 && dropdownOpen && /* @__PURE__ */ React14.createElement("div", { className: "ai-chat-agent-selector__dropdown-inside" }, agentOptions.map((option) => /* @__PURE__ */ React14.createElement(
       "button",
@@ -4133,7 +5181,11 @@ var AIChatPanel = ({
   initialHistory = {},
   hideRagContextInPrompt = true,
   createConversationOnFirstChat = true,
+  autoApproveTools = false,
   mcpServers = [],
+  resolveMcpAuthHeaders,
+  localToolExecutors,
+  traceContextMode = "standard",
   progressiveActions = true,
   agentOptions = [],
   currentAgentId,
@@ -4146,6 +5198,7 @@ var AIChatPanel = ({
   disabledSectionIds: propDisabledSectionIds,
   onToggleSection: propOnToggleSection,
   onConversationCreated,
+  onBeforeSend,
   // UI Customization Props
   cssUrl,
   markdownClass,
@@ -4181,6 +5234,8 @@ var AIChatPanel = ({
   const [collapsedBlocks, setCollapsedBlocks] = useState7(/* @__PURE__ */ new Set());
   const hasAutoCollapsedRef = useRef6(false);
   const prevBlockCountRef = useRef6(0);
+  const thinkingBlocksByKeyRef = useRef6({});
+  const [thinkingBlocksByKey, setThinkingBlocksByKey] = useState7({});
   const [newConversationConfirm, setNewConversationConfirm] = useState7(false);
   const [justReset, setJustReset] = useState7(false);
   const [copiedCallId, setCopiedCallId] = useState7(null);
@@ -4200,8 +5255,64 @@ var AIChatPanel = ({
   const [pendingToolRequests, setPendingToolRequests] = useState7([]);
   const [sessionApprovedTools, setSessionApprovedTools] = useState7([]);
   const [alwaysApprovedTools, setAlwaysApprovedTools] = useState7([]);
+  const [toolList, setToolList] = useState7([]);
+  const [toolsLoading, setToolsLoading] = useState7(false);
+  const [toolsFetchError, setToolsFetchError] = useState7(false);
+  const [resolvedMcpServers, setResolvedMcpServers] = useState7(mcpServers || []);
+  const [activeToolCalls, setActiveToolCalls] = useState7([]);
+  const normalizeToolName = useCallback2((toolName) => {
+    return String(toolName != null ? toolName : "").trim().toLowerCase();
+  }, []);
+  const getToolCallSignature = useCallback2(
+    (toolName, callId) => {
+      const normalizedToolName = normalizeToolName(toolName);
+      const normalizedCallId = String(callId != null ? callId : "").trim();
+      if (!normalizedToolName || !normalizedCallId) return "";
+      return `${normalizedToolName}::${normalizedCallId}`;
+    },
+    [normalizeToolName]
+  );
+  const alwaysApprovedToolsStorageKey = useMemo2(() => {
+    const customerId = (customer == null ? void 0 : customer.customer_id) || (customer == null ? void 0 : customer.id) || (customer == null ? void 0 : customer.customer_user_email) || "anonymous";
+    const agentIdForScope = currentAgentId || agent || "default";
+    return `llmasaservice-ui:always-approved-tools:${project_id}:${customerId}:${agentIdForScope}`;
+  }, [project_id, customer, currentAgentId, agent]);
   const [internalDisabledSectionIds, setInternalDisabledSectionIds] = useState7(/* @__PURE__ */ new Set());
   const disabledSectionIds = propDisabledSectionIds != null ? propDisabledSectionIds : internalDisabledSectionIds;
+  useEffect8(() => {
+    if (typeof window === "undefined") return;
+    try {
+      const stored = window.localStorage.getItem(alwaysApprovedToolsStorageKey);
+      if (!stored) return;
+      const parsed = JSON.parse(stored);
+      if (!Array.isArray(parsed)) return;
+      const normalized = Array.from(
+        new Set(
+          parsed.map((value) => normalizeToolName(String(value))).filter((value) => value.length > 0)
+        )
+      );
+      setAlwaysApprovedTools(normalized);
+    } catch (error2) {
+      console.warn("[AIChatPanel] Failed to load always-approved tools from localStorage:", error2);
+    }
+  }, [alwaysApprovedToolsStorageKey, normalizeToolName]);
+  useEffect8(() => {
+    if (typeof window === "undefined") return;
+    try {
+      if (alwaysApprovedTools.length === 0) {
+        window.localStorage.removeItem(alwaysApprovedToolsStorageKey);
+        return;
+      }
+      window.localStorage.setItem(
+        alwaysApprovedToolsStorageKey,
+        JSON.stringify(
+          Array.from(new Set(alwaysApprovedTools.map((value) => normalizeToolName(value)).filter(Boolean)))
+        )
+      );
+    } catch (error2) {
+      console.warn("[AIChatPanel] Failed to persist always-approved tools to localStorage:", error2);
+    }
+  }, [alwaysApprovedToolsStorageKey, alwaysApprovedTools, normalizeToolName]);
   useEffect8(() => {
     setShowEmailPanel(customerEmailCaptureMode !== "HIDE");
     if (customerEmailCaptureMode === "REQUIRED") {
@@ -4224,6 +5335,14 @@ var AIChatPanel = ({
   const latestHistoryRef = useRef6(initialHistory);
   const initialPromptSentRef = useRef6(false);
   const lastFollowOnPromptRef = useRef6("");
+  const handledToolCallSignaturesRef = useRef6(/* @__PURE__ */ new Set());
+  const inFlightToolCallSignaturesRef = useRef6(/* @__PURE__ */ new Set());
+  const toolContinuationCountRef = useRef6(0);
+  const activeStreamAppendBaseRef = useRef6(null);
+  const toolRequestProcessingRef = useRef6(false);
+  const queuedToolRequestsRef = useRef6(null);
+  const suppressAbortHistoryUpdateRef = useRef6(false);
+  const toolReplaySummariesByKeyRef = useRef6({});
   useEffect8(() => {
     if (!initialHistory) return;
     setHistory((prev) => {
@@ -4242,10 +5361,158 @@ var AIChatPanel = ({
       return prev;
     });
   }, [initialHistory]);
-  const llmResult = useLLM2(__spreadValues(__spreadValues(__spreadValues(__spreadValues({
+  useEffect8(() => {
+    latestHistoryRef.current = history;
+  }, [history]);
+  useEffect8(() => {
+    let cancelled = false;
+    const resolveServers = () => __async(void 0, null, function* () {
+      if (!mcpServers || mcpServers.length === 0) {
+        if (!cancelled) {
+          setResolvedMcpServers((prev) => prev.length === 0 ? prev : []);
+        }
+        return;
+      }
+      if (!resolveMcpAuthHeaders) {
+        if (!cancelled) {
+          setResolvedMcpServers((prev) => {
+            const hasSameServers = prev.length === mcpServers.length && prev.every((server, index) => server === mcpServers[index]);
+            return hasSameServers ? prev : mcpServers;
+          });
+        }
+        return;
+      }
+      try {
+        const enriched = yield Promise.all(
+          mcpServers.map((server) => __async(void 0, null, function* () {
+            const resolved = yield resolveMcpAuthHeaders({
+              phase: "list",
+              mcpServer: server || {},
+              projectId: project_id,
+              customer
+            });
+            return __spreadProps(__spreadValues({}, server || {}), {
+              headers: __spreadValues(__spreadValues({}, typeof (server == null ? void 0 : server.headers) === "object" && (server == null ? void 0 : server.headers) ? server.headers : {}), normalizeMcpHeaders(
+                resolved
+              ))
+            });
+          }))
+        );
+        if (!cancelled) setResolvedMcpServers(enriched);
+      } catch (error2) {
+        console.error("[AIChatPanel] Failed to resolve MCP auth headers:", error2);
+        if (!cancelled) setResolvedMcpServers(mcpServers);
+      }
+    });
+    void resolveServers();
+    return () => {
+      cancelled = true;
+    };
+  }, [mcpServers, resolveMcpAuthHeaders, project_id, customer]);
+  const buildMcpRequestHeaders = useCallback2(
+    (_0) => __async(void 0, [_0], function* ({
+      phase,
+      mcpServer,
+      toolName,
+      toolArgs
+    }) {
+      const merged = {};
+      const packScopeIntoAccessToken = (headers) => {
+        const accessToken = typeof headers["x-mcp-access-token"] === "string" ? headers["x-mcp-access-token"].trim() : "";
+        const scopeToken = typeof headers["x-client-id"] === "string" ? headers["x-client-id"].trim() : "";
+        if (!accessToken || !scopeToken) return headers;
+        return __spreadProps(__spreadValues({}, headers), {
+          "x-mcp-access-token": `${accessToken}::scope::${scopeToken}`
+        });
+      };
+      const baseAccessToken = typeof mcpServer.accessToken === "string" ? mcpServer.accessToken.trim() : "";
+      if (baseAccessToken) {
+        merged["x-mcp-access-token"] = baseAccessToken;
+      }
+      if (project_id) {
+        merged["x-project-id"] = project_id;
+      }
+      if (!resolveMcpAuthHeaders) return merged;
+      try {
+        const resolved = yield resolveMcpAuthHeaders({
+          phase,
+          mcpServer,
+          projectId: project_id,
+          customer,
+          toolName,
+          toolArgs
+        });
+        return packScopeIntoAccessToken(__spreadValues(__spreadValues({}, merged), normalizeMcpHeaders(
+          resolved
+        )));
+      } catch (error2) {
+        console.error(
+          `Failed to resolve MCP auth headers for ${phase} request:`,
+          error2
+        );
+        return merged;
+      }
+    }),
+    [project_id, customer, resolveMcpAuthHeaders]
+  );
+  useEffect8(() => {
+    const fetchAndSetTools = () => __async(void 0, null, function* () {
+      if (!resolvedMcpServers || resolvedMcpServers.length === 0) {
+        setToolList((prev) => prev.length === 0 ? prev : []);
+        setToolsLoading((prev) => prev ? false : prev);
+        setToolsFetchError((prev) => prev ? false : prev);
+        return;
+      }
+      setToolsLoading(true);
+      setToolsFetchError(false);
+      try {
+        const fetchPromises = (resolvedMcpServers != null ? resolvedMcpServers : []).map((m) => __async(void 0, null, function* () {
+          const urlToFetch = `${publicAPIUrl}/tools/${encodeURIComponent(m.url)}`;
+          const requestHeaders = yield buildMcpRequestHeaders({
+            phase: "list",
+            mcpServer: m
+          });
+          const response2 = yield fetch(urlToFetch, {
+            headers: requestHeaders
+          });
+          if (!response2.ok) {
+            const errorBody = yield response2.text();
+            throw new Error(
+              `HTTP ${response2.status}: ${response2.statusText} ${errorBody}`
+            );
+          }
+          const toolsFromServer = yield response2.json();
+          if (!Array.isArray(toolsFromServer)) return [];
+          return toolsFromServer.map((tool) => __spreadProps(__spreadValues({}, tool), {
+            url: m.url,
+            accessToken: m.accessToken || "",
+            headers: requestHeaders
+          }));
+        }));
+        const results = yield Promise.all(fetchPromises);
+        const allTools = results.flat();
+        setToolList(allTools);
+        setToolsFetchError(false);
+      } catch (error2) {
+        console.error("[AIChatPanel] Failed to load MCP tools:", error2);
+        setToolList([]);
+        setToolsFetchError(true);
+      } finally {
+        setToolsLoading(false);
+      }
+    });
+    void fetchAndSetTools();
+  }, [resolvedMcpServers, publicAPIUrl, buildMcpRequestHeaders]);
+  const llmResult = useLLM2(__spreadProps(__spreadValues(__spreadValues(__spreadValues({
     project_id,
     customer
-  }, url && { url }), service && { group_id: service }), agent && { agent }), mcpServers && mcpServers.length > 0 && { mcp_servers: mcpServers }));
+  }, url && { url }), service && { group_id: service }), agent && { agent }), {
+    tools: toolList.map((item) => ({
+      name: item.name,
+      description: item.description,
+      parameters: item.parameters
+    }))
+  }));
   const {
     send,
     response,
@@ -4255,9 +5522,6 @@ var AIChatPanel = ({
     setResponse,
     error: llmError
   } = llmResult;
-  const toolList = llmResult.toolList || [];
-  const toolsLoading = llmResult.toolsLoading || false;
-  const toolsFetchError = llmResult.toolsFetchError || null;
   const historyCallbackRef = useRef6(historyChangedCallback);
   const responseCompleteCallbackRef = useRef6(responseCompleteCallback);
   const responseRef = useRef6(response);
@@ -4298,18 +5562,26 @@ var AIChatPanel = ({
     }
   }, [propOnToggleSection]);
   const ensureConversation = useCallback2(() => {
-    var _a2, _b;
+    const normalizedConversationId = typeof currentConversation === "string" ? currentConversation.trim() : "";
     console.log("ensureConversation - called with:", {
-      currentConversation,
+      currentConversation: normalizedConversationId || null,
       createConversationOnFirstChat,
       project_id,
       publicAPIUrl
     });
-    if ((!currentConversation || currentConversation === "") && createConversationOnFirstChat) {
-      if (!project_id) {
-        console.error("ensureConversation - Cannot create conversation without project_id");
-        return Promise.resolve("");
-      }
+    if (normalizedConversationId) {
+      console.log("ensureConversation - using existing conversation:", normalizedConversationId);
+      return Promise.resolve(normalizedConversationId);
+    }
+    if (!createConversationOnFirstChat) {
+      return Promise.resolve("");
+    }
+    if (!project_id) {
+      console.error("ensureConversation - Cannot create conversation without project_id");
+      return Promise.resolve("");
+    }
+    const createConversation = () => {
+      var _a2, _b;
       const requestBody = {
         project_id,
         agentId: agent,
@@ -4335,11 +5607,13 @@ var AIChatPanel = ({
         }
         return res.json();
       })).then((newConvo) => {
+        var _a3;
         console.log("ensureConversation - API response:", newConvo);
-        if (newConvo == null ? void 0 : newConvo.id) {
-          console.log("ensureConversation - New conversation ID:", newConvo.id);
-          setCurrentConversation(newConvo.id);
-          return newConvo.id;
+        const createdId = typeof (newConvo == null ? void 0 : newConvo.id) === "string" && newConvo.id.trim() || typeof (newConvo == null ? void 0 : newConvo.conversationId) === "string" && newConvo.conversationId.trim() || typeof (newConvo == null ? void 0 : newConvo.conversation_id) === "string" && newConvo.conversation_id.trim() || typeof ((_a3 = newConvo == null ? void 0 : newConvo.conversation) == null ? void 0 : _a3.id) === "string" && newConvo.conversation.id.trim() || "";
+        if (createdId) {
+          console.log("ensureConversation - New conversation ID:", createdId);
+          setCurrentConversation(createdId);
+          return createdId;
         }
         console.warn("ensureConversation - No ID in response");
         return "";
@@ -4347,9 +5621,8 @@ var AIChatPanel = ({
         console.error("Error creating new conversation", error2);
         return "";
       });
-    }
-    console.log("ensureConversation - using existing conversation:", currentConversation);
-    return Promise.resolve(currentConversation);
+    };
+    return createConversation();
   }, [currentConversation, createConversationOnFirstChat, publicAPIUrl, project_id, agent, customer, browserInfo]);
   const dataWithExtras = useCallback2(() => {
     var _a2, _b, _c, _d, _e, _f, _g, _h;
@@ -4532,19 +5805,565 @@ var AIChatPanel = ({
     }
     return false;
   }, [customerEmailCaptureMode, emailInputSet]);
-  const handleToolApproval = useCallback2((toolName, scope) => {
-    if (scope === "session" || scope === "always") {
-      setSessionApprovedTools((prev) => Array.from(/* @__PURE__ */ new Set([...prev, toolName])));
-    }
-    if (scope === "always") {
-      setAlwaysApprovedTools((prev) => Array.from(/* @__PURE__ */ new Set([...prev, toolName])));
+  const pendingToolRequestsRef = useRef6(pendingToolRequests);
+  const streamIdleRef = useRef6(idle);
+  streamIdleRef.current = idle;
+  const waitForStreamIdle = useCallback2((timeoutMs = 2500) => __async(void 0, null, function* () {
+    const startedAt = Date.now();
+    while (!streamIdleRef.current && Date.now() - startedAt < timeoutMs) {
+      yield new Promise((resolve) => {
+        setTimeout(resolve, 25);
+      });
     }
-    setPendingToolRequests((prev) => prev.filter((r) => r.toolName !== toolName));
-    console.log(`[AIChatPanel] Tool "${toolName}" approved with scope: ${scope}`);
-  }, []);
-  const getUniqueToolNames = useCallback2(() => {
-    return Array.from(new Set(pendingToolRequests.map((r) => r.toolName)));
+  }), []);
+  useEffect8(() => {
+    pendingToolRequestsRef.current = pendingToolRequests;
   }, [pendingToolRequests]);
+  const processGivenToolRequests = useCallback2(
+    (requests) => __async(void 0, null, function* () {
+      var _a2, _b, _c;
+      const dedupeToolRequests = (input) => {
+        const seen = /* @__PURE__ */ new Set();
+        const deduped = [];
+        for (const request of Array.isArray(input) ? input : []) {
+          if (!request) continue;
+          const signature = getToolCallSignature(request.toolName, request.callId) || request.match;
+          if (!signature || seen.has(signature)) continue;
+          seen.add(signature);
+          deduped.push(request);
+        }
+        return deduped;
+      };
+      if (toolRequestProcessingRef.current) {
+        const queued = dedupeToolRequests([
+          ...queuedToolRequestsRef.current || [],
+          ...Array.isArray(requests) ? requests : []
+        ]);
+        if (queued.length > 0) {
+          queuedToolRequestsRef.current = queued;
+        }
+        return;
+      }
+      toolRequestProcessingRef.current = true;
+      try {
+        let requestsToProcess = requests;
+        if (!requestsToProcess || requestsToProcess.length === 0) {
+          requestsToProcess = pendingToolRequestsRef.current || [];
+        }
+        if (!requestsToProcess || requestsToProcess.length === 0) return;
+        setIsLoading(true);
+        const userPrompt = lastPromptRef.current || lastKeyRef.current || "";
+        const lastPromptKey = lastKeyRef.current;
+        const assistantSeedText = lastPromptKey && ((_a2 = latestHistoryRef.current[lastPromptKey]) == null ? void 0 : _a2.content) ? (_b = latestHistoryRef.current[lastPromptKey]) == null ? void 0 : _b.content : "";
+        const historyForContinuation = latestHistoryRef.current || {};
+        const newMessages = [];
+        Object.entries(historyForContinuation).forEach(([historyPrompt, historyEntry]) => {
+          let promptForHistory = String(historyPrompt || "");
+          const isoTimestampRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z:/;
+          if (isoTimestampRegex.test(promptForHistory)) {
+            const colonIndex = promptForHistory.indexOf(":", 19);
+            promptForHistory = promptForHistory.substring(colonIndex + 1);
+          } else if (/^\d+:/.test(promptForHistory)) {
+            const colonIndex = promptForHistory.indexOf(":");
+            promptForHistory = promptForHistory.substring(colonIndex + 1);
+          }
+          const typedHistoryEntry = historyEntry || { content: "", callId: "" };
+          const assistantBaseContent = typeof typedHistoryEntry.content === "string" ? typedHistoryEntry.content : "";
+          let assistantContextContent = assistantBaseContent;
+          if (traceContextMode === "full") {
+            const traceSummary = buildCompactTraceSummary({
+              reasoningBlocks: thinkingBlocksByKeyRef.current[historyPrompt] || [],
+              toolCalls: typedHistoryEntry.toolCalls,
+              toolResponses: typedHistoryEntry.toolResponses
+            });
+            if (traceSummary) {
+              assistantContextContent = assistantBaseContent ? `${assistantBaseContent}
+
+${traceSummary}` : traceSummary;
+            }
+          }
+          newMessages.push({
+            role: "user",
+            content: [
+              {
+                type: "text",
+                text: promptForHistory
+              }
+            ]
+          });
+          newMessages.push({
+            role: "assistant",
+            content: [
+              {
+                type: "text",
+                text: assistantContextContent
+              }
+            ]
+          });
+        });
+        if (newMessages.length === 0 && userPrompt.trim().length > 0) {
+          newMessages.push({
+            role: "user",
+            content: [
+              {
+                type: "text",
+                text: userPrompt
+              }
+            ]
+          });
+          if (assistantSeedText.trim().length > 0) {
+            newMessages.push({
+              role: "assistant",
+              content: [
+                {
+                  type: "text",
+                  text: assistantSeedText
+                }
+              ]
+            });
+          }
+        }
+        const parsedToolCalls = yield Promise.all(
+          requestsToProcess.map((req, index) => __async(void 0, null, function* () {
+            var _a3, _b2, _c2, _d, _e, _f;
+            let parsedToolCall = null;
+            try {
+              parsedToolCall = JSON.parse(req.match);
+            } catch (error2) {
+              console.error("[AIChatPanel] Failed to parse tool call payload:", error2);
+            }
+            const toolName = req.groups[1] || req.toolName || (typeof (parsedToolCall == null ? void 0 : parsedToolCall.name) === "string" ? parsedToolCall.name : "") || (typeof ((_a3 = parsedToolCall == null ? void 0 : parsedToolCall.function) == null ? void 0 : _a3.name) === "string" ? parsedToolCall.function.name : "");
+            if (!toolName) return null;
+            const rawCallId = req.callId || req.groups[0] || (parsedToolCall == null ? void 0 : parsedToolCall.id) || (parsedToolCall == null ? void 0 : parsedToolCall.tool_call_id) || `${toolName}-${index + 1}`;
+            const callId = typeof rawCallId === "string" && rawCallId.trim().length > 0 && rawCallId !== "functionCall" ? rawCallId : `${toolName}-${index + 1}`;
+            let args = {};
+            const rawArgs = (_f = (_e = (_c2 = (_b2 = req.groups[2]) != null ? _b2 : parsedToolCall == null ? void 0 : parsedToolCall.input) != null ? _c2 : parsedToolCall == null ? void 0 : parsedToolCall.args) != null ? _e : (_d = parsedToolCall == null ? void 0 : parsedToolCall.function) == null ? void 0 : _d.arguments) != null ? _f : "{}";
+            const parsedArgs = parseToolArguments(rawArgs);
+            if (!parsedArgs) {
+              console.error("[AIChatPanel] Failed to parse tool arguments", {
+                toolName,
+                callId,
+                rawArgsPreview: typeof rawArgs === "string" ? rawArgs.slice(0, 500) : JSON.stringify(rawArgs).slice(0, 500)
+              });
+              return null;
+            }
+            args = parsedArgs;
+            const serviceTag = typeof req.serviceTag === "string" && req.serviceTag || typeof req.groups[3] === "string" && req.groups[3] || typeof (parsedToolCall == null ? void 0 : parsedToolCall.service) === "string" && parsedToolCall.service || "";
+            const callSignature = getToolCallSignature(toolName, callId);
+            if (!callSignature) return null;
+            return {
+              req,
+              toolName,
+              callId,
+              args,
+              serviceTag,
+              callSignature
+            };
+          }))
+        );
+        const toolCallBatch = parsedToolCalls.filter(Boolean);
+        const seenCallSignatures = /* @__PURE__ */ new Set();
+        const callsToRun = [];
+        toolCallBatch.forEach((toolCall) => {
+          if (seenCallSignatures.has(toolCall.callSignature)) return;
+          seenCallSignatures.add(toolCall.callSignature);
+          if (handledToolCallSignaturesRef.current.has(toolCall.callSignature)) return;
+          if (inFlightToolCallSignaturesRef.current.has(toolCall.callSignature)) return;
+          callsToRun.push(toolCall);
+        });
+        if (callsToRun.length === 0) {
+          setPendingToolRequests(
+            (prev) => prev.filter((request) => {
+              const signature = getToolCallSignature(request.toolName, request.callId);
+              if (!signature) return true;
+              return !seenCallSignatures.has(signature);
+            })
+          );
+          setActiveToolCalls([]);
+          setIsLoading(false);
+          return;
+        }
+        const callsToRunSignatures = new Set(callsToRun.map((toolCall) => toolCall.callSignature));
+        setPendingToolRequests(
+          (prev) => prev.filter((request) => {
+            const signature = getToolCallSignature(request.toolName, request.callId);
+            return !signature || !callsToRunSignatures.has(signature);
+          })
+        );
+        callsToRun.forEach((toolCall) => {
+          inFlightToolCallSignaturesRef.current.add(toolCall.callSignature);
+        });
+        setActiveToolCalls(
+          callsToRun.map((toolCall) => ({
+            toolName: toolCall.toolName,
+            callId: toolCall.callId
+          }))
+        );
+        const finalToolCalls = callsToRun.map((toolCall) => ({
+          id: toolCall.callId,
+          type: "tool_use",
+          name: toolCall.toolName,
+          input: toolCall.args,
+          service: toolCall.serviceTag
+        }));
+        let finalToolResponses = [];
+        try {
+          const toolResponses = yield Promise.all(
+            callsToRun.map((toolCall) => __async(void 0, null, function* () {
+              var _a3, _b2, _c2, _d, _e, _f, _g;
+              const mcpTool = toolList.find((tool) => tool.name === toolCall.toolName) || null;
+              const localExecutor = localToolExecutors && typeof localToolExecutors[toolCall.toolName] === "function" ? localToolExecutors[toolCall.toolName] : null;
+              if (localExecutor) {
+                try {
+                  const localResult = yield localExecutor(toolCall.args, {
+                    toolName: toolCall.toolName,
+                    callId: toolCall.callId,
+                    serviceTag: toolCall.serviceTag,
+                    mcpTool
+                  });
+                  if (localResult && typeof localResult === "object" && !Array.isArray(localResult)) {
+                    const objectResult = localResult;
+                    const isError = objectResult.isError === true || objectResult.error === true;
+                    const maybeResult = Object.prototype.hasOwnProperty.call(objectResult, "result") ? objectResult.result : localResult;
+                    const textResult = typeof maybeResult === "string" ? maybeResult : JSON.stringify(maybeResult != null ? maybeResult : {});
+                    return {
+                      tool_call_id: toolCall.callId,
+                      tool_name: toolCall.toolName,
+                      result: textResult || "",
+                      isError
+                    };
+                  }
+                  return {
+                    tool_call_id: toolCall.callId,
+                    tool_name: toolCall.toolName,
+                    result: typeof localResult === "string" ? localResult : JSON.stringify(localResult != null ? localResult : {}),
+                    isError: false
+                  };
+                } catch (error2) {
+                  return {
+                    tool_call_id: toolCall.callId,
+                    tool_name: toolCall.toolName,
+                    result: error2 instanceof Error ? error2.message : `Unhandled error calling ${toolCall.toolName}`,
+                    isError: true
+                  };
+                }
+              }
+              if (!mcpTool) {
+                console.error(`[AIChatPanel] Tool ${toolCall.toolName} not found in tool list`);
+                return {
+                  tool_call_id: toolCall.callId,
+                  tool_name: toolCall.toolName,
+                  result: `Tool ${toolCall.toolName} not found in current tool list.`,
+                  isError: true
+                };
+              }
+              const toolUrl = typeof mcpTool.url === "string" ? mcpTool.url : "";
+              if (!toolUrl) {
+                return {
+                  tool_call_id: toolCall.callId,
+                  tool_name: toolCall.toolName,
+                  result: `Tool ${toolCall.toolName} is missing url metadata.`,
+                  isError: true
+                };
+              }
+              const body = {
+                tool: toolCall.toolName,
+                args: toolCall.args
+              };
+              try {
+                const result = yield fetch(
+                  `${publicAPIUrl}/tools/${encodeURIComponent(toolUrl)}`,
+                  {
+                    method: "POST",
+                    headers: __spreadValues({
+                      "Content-Type": "application/json"
+                    }, yield buildMcpRequestHeaders({
+                      phase: "call",
+                      mcpServer: mcpTool,
+                      toolName: toolCall.toolName,
+                      toolArgs: toolCall.args
+                    })),
+                    body: JSON.stringify(body)
+                  }
+                );
+                if (!result.ok) {
+                  const errorBody = yield result.text();
+                  console.error(
+                    `[AIChatPanel] Tool call failed ${toolCall.toolName}: ${result.status} ${result.statusText} ${errorBody}`
+                  );
+                  return {
+                    tool_call_id: toolCall.callId,
+                    tool_name: toolCall.toolName,
+                    result: `HTTP ${result.status} ${result.statusText}: ${errorBody || "Tool call failed"}`,
+                    isError: true
+                  };
+                }
+                let resultData = null;
+                try {
+                  resultData = yield result.json();
+                } catch (error2) {
+                  console.error("[AIChatPanel] Failed parsing tool call JSON response:", error2);
+                  return {
+                    tool_call_id: toolCall.callId,
+                    tool_name: toolCall.toolName,
+                    result: "Tool returned a non-JSON response.",
+                    isError: true
+                  };
+                }
+                const textResult = (_c2 = (_b2 = (_a3 = resultData == null ? void 0 : resultData.content) == null ? void 0 : _a3[0]) == null ? void 0 : _b2.text) != null ? _c2 : (resultData == null ? void 0 : resultData.result) ? JSON.stringify(resultData.result) : JSON.stringify(resultData);
+                const inferredError = (resultData == null ? void 0 : resultData.isError) === true || (resultData == null ? void 0 : resultData.error) === true || typeof (resultData == null ? void 0 : resultData.error) === "string" || (resultData == null ? void 0 : resultData.status) === "error" || ((_d = resultData == null ? void 0 : resultData.result) == null ? void 0 : _d.isError) === true || ((_e = resultData == null ? void 0 : resultData.result) == null ? void 0 : _e.error) === true || typeof ((_f = resultData == null ? void 0 : resultData.result) == null ? void 0 : _f.error) === "string";
+                const normalizedResultText = typeof textResult === "string" && textResult.trim().length > 0 ? textResult : inferredError && typeof (resultData == null ? void 0 : resultData.error) === "string" ? resultData.error : inferredError && typeof ((_g = resultData == null ? void 0 : resultData.result) == null ? void 0 : _g.error) === "string" ? resultData.result.error : "";
+                return {
+                  tool_call_id: toolCall.callId,
+                  tool_name: toolCall.toolName,
+                  result: normalizedResultText,
+                  isError: inferredError
+                };
+              } catch (error2) {
+                console.error(`[AIChatPanel] Error calling tool ${toolCall.toolName}:`, error2);
+                return {
+                  tool_call_id: toolCall.callId,
+                  tool_name: toolCall.toolName,
+                  result: error2 instanceof Error ? error2.message : `Unhandled error calling ${toolCall.toolName}`,
+                  isError: true
+                };
+              }
+            }))
+          );
+          finalToolResponses = toolResponses.filter(Boolean);
+        } finally {
+          callsToRun.forEach((toolCall) => {
+            inFlightToolCallSignaturesRef.current.delete(toolCall.callSignature);
+            handledToolCallSignaturesRef.current.add(toolCall.callSignature);
+          });
+        }
+        setActiveToolCalls([]);
+        const currentLastKey = lastKeyRef.current;
+        if (currentLastKey) {
+          setHistory((prev) => {
+            const existingEntry = prev[currentLastKey] || { content: "", callId: "" };
+            return __spreadProps(__spreadValues({}, prev), {
+              [currentLastKey]: __spreadProps(__spreadValues({}, existingEntry), {
+                toolCalls: [...existingEntry.toolCalls || [], ...finalToolCalls],
+                toolResponses: [...existingEntry.toolResponses || [], ...finalToolResponses]
+              })
+            });
+          });
+        }
+        const toReplayText = (value) => {
+          const raw = typeof value === "string" ? value : (() => {
+            try {
+              return JSON.stringify(value);
+            } catch (_error) {
+              return String(value != null ? value : "");
+            }
+          })();
+          return String(raw != null ? raw : "");
+        };
+        const replayEntryKey = lastKeyRef.current || "";
+        const previousReplayEntries = replayEntryKey ? toolReplaySummariesByKeyRef.current[replayEntryKey] || [] : [];
+        const currentReplayEntries = callsToRun.map((toolCall, index) => {
+          var _a3;
+          const matchedResponse = finalToolResponses.find((response2) => (response2 == null ? void 0 : response2.tool_call_id) === toolCall.callId) || finalToolResponses[index];
+          return {
+            toolName: toolCall.toolName,
+            callId: toolCall.callId,
+            status: (matchedResponse == null ? void 0 : matchedResponse.isError) ? "error" : "ok",
+            argsText: toReplayText(toolCall.args),
+            resultText: toReplayText((_a3 = matchedResponse == null ? void 0 : matchedResponse.result) != null ? _a3 : "No result returned")
+          };
+        });
+        const replayEntries = [...previousReplayEntries, ...currentReplayEntries];
+        if (replayEntryKey) {
+          toolReplaySummariesByKeyRef.current[replayEntryKey] = replayEntries;
+        }
+        const replayLines = replayEntries.map(
+          (entry) => [
+            `Tool: ${entry.toolName}`,
+            `Call ID: ${entry.callId}`,
+            `Status: ${entry.status}`,
+            `Args: ${entry.argsText}`,
+            `Result: ${entry.resultText}`
+          ].join("\n")
+        );
+        const originalRequest = typeof lastPromptRef.current === "string" && lastPromptRef.current.trim() || typeof userPrompt === "string" && userPrompt.trim() || "";
+        const continuationPromptText = [
+          originalRequest ? `Original request: ${originalRequest}` : "",
+          "Tool execution summary for the previous request:",
+          ...replayLines,
+          "Continue the same assistant response from exactly where you paused using these tool results.",
+          "Treat successful mutating tool results above as already completed actions. Do not repeat those same mutating tool calls unless the user explicitly asks to retry.",
+          "If you include meta tags, use only <thinking>, <reasoning>, <searching> for internal process.",
+          "Put the final user-facing answer outside all meta tags."
+        ].filter(Boolean).join("\n\n");
+        if (continuationPromptText.length > MAX_TOOL_REPLAY_PAYLOAD_CHARS) {
+          setActiveToolCalls([]);
+          setIsLoading(false);
+          setError({
+            message: "Tool result payload is too large to continue safely in a single turn. Narrow the query or fetch steps in chunks.",
+            code: "TOOL_REPLAY_TOO_LARGE"
+          });
+          return;
+        }
+        newMessages.push({
+          role: "user",
+          content: [
+            {
+              type: "text",
+              text: continuationPromptText
+            }
+          ]
+        });
+        if (toolContinuationCountRef.current >= MAX_TOOL_CONTINUATIONS_PER_TURN) {
+          setActiveToolCalls([]);
+          setIsLoading(false);
+          setError({
+            message: "Tool continuation limit reached for this response. Please refine the prompt and retry.",
+            code: "TOOL_CONTINUATION_LIMIT"
+          });
+          return;
+        }
+        toolContinuationCountRef.current += 1;
+        if (!streamIdleRef.current) {
+          yield waitForStreamIdle(1e4);
+        }
+        if (!streamIdleRef.current) {
+          suppressAbortHistoryUpdateRef.current = true;
+          try {
+            stop(lastController);
+            yield waitForStreamIdle(3e3);
+          } finally {
+            suppressAbortHistoryUpdateRef.current = false;
+          }
+        }
+        if (!streamIdleRef.current) {
+          setActiveToolCalls([]);
+          setIsLoading(false);
+          setError({
+            message: "Timed out waiting for the previous stream to settle before tool continuation.",
+            code: "TOOL_CONTINUATION_WAIT_TIMEOUT"
+          });
+          return;
+        }
+        const newController = new AbortController();
+        setLastController(newController);
+        const continuationKey = lastKeyRef.current;
+        if (continuationKey) {
+          const continuationBase = ((_c = latestHistoryRef.current[continuationKey]) == null ? void 0 : _c.content) || "";
+          activeStreamAppendBaseRef.current = continuationBase.trim().length > 0 ? { key: continuationKey, base: continuationBase } : null;
+        } else {
+          activeStreamAppendBaseRef.current = null;
+        }
+        send(
+          "",
+          newMessages,
+          [
+            ...dataWithExtras(),
+            {
+              key: "--messages",
+              data: newMessages.length.toString()
+            }
+          ],
+          true,
+          true,
+          service,
+          currentConversation,
+          newController,
+          void 0,
+          (errorMsg) => {
+            setActiveToolCalls([]);
+            setIsLoading(false);
+            setError({
+              message: errorMsg,
+              code: "TOOL_ERROR"
+            });
+          }
+        );
+      } finally {
+        toolRequestProcessingRef.current = false;
+        const queued = queuedToolRequestsRef.current;
+        if (queued && queued.length > 0) {
+          queuedToolRequestsRef.current = null;
+          queueMicrotask(() => {
+            void processGivenToolRequests(queued);
+          });
+        }
+      }
+    }),
+    [
+      toolList,
+      localToolExecutors,
+      publicAPIUrl,
+      buildMcpRequestHeaders,
+      dataWithExtras,
+      send,
+      service,
+      currentConversation,
+      setActiveToolCalls,
+      getToolCallSignature,
+      traceContextMode,
+      idle,
+      stop,
+      lastController,
+      waitForStreamIdle
+    ]
+  );
+  const handleToolApproval = useCallback2(
+    (toolName, scope) => {
+      const normalizedToolName = normalizeToolName(toolName);
+      if (!normalizedToolName) return;
+      if (scope === "session" || scope === "always") {
+        setSessionApprovedTools((prev) => Array.from(/* @__PURE__ */ new Set([...prev, normalizedToolName])));
+      }
+      if (scope === "always") {
+        setAlwaysApprovedTools((prev) => Array.from(/* @__PURE__ */ new Set([...prev, normalizedToolName])));
+      }
+      const requestsToRun = (pendingToolRequestsRef.current || []).filter(
+        (r) => normalizeToolName(r.toolName) === normalizedToolName
+      );
+      void processGivenToolRequests(requestsToRun);
+      setPendingToolRequests(
+        (prev) => prev.filter((r) => normalizeToolName(r.toolName) !== normalizedToolName)
+      );
+    },
+    [processGivenToolRequests, normalizeToolName]
+  );
+  useEffect8(() => {
+    if (pendingToolRequests.length === 0) return;
+    const configuredAutoApproveTools = Array.isArray(autoApproveTools) ? new Set(
+      autoApproveTools.map((toolName) => normalizeToolName(String(toolName))).filter(Boolean)
+    ) : null;
+    const toAuto = pendingToolRequests.filter(
+      (r) => {
+        const normalized = normalizeToolName(r.toolName);
+        if (!normalized) return false;
+        if (autoApproveTools === true) return true;
+        if (configuredAutoApproveTools == null ? void 0 : configuredAutoApproveTools.has(normalized)) return true;
+        return sessionApprovedTools.includes(normalized) || alwaysApprovedTools.includes(normalized);
+      }
+    );
+    if (toAuto.length > 0) {
+      void processGivenToolRequests(toAuto);
+      setPendingToolRequests(
+        (prev) => prev.filter(
+          (r) => {
+            const normalized = normalizeToolName(r.toolName);
+            if (!normalized) return true;
+            if (autoApproveTools === true) return false;
+            if (configuredAutoApproveTools == null ? void 0 : configuredAutoApproveTools.has(normalized)) return false;
+            return !sessionApprovedTools.includes(normalized) && !alwaysApprovedTools.includes(normalized);
+          }
+        )
+      );
+    }
+  }, [
+    autoApproveTools,
+    pendingToolRequests,
+    sessionApprovedTools,
+    alwaysApprovedTools,
+    processGivenToolRequests,
+    normalizeToolName
+  ]);
   const cleanContentForDisplay = useCallback2((content) => {
     let cleaned = content.replace(/\*\*(.*?)\*\*/g, "$1").replace(/\*(.*?)\*/g, "$1").replace(/\n+/g, " ").replace(/\s+/g, " ").trim();
     if (cleaned.length > 100) {
@@ -4553,7 +6372,6 @@ var AIChatPanel = ({
     return cleaned || "Thinking";
   }, []);
   const processThinkingTags = useCallback2((text) => {
-    var _a2, _b, _c;
     if (!text) {
       return {
         cleanedText: "",
@@ -4563,30 +6381,28 @@ var AIChatPanel = ({
       };
     }
     const processedText = text.replace(/\u200B/g, "");
-    const allMatches = [];
-    const thinkingRegex = /<thinking>([\s\S]*?)<\/thinking>/gi;
-    let match;
-    while ((match = thinkingRegex.exec(processedText)) !== null) {
-      const content = (_a2 = match[1]) == null ? void 0 : _a2.trim();
-      if (content) {
-        allMatches.push({ content, index: match.index, type: "thinking" });
-      }
-    }
-    const reasoningRegex = /<reasoning>([\s\S]*?)<\/reasoning>/gi;
-    while ((match = reasoningRegex.exec(processedText)) !== null) {
-      const content = (_b = match[1]) == null ? void 0 : _b.trim();
-      if (content) {
-        allMatches.push({ content, index: match.index, type: "reasoning" });
-      }
-    }
-    const searchingRegex = /<searching>([\s\S]*?)<\/searching>/gi;
-    while ((match = searchingRegex.exec(processedText)) !== null) {
-      const content = (_c = match[1]) == null ? void 0 : _c.trim();
-      if (content) {
-        allMatches.push({ content, index: match.index, type: "searching" });
+    const completedBlocks = [];
+    const textWithCompleteMarkers = processedText.replace(
+      /<(thinking|reasoning|searching)>([\s\S]*?)<\/\1>/gi,
+      (_fullMatch, rawType, rawContent, offset) => {
+        const normalizedType = String(rawType || "").trim().toLowerCase();
+        const type = normalizedType === "reasoning" ? "reasoning" : normalizedType === "searching" ? "searching" : "thinking";
+        const content = String(rawContent || "").trim();
+        if (!content) return "\n\n";
+        const signature = getThinkingBlockSignature(type, content);
+        completedBlocks.push({
+          type,
+          content,
+          index: Number(offset || 0),
+          signature
+        });
+        return `
+
+${buildThinkingBlockMarker(type, signature)}
+
+`;
       }
-    }
-    const completedBlocks = allMatches.sort((a, b) => a.index - b.index);
+    );
     let activeBlock = null;
     const tagTypes = ["thinking", "reasoning", "searching"];
     let latestIncompletePos = -1;
@@ -4616,7 +6432,7 @@ var AIChatPanel = ({
         }
       }
     }
-    let cleanedText = processedText.replace(/<thinking>[\s\S]*?<\/thinking>/gi, "").replace(/<reasoning>[\s\S]*?<\/reasoning>/gi, "").replace(/<searching>[\s\S]*?<\/searching>/gi, "").replace(/<think(?:i(?:n(?:g)?)?)?$/i, "").replace(/<reas(?:o(?:n(?:i(?:n(?:g)?)?)?)?)?$/i, "").replace(/<sear(?:c(?:h(?:i(?:n(?:g)?)?)?)?)?$/i, "").replace(/<thinking>[\s\S]*$/i, "").replace(/<reasoning>[\s\S]*$/i, "").replace(/<searching>[\s\S]*$/i, "").trim();
+    let cleanedText = textWithCompleteMarkers.replace(/<think(?:i(?:n(?:g)?)?)?$/i, "").replace(/<reas(?:o(?:n(?:i(?:n(?:g)?)?)?)?)?$/i, "").replace(/<sear(?:c(?:h(?:i(?:n(?:g)?)?)?)?)?$/i, "").replace(/<thinking>[\s\S]*$/i, "").replace(/<reasoning>[\s\S]*$/i, "").replace(/<searching>[\s\S]*$/i, "").trim();
     let lastThinkingContent = "Thinking";
     if (completedBlocks.length > 0) {
       const lastBlock = completedBlocks[completedBlocks.length - 1];
@@ -4628,15 +6444,67 @@ var AIChatPanel = ({
     }
     return { cleanedText, completedBlocks, activeBlock, lastThinkingContent };
   }, [cleanContentForDisplay]);
+  const mergeThinkingBlocks = useCallback2(
+    (existing, incoming) => {
+      if (incoming.length === 0) return existing;
+      if (existing.length === 0) return incoming;
+      const incomingSupersetPrefix = incoming.length >= existing.length && existing.every((block, index) => {
+        const next = incoming[index];
+        return !!next && next.type === block.type && next.content === block.content;
+      });
+      if (incomingSupersetPrefix) {
+        return incoming;
+      }
+      const merged = [...existing];
+      const seen = new Set(existing.map((block) => block.signature || `${block.type}::${block.content}`));
+      for (const block of incoming) {
+        const signature = block.signature || `${block.type}::${block.content}`;
+        if (seen.has(signature)) continue;
+        seen.add(signature);
+        merged.push(block);
+      }
+      return merged;
+    },
+    []
+  );
+  const getThinkingBlockCollapseKey = useCallback2((entryKey, blockKey) => {
+    return `${entryKey}::${blockKey}`;
+  }, []);
+  const getThinkingBlockRenderKey = useCallback2((block, fallbackIndex) => {
+    return String((block == null ? void 0 : block.signature) || "").trim() || `block-${fallbackIndex}`;
+  }, []);
+  const AGENT_SUGGESTION_ACTION = {
+    pattern: "\\[SUGGEST_AGENT:([^|\\]]+)\\|([^|\\]]+)\\|([^\\]]+)\\]",
+    markdown: '<agent-suggestion data-agent-id="$1" data-agent-name="$2" data-reason="$3"></agent-suggestion>'
+  };
+  const extractToolRequests = useCallback2((rawResponse) => {
+    return extractToolRequestMatchesFromText(rawResponse);
+  }, []);
+  const formatToolRequestsForDisplay = useCallback2((rawResponse) => {
+    if (!rawResponse) return rawResponse;
+    const requests = extractToolRequestMatchesFromText(rawResponse);
+    if (requests.length === 0) return stripStandaloneRawToolJsonLines(rawResponse);
+    const output = [];
+    let cursor = 0;
+    requests.forEach((request) => {
+      const start = Math.max(0, Math.min(rawResponse.length, request.start));
+      const end = Math.max(start, Math.min(rawResponse.length, request.end));
+      output.push(rawResponse.slice(cursor, start));
+      output.push(`
+
+${buildInlineToolMarker(request.toolName, request.callId)}
+
+`);
+      cursor = end;
+    });
+    output.push(rawResponse.slice(cursor));
+    return stripStandaloneRawToolJsonLines(output.join(""));
+  }, []);
   const activeThinkingBlock = useMemo2(() => {
     if (!response || justReset) return null;
     const { activeBlock } = processThinkingTags(response);
     return activeBlock;
   }, [response, justReset, processThinkingTags]);
-  const AGENT_SUGGESTION_ACTION = {
-    pattern: "\\[SUGGEST_AGENT:([^|\\]]+)\\|([^|\\]]+)\\|([^\\]]+)\\]",
-    markdown: '<agent-suggestion data-agent-id="$1" data-agent-name="$2" data-reason="$3"></agent-suggestion>'
-  };
   const processActions = useCallback2((content) => {
     const allActions = [AGENT_SUGGESTION_ACTION, ...actions || []];
     let processed = content;
@@ -4670,6 +6538,38 @@ var AIChatPanel = ({
     }
     return displayPrompt;
   }, [hideRagContextInPrompt]);
+  const normalizeHistoryPromptForContext = useCallback2((historyPrompt) => {
+    let promptForHistory = String(historyPrompt || "");
+    const isoTimestampRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z:/;
+    if (isoTimestampRegex.test(promptForHistory)) {
+      const colonIndex = promptForHistory.indexOf(":", 19);
+      promptForHistory = promptForHistory.substring(colonIndex + 1);
+    } else if (/^\d+:/.test(promptForHistory)) {
+      const colonIndex = promptForHistory.indexOf(":");
+      promptForHistory = promptForHistory.substring(colonIndex + 1);
+    }
+    return promptForHistory;
+  }, []);
+  const buildAssistantContextContent = useCallback2(
+    (historyPrompt, historyEntry) => {
+      const assistantBaseContent = typeof (historyEntry == null ? void 0 : historyEntry.content) === "string" ? historyEntry.content : "";
+      if (traceContextMode !== "full") {
+        return assistantBaseContent;
+      }
+      const traceSummary = buildCompactTraceSummary({
+        reasoningBlocks: thinkingBlocksByKeyRef.current[historyPrompt] || [],
+        toolCalls: historyEntry == null ? void 0 : historyEntry.toolCalls,
+        toolResponses: historyEntry == null ? void 0 : historyEntry.toolResponses
+      });
+      if (!traceSummary) {
+        return assistantBaseContent;
+      }
+      return assistantBaseContent ? `${assistantBaseContent}
+
+${traceSummary}` : traceSummary;
+    },
+    [traceContextMode]
+  );
   const interactionClicked = useCallback2((callId, action, emailaddress = "", comment = "") => __async(void 0, null, function* () {
     var _a2, _b;
     console.log(`[AIChatPanel] Interaction: ${action} for callId: ${callId}`);
@@ -4752,9 +6652,24 @@ var AIChatPanel = ({
     lastScrollTimeRef.current = now;
   }, []);
   const continueChat = useCallback2((promptText) => {
+    handledToolCallSignaturesRef.current = /* @__PURE__ */ new Set();
+    inFlightToolCallSignaturesRef.current = /* @__PURE__ */ new Set();
+    toolContinuationCountRef.current = 0;
+    activeStreamAppendBaseRef.current = null;
+    toolReplaySummariesByKeyRef.current = {};
+    setPendingToolRequests([]);
+    setActiveToolCalls([]);
+    setCollapsedBlocks((prev) => {
+      const next = new Set(prev);
+      Object.entries(thinkingBlocksByKeyRef.current).forEach(([entryKey, blocks]) => {
+        blocks.forEach((block, index) => {
+          next.add(getThinkingBlockCollapseKey(entryKey, getThinkingBlockRenderKey(block, index)));
+        });
+      });
+      return next;
+    });
     setThinkingBlocks([]);
     setCurrentThinkingIndex(0);
-    setCollapsedBlocks(/* @__PURE__ */ new Set());
     hasAutoCollapsedRef.current = false;
     prevBlockCountRef.current = 0;
     setError(null);
@@ -4783,6 +6698,7 @@ var AIChatPanel = ({
     setHistory((prevHistory) => __spreadProps(__spreadValues({}, prevHistory), {
       [promptKey]: { content: "", callId: "" }
     }));
+    toolReplaySummariesByKeyRef.current[promptKey] = [];
     setLastPrompt(promptToSend.trim());
     setLastKey(promptKey);
     setTimeout(() => {
@@ -4791,20 +6707,14 @@ var AIChatPanel = ({
     console.log("AIChatPanel.continueChat - about to call ensureConversation");
     ensureConversation().then((convId) => {
       console.log("AIChatPanel.continueChat - ensureConversation resolved with:", convId);
+      const historyForCall = latestHistoryRef.current || {};
       const messagesAndHistory = [];
-      Object.entries(history).forEach(([historyPrompt, historyEntry]) => {
+      Object.entries(historyForCall).forEach(([historyPrompt, historyEntry]) => {
         if (historyPrompt === promptKey) return;
-        let promptForHistory = historyPrompt;
-        const isoTimestampRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z:/;
-        if (isoTimestampRegex.test(historyPrompt)) {
-          const colonIndex = historyPrompt.indexOf(":", 19);
-          promptForHistory = historyPrompt.substring(colonIndex + 1);
-        } else if (/^\d+:/.test(historyPrompt)) {
-          const colonIndex = historyPrompt.indexOf(":");
-          promptForHistory = historyPrompt.substring(colonIndex + 1);
-        }
+        const promptForHistory = normalizeHistoryPromptForContext(historyPrompt);
+        const assistantContextContent = buildAssistantContextContent(historyPrompt, historyEntry);
         messagesAndHistory.push({ role: "user", content: promptForHistory });
-        messagesAndHistory.push({ role: "assistant", content: historyEntry.content });
+        messagesAndHistory.push({ role: "assistant", content: assistantContextContent });
       });
       let fullPromptToSend = promptToSend.trim();
       if (messagesAndHistory.length === 0 && promptTemplate) {
@@ -4812,6 +6722,19 @@ var AIChatPanel = ({
       }
       const newController = new AbortController();
       setLastController(newController);
+      if (onBeforeSend) {
+        void Promise.resolve(
+          onBeforeSend({
+            prompt: promptToSend.trim(),
+            conversationId: convId || null,
+            agentId: agent,
+            service,
+            messages: messagesAndHistory
+          })
+        ).catch((error2) => {
+          console.warn("[AIChatPanel] onBeforeSend callback failed:", error2);
+        });
+      }
       send(
         fullPromptToSend,
         messagesAndHistory,
@@ -4834,14 +6757,21 @@ var AIChatPanel = ({
           console.log("[AIChatPanel] Error callback triggered:", errorMsg);
           const isAbortError = errorMsg.toLowerCase().includes("abort") || errorMsg.toLowerCase().includes("canceled") || errorMsg.toLowerCase().includes("cancelled");
           if (isAbortError) {
+            if (suppressAbortHistoryUpdateRef.current) {
+              setIsLoading(false);
+              return;
+            }
             console.log("[AIChatPanel] Request was aborted by user");
             if (promptKey) {
-              setHistory((prev) => __spreadProps(__spreadValues({}, prev), {
-                [promptKey]: {
-                  content: "Response canceled",
-                  callId: lastCallId || ""
-                }
-              }));
+              setHistory((prev) => {
+                const existingEntry = prev[promptKey] || { content: "", callId: "" };
+                return __spreadProps(__spreadValues({}, prev), {
+                  [promptKey]: __spreadProps(__spreadValues({}, existingEntry), {
+                    content: "Response canceled",
+                    callId: lastCallId || existingEntry.callId || ""
+                  })
+                });
+              });
             }
           } else if (errorMsg.includes("413") || errorMsg.toLowerCase().includes("content too large")) {
             setError({
@@ -4849,12 +6779,15 @@ var AIChatPanel = ({
               code: "413"
             });
             if (promptKey) {
-              setHistory((prev) => __spreadProps(__spreadValues({}, prev), {
-                [promptKey]: {
-                  content: `Error: ${errorMsg}`,
-                  callId: lastCallId || ""
-                }
-              }));
+              setHistory((prev) => {
+                const existingEntry = prev[promptKey] || { content: "", callId: "" };
+                return __spreadProps(__spreadValues({}, prev), {
+                  [promptKey]: __spreadProps(__spreadValues({}, existingEntry), {
+                    content: `Error: ${errorMsg}`,
+                    callId: lastCallId || existingEntry.callId || ""
+                  })
+                });
+              });
             }
           } else if (errorMsg.toLowerCase().includes("network error") || errorMsg.toLowerCase().includes("fetch")) {
             setError({
@@ -4862,12 +6795,15 @@ var AIChatPanel = ({
               code: "NETWORK_ERROR"
             });
             if (promptKey) {
-              setHistory((prev) => __spreadProps(__spreadValues({}, prev), {
-                [promptKey]: {
-                  content: `Error: ${errorMsg}`,
-                  callId: lastCallId || ""
-                }
-              }));
+              setHistory((prev) => {
+                const existingEntry = prev[promptKey] || { content: "", callId: "" };
+                return __spreadProps(__spreadValues({}, prev), {
+                  [promptKey]: __spreadProps(__spreadValues({}, existingEntry), {
+                    content: `Error: ${errorMsg}`,
+                    callId: lastCallId || existingEntry.callId || ""
+                  })
+                });
+              });
             }
           } else {
             setError({
@@ -4875,12 +6811,15 @@ var AIChatPanel = ({
               code: "UNKNOWN_ERROR"
             });
             if (promptKey) {
-              setHistory((prev) => __spreadProps(__spreadValues({}, prev), {
-                [promptKey]: {
-                  content: `Error: ${errorMsg}`,
-                  callId: lastCallId || ""
-                }
-              }));
+              setHistory((prev) => {
+                const existingEntry = prev[promptKey] || { content: "", callId: "" };
+                return __spreadProps(__spreadValues({}, prev), {
+                  [promptKey]: __spreadProps(__spreadValues({}, existingEntry), {
+                    content: `Error: ${errorMsg}`,
+                    callId: lastCallId || existingEntry.callId || ""
+                  })
+                });
+              });
             }
           }
           setIsLoading(false);
@@ -4902,14 +6841,20 @@ var AIChatPanel = ({
     lastCallId,
     processThinkingTags,
     clearFollowOnQuestionsNextPrompt,
-    history,
     promptTemplate,
     send,
     service,
+    agent,
     ensureConversation,
+    normalizeHistoryPromptForContext,
+    buildAssistantContextContent,
+    traceContextMode,
     dataWithExtras,
     scrollToBottom,
     onConversationCreated,
+    onBeforeSend,
+    getThinkingBlockCollapseKey,
+    getThinkingBlockRenderKey,
     setResponse
   ]);
   const handleSuggestionClick = useCallback2((question) => {
@@ -4937,6 +6882,14 @@ var AIChatPanel = ({
     setLastKey(null);
     setIsLoading(false);
     setCurrentConversation(null);
+    thinkingBlocksByKeyRef.current = {};
+    setThinkingBlocksByKey({});
+    handledToolCallSignaturesRef.current = /* @__PURE__ */ new Set();
+    inFlightToolCallSignaturesRef.current = /* @__PURE__ */ new Set();
+    toolContinuationCountRef.current = 0;
+    activeStreamAppendBaseRef.current = null;
+    toolReplaySummariesByKeyRef.current = {};
+    setPendingToolRequests([]);
     setFollowOnQuestionsState(followOnQuestions);
     setThinkingBlocks([]);
     setCurrentThinkingIndex(0);
@@ -4947,6 +6900,7 @@ var AIChatPanel = ({
     setLastController(new AbortController());
     setUserHasScrolled(false);
     setError(null);
+    setActiveToolCalls([]);
     setTimeout(() => {
       var _a2;
       setJustReset(false);
@@ -4955,43 +6909,85 @@ var AIChatPanel = ({
   }, [newConversationConfirm, idle, stop, lastController, setResponse, followOnQuestions]);
   useEffect8(() => {
     if (!response || !lastKey || justReset) return;
-    const { cleanedText, completedBlocks } = processThinkingTags(response);
-    setThinkingBlocks(completedBlocks);
-    if (completedBlocks.length > prevBlockCountRef.current) {
+    const extractedToolRequests = extractToolRequests(response);
+    const seenToolCallSignatures = /* @__PURE__ */ new Set();
+    const unseenToolRequests = extractedToolRequests.filter((request) => {
+      const callSignature = getToolCallSignature(request.toolName, request.callId);
+      if (!callSignature) return false;
+      if (seenToolCallSignatures.has(callSignature)) return false;
+      seenToolCallSignatures.add(callSignature);
+      if (handledToolCallSignaturesRef.current.has(callSignature)) return false;
+      if (inFlightToolCallSignaturesRef.current.has(callSignature)) return false;
+      return true;
+    });
+    setPendingToolRequests((prev) => {
+      if (areToolRequestListsEqual(prev, unseenToolRequests)) {
+        return prev;
+      }
+      return unseenToolRequests;
+    });
+    const responseWithInlineToolLabels = formatToolRequestsForDisplay(response);
+    const { cleanedText: parsedCleanedText, completedBlocks } = processThinkingTags(responseWithInlineToolLabels);
+    const cleanedText = parsedCleanedText.trim();
+    const existingBlocks = thinkingBlocksByKeyRef.current[lastKey] || [];
+    const mergedBlocks = mergeThinkingBlocks(existingBlocks, completedBlocks);
+    thinkingBlocksByKeyRef.current[lastKey] = mergedBlocks;
+    setThinkingBlocksByKey((prev) => {
+      const existing = prev[lastKey];
+      const isSame = !!existing && existing.length === mergedBlocks.length && existing.every(
+        (block, index) => {
+          var _a2, _b;
+          return block.type === ((_a2 = mergedBlocks[index]) == null ? void 0 : _a2.type) && block.content === ((_b = mergedBlocks[index]) == null ? void 0 : _b.content);
+        }
+      );
+      if (isSame) return prev;
+      return __spreadProps(__spreadValues({}, prev), {
+        [lastKey]: mergedBlocks
+      });
+    });
+    setThinkingBlocks(mergedBlocks);
+    setCurrentThinkingIndex(Math.max(0, mergedBlocks.length - 1));
+    if (mergedBlocks.length > prevBlockCountRef.current) {
       setCollapsedBlocks((prev) => {
         const next = new Set(prev);
-        for (let i = 0; i < completedBlocks.length - 1; i++) {
-          next.add(`block-${i}`);
+        for (let i = 0; i < mergedBlocks.length - 1; i++) {
+          const block = mergedBlocks[i];
+          if (!block) continue;
+          next.add(getThinkingBlockCollapseKey(lastKey, getThinkingBlockRenderKey(block, i)));
         }
         return next;
       });
-      prevBlockCountRef.current = completedBlocks.length;
-    }
-    const hasMainContent = cleanedText.trim().length > 0;
-    const hasThinkingContent = completedBlocks.length > 0 || processThinkingTags(response).activeBlock !== null;
-    if (hasMainContent && hasThinkingContent && !hasAutoCollapsedRef.current) {
-      hasAutoCollapsedRef.current = true;
-      setTimeout(() => {
-        setCollapsedBlocks((prev) => {
-          const next = new Set(prev);
-          completedBlocks.forEach((_, index) => next.add(`block-${index}`));
-          next.add("active");
-          return next;
-        });
-      }, 500);
+      prevBlockCountRef.current = mergedBlocks.length;
     }
     setHistory((prev) => {
       const newHistory = __spreadValues({}, prev);
-      newHistory[lastKey] = {
-        content: cleanedText,
-        // Store raw content, not processed
-        callId: lastCallId || ""
-      };
+      const existingEntry = newHistory[lastKey] || { content: "", callId: "" };
+      const appendBase = activeStreamAppendBaseRef.current;
+      const mergedContinuationContent = appendBase && appendBase.key === lastKey ? mergeContinuationResponseText(appendBase.base, cleanedText) : cleanedText;
+      const existingContent = typeof existingEntry.content === "string" ? existingEntry.content : "";
+      const nextContent = appendBase && appendBase.key === lastKey && existingContent.length > mergedContinuationContent.length ? existingContent : shouldPreserveBoundaryDroppedStreamText(existingContent, mergedContinuationContent) ? existingContent : mergedContinuationContent;
+      newHistory[lastKey] = __spreadProps(__spreadValues({}, existingEntry), {
+        content: nextContent,
+        // Store raw content without tool JSON or thinking tags
+        callId: lastCallId || existingEntry.callId || ""
+      });
       latestHistoryRef.current = newHistory;
       return newHistory;
     });
-  }, [response, lastKey, lastCallId, processThinkingTags, justReset]);
+  }, [
+    response,
+    lastKey,
+    lastCallId,
+    processThinkingTags,
+    justReset,
+    extractToolRequests,
+    getToolCallSignature,
+    getThinkingBlockCollapseKey,
+    getThinkingBlockRenderKey,
+    formatToolRequestsForDisplay
+  ]);
   useEffect8(() => {
+    var _a2;
     const wasStreaming = !prevIdleRef.current;
     const isNowIdle = idle;
     prevIdleRef.current = idle;
@@ -5015,6 +7011,12 @@ var AIChatPanel = ({
     if (!isNowIdle && hasNotifiedCompletionRef.current) {
       hasNotifiedCompletionRef.current = false;
       prevResponseLengthRef.current = 0;
+      const currentLastKey = lastKeyRef.current;
+      const existingContent = currentLastKey ? ((_a2 = latestHistoryRef.current[currentLastKey]) == null ? void 0 : _a2.content) || "" : "";
+      activeStreamAppendBaseRef.current = currentLastKey && existingContent.trim().length > 0 ? {
+        key: currentLastKey,
+        base: existingContent
+      } : null;
     }
   }, [idle]);
   useEffect8(() => {
@@ -5035,21 +7037,19 @@ var AIChatPanel = ({
       scrollToBottom(true);
     }
   }, [response, idle]);
-  const idleRef = useRef6(idle);
-  idleRef.current = idle;
   useEffect8(() => {
     const scrollArea = responseAreaRef.current;
     if (!scrollArea) return;
     const scrollViewport = scrollArea.querySelector(".ai-scroll-area-viewport");
     const scrollElement = scrollViewport || scrollArea;
     const handleWheel = (e) => {
-      if (idleRef.current) return;
+      if (streamIdleRef.current) return;
       if (e.deltaY < 0 && !userHasScrolledRef.current) {
         setUserHasScrolled(true);
       }
     };
     const handleScroll = () => {
-      if (idleRef.current || !userHasScrolledRef.current) return;
+      if (streamIdleRef.current || !userHasScrolledRef.current) return;
       const scrollHeight = scrollElement.scrollHeight;
       const currentScrollTop = scrollElement.scrollTop;
       const clientHeight = scrollElement.clientHeight;
@@ -5066,7 +7066,12 @@ var AIChatPanel = ({
     };
   }, []);
   useEffect8(() => {
-    setFollowOnQuestionsState(followOnQuestions);
+    setFollowOnQuestionsState((prev) => {
+      if (prev.length === followOnQuestions.length && prev.every((question, index) => question === followOnQuestions[index])) {
+        return prev;
+      }
+      return followOnQuestions;
+    });
   }, [followOnQuestions]);
   useEffect8(() => {
     const currentlyLoading = isLoading || !idle;
@@ -5084,10 +7089,11 @@ var AIChatPanel = ({
       const currentLastKey = lastKeyRef.current;
       const currentLastCallId = lastCallIdRef.current;
       if (currentLastKey && currentResponse) {
-        currentHistory[currentLastKey] = {
+        const existingEntry = currentHistory[currentLastKey] || { content: "", callId: "" };
+        currentHistory[currentLastKey] = __spreadProps(__spreadValues({}, existingEntry), {
           content: currentResponse + "\n\n(response interrupted)",
-          callId: currentLastCallId || ""
-        };
+          callId: currentLastCallId || existingEntry.callId || ""
+        });
       }
       if (historyCallbackRef.current && Object.keys(currentHistory).length > 0 && !hasNotifiedCompletionRef.current) {
         historyCallbackRef.current(currentHistory);
@@ -5124,12 +7130,15 @@ var AIChatPanel = ({
           code: "413"
         });
         if (lastKey) {
-          setHistory((prev) => __spreadProps(__spreadValues({}, prev), {
-            [lastKey]: {
-              content: `Error: ${errorMessage}`,
-              callId: lastCallId || ""
-            }
-          }));
+          setHistory((prev) => {
+            const existingEntry = prev[lastKey] || { content: "", callId: "" };
+            return __spreadProps(__spreadValues({}, prev), {
+              [lastKey]: __spreadProps(__spreadValues({}, existingEntry), {
+                content: `Error: ${errorMessage}`,
+                callId: lastCallId || existingEntry.callId || ""
+              })
+            });
+          });
         }
       } else if (errorMessage.toLowerCase().includes("network error") || errorMessage.toLowerCase().includes("fetch")) {
         setError({
@@ -5137,12 +7146,15 @@ var AIChatPanel = ({
           code: "NETWORK_ERROR"
         });
         if (lastKey) {
-          setHistory((prev) => __spreadProps(__spreadValues({}, prev), {
-            [lastKey]: {
-              content: `Error: ${errorMessage}`,
-              callId: lastCallId || ""
-            }
-          }));
+          setHistory((prev) => {
+            const existingEntry = prev[lastKey] || { content: "", callId: "" };
+            return __spreadProps(__spreadValues({}, prev), {
+              [lastKey]: __spreadProps(__spreadValues({}, existingEntry), {
+                content: `Error: ${errorMessage}`,
+                callId: lastCallId || existingEntry.callId || ""
+              })
+            });
+          });
         }
       } else {
         setError({
@@ -5150,12 +7162,15 @@ var AIChatPanel = ({
           code: "UNKNOWN_ERROR"
         });
         if (lastKey) {
-          setHistory((prev) => __spreadProps(__spreadValues({}, prev), {
-            [lastKey]: {
-              content: `Error: ${errorMessage}`,
-              callId: lastCallId || ""
-            }
-          }));
+          setHistory((prev) => {
+            const existingEntry = prev[lastKey] || { content: "", callId: "" };
+            return __spreadProps(__spreadValues({}, prev), {
+              [lastKey]: __spreadProps(__spreadValues({}, existingEntry), {
+                content: `Error: ${errorMessage}`,
+                callId: lastCallId || existingEntry.callId || ""
+              })
+            });
+          });
         }
       }
       setIsLoading(false);
@@ -5286,47 +7301,220 @@ var AIChatPanel = ({
       );
     }
   }), [CodeBlock, AgentSuggestionCard]);
-  const renderThinkingBlocks = useCallback2((isStreaming = false) => {
-    const hasActiveBlock = activeThinkingBlock !== null;
-    const hasCompletedBlocks = thinkingBlocks.length > 0;
-    if (!hasActiveBlock && !hasCompletedBlocks) return null;
-    const handleToggleCollapse = (blockKey) => {
-      setCollapsedBlocks((prev) => {
-        const next = new Set(prev);
-        if (next.has(blockKey)) {
-          next.delete(blockKey);
-        } else {
-          next.add(blockKey);
+  const toggleThinkingBlockCollapsed = useCallback2((entryKey, blockKey) => {
+    const collapseKey = getThinkingBlockCollapseKey(entryKey, blockKey);
+    setCollapsedBlocks((prev) => {
+      const next = new Set(prev);
+      if (next.has(collapseKey)) {
+        next.delete(collapseKey);
+      } else {
+        next.add(collapseKey);
+      }
+      return next;
+    });
+  }, [getThinkingBlockCollapseKey]);
+  const renderThinkingBlockCard = (entryKey, block, blockKey, renderKey, isStreaming) => {
+    const collapseKey = getThinkingBlockCollapseKey(entryKey, blockKey);
+    return /* @__PURE__ */ React14.createElement(
+      ThinkingBlock,
+      {
+        key: renderKey,
+        type: block.type,
+        content: block.content,
+        isStreaming,
+        isCollapsed: collapsedBlocks.has(collapseKey),
+        onToggleCollapse: () => toggleThinkingBlockCollapsed(entryKey, blockKey)
+      }
+    );
+  };
+  const renderActiveThinkingBlock = (entryKey, activeBlock, keyPrefix) => {
+    if (!activeBlock) return null;
+    return /* @__PURE__ */ React14.createElement("div", { className: "ai-chat-inline-thinking-events" }, renderThinkingBlockCard(entryKey, activeBlock, "active", `${keyPrefix}-active`, true));
+  };
+  const panelClasses = ["ai-chat-panel", theme === "dark" ? "dark-theme" : ""].filter(Boolean).join(" ");
+  const getToolStatusRank = (status) => {
+    switch (status) {
+      case "error":
+        return 4;
+      case "completed":
+        return 3;
+      case "running":
+        return 2;
+      case "pending":
+      default:
+        return 1;
+    }
+  };
+  const formatToolCallId = (callId) => {
+    const normalized = String(callId || "").trim();
+    if (normalized.length <= 22) return normalized;
+    return `${normalized.slice(0, 10)}...${normalized.slice(-8)}`;
+  };
+  const renderMarkdownContent = (content, key) => {
+    if (!content || !content.trim()) return null;
+    if (markdownClass) {
+      return /* @__PURE__ */ React14.createElement("div", { key, className: markdownClass }, /* @__PURE__ */ React14.createElement(
+        ReactMarkdown2,
+        {
+          remarkPlugins: [remarkGfm2],
+          rehypePlugins: [rehypeRaw2],
+          components: markdownComponents
+        },
+        content
+      ));
+    }
+    return /* @__PURE__ */ React14.createElement(
+      ReactMarkdown2,
+      {
+        key,
+        remarkPlugins: [remarkGfm2],
+        rehypePlugins: [rehypeRaw2],
+        components: markdownComponents
+      },
+      content
+    );
+  };
+  const renderToolStatusRow = (toolStatusRow, key) => /* @__PURE__ */ React14.createElement(
+    "div",
+    {
+      key,
+      className: `ai-chat-tool-status-row ai-chat-tool-status-row--${toolStatusRow.status}`
+    },
+    /* @__PURE__ */ React14.createElement("div", { className: "ai-chat-tool-status-row__main" }, /* @__PURE__ */ React14.createElement(ToolIcon, null), /* @__PURE__ */ React14.createElement("span", { className: "ai-chat-tool-status-row__label" }, toolStatusRow.statusLabel), /* @__PURE__ */ React14.createElement("span", { className: "ai-chat-tool-status-row__call-id" }, formatToolCallId(toolStatusRow.callId))),
+    toolStatusRow.status === "pending" && /* @__PURE__ */ React14.createElement("div", { className: "ai-chat-tool-status-row__actions" }, /* @__PURE__ */ React14.createElement(
+      Button,
+      {
+        size: "sm",
+        variant: "ghost",
+        className: "ai-chat-tool-status-row__button",
+        onClick: () => handleToolApproval(toolStatusRow.toolName, "once")
+      },
+      "once"
+    ), /* @__PURE__ */ React14.createElement(
+      Button,
+      {
+        size: "sm",
+        variant: "ghost",
+        className: "ai-chat-tool-status-row__button",
+        onClick: () => handleToolApproval(toolStatusRow.toolName, "session")
+      },
+      "session"
+    ), /* @__PURE__ */ React14.createElement(
+      Button,
+      {
+        size: "sm",
+        variant: "ghost",
+        className: "ai-chat-tool-status-row__button",
+        onClick: () => handleToolApproval(toolStatusRow.toolName, "always")
+      },
+      "always"
+    ))
+  );
+  const renderContentWithInlineToolCards = (content, toolStatusRows, thinkingBlocksForEntry, entryKey, keyPrefix) => {
+    const { parts, markers } = parseInlineToolMarkers(content);
+    const thinkingBlocksBySignature = /* @__PURE__ */ new Map();
+    thinkingBlocksForEntry.forEach((block, index) => {
+      const signature = String((block == null ? void 0 : block.signature) || "").trim() || getThinkingBlockRenderKey(block, index);
+      if (!thinkingBlocksBySignature.has(signature)) {
+        thinkingBlocksBySignature.set(signature, __spreadProps(__spreadValues({}, block), {
+          signature
+        }));
+      }
+    });
+    const pendingBySignature = /* @__PURE__ */ new Map();
+    const pendingByCallId = /* @__PURE__ */ new Map();
+    toolStatusRows.forEach((row) => {
+      if (!pendingBySignature.has(row.signature)) {
+        pendingBySignature.set(row.signature, row);
+      }
+      if (!pendingByCallId.has(row.callId)) {
+        pendingByCallId.set(row.callId, row);
+      }
+    });
+    const nodes = [];
+    parts.forEach((part, partIndex) => {
+      const { parts: thinkingParts, markers: thinkingMarkers } = parseInlineThinkingMarkers(part);
+      thinkingParts.forEach((thinkingPart, thinkingIndex) => {
+        const markdownNode = renderMarkdownContent(
+          thinkingPart,
+          `${keyPrefix}-md-${partIndex}-${thinkingIndex}`
+        );
+        if (markdownNode) {
+          nodes.push(markdownNode);
         }
-        return next;
+        const thinkingMarker = thinkingMarkers[thinkingIndex];
+        if (!thinkingMarker) return;
+        const matchedBlock = thinkingBlocksBySignature.get(thinkingMarker.signature);
+        if (!matchedBlock) return;
+        const blockKey = getThinkingBlockRenderKey(matchedBlock, thinkingIndex);
+        nodes.push(
+          /* @__PURE__ */ React14.createElement(
+            "div",
+            {
+              key: `${keyPrefix}-thinking-${partIndex}-${thinkingIndex}-${blockKey}`,
+              className: "ai-chat-inline-thinking-events"
+            },
+            renderThinkingBlockCard(
+              entryKey,
+              matchedBlock,
+              blockKey,
+              `${keyPrefix}-thinking-card-${partIndex}-${thinkingIndex}-${blockKey}`,
+              false
+            )
+          )
+        );
       });
-    };
-    return /* @__PURE__ */ React14.createElement(React14.Fragment, null, thinkingBlocks.map((block, index) => {
-      const blockKey = `block-${index}`;
-      return /* @__PURE__ */ React14.createElement(
-        ThinkingBlock,
-        {
-          key: blockKey,
-          type: block.type,
-          content: block.content,
-          isStreaming: false,
-          isCollapsed: collapsedBlocks.has(blockKey),
-          onToggleCollapse: () => handleToggleCollapse(blockKey)
+      const marker = markers[partIndex];
+      if (!marker) return;
+      const markerSignature = getToolCallSignature(marker.toolName, marker.callId);
+      const matchedRow = (markerSignature ? pendingBySignature.get(markerSignature) : void 0) || pendingByCallId.get(marker.callId);
+      const fallbackSignature = markerSignature || getToolCallSignature(marker.toolName, `${marker.callId}-${partIndex + 1}`) || `${marker.toolName}::${marker.callId}::${partIndex}`;
+      const rowToRender = matchedRow || {
+        signature: fallbackSignature,
+        toolName: marker.toolName,
+        callId: marker.callId,
+        status: "running",
+        statusLabel: `tool call ${marker.toolName} running`
+      };
+      if (matchedRow) {
+        pendingBySignature.delete(matchedRow.signature);
+        const pendingByCallIdMatch = pendingByCallId.get(matchedRow.callId);
+        if ((pendingByCallIdMatch == null ? void 0 : pendingByCallIdMatch.signature) === matchedRow.signature) {
+          pendingByCallId.delete(matchedRow.callId);
         }
-      );
-    }), activeThinkingBlock && /* @__PURE__ */ React14.createElement(
-      ThinkingBlock,
-      {
-        key: "active-streaming",
-        type: activeThinkingBlock.type,
-        content: activeThinkingBlock.content,
-        isStreaming: true,
-        isCollapsed: collapsedBlocks.has("active"),
-        onToggleCollapse: () => handleToggleCollapse("active")
       }
-    ));
-  }, [thinkingBlocks, activeThinkingBlock, collapsedBlocks]);
-  const panelClasses = ["ai-chat-panel", theme === "dark" ? "dark-theme" : ""].filter(Boolean).join(" ");
+      nodes.push(
+        /* @__PURE__ */ React14.createElement(
+          "div",
+          {
+            key: `${keyPrefix}-inline-${rowToRender.signature}-${partIndex}`,
+            className: "ai-chat-inline-tool-events",
+            role: "status",
+            "aria-live": "polite"
+          },
+          renderToolStatusRow(rowToRender, `${keyPrefix}-row-${rowToRender.signature}-${partIndex}`)
+        )
+      );
+    });
+    const unmatchedRows = Array.from(pendingBySignature.values());
+    if (unmatchedRows.length > 0) {
+      nodes.push(
+        /* @__PURE__ */ React14.createElement(
+          "div",
+          {
+            key: `${keyPrefix}-tail`,
+            className: "ai-chat-inline-tool-events ai-chat-inline-tool-events--tail",
+            role: "status",
+            "aria-live": "polite"
+          },
+          unmatchedRows.map(
+            (row, rowIndex) => renderToolStatusRow(row, `${keyPrefix}-tail-${row.signature}-${rowIndex}`)
+          )
+        )
+      );
+    }
+    return /* @__PURE__ */ React14.createElement(React14.Fragment, null, nodes);
+  };
   return /* @__PURE__ */ React14.createElement(
     "div",
     {
@@ -5359,47 +7547,114 @@ var AIChatPanel = ({
       initialMessage
     ))), Object.entries(history).map(([prompt, entry], index, entries) => {
       const isLastEntry = index === entries.length - 1;
+      const isStreamingEntry = isLastEntry && (isLoading || !idle) && !justReset;
+      const continuationAppendBase = isStreamingEntry && activeStreamAppendBaseRef.current && activeStreamAppendBaseRef.current.key === prompt && activeStreamAppendBaseRef.current.base.trim().length > 0 ? activeStreamAppendBaseRef.current : null;
+      const isContinuationStreamingEntry = !!continuationAppendBase;
       const isSystemMessage = prompt.startsWith("__system__:");
       const { cleanedText } = processThinkingTags(entry.content);
       const processedContent = processActions(cleanedText);
-      return /* @__PURE__ */ React14.createElement("div", { key: index, className: "ai-chat-entry" }, !(hideInitialPrompt && index === 0) && !isSystemMessage && /* @__PURE__ */ React14.createElement("div", { className: "ai-chat-message ai-chat-message--user" }, /* @__PURE__ */ React14.createElement("div", { className: "ai-chat-message__content" }, formatPromptForDisplay(prompt))), /* @__PURE__ */ React14.createElement("div", { className: "ai-chat-message ai-chat-message--assistant" }, /* @__PURE__ */ React14.createElement("div", { className: "ai-chat-message__content" }, isLastEntry && (isLoading || !idle) && !justReset ? (() => {
-        const { cleanedText: streamingCleanedText } = processThinkingTags(response || "");
-        const streamingContent = processActions(streamingCleanedText);
+      const entryThinkingBlocks = thinkingBlocksByKey[prompt] || [];
+      const statusBySignature = /* @__PURE__ */ new Map();
+      const upsertToolStatus = (row) => {
+        const existing = statusBySignature.get(row.signature);
+        if (!existing || getToolStatusRank(row.status) >= getToolStatusRank(existing.status)) {
+          statusBySignature.set(row.signature, row);
+        }
+      };
+      const entryToolCalls = Array.isArray(entry.toolCalls) ? entry.toolCalls : [];
+      const entryToolResponses = Array.isArray(entry.toolResponses) ? entry.toolResponses : [];
+      entryToolCalls.forEach((toolCall, toolIndex) => {
+        const toolName = String((toolCall == null ? void 0 : toolCall.name) || "").trim() || "tool";
+        const callId = String((toolCall == null ? void 0 : toolCall.id) || "").trim() || `${toolName}-${toolIndex + 1}`;
+        const signature = getToolCallSignature(toolName, callId) || `completed-${prompt}-${toolIndex}-${toolName}-${callId}`;
+        const matchedResponse = entryToolResponses.find((response2) => String((response2 == null ? void 0 : response2.tool_call_id) || "").trim() === callId) || entryToolResponses[toolIndex];
+        const isError = Boolean(matchedResponse == null ? void 0 : matchedResponse.isError);
+        upsertToolStatus({
+          signature,
+          toolName,
+          callId,
+          status: isError ? "error" : "completed",
+          statusLabel: isError ? `tool call ${toolName} errored` : `tool call ${toolName} completed`
+        });
+      });
+      if (isLastEntry && !justReset) {
+        pendingToolRequests.forEach((request, requestIndex) => {
+          const toolName = String((request == null ? void 0 : request.toolName) || "").trim() || "tool";
+          const callId = String((request == null ? void 0 : request.callId) || "").trim() || `${toolName}-pending-${requestIndex + 1}`;
+          const signature = getToolCallSignature(toolName, callId) || `pending-${prompt}-${requestIndex}-${toolName}-${callId}`;
+          upsertToolStatus({
+            signature,
+            toolName,
+            callId,
+            status: "pending",
+            statusLabel: `tool call ${toolName} awaiting approval`
+          });
+        });
+        activeToolCalls.forEach((activeToolCall, activeIndex) => {
+          const toolName = String((activeToolCall == null ? void 0 : activeToolCall.toolName) || "").trim() || "tool";
+          const callId = String((activeToolCall == null ? void 0 : activeToolCall.callId) || "").trim() || `${toolName}-running-${activeIndex + 1}`;
+          const signature = getToolCallSignature(toolName, callId) || `running-${prompt}-${activeIndex}-${toolName}-${callId}`;
+          upsertToolStatus({
+            signature,
+            toolName,
+            callId,
+            status: "running",
+            statusLabel: `tool call ${toolName} running`
+          });
+        });
+      }
+      const entryToolStatusRows = Array.from(statusBySignature.values());
+      const hasInFlightToolStatus = entryToolStatusRows.some(
+        (row) => row.status === "pending" || row.status === "running"
+      );
+      const isActivePromptEntry = !!lastKey && prompt === lastKey;
+      const shouldShowBusyGapThinkingFallback = isActivePromptEntry && !isStreamingEntry && (isLoading || !idle) && !activeThinkingBlock && !hasInFlightToolStatus;
+      return /* @__PURE__ */ React14.createElement("div", { key: prompt, className: "ai-chat-entry" }, !(hideInitialPrompt && index === 0) && !isSystemMessage && /* @__PURE__ */ React14.createElement("div", { className: "ai-chat-message ai-chat-message--user" }, /* @__PURE__ */ React14.createElement("div", { className: "ai-chat-message__content" }, formatPromptForDisplay(prompt))), /* @__PURE__ */ React14.createElement("div", { className: "ai-chat-message ai-chat-message--assistant" }, /* @__PURE__ */ React14.createElement("div", { className: "ai-chat-message__content" }, isStreamingEntry ? (() => {
+        if (isContinuationStreamingEntry) {
+          const continuationResponseWithInlineToolLabels = formatToolRequestsForDisplay(response || "");
+          const { cleanedText: continuationCleanedText } = processThinkingTags(
+            continuationResponseWithInlineToolLabels
+          );
+          const appendBase2 = continuationAppendBase || activeStreamAppendBaseRef.current;
+          const continuationMergedText = appendBase2 && appendBase2.key === prompt ? mergeContinuationResponseText(appendBase2.base, continuationCleanedText.trim()) : continuationCleanedText;
+          const continuationDisplaySource = continuationMergedText.trim().length > 0 ? continuationMergedText : cleanedText;
+          const continuationDisplayContent = processActions(continuationDisplaySource);
+          const hasVisibleContinuationContent = continuationDisplayContent.trim().length > 0;
+          const hasFreshContinuationContent = continuationCleanedText.trim().length > 0;
+          const showThinkingFallback2 = !activeThinkingBlock && !hasFreshContinuationContent && !hasInFlightToolStatus;
+          return /* @__PURE__ */ React14.createElement("div", { className: "ai-chat-streaming" }, renderActiveThinkingBlock(prompt, activeThinkingBlock, `${prompt}-continuation`), hasVisibleContinuationContent ? /* @__PURE__ */ React14.createElement(React14.Fragment, null, renderContentWithInlineToolCards(
+            continuationDisplayContent,
+            entryToolStatusRows,
+            entryThinkingBlocks,
+            prompt,
+            `${prompt}-continuation`
+          ), showThinkingFallback2 && /* @__PURE__ */ React14.createElement("div", { className: "ai-chat-loading ai-chat-loading--inline" }, /* @__PURE__ */ React14.createElement("span", null, "Thinking"), /* @__PURE__ */ React14.createElement("span", { className: "ai-chat-loading__dots" }, /* @__PURE__ */ React14.createElement("span", { className: "ai-chat-loading__dot" }), /* @__PURE__ */ React14.createElement("span", { className: "ai-chat-loading__dot" }), /* @__PURE__ */ React14.createElement("span", { className: "ai-chat-loading__dot" })))) : /* @__PURE__ */ React14.createElement("div", { className: "ai-chat-loading" }, /* @__PURE__ */ React14.createElement("span", null, "Continuing response"), /* @__PURE__ */ React14.createElement("span", { className: "ai-chat-loading__dots" }, /* @__PURE__ */ React14.createElement("span", { className: "ai-chat-loading__dot" }), /* @__PURE__ */ React14.createElement("span", { className: "ai-chat-loading__dot" }), /* @__PURE__ */ React14.createElement("span", { className: "ai-chat-loading__dot" }))));
+        }
+        const streamingResponseWithInlineToolLabels = formatToolRequestsForDisplay(response || "");
+        const { cleanedText: streamingCleanedText } = processThinkingTags(streamingResponseWithInlineToolLabels);
+        const appendBase = activeStreamAppendBaseRef.current;
+        const streamingMergedText = appendBase && appendBase.key === prompt ? mergeContinuationResponseText(appendBase.base, streamingCleanedText.trim()) : streamingCleanedText;
+        const streamingContent = processActions(streamingMergedText);
         const hasStreamingContent = streamingContent.trim().length > 0;
-        return /* @__PURE__ */ React14.createElement("div", { className: "ai-chat-streaming" }, (thinkingBlocks.length > 0 || activeThinkingBlock) && renderThinkingBlocks(true), hasStreamingContent ? markdownClass ? /* @__PURE__ */ React14.createElement("div", { className: markdownClass }, /* @__PURE__ */ React14.createElement(
-          ReactMarkdown2,
-          {
-            remarkPlugins: [remarkGfm2],
-            rehypePlugins: [rehypeRaw2],
-            components: markdownComponents
-          },
-          streamingContent
-        )) : /* @__PURE__ */ React14.createElement(
-          ReactMarkdown2,
-          {
-            remarkPlugins: [remarkGfm2],
-            rehypePlugins: [rehypeRaw2],
-            components: markdownComponents
-          },
-          streamingContent
-        ) : /* @__PURE__ */ React14.createElement("div", { className: "ai-chat-loading" }, /* @__PURE__ */ React14.createElement("span", null, thinkingBlocks.length > 0 || activeThinkingBlock ? "Still thinking" : "Thinking"), /* @__PURE__ */ React14.createElement("span", { className: "ai-chat-loading__dots" }, /* @__PURE__ */ React14.createElement("span", { className: "ai-chat-loading__dot" }), /* @__PURE__ */ React14.createElement("span", { className: "ai-chat-loading__dot" }), /* @__PURE__ */ React14.createElement("span", { className: "ai-chat-loading__dot" }))));
-      })() : /* @__PURE__ */ React14.createElement(React14.Fragment, null, isLastEntry && thinkingBlocks.length > 0 && renderThinkingBlocks(false), markdownClass ? /* @__PURE__ */ React14.createElement("div", { className: markdownClass }, /* @__PURE__ */ React14.createElement(
-        ReactMarkdown2,
-        {
-          remarkPlugins: [remarkGfm2],
-          rehypePlugins: [rehypeRaw2],
-          components: markdownComponents
-        },
-        processedContent
-      )) : /* @__PURE__ */ React14.createElement(
-        ReactMarkdown2,
-        {
-          remarkPlugins: [remarkGfm2],
-          rehypePlugins: [rehypeRaw2],
-          components: markdownComponents
-        },
-        processedContent
-      ))), (!isLastEntry || !isLoading) && /* @__PURE__ */ React14.createElement("div", { className: "ai-chat-message__actions" }, /* @__PURE__ */ React14.createElement(
+        const hasFreshStreamingContent = streamingCleanedText.trim().length > 0;
+        const fallbackHistoryContent = processedContent.trim();
+        const streamingDisplayContent = hasStreamingContent ? streamingContent : fallbackHistoryContent;
+        const hasDisplayContent = streamingDisplayContent.trim().length > 0;
+        const showThinkingFallback = !activeThinkingBlock && !hasFreshStreamingContent && !hasInFlightToolStatus;
+        return /* @__PURE__ */ React14.createElement("div", { className: "ai-chat-streaming" }, renderActiveThinkingBlock(prompt, activeThinkingBlock, `${prompt}-streaming`), hasDisplayContent ? /* @__PURE__ */ React14.createElement(React14.Fragment, null, renderContentWithInlineToolCards(
+          streamingDisplayContent,
+          entryToolStatusRows,
+          entryThinkingBlocks,
+          prompt,
+          `${prompt}-streaming`
+        ), showThinkingFallback && /* @__PURE__ */ React14.createElement("div", { className: "ai-chat-loading ai-chat-loading--inline" }, /* @__PURE__ */ React14.createElement("span", null, "Thinking"), /* @__PURE__ */ React14.createElement("span", { className: "ai-chat-loading__dots" }, /* @__PURE__ */ React14.createElement("span", { className: "ai-chat-loading__dot" }), /* @__PURE__ */ React14.createElement("span", { className: "ai-chat-loading__dot" }), /* @__PURE__ */ React14.createElement("span", { className: "ai-chat-loading__dot" })))) : /* @__PURE__ */ React14.createElement("div", { className: "ai-chat-loading" }, /* @__PURE__ */ React14.createElement("span", null, activeThinkingBlock ? "Still thinking" : "Thinking"), /* @__PURE__ */ React14.createElement("span", { className: "ai-chat-loading__dots" }, /* @__PURE__ */ React14.createElement("span", { className: "ai-chat-loading__dot" }), /* @__PURE__ */ React14.createElement("span", { className: "ai-chat-loading__dot" }), /* @__PURE__ */ React14.createElement("span", { className: "ai-chat-loading__dot" }))));
+      })() : /* @__PURE__ */ React14.createElement(React14.Fragment, null, renderContentWithInlineToolCards(
+        processedContent,
+        entryToolStatusRows,
+        entryThinkingBlocks,
+        prompt,
+        `${prompt}-final`
+      ), shouldShowBusyGapThinkingFallback && /* @__PURE__ */ React14.createElement("div", { className: "ai-chat-loading ai-chat-loading--inline", "aria-live": "polite" }, /* @__PURE__ */ React14.createElement("span", null, "Thinking"), /* @__PURE__ */ React14.createElement("span", { className: "ai-chat-loading__dots" }, /* @__PURE__ */ React14.createElement("span", { className: "ai-chat-loading__dot" }), /* @__PURE__ */ React14.createElement("span", { className: "ai-chat-loading__dot" }), /* @__PURE__ */ React14.createElement("span", { className: "ai-chat-loading__dot" }))))), (!isLastEntry || !isLoading) && /* @__PURE__ */ React14.createElement("div", { className: "ai-chat-message__actions" }, /* @__PURE__ */ React14.createElement(
         "button",
         {
           className: "ai-chat-action-button",
@@ -5425,7 +7680,7 @@ var AIChatPanel = ({
           style: (feedbackCallId == null ? void 0 : feedbackCallId.callId) === entry.callId && (feedbackCallId == null ? void 0 : feedbackCallId.type) === "down" ? { color: "#ef4444" } : void 0
         },
         (feedbackCallId == null ? void 0 : feedbackCallId.callId) === entry.callId && (feedbackCallId == null ? void 0 : feedbackCallId.type) === "down" ? /* @__PURE__ */ React14.createElement("span", { style: { fontSize: "11px", fontWeight: 500 } }, "Thanks!") : /* @__PURE__ */ React14.createElement("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", className: "ai-chat-icon-sm" }, /* @__PURE__ */ React14.createElement("path", { d: "M10 15v4a3 3 0 0 0 3 3l4-9V2H5.72a2 2 0 0 0-2 1.7l-1.38 9a2 2 0 0 0 2 2.3zm7-13h2.67A2.31 2.31 0 0 1 22 4v7a2.31 2.31 0 0 1-2.33 2H17" }))
-      ), (entry.toolCalls || entry.toolResponses) && /* @__PURE__ */ React14.createElement(
+      ), /* @__PURE__ */ React14.createElement(
         "button",
         {
           className: "ai-chat-action-button",
@@ -5451,34 +7706,6 @@ var AIChatPanel = ({
       },
       question
     ))), /* @__PURE__ */ React14.createElement("div", { ref: bottomRef })),
-    pendingToolRequests.length > 0 && /* @__PURE__ */ React14.createElement("div", { className: "ai-chat-approve-tools-panel" }, /* @__PURE__ */ React14.createElement("div", { className: "ai-chat-approve-tools-header" }, "Tool Approval Required"), /* @__PURE__ */ React14.createElement("div", { className: "ai-chat-approve-tools-description" }, "The AI wants to use the following tools:"), getUniqueToolNames().map((toolName) => /* @__PURE__ */ React14.createElement("div", { key: toolName, className: "ai-chat-approve-tool-item" }, /* @__PURE__ */ React14.createElement("div", { className: "ai-chat-approve-tool-name" }, toolName), /* @__PURE__ */ React14.createElement("div", { className: "ai-chat-approve-tools-buttons" }, /* @__PURE__ */ React14.createElement(
-      Button,
-      {
-        size: "sm",
-        variant: "outline",
-        className: "ai-chat-approve-tools-button",
-        onClick: () => handleToolApproval(toolName, "once")
-      },
-      "Once"
-    ), /* @__PURE__ */ React14.createElement(
-      Button,
-      {
-        size: "sm",
-        variant: "outline",
-        className: "ai-chat-approve-tools-button",
-        onClick: () => handleToolApproval(toolName, "session")
-      },
-      "This Session"
-    ), /* @__PURE__ */ React14.createElement(
-      Button,
-      {
-        size: "sm",
-        variant: "default",
-        className: "ai-chat-approve-tools-button",
-        onClick: () => handleToolApproval(toolName, "always")
-      },
-      "Always"
-    ))))),
     (showSaveButton || showEmailButton || showCallToAction) && /* @__PURE__ */ React14.createElement("div", { className: "ai-chat-button-container" }, showSaveButton && /* @__PURE__ */ React14.createElement(
       Button,
       {
@@ -5614,7 +7841,7 @@ var AIChatPanel = ({
       ChatInput,
       {
         placeholder,
-        idle,
+        isBusy: isLoading || !idle,
         onSubmit: continueChat,
         onStop: handleStop,
         agentOptions,
@@ -5861,13 +8088,14 @@ var SparkleIcon = () => /* @__PURE__ */ React15.createElement("svg", { width: "1
 var normalizeConversationListPayload = (payload) => {
   if (!payload) return [];
   const conversations = Array.isArray(payload) ? payload : payload.conversations || [];
-  return conversations.map((conv) => {
+  const normalized = conversations.map((conv, index) => {
     let title = conv.title && conv.title !== "Conversation" ? conv.title : "";
     if (!title) {
       title = conv.summary || extractTitleFromConversation(conv);
     }
+    const resolvedConversationId = conv.conversationId || conv.id || conv.conversation_id || `conversation-${index}-${Date.now()}`;
     return {
-      conversationId: conv.conversationId || conv.id || conv.conversation_id,
+      conversationId: resolvedConversationId,
       title,
       summary: conv.summary,
       createdAt: conv.createdAt || conv.created_at || conv.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
@@ -5876,6 +8104,20 @@ var normalizeConversationListPayload = (payload) => {
       messageCount: conv.messageCount || conv.message_count
     };
   });
+  const dedupedById = /* @__PURE__ */ new Map();
+  for (const conv of normalized) {
+    const existing = dedupedById.get(conv.conversationId);
+    if (!existing) {
+      dedupedById.set(conv.conversationId, conv);
+      continue;
+    }
+    const existingUpdated = new Date(existing.updatedAt).getTime();
+    const incomingUpdated = new Date(conv.updatedAt).getTime();
+    if (incomingUpdated >= existingUpdated) {
+      dedupedById.set(conv.conversationId, conv);
+    }
+  }
+  return Array.from(dedupedById.values());
 };
 var extractTitleFromConversation = (conv) => {
   var _a;
@@ -5949,6 +8191,248 @@ var groupConversationsByTime = (conversations, showAllGroups = false) => {
   });
   return Object.entries(groups).filter(([_, convs]) => showAllGroups || convs.length > 0).map(([label, conversations2]) => ({ label, conversations: conversations2, count: conversations2.length }));
 };
+var toRecord = (value) => {
+  if (typeof value === "object" && value !== null) {
+    return value;
+  }
+  return null;
+};
+var toStringValue = (value) => {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  return "";
+};
+var normalizeContentText = (value) => {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (Array.isArray(value)) {
+    return value.map((item) => normalizeContentText(item)).filter(Boolean).join("\n").trim();
+  }
+  const record = toRecord(value);
+  if (!record) return "";
+  const directText = toStringValue(record.text);
+  if (directText) return directText;
+  const directValue = toStringValue(record.value);
+  if (directValue) return directValue;
+  const directContent = toStringValue(record.content);
+  if (directContent) return directContent;
+  if (Array.isArray(record.content)) {
+    return normalizeContentText(record.content);
+  }
+  if (Array.isArray(record.parts)) {
+    return normalizeContentText(record.parts);
+  }
+  if (record.content && typeof record.content === "object") {
+    return normalizeContentText(record.content);
+  }
+  return "";
+};
+var parseCallMessages = (rawMessages) => {
+  var _a, _b;
+  let parsed = rawMessages;
+  if (typeof rawMessages === "string") {
+    try {
+      parsed = JSON.parse(rawMessages);
+    } catch (e) {
+      return [];
+    }
+  }
+  const parsedRecord = toRecord(parsed);
+  if (parsedRecord && Array.isArray(parsedRecord.messages)) {
+    parsed = parsedRecord.messages;
+  }
+  if (!Array.isArray(parsed)) {
+    return [];
+  }
+  const normalized = [];
+  for (const message of parsed) {
+    const messageRecord = toRecord(message);
+    if (!messageRecord) continue;
+    const role = toStringValue(messageRecord.role).toLowerCase().trim();
+    if (!role) continue;
+    const content = normalizeContentText(
+      (_b = (_a = messageRecord.content) != null ? _a : messageRecord.text) != null ? _b : messageRecord.message
+    ).trim();
+    if (!content) continue;
+    normalized.push({ role, content });
+  }
+  return normalized;
+};
+var shouldSkipTranscriptMessage = (message) => {
+  return message.role === "system" || message.role === "user" && message.content.startsWith("__system__:");
+};
+var parseTimestampMs = (value) => {
+  const timestamp = toStringValue(value).trim();
+  if (!timestamp) return null;
+  const parsed = Date.parse(timestamp);
+  return Number.isFinite(parsed) ? parsed : null;
+};
+var getCallTimestampMs = (call, fallbackIndex) => {
+  const timestampCandidates = [
+    call.createdAt,
+    call.created_at,
+    call.timestamp,
+    call.updatedAt,
+    call.updated_at
+  ];
+  for (const candidate of timestampCandidates) {
+    const parsed = parseTimestampMs(candidate);
+    if (parsed !== null) return parsed;
+  }
+  return fallbackIndex;
+};
+var getCallId = (call) => {
+  const id = toStringValue(call.id);
+  if (id) return id;
+  return toStringValue(call.callId);
+};
+var normalizeCallsPayload = (payload) => {
+  const payloadRecord = toRecord(payload);
+  const calls = Array.isArray(payload) ? payload : payloadRecord && Array.isArray(payloadRecord.calls) ? payloadRecord.calls : [];
+  return calls.map((call) => toRecord(call)).filter((call) => call !== null);
+};
+var turnsEqual = (left, right) => {
+  return left.prompt === right.prompt && left.response === right.response;
+};
+var getPrefixMatchLength = (existing, incoming) => {
+  const max = Math.min(existing.length, incoming.length);
+  let matched = 0;
+  while (matched < max && turnsEqual(existing[matched], incoming[matched])) {
+    matched += 1;
+  }
+  return matched;
+};
+var getSuffixPrefixOverlap = (existing, incoming) => {
+  const max = Math.min(existing.length, incoming.length);
+  for (let overlap = max; overlap > 0; overlap -= 1) {
+    let matches = true;
+    for (let idx = 0; idx < overlap; idx += 1) {
+      const left = existing[existing.length - overlap + idx];
+      const right = incoming[idx];
+      if (!turnsEqual(left, right)) {
+        matches = false;
+        break;
+      }
+    }
+    if (matches) return overlap;
+  }
+  return 0;
+};
+var mergeTranscriptTurns = (existing, incoming) => {
+  if (incoming.length === 0) return existing;
+  if (existing.length === 0) return [...incoming];
+  const prefixMatchLength = getPrefixMatchLength(existing, incoming);
+  if (prefixMatchLength > 0) {
+    return [...existing, ...incoming.slice(prefixMatchLength)];
+  }
+  const overlap = getSuffixPrefixOverlap(existing, incoming);
+  if (overlap > 0) {
+    return [...existing, ...incoming.slice(overlap)];
+  }
+  return [...existing, ...incoming];
+};
+var buildTurnsFromMessages = (messages, fallbackResponse, callId, timestampMs) => {
+  const turns = [];
+  for (let index = 0; index < messages.length; index += 1) {
+    const message = messages[index];
+    if (!message || message.role !== "user") continue;
+    const prompt = message.content.trim();
+    if (!prompt) continue;
+    let response = "";
+    let reachedNextUser = false;
+    for (let lookAhead = index + 1; lookAhead < messages.length; lookAhead += 1) {
+      const nextMessage = messages[lookAhead];
+      if (!nextMessage) continue;
+      if (nextMessage.role === "assistant") {
+        response = nextMessage.content.trim();
+        index = lookAhead;
+        break;
+      }
+      if (nextMessage.role === "user") {
+        reachedNextUser = true;
+        break;
+      }
+    }
+    if (!response && !reachedNextUser) {
+      response = fallbackResponse;
+    }
+    if (!response) continue;
+    turns.push({
+      prompt,
+      response,
+      callId,
+      timestampMs
+    });
+  }
+  return turns;
+};
+var buildTranscriptTurnsFromCalls = (calls) => {
+  const orderedCalls = calls.map((call, index) => ({
+    call,
+    index,
+    timestampMs: getCallTimestampMs(call, index)
+  })).sort((left, right) => {
+    if (left.timestampMs === right.timestampMs) return left.index - right.index;
+    return left.timestampMs - right.timestampMs;
+  });
+  let mergedTurns = [];
+  for (const orderedCall of orderedCalls) {
+    const { call, timestampMs } = orderedCall;
+    const callId = getCallId(call);
+    const fallbackResponse = normalizeContentText(call.response).trim();
+    const parsedMessages = parseCallMessages(call.messages).filter(
+      (message) => !shouldSkipTranscriptMessage(message)
+    );
+    let callTurns = buildTurnsFromMessages(
+      parsedMessages,
+      fallbackResponse,
+      callId,
+      timestampMs
+    );
+    if (callTurns.length === 0) {
+      const fallbackPrompt = normalizeContentText(call.prompt).trim();
+      if (fallbackPrompt && fallbackResponse) {
+        callTurns = [
+          {
+            prompt: fallbackPrompt,
+            response: fallbackResponse,
+            callId,
+            timestampMs
+          }
+        ];
+      }
+    }
+    mergedTurns = mergeTranscriptTurns(mergedTurns, callTurns);
+  }
+  return mergedTurns;
+};
+var buildHistoryFromTranscriptTurns = (turns) => {
+  const history = {};
+  const keyUsageByPrompt = /* @__PURE__ */ new Map();
+  turns.forEach((turn, index) => {
+    var _a;
+    const prompt = turn.prompt.trim();
+    const response = turn.response.trim();
+    if (!prompt || !response) return;
+    const baseTimestampMs = Number.isFinite(turn.timestampMs) ? turn.timestampMs : index;
+    const keySeed = `${baseTimestampMs}:${prompt}`;
+    const keyUsageCount = (_a = keyUsageByPrompt.get(keySeed)) != null ? _a : 0;
+    keyUsageByPrompt.set(keySeed, keyUsageCount + 1);
+    const uniqueTimestamp = new Date(baseTimestampMs + keyUsageCount).toISOString();
+    const historyKey = `${uniqueTimestamp}:${prompt}`;
+    history[historyKey] = {
+      content: response,
+      callId: turn.callId
+    };
+  });
+  return history;
+};
+var truncatePromptForTitle = (prompt) => {
+  if (prompt.length > 60) {
+    return `${prompt.slice(0, 57)}...`;
+  }
+  return prompt;
+};
 var EMPTY_ARRAY = [];
 var EMPTY_HISTORY = {};
 var ChatPanelWrapper = ({
@@ -5982,6 +8466,7 @@ var ChatPanelWrapper = ({
   disabledSectionIds,
   onToggleSection,
   onConversationCreated,
+  onBeforeSend,
   conversationInitialPrompt,
   // New props from ChatPanel port
   cssUrl,
@@ -5998,7 +8483,11 @@ var ChatPanelWrapper = ({
   callToActionEmailAddress,
   callToActionEmailSubject,
   customerEmailCaptureMode,
-  customerEmailCapturePlaceholder
+  customerEmailCapturePlaceholder,
+  resolveMcpAuthHeaders,
+  localToolExecutors,
+  traceContextMode,
+  autoApproveTools
 }) => {
   var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
   const convAgentProfile = getAgent(activeConv.agentId);
@@ -6022,6 +8511,16 @@ var ChatPanelWrapper = ({
     },
     [onConversationCreated, activeConv.conversationId]
   );
+  const beforeSendCallback = useCallback4(
+    (payload) => {
+      if (!onBeforeSend) return;
+      return onBeforeSend(__spreadProps(__spreadValues({}, payload), {
+        conversationId: payload.conversationId || activeConv.conversationId,
+        agentId: payload.agentId || activeConv.agentId
+      }));
+    },
+    [onBeforeSend, activeConv.conversationId, activeConv.agentId]
+  );
   const agentStatus = convAgentProfile == null ? void 0 : convAgentProfile.status;
   const promptsString = (convAgentMetadata == null ? void 0 : convAgentMetadata.displayFollowOnPrompts) || "";
   let effectiveFollowOnQuestions;
@@ -6085,6 +8584,7 @@ var ChatPanelWrapper = ({
         disabledSectionIds,
         onToggleSection,
         onConversationCreated: conversationCreatedCallback,
+        onBeforeSend: beforeSendCallback,
         cssUrl,
         markdownClass,
         width,
@@ -6099,7 +8599,11 @@ var ChatPanelWrapper = ({
         callToActionEmailAddress: (_g = callToActionEmailAddress != null ? callToActionEmailAddress : convAgentMetadata.displayCallToActionEmailAddress) != null ? _g : "",
         callToActionEmailSubject: (_h = callToActionEmailSubject != null ? callToActionEmailSubject : convAgentMetadata.displayCallToActionEmailSubject) != null ? _h : "Agent CTA submitted",
         customerEmailCaptureMode: (_i = customerEmailCaptureMode != null ? customerEmailCaptureMode : convAgentMetadata == null ? void 0 : convAgentMetadata.customerEmailCaptureMode) != null ? _i : "HIDE",
-        customerEmailCapturePlaceholder: (_j = customerEmailCapturePlaceholder != null ? customerEmailCapturePlaceholder : convAgentMetadata == null ? void 0 : convAgentMetadata.customerEmailCapturePlaceholder) != null ? _j : "Please enter your email..."
+        customerEmailCapturePlaceholder: (_j = customerEmailCapturePlaceholder != null ? customerEmailCapturePlaceholder : convAgentMetadata == null ? void 0 : convAgentMetadata.customerEmailCapturePlaceholder) != null ? _j : "Please enter your email...",
+        resolveMcpAuthHeaders,
+        localToolExecutors,
+        traceContextMode,
+        autoApproveTools
       }
     )
   );
@@ -6150,6 +8654,7 @@ var AIAgentPanel = React15.forwardRef(({
   enableContextDetailView = false,
   onAgentSwitch,
   onConversationChange,
+  onBeforeSend,
   historyChangedCallback,
   responseCompleteCallback,
   thumbsUpClick,
@@ -6181,7 +8686,11 @@ var AIAgentPanel = React15.forwardRef(({
   callToActionEmailAddress,
   callToActionEmailSubject,
   customerEmailCaptureMode,
-  customerEmailCapturePlaceholder
+  customerEmailCapturePlaceholder,
+  resolveMcpAuthHeaders,
+  localToolExecutors,
+  traceContextMode = "standard",
+  autoApproveTools
 }, ref) => {
   var _a, _b, _c, _d;
   useEffect10(() => {
@@ -6201,13 +8710,7 @@ var AIAgentPanel = React15.forwardRef(({
   const [uncontrolledIsCollapsed, setUncontrolledIsCollapsed] = useState9(collapsible && defaultCollapsed);
   const isControlled = controlledIsCollapsed !== void 0;
   const isCollapsed = isControlled ? controlledIsCollapsed : uncontrolledIsCollapsed;
-  const [isHistoryCollapsed, setIsHistoryCollapsed] = useState9(() => {
-    if (typeof window !== "undefined") {
-      const saved = localStorage.getItem("ai-agent-panel-history-collapsed");
-      return saved === "true";
-    }
-    return false;
-  });
+  const [isHistoryCollapsed, setIsHistoryCollapsed] = useState9(true);
   const [panelWidth, setPanelWidth] = useState9(() => {
     if (typeof window !== "undefined") {
       const savedWidth = localStorage.getItem("ai-agent-panel-width");
@@ -6309,8 +8812,12 @@ var AIAgentPanel = React15.forwardRef(({
   const [conversationsLoading, setConversationsLoading] = useState9(false);
   const [conversationsError, setConversationsError] = useState9(null);
   const [searchQuery, setSearchQuery] = useState9("");
+  const controlledConversationId = typeof conversation === "string" && conversation.trim() !== "" ? conversation.trim() : null;
+  const isConversationControlled = controlledConversationId !== null;
   const [activeConversations, setActiveConversations] = useState9(/* @__PURE__ */ new Map());
-  const [currentConversationId, setCurrentConversationId] = useState9(conversation || null);
+  const [currentConversationId, setCurrentConversationId] = useState9(
+    controlledConversationId
+  );
   const [conversationFirstPrompts, setConversationFirstPrompts] = useState9({});
   const [loadingPrompts, setLoadingPrompts] = useState9(/* @__PURE__ */ new Set());
   const [loadingConversationId, setLoadingConversationId] = useState9(null);
@@ -6330,6 +8837,7 @@ var AIAgentPanel = React15.forwardRef(({
     agentList
   } = useAgentRegistry(agentIds, { url, localOverrides });
   const fetchInProgressRef = useRef7(false);
+  const loadingTranscriptIdsRef = useRef7(/* @__PURE__ */ new Set());
   const lastFetchedAgentRef = useRef7(null);
   const checkedPromptsRef = useRef7(/* @__PURE__ */ new Set());
   const fetchingPromptsRef = useRef7(/* @__PURE__ */ new Set());
@@ -6338,29 +8846,49 @@ var AIAgentPanel = React15.forwardRef(({
   activeConversationsRef.current = activeConversations;
   const currentConversationIdRef = useRef7(currentConversationId);
   currentConversationIdRef.current = currentConversationId;
-  React15.useImperativeHandle(ref, () => ({
-    startNewConversation: (prompt, agent) => {
-      const targetAgent = agent || currentAgentId;
+  const commitConversationSelection = useCallback4(
+    (conversationId, notifyChange) => {
+      const shouldSyncLocalState = !isConversationControlled || !notifyChange || controlledConversationId === conversationId;
+      if (shouldSyncLocalState) {
+        setCurrentConversationId(conversationId);
+      }
+      if (notifyChange && conversationId && onConversationChange) {
+        const shouldNotifyParent = !isConversationControlled || controlledConversationId !== conversationId;
+        if (shouldNotifyParent) {
+          onConversationChange(conversationId);
+        }
+      }
+    },
+    [controlledConversationId, isConversationControlled, onConversationChange]
+  );
+  const createDraftConversation = useCallback4(
+    (agentId, conversationInitialPrompt) => {
       const tempId = `new-${Date.now()}`;
       setActiveConversations((prev) => {
         const next = new Map(prev);
         next.set(tempId, {
           conversationId: tempId,
           stableKey: tempId,
-          agentId: targetAgent,
+          agentId,
           history: {},
+          transcriptLoaded: true,
           isLoading: false,
           title: "New conversation",
-          conversationInitialPrompt: prompt
+          conversationInitialPrompt
         });
         return next;
       });
-      setCurrentConversationId(tempId);
-      if (onConversationChange) {
-        onConversationChange(tempId);
-      }
+      return tempId;
+    },
+    []
+  );
+  React15.useImperativeHandle(ref, () => ({
+    startNewConversation: (prompt, agent) => {
+      const targetAgent = agent || currentAgentId;
+      const tempId = createDraftConversation(targetAgent, prompt);
+      commitConversationSelection(tempId, true);
     }
-  }), [currentAgentId, onConversationChange]);
+  }), [commitConversationSelection, createDraftConversation, currentAgentId]);
   const [showContextNotification, setShowContextNotification] = useState9(false);
   const prevContextRef = useRef7(null);
   const contextNotificationTimeoutRef = useRef7(null);
@@ -6502,14 +9030,15 @@ var AIAgentPanel = React15.forwardRef(({
       }
     }
   }), [apiKey, customerId, getAgent, fetchFirstPrompt]);
-  const loadConversationTranscript = useCallback4((conversationId, agentIdForConversation, title) => __async(void 0, null, function* () {
+  const loadConversationTranscript = useCallback4((conversationId, agentIdForConversation, title, notifyConversationChange = true) => __async(void 0, null, function* () {
     var _a2;
     const existingActive = activeConversationsRef.current.get(conversationId);
-    if (existingActive) {
-      setCurrentConversationId(conversationId);
-      if (onConversationChange) {
-        onConversationChange(conversationId);
-      }
+    if (existingActive && (existingActive.transcriptLoaded || Object.keys(existingActive.history || {}).length > 0)) {
+      commitConversationSelection(conversationId, notifyConversationChange);
+      return;
+    }
+    if (loadingTranscriptIdsRef.current.has(conversationId)) {
+      commitConversationSelection(conversationId, notifyConversationChange);
       return;
     }
     const agentIdToUse = agentIdForConversation || currentAgentId;
@@ -6519,6 +9048,8 @@ var AIAgentPanel = React15.forwardRef(({
       setConversationsError("Missing API key or project ID");
       return;
     }
+    loadingTranscriptIdsRef.current.add(conversationId);
+    setConversationsError(null);
     setLoadingConversationId(conversationId);
     try {
       console.log("loadConversationTranscript - conversationId:", conversationId);
@@ -6531,57 +9062,34 @@ var AIAgentPanel = React15.forwardRef(({
         }
       });
       if (!response.ok) {
+        if (response.status === 404) {
+          const conversationTitle2 = title || conversationFirstPrompts[conversationId] || "New conversation";
+          setActiveConversations((prev) => {
+            const next = new Map(prev);
+            next.set(conversationId, {
+              conversationId,
+              stableKey: conversationId,
+              agentId: agentIdToUse,
+              history: {},
+              transcriptLoaded: true,
+              isLoading: false,
+              title: conversationTitle2
+            });
+            return next;
+          });
+          commitConversationSelection(conversationId, notifyConversationChange);
+          return;
+        }
         throw new Error(`Failed to load conversation (${response.status})`);
       }
       const payload = yield response.json();
       console.log("loadConversationTranscript - API response:", payload);
-      const history = {};
-      let firstPrompt = null;
-      if (Array.isArray(payload) && payload.length > 0) {
-        const lastCall = payload[payload.length - 1];
-        const callId = lastCall.id || "";
-        const timestamp = lastCall.createdAt || lastCall.created_at || (/* @__PURE__ */ new Date()).toISOString();
-        if (lastCall.messages) {
-          try {
-            const messages2 = JSON.parse(lastCall.messages);
-            console.log("loadConversationTranscript - parsed messages:", messages2);
-            const relevantMessages = messages2.filter(
-              (msg) => msg.role !== "system" && !(msg.role === "user" && msg.content.startsWith("__system__:"))
-            );
-            console.log("loadConversationTranscript - filtered messages:", relevantMessages);
-            for (let i = 0; i < relevantMessages.length; i++) {
-              const msg = relevantMessages[i];
-              if (!msg) continue;
-              if (msg.role === "user") {
-                if (!firstPrompt) {
-                  firstPrompt = msg.content.length > 60 ? msg.content.slice(0, 57) + "..." : msg.content;
-                }
-                const nextMsg = relevantMessages[i + 1];
-                if (nextMsg && nextMsg.role === "assistant") {
-                  const historyKey = `${timestamp}:${msg.content}`;
-                  history[historyKey] = {
-                    content: nextMsg.content,
-                    callId
-                  };
-                  i++;
-                } else {
-                  if (lastCall.response) {
-                    const historyKey = `${timestamp}:${msg.content}`;
-                    history[historyKey] = {
-                      content: lastCall.response,
-                      callId
-                    };
-                  }
-                }
-              }
-            }
-          } catch (err) {
-            console.error("loadConversationTranscript - failed to parse messages property:", err);
-          }
-        }
-      }
-      console.log("loadConversationTranscript - created", Object.keys(history).length, "history entries");
-      console.log("loadConversationTranscript - parsed history:", history);
+      const calls = normalizeCallsPayload(payload);
+      const transcriptTurns = buildTranscriptTurnsFromCalls(calls);
+      const history = buildHistoryFromTranscriptTurns(transcriptTurns);
+      const firstPrompt = transcriptTurns.length > 0 ? truncatePromptForTitle(transcriptTurns[0].prompt) : null;
+      console.log("loadConversationTranscript - parsed calls:", calls.length);
+      console.log("loadConversationTranscript - created history entries:", Object.keys(history).length);
       if (firstPrompt) {
         setConversationFirstPrompts((prev) => __spreadProps(__spreadValues({}, prev), {
           [conversationId]: firstPrompt
@@ -6596,22 +9104,85 @@ var AIAgentPanel = React15.forwardRef(({
           // Use real ID as stable key when loading from API
           agentId: agentIdToUse,
           history,
+          transcriptLoaded: true,
           isLoading: false,
           title: conversationTitle
         });
         return next;
       });
-      setCurrentConversationId(conversationId);
-      if (onConversationChange) {
-        onConversationChange(conversationId);
-      }
-      setLoadingConversationId(null);
+      commitConversationSelection(conversationId, notifyConversationChange);
     } catch (error) {
       console.error("Failed to load conversation:", error);
       setConversationsError(error.message || "Failed to load conversation");
-      setLoadingConversationId(null);
+    } finally {
+      loadingTranscriptIdsRef.current.delete(conversationId);
+      setLoadingConversationId((prev) => prev === conversationId ? null : prev);
+    }
+  }), [apiKey, commitConversationSelection, conversationFirstPrompts, currentAgentId, getAgent]);
+  useEffect10(() => {
+    if (!isConversationControlled) return;
+    const targetConversationId = controlledConversationId;
+    if (!targetConversationId) {
+      if (currentConversationIdRef.current !== null) {
+        setCurrentConversationId(null);
+      }
+      return;
+    }
+    if (targetConversationId.startsWith("new-")) {
+      setActiveConversations((prev) => {
+        if (prev.has(targetConversationId)) {
+          return prev;
+        }
+        const next = new Map(prev);
+        next.set(targetConversationId, {
+          conversationId: targetConversationId,
+          stableKey: targetConversationId,
+          agentId: currentAgentId,
+          history: {},
+          transcriptLoaded: true,
+          isLoading: false,
+          title: "New conversation"
+        });
+        return next;
+      });
+      if (currentConversationIdRef.current !== targetConversationId) {
+        setCurrentConversationId(targetConversationId);
+      }
+      return;
+    }
+    if (loadingConversationId === targetConversationId) {
+      return;
+    }
+    const existingActive = activeConversationsRef.current.get(targetConversationId);
+    if (existingActive && existingActive.transcriptLoaded && currentConversationIdRef.current === targetConversationId) {
+      return;
+    }
+    const apiConversation = apiConversations.find(
+      (conv) => conv.conversationId === targetConversationId
+    );
+    const targetAgentId = (apiConversation == null ? void 0 : apiConversation.agentId) || (existingActive == null ? void 0 : existingActive.agentId) || currentAgentId;
+    if (!targetAgentId) {
+      return;
+    }
+    if (targetAgentId !== currentAgentId) {
+      setCurrentAgentId(targetAgentId);
     }
-  }), [apiKey, currentAgentId, getAgent, onConversationChange]);
+    const targetTitle = conversationFirstPrompts[targetConversationId] || (apiConversation == null ? void 0 : apiConversation.title) || (existingActive == null ? void 0 : existingActive.title);
+    void loadConversationTranscript(
+      targetConversationId,
+      targetAgentId,
+      targetTitle,
+      false
+    );
+  }, [
+    apiConversations,
+    controlledConversationId,
+    conversationFirstPrompts,
+    currentAgentId,
+    isConversationControlled,
+    loadConversationTranscript,
+    loadingConversationId
+  ]);
   const handleRefreshConversations = useCallback4(() => {
     fetchConversations(currentAgentId);
   }, [currentAgentId, fetchConversations]);
@@ -6628,30 +9199,18 @@ var AIAgentPanel = React15.forwardRef(({
     }
   }, [agentsLoading, currentAgentId, apiKey, fetchConversations, getAgent, showConversationHistory]);
   const handleNewConversation = useCallback4(() => {
-    const tempId = `new-${Date.now()}`;
-    setActiveConversations((prev) => {
-      const next = new Map(prev);
-      next.set(tempId, {
-        conversationId: tempId,
-        stableKey: tempId,
-        // Stable key never changes even when conversationId updates
-        agentId: currentAgentId,
-        history: {},
-        isLoading: false,
-        title: "New conversation"
-      });
-      return next;
-    });
-    setCurrentConversationId(tempId);
-  }, [currentAgentId]);
+    const tempId = createDraftConversation(currentAgentId);
+    commitConversationSelection(tempId, true);
+  }, [commitConversationSelection, createDraftConversation, currentAgentId]);
   useEffect10(() => {
     var _a2;
+    if (isConversationControlled) return;
     const agentProfile = getAgent(currentAgentId);
     const isAgentReady = (_a2 = agentProfile == null ? void 0 : agentProfile.metadata) == null ? void 0 : _a2.projectId;
     if (isAgentReady && !agentsLoading && activeConversations.size === 0) {
       handleNewConversation();
     }
-  }, [currentAgentId, agentsLoading, activeConversations.size, getAgent, handleNewConversation]);
+  }, [currentAgentId, agentsLoading, activeConversations.size, getAgent, handleNewConversation, isConversationControlled]);
   const handleCloseConversation = useCallback4((conversationId, e) => {
     var _a2;
     if (e) {
@@ -6665,9 +9224,13 @@ var AIAgentPanel = React15.forwardRef(({
     if (currentConversationIdRef.current === conversationId) {
       const remaining = Array.from(activeConversationsRef.current.keys()).filter((id) => id !== conversationId);
       const nextId = remaining.length > 0 ? (_a2 = remaining[0]) != null ? _a2 : null : null;
-      setCurrentConversationId(nextId);
+      if (nextId) {
+        commitConversationSelection(nextId, true);
+      } else if (!isConversationControlled) {
+        setCurrentConversationId(null);
+      }
     }
-  }, []);
+  }, [commitConversationSelection, isConversationControlled]);
   const handleSelectConversation = useCallback4((conversationId) => {
     loadConversationTranscript(conversationId);
   }, [loadConversationTranscript]);
@@ -6968,6 +9531,7 @@ var AIAgentPanel = React15.forwardRef(({
             }
             next.set(targetConversationId, __spreadProps(__spreadValues({}, existing), {
               history,
+              transcriptLoaded: true,
               title
             }));
             return next;
@@ -7057,26 +9621,23 @@ var AIAgentPanel = React15.forwardRef(({
       return prev;
     });
     if (currentConversationIdRef.current === tempId) {
-      setCurrentConversationId(realId);
-      if (onConversationChange) {
-        onConversationChange(realId);
-      }
+      commitConversationSelection(realId, true);
     }
-  }, [onConversationChange]);
+  }, [commitConversationSelection]);
   const toggleCollapse = useCallback4(() => {
     if (!collapsible) return;
     const newValue = !isCollapsed;
+    if (!newValue) {
+      setIsHistoryCollapsed(true);
+      setShowSearch(false);
+    }
     if (!isControlled) {
       setUncontrolledIsCollapsed(newValue);
     }
     onCollapsedChange == null ? void 0 : onCollapsedChange(newValue);
   }, [collapsible, isCollapsed, isControlled, onCollapsedChange]);
   const toggleHistoryCollapse = useCallback4(() => {
-    setIsHistoryCollapsed((prev) => {
-      const next = !prev;
-      localStorage.setItem("ai-agent-panel-history-collapsed", String(next));
-      return next;
-    });
+    setIsHistoryCollapsed((prev) => !prev);
   }, []);
   const panelClasses = [
     "ai-agent-panel",
@@ -7148,27 +9709,11 @@ var AIAgentPanel = React15.forwardRef(({
               }
               onCollapsedChange == null ? void 0 : onCollapsedChange(false);
               if (hasActiveConversation && activeConvForAgent) {
-                setCurrentConversationId(activeConvForAgent.conversationId);
                 setCurrentAgentId(agent.id);
-                if (onConversationChange) {
-                  onConversationChange(activeConvForAgent.conversationId);
-                }
+                commitConversationSelection(activeConvForAgent.conversationId, true);
               } else {
-                const tempId = `new-${Date.now()}`;
-                setActiveConversations((prev) => {
-                  const next = new Map(prev);
-                  next.set(tempId, {
-                    conversationId: tempId,
-                    stableKey: tempId,
-                    // Stable key never changes
-                    agentId: agent.id,
-                    history: {},
-                    isLoading: false,
-                    title: "New conversation"
-                  });
-                  return next;
-                });
-                setCurrentConversationId(tempId);
+                const tempId = createDraftConversation(agent.id);
+                commitConversationSelection(tempId, true);
                 setCurrentAgentId(agent.id);
               }
             },
@@ -7253,27 +9798,11 @@ var AIAgentPanel = React15.forwardRef(({
               title: agent.name,
               onClick: () => {
                 if (hasActiveConversation && activeConvForAgent) {
-                  setCurrentConversationId(activeConvForAgent.conversationId);
                   setCurrentAgentId(agent.id);
-                  if (onConversationChange) {
-                    onConversationChange(activeConvForAgent.conversationId);
-                  }
+                  commitConversationSelection(activeConvForAgent.conversationId, true);
                 } else {
-                  const tempId = `new-${Date.now()}`;
-                  setActiveConversations((prev) => {
-                    const next = new Map(prev);
-                    next.set(tempId, {
-                      conversationId: tempId,
-                      stableKey: tempId,
-                      // Stable key never changes
-                      agentId: agent.id,
-                      history: {},
-                      isLoading: false,
-                      title: "New conversation"
-                    });
-                    return next;
-                  });
-                  setCurrentConversationId(tempId);
+                  const tempId = createDraftConversation(agent.id);
+                  commitConversationSelection(tempId, true);
                   setCurrentAgentId(agent.id);
                 }
               },
@@ -7326,10 +9855,7 @@ var AIAgentPanel = React15.forwardRef(({
         key: activeConv.stableKey,
         className: `ai-agent-panel__conversation ai-agent-panel__conversation--active-item ${currentConversationId === activeConv.conversationId ? "ai-agent-panel__conversation--current" : ""}`,
         onClick: () => {
-          setCurrentConversationId(activeConv.conversationId);
-          if (onConversationChange) {
-            onConversationChange(activeConv.conversationId);
-          }
+          commitConversationSelection(activeConv.conversationId, true);
         }
       },
       /* @__PURE__ */ React15.createElement("div", { className: "ai-agent-panel__conversation-content" }, /* @__PURE__ */ React15.createElement("div", { className: "ai-agent-panel__conversation-title" }, activeConv.isLoading && /* @__PURE__ */ React15.createElement(LoadingDotIcon, null), /* @__PURE__ */ React15.createElement("span", null, activeConv.title))),
@@ -7350,12 +9876,12 @@ var AIAgentPanel = React15.forwardRef(({
       },
       /* @__PURE__ */ React15.createElement("span", null, group.label, " ", group.count > 0 && `(${group.count})`),
       /* @__PURE__ */ React15.createElement("span", { className: "ai-agent-panel__group-chevron" }, expandedSections[group.label] ? "\u25BC" : "\u25B6")
-    ), expandedSections[group.label] && group.conversations.length > 0 && group.conversations.map((conv) => {
+    ), expandedSections[group.label] && group.conversations.length > 0 && group.conversations.map((conv, convIndex) => {
       const isActive = activeConversations.has(conv.conversationId);
       return /* @__PURE__ */ React15.createElement(
         "div",
         {
-          key: conv.conversationId,
+          key: `${group.label}-${conv.conversationId}-${convIndex}`,
           className: `ai-agent-panel__conversation ${currentConversationId === conv.conversationId ? "ai-agent-panel__conversation--current" : ""} ${isActive ? "ai-agent-panel__conversation--in-active" : ""}`,
           onClick: () => handleConversationSelect(conv)
         },
@@ -7365,7 +9891,7 @@ var AIAgentPanel = React15.forwardRef(({
     /* @__PURE__ */ React15.createElement("div", { className: "ai-agent-panel__chat" }, !showConversationHistory && collapsible && /* @__PURE__ */ React15.createElement("div", { className: "ai-agent-panel__chat-header" }, /* @__PURE__ */ React15.createElement("div", { className: "ai-agent-panel__chat-header-spacer" }), /* @__PURE__ */ React15.createElement(Tooltip, { content: "Collapse Panel", side: position === "right" ? "left" : "right" }, /* @__PURE__ */ React15.createElement(Button, { variant: "ghost", size: "icon", onClick: toggleCollapse }, position === "right" ? /* @__PURE__ */ React15.createElement(ChevronRightIcon, null) : /* @__PURE__ */ React15.createElement(ChevronLeftIcon, null)))), showContextNotification && /* @__PURE__ */ React15.createElement("div", { className: "ai-agent-panel__context-notification" }, /* @__PURE__ */ React15.createElement(SparkleIcon, null), /* @__PURE__ */ React15.createElement("span", null, "Agent now has new context")), activeConversationsList.map((activeConv) => /* @__PURE__ */ React15.createElement(
       ChatPanelWrapper,
       {
-        key: `${activeConv.stableKey}-${activeConv.agentId}`,
+        key: activeConv.stableKey,
         activeConv,
         currentConversationId,
         getAgent,
@@ -7396,6 +9922,7 @@ var AIAgentPanel = React15.forwardRef(({
         disabledSectionIds: currentDisabledSections,
         onToggleSection: handleContextSectionToggle,
         onConversationCreated: handleConversationCreated,
+        onBeforeSend,
         conversationInitialPrompt: activeConv.conversationInitialPrompt,
         cssUrl,
         markdownClass,
@@ -7411,7 +9938,11 @@ var AIAgentPanel = React15.forwardRef(({
         callToActionEmailAddress,
         callToActionEmailSubject,
         customerEmailCaptureMode,
-        customerEmailCapturePlaceholder
+        customerEmailCapturePlaceholder,
+        resolveMcpAuthHeaders,
+        localToolExecutors,
+        traceContextMode,
+        autoApproveTools
       }
     )), loadingConversationId && /* @__PURE__ */ React15.createElement("div", { className: "ai-agent-panel__conversation-loading-overlay" }, /* @__PURE__ */ React15.createElement("div", { className: "ai-agent-panel__loading-spinner" }), /* @__PURE__ */ React15.createElement("p", null, "Loading conversation...")), currentAgentMetadata && activeConversationsList.length === 0 && !loadingConversationId && /* @__PURE__ */ React15.createElement("div", { className: "ai-agent-panel__empty-chat" }, /* @__PURE__ */ React15.createElement(MessageIcon, null), /* @__PURE__ */ React15.createElement("p", null, "Select a conversation or start a new one"), /* @__PURE__ */ React15.createElement(Button, { variant: "default", size: "sm", onClick: handleNewConversation }, "New Conversation")), agentsLoading && !currentAgentMetadata && /* @__PURE__ */ React15.createElement("div", { className: "ai-agent-panel__loading" }, /* @__PURE__ */ React15.createElement("div", { className: "ai-agent-panel__loading-spinner" }), /* @__PURE__ */ React15.createElement("p", null, "Loading agent..."))),
     /* @__PURE__ */ React15.createElement(