@yumiai/chat-widget 0.1.0

package/dist/index.js

@@ -0,0 +1,3182 @@
+// src/ChatWidget.tsx
+import React19, { useCallback as useCallback5, useEffect as useEffect4, useMemo as useMemo5, useRef as useRef6, useState as useState11 } from "react";
+
+// src/types.ts
+function isTodoNotificationContent(data) {
+  if (!data || typeof data !== "object") return false;
+  const obj = data;
+  return obj.operation === "checklist_edit" && obj.checklist != null;
+}
+var DEFAULT_CONFIG = {
+  showPinnedArea: true,
+  showPlan: true,
+  enableTypewriter: true,
+  typewriterSpeed: 30,
+  autoScroll: true,
+  childAgentMaxHeight: 200,
+  theme: "auto",
+  displayLevels: [0, 1, 2]
+};
+function mergeConsecutiveThinkMessages(messages) {
+  if (messages.length === 0) return messages;
+  const result = [];
+  let pendingThink = null;
+  for (const msg of messages) {
+    if (msg.contentType === "think") {
+      if (pendingThink) {
+        const prev = pendingThink;
+        pendingThink = {
+          ...prev,
+          contentChunks: [...prev.contentChunks, ...msg.contentChunks]
+        };
+      } else {
+        pendingThink = { ...msg, contentChunks: [...msg.contentChunks] };
+      }
+    } else {
+      if (pendingThink) {
+        result.push(pendingThink);
+        pendingThink = null;
+      }
+      result.push(msg);
+    }
+  }
+  if (pendingThink) {
+    result.push(pendingThink);
+  }
+  return result;
+}
+
+// src/hooks/useMessageAggregator.ts
+import { useCallback, useRef, useState } from "react";
+function extractTaskPurposeFromPreview(preview) {
+  const m = preview.match(/"_?task_purpose"\s*:\s*"([^"]*)"/);
+  return m?.[1] || void 0;
+}
+function useMessageAggregator() {
+  const [state, setState] = useState({
+    rounds: /* @__PURE__ */ new Map(),
+    currentInteractionId: null
+  });
+  const [todoMap, setTodoMap] = useState(/* @__PURE__ */ new Map());
+  const todoMapRef = useRef(/* @__PURE__ */ new Map());
+  const pendingUpdates = useRef([]);
+  const rafId = useRef(null);
+  const messageIndexRef = useRef(/* @__PURE__ */ new Map());
+  const roundIndexRef = useRef(/* @__PURE__ */ new Map());
+  const processedChunksRef = useRef(/* @__PURE__ */ new Set());
+  const callBatchToRoundRef = useRef(/* @__PURE__ */ new Map());
+  const parsePlan = useCallback((content) => {
+    try {
+      const parsed = JSON.parse(content);
+      if (parsed.items && Array.isArray(parsed.items)) {
+        return {
+          title: parsed.title,
+          items: parsed.items.map((item) => ({
+            text: item.text || "",
+            status: item.status || "pending"
+          })),
+          progress: {
+            completed: parsed.items.filter((i) => i.status === "completed").length,
+            total: parsed.items.length
+          }
+        };
+      }
+    } catch {
+      const lines = content.split("\n").filter(Boolean);
+      return {
+        items: lines.map((line) => ({
+          text: line.replace(/^[-*]\s*/, ""),
+          status: "pending"
+        })),
+        progress: { completed: 0, total: lines.length }
+      };
+    }
+    return null;
+  }, []);
+  const parseSingleArtifact = useCallback((parsed) => {
+    if (parsed.type === "file" && parsed.data) {
+      const data = parsed.data;
+      const fileSize = data.file_size;
+      const sizeStr = fileSize ? fileSize > 1024 ? `${(fileSize / 1024).toFixed(1)} KB` : `${fileSize} B` : void 0;
+      return {
+        id: parsed.identifier || data.file_id || crypto.randomUUID(),
+        name: data.file_name || parsed.description || "Untitled",
+        type: data.mime_type || "text/plain",
+        size: sizeStr,
+        content: parsed.description,
+        preview: `${parsed.intention}: ${parsed.description}`,
+        metadata: {
+          gitPath: data.git_path,
+          gitCommitHash: data.git_commit_hash,
+          createdByAgentId: data.created_by_agent_id,
+          operationType: data.operation_type
+        }
+      };
+    }
+    return {
+      id: parsed.id || crypto.randomUUID(),
+      name: parsed.name || "Untitled",
+      type: parsed.type || "text/plain",
+      size: parsed.size,
+      content: parsed.content,
+      preview: parsed.preview
+    };
+  }, []);
+  const parseArtifact = useCallback((content) => {
+    try {
+      const parsed = JSON.parse(content);
+      return parseSingleArtifact(parsed);
+    } catch {
+      const firstJsonEnd = content.indexOf("}{");
+      if (firstJsonEnd > 0) {
+        try {
+          const firstJson = content.substring(0, firstJsonEnd + 1);
+          const parsed = JSON.parse(firstJson);
+          return parseSingleArtifact(parsed);
+        } catch {
+          return null;
+        }
+      }
+      return null;
+    }
+  }, [parseSingleArtifact]);
+  const parseArtifacts = useCallback((content) => {
+    const artifacts = [];
+    const jsonStrings = content.split(/\}\s*\{/).map((str, index, arr) => {
+      if (index === 0) return str + (arr.length > 1 ? "}" : "");
+      if (index === arr.length - 1) return "{" + str;
+      return "{" + str + "}";
+    });
+    for (const jsonStr of jsonStrings) {
+      try {
+        const parsed = JSON.parse(jsonStr);
+        const artifact = parseSingleArtifact(parsed);
+        if (artifact) {
+          artifacts.push(artifact);
+        }
+      } catch {
+      }
+    }
+    return artifacts;
+  }, [parseSingleArtifact]);
+  const parseHITLRequest = useCallback((content, contentType) => {
+    try {
+      const parsed = JSON.parse(content);
+      return {
+        await_command_uuid: parsed.await_command_uuid || "",
+        schema_type: contentType === "html_schema" ? "html_schema" : "json_schema",
+        schema: parsed.schema || parsed,
+        title: parsed.title,
+        description: parsed.description
+      };
+    } catch {
+      return null;
+    }
+  }, []);
+  const flushUpdates = useCallback(() => {
+    if (pendingUpdates.current.length === 0) return;
+    const updates = [...pendingUpdates.current];
+    pendingUpdates.current = [];
+    let latestInteractionId = null;
+    let todoMapChanged = false;
+    for (const msg of updates) {
+      const { agent_instance_id, call_batch_id, content_type, content } = msg;
+      let { interaction_id } = msg;
+      if (msg.notification_type === "node_summary") {
+        continue;
+      }
+      if (msg.notification_type === "compression_started" || msg.notification_type === "compression_completed") {
+        continue;
+      }
+      if (msg.notification_type === "plan_result" && content) {
+        try {
+          const parsed = typeof content === "string" ? JSON.parse(content) : content;
+          if (isTodoNotificationContent(parsed)) {
+            const planId = parsed.plan_id || "default";
+            todoMapRef.current = new Map(todoMapRef.current).set(planId, parsed.checklist);
+            todoMapChanged = true;
+            continue;
+          }
+        } catch {
+        }
+      }
+      const existingRoundForBatch = callBatchToRoundRef.current.get(call_batch_id);
+      if (existingRoundForBatch && existingRoundForBatch !== interaction_id) {
+        interaction_id = existingRoundForBatch;
+      } else if (!existingRoundForBatch) {
+        callBatchToRoundRef.current.set(call_batch_id, interaction_id);
+      }
+      let round = roundIndexRef.current.get(interaction_id);
+      if (!round) {
+        round = {
+          interactionId: interaction_id,
+          index: roundIndexRef.current.size + 1,
+          userMessage: "",
+          timestamp: msg.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+          status: "running",
+          messages: []
+        };
+        roundIndexRef.current.set(interaction_id, round);
+      }
+      latestInteractionId = interaction_id;
+      const notification_type = msg.notification_type;
+      const isMcpMessage = notification_type && ["mcp_generating", "mcp_start", "mcp_result", "mcp_end"].includes(notification_type);
+      let messageKey = isMcpMessage ? `${interaction_id}-${agent_instance_id}-mcp-${msg.tool_call_id || call_batch_id}` : `${interaction_id}-${agent_instance_id}-${call_batch_id}-${content_type}`;
+      if (isMcpMessage && notification_type !== "mcp_generating" && !messageIndexRef.current.has(messageKey)) {
+        const fallback = round.messages.find(
+          (m) => m.toolPhase && m.toolPhase !== "complete" && m.toolPhase !== "error" && m.callBatchId === call_batch_id && (msg.tool_name ? m.toolName === msg.tool_name : true)
+        );
+        if (fallback) {
+          messageKey = fallback.id;
+        }
+      }
+      if (!isMcpMessage && messageIndexRef.current.has(messageKey)) {
+        const baseKey = messageKey;
+        const candidateKeys = [baseKey];
+        let segIdx = 1;
+        while (messageIndexRef.current.has(`${baseKey}-${segIdx}`)) {
+          candidateKeys.push(`${baseKey}-${segIdx}`);
+          segIdx++;
+        }
+        const lastMsgId = round.messages.length > 0 ? round.messages[round.messages.length - 1].id : null;
+        const mergeTarget = candidateKeys.find((k) => k === lastMsgId);
+        if (mergeTarget) {
+          messageKey = mergeTarget;
+        } else {
+          const lastMsg = round.messages.length > 0 ? round.messages[round.messages.length - 1] : null;
+          const isAfterToolCard = lastMsg && lastMsg.toolPhase !== void 0;
+          const isShortFragment = content.length < 10;
+          if (isAfterToolCard && isShortFragment) {
+            const latestTextKey = candidateKeys[candidateKeys.length - 1];
+            messageKey = latestTextKey;
+          } else {
+            messageKey = `${baseKey}-${segIdx}`;
+          }
+        }
+      }
+      let message = messageIndexRef.current.get(messageKey);
+      if (!message) {
+        message = {
+          id: messageKey,
+          agentInstanceId: agent_instance_id,
+          callBatchId: call_batch_id,
+          parentCallBatchId: msg.parent_call_batch_id,
+          level: msg.level,
+          agentName: msg.agent_name,
+          taskPurpose: msg.task_purpose,
+          // 任务目标
+          notificationType: msg.notification_type,
+          // 顶层通知类型
+          toolName: msg.tool_name,
+          // 工具名称
+          toolCallId: msg.tool_call_id,
+          // 工具调用 ID
+          toolStatus: msg.tool_status,
+          // 工具执行状态
+          toolPhase: notification_type === "mcp_generating" ? "generating" : notification_type === "mcp_start" ? "executing" : notification_type === "mcp_end" ? msg.tool_status === "error" ? "error" : "complete" : void 0,
+          argsPreview: msg.args_preview,
+          uiConfig: msg.ui_config,
+          parentToolCallId: msg.parent_tool_call_id,
+          contentType: content_type,
+          contentChunks: [],
+          timestamp: msg.timestamp || (/* @__PURE__ */ new Date()).toISOString()
+        };
+        messageIndexRef.current.set(messageKey, message);
+        if (!round.messages.some((m) => m.id === messageKey)) {
+          round.messages.push(message);
+        }
+      } else if (isMcpMessage) {
+        const prev = message;
+        message = { ...message, contentChunks: [...message.contentChunks] };
+        message.notificationType = msg.notification_type;
+        if (msg.tool_status) {
+          message.toolStatus = msg.tool_status;
+        }
+        if (msg.task_purpose && !message.taskPurpose) {
+          message.taskPurpose = msg.task_purpose;
+        }
+        if (!message.taskPurpose && msg.args_preview) {
+          const tp = extractTaskPurposeFromPreview(msg.args_preview);
+          if (tp) message.taskPurpose = tp;
+        }
+        const isTerminal = message.toolPhase === "complete" || message.toolPhase === "error";
+        if (notification_type === "mcp_generating") {
+          if (!isTerminal) {
+            message.toolPhase = "generating";
+          }
+          if (msg.args_preview) {
+            message.argsPreview = msg.args_preview;
+          }
+          if (msg.ui_config && !message.uiConfig) {
+            message.uiConfig = msg.ui_config;
+          }
+        } else if (notification_type === "mcp_start") {
+          if (!isTerminal) {
+            message.toolPhase = "executing";
+          }
+        } else if (notification_type === "mcp_end") {
+          message.toolPhase = msg.tool_status === "error" ? "error" : "complete";
+        }
+        messageIndexRef.current.set(messageKey, message);
+        const prevIdx = round.messages.indexOf(prev);
+        if (prevIdx >= 0) round.messages[prevIdx] = message;
+      }
+      const skipContent = isMcpMessage && notification_type !== "mcp_result";
+      if (!skipContent) {
+        const chunkIndex = message.contentChunks.length;
+        const chunkId = `${messageKey}-chunk-${chunkIndex}`;
+        if (!processedChunksRef.current.has(chunkId)) {
+          processedChunksRef.current.add(chunkId);
+          const prevMsg = message;
+          message = { ...message, contentChunks: [...message.contentChunks, content] };
+          messageIndexRef.current.set(messageKey, message);
+          const idx = round.messages.indexOf(prevMsg);
+          if (idx >= 0) round.messages[idx] = message;
+        }
+      }
+      if (content_type === "plan") {
+        const plan = parsePlan(message.contentChunks.join(""));
+        if (plan) {
+          message.plan = plan;
+          round.plan = plan;
+        }
+      } else if (content_type === "artifact") {
+        const allContent = message.contentChunks.join("");
+        const artifacts = parseArtifacts(allContent);
+        if (artifacts.length > 0) {
+          message.artifacts = artifacts;
+          message.artifact = artifacts[0];
+        }
+      } else if (content_type === "json_schema" || content_type === "html_schema" || content_type === "json_schema_wait") {
+        message.hitlRequest = parseHITLRequest(message.contentChunks.join(""), content_type) ?? void 0;
+      }
+    }
+    setState(() => {
+      const newRounds = new Map(roundIndexRef.current);
+      return {
+        rounds: newRounds,
+        currentInteractionId: latestInteractionId
+      };
+    });
+    if (todoMapChanged) {
+      setTodoMap(new Map(todoMapRef.current));
+    }
+    rafId.current = null;
+  }, [parsePlan, parseArtifact, parseHITLRequest]);
+  const processMessage = useCallback((message) => {
+    pendingUpdates.current.push(message);
+    if (rafId.current === null) {
+      rafId.current = requestAnimationFrame(flushUpdates);
+    }
+  }, [flushUpdates]);
+  const getRoundsList = useCallback(() => {
+    return Array.from(state.rounds.values()).sort((a, b) => a.index - b.index);
+  }, [state.rounds]);
+  const getCurrentRound = useCallback(() => {
+    if (!state.currentInteractionId) return null;
+    return state.rounds.get(state.currentInteractionId) || null;
+  }, [state.rounds, state.currentInteractionId]);
+  const startNewRound = useCallback((interactionId, userMessage) => {
+    const round = {
+      interactionId,
+      index: roundIndexRef.current.size + 1,
+      userMessage,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      status: "running",
+      messages: []
+    };
+    roundIndexRef.current.set(interactionId, round);
+    setState((prevState) => {
+      const newRounds = new Map(prevState.rounds);
+      newRounds.set(interactionId, round);
+      return {
+        rounds: newRounds,
+        currentInteractionId: interactionId
+      };
+    });
+  }, []);
+  const loadRounds = useCallback((rounds) => {
+    roundIndexRef.current.clear();
+    messageIndexRef.current.clear();
+    callBatchToRoundRef.current.clear();
+    processedChunksRef.current.clear();
+    const newRounds = /* @__PURE__ */ new Map();
+    for (const round of rounds) {
+      newRounds.set(round.interactionId, round);
+      roundIndexRef.current.set(round.interactionId, round);
+      for (const msg of round.messages) {
+        messageIndexRef.current.set(msg.id, msg);
+        if (msg.callBatchId) {
+          callBatchToRoundRef.current.set(msg.callBatchId, round.interactionId);
+        }
+      }
+    }
+    const lastId = rounds.length > 0 ? rounds[rounds.length - 1].interactionId : null;
+    setState({ rounds: newRounds, currentInteractionId: lastId });
+  }, []);
+  const finalizeRound = useCallback((interactionId) => {
+    const round = roundIndexRef.current.get(interactionId);
+    if (!round) return;
+    let changed = false;
+    for (let i = 0; i < round.messages.length; i++) {
+      const msg = round.messages[i];
+      if (msg.toolPhase && msg.toolPhase !== "complete" && msg.toolPhase !== "error") {
+        const updated = { ...msg, toolPhase: "complete" };
+        round.messages[i] = updated;
+        messageIndexRef.current.set(msg.id, updated);
+        changed = true;
+      }
+    }
+    if (changed) {
+      setState(() => ({
+        rounds: new Map(roundIndexRef.current),
+        currentInteractionId: interactionId
+      }));
+    }
+  }, []);
+  const clear = useCallback(() => {
+    pendingUpdates.current = [];
+    messageIndexRef.current.clear();
+    roundIndexRef.current.clear();
+    processedChunksRef.current.clear();
+    callBatchToRoundRef.current.clear();
+    todoMapRef.current.clear();
+    if (rafId.current) {
+      cancelAnimationFrame(rafId.current);
+      rafId.current = null;
+    }
+    setState({
+      rounds: /* @__PURE__ */ new Map(),
+      currentInteractionId: null
+    });
+    setTodoMap(/* @__PURE__ */ new Map());
+  }, []);
+  return {
+    state,
+    todoMap,
+    processMessage,
+    getRoundsList,
+    getCurrentRound,
+    startNewRound,
+    loadRounds,
+    finalizeRound,
+    clear
+  };
+}
+
+// src/hooks/useSSE.ts
+import { useCallback as useCallback2, useEffect, useRef as useRef2, useState as useState2 } from "react";
+function useSSE(options) {
+  const {
+    adapter,
+    autoConnect = false,
+    reconnectInterval = 3e3,
+    maxReconnectAttempts = 3,
+    onMessage,
+    onStatusChange,
+    onError
+  } = options;
+  const [status, setStatus] = useState2("idle");
+  const eventSourceRef = useRef2(null);
+  const abortControllerRef = useRef2(null);
+  const reconnectAttemptsRef = useRef2(0);
+  const reconnectTimerRef = useRef2(null);
+  const updateStatus = useCallback2((newStatus) => {
+    setStatus(newStatus);
+    onStatusChange?.(newStatus);
+  }, [onStatusChange]);
+  const disconnect = useCallback2(() => {
+    if (reconnectTimerRef.current) {
+      clearTimeout(reconnectTimerRef.current);
+      reconnectTimerRef.current = null;
+    }
+    if (eventSourceRef.current) {
+      eventSourceRef.current.close();
+      eventSourceRef.current = null;
+    }
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+      abortControllerRef.current = null;
+    }
+    reconnectAttemptsRef.current = 0;
+    updateStatus("disconnected");
+  }, [updateStatus]);
+  const connect = useCallback2((url, body) => {
+    disconnect();
+    updateStatus("connecting");
+    if (body) {
+      abortControllerRef.current = new AbortController();
+      const doFetch = () => {
+        const headers = {
+          "Content-Type": "application/json",
+          "Accept": "text/event-stream",
+          ...adapter.getAuthHeaders(),
+          ...adapter.getExtraHeaders?.() ?? {}
+        };
+        return fetch(url, {
+          method: "POST",
+          headers,
+          body: JSON.stringify(body),
+          signal: abortControllerRef.current.signal
+        });
+      };
+      doFetch().then(async (response) => {
+        if (response.status === 401) {
+          console.warn("[useSSE] Got 401, attempting token refresh via adapter...");
+          const refreshed = await adapter.refreshAuth?.();
+          if (refreshed) {
+            console.log("[useSSE] Token refreshed, retrying SSE connection");
+            const retryResponse = await doFetch();
+            if (!retryResponse.ok) {
+              throw new Error(`HTTP ${retryResponse.status}: ${retryResponse.statusText}`);
+            }
+            return retryResponse;
+          }
+          adapter.onAuthFailure?.();
+          throw new Error("HTTP 401: Unauthorized");
+        }
+        if (!response.ok) {
+          throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        return response;
+      }).then(async (response) => {
+        updateStatus("connected");
+        reconnectAttemptsRef.current = 0;
+        const reader = response.body?.getReader();
+        if (!reader) {
+          throw new Error("Response body is not readable");
+        }
+        const decoder = new TextDecoder();
+        let buffer = "";
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            if (line.startsWith("data:")) {
+              const data = line.slice(5).trim();
+              if (data && data !== "[DONE]") {
+                try {
+                  const message = JSON.parse(data);
+                  onMessage?.(message);
+                } catch (e) {
+                  console.warn("Failed to parse SSE message:", data, e);
+                }
+              }
+            }
+          }
+        }
+        updateStatus("disconnected");
+      }).catch((error) => {
+        if (error.name === "AbortError") {
+          updateStatus("disconnected");
+        } else {
+          const is401 = error instanceof Error && error.message.includes("401");
+          console.error("SSE connection error:", error);
+          updateStatus("error");
+          onError?.(error instanceof Error ? error : new Error(String(error)));
+          if (is401) return;
+          if (reconnectAttemptsRef.current < maxReconnectAttempts) {
+            reconnectAttemptsRef.current++;
+            reconnectTimerRef.current = window.setTimeout(() => {
+              connect(url, body);
+            }, reconnectInterval);
+          }
+        }
+      });
+    } else {
+      try {
+        const eventSource = new EventSource(url);
+        eventSourceRef.current = eventSource;
+        eventSource.onopen = () => {
+          updateStatus("connected");
+          reconnectAttemptsRef.current = 0;
+        };
+        eventSource.onmessage = (event) => {
+          if (event.data && event.data !== "[DONE]") {
+            try {
+              const message = JSON.parse(event.data);
+              onMessage?.(message);
+            } catch (e) {
+              console.warn("Failed to parse SSE message:", event.data, e);
+            }
+          }
+        };
+        eventSource.onerror = () => {
+          eventSource.close();
+          updateStatus("error");
+          if (reconnectAttemptsRef.current < maxReconnectAttempts) {
+            reconnectAttemptsRef.current++;
+            reconnectTimerRef.current = window.setTimeout(() => {
+              connect(url);
+            }, reconnectInterval);
+          }
+        };
+      } catch (error) {
+        updateStatus("error");
+        onError?.(error instanceof Error ? error : new Error(String(error)));
+      }
+    }
+  }, [adapter, disconnect, updateStatus, onMessage, onError, maxReconnectAttempts, reconnectInterval]);
+  useEffect(() => {
+    if (autoConnect) {
+      connect(adapter.getStreamUrl());
+    }
+    return () => {
+      disconnect();
+    };
+  }, []);
+  return {
+    status,
+    connect,
+    disconnect
+  };
+}
+
+// src/components/PinnedArea.tsx
+import "react";
+
+// src/components/PlanCard.tsx
+import "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+var PlanCard = ({
+  plan,
+  status,
+  compact = false
+}) => {
+  const statusIcons = {
+    completed: "\u2713",
+    active: "\u2192",
+    pending: "\u25CB",
+    error: "\u2717"
+  };
+  if (compact) {
+    return /* @__PURE__ */ jsxs("div", { className: "plan-card-compact", children: [
+      /* @__PURE__ */ jsx("span", { className: "plan-icon", children: "\u{1F4CB}" }),
+      /* @__PURE__ */ jsx("span", { className: "plan-items-inline", children: plan.items.map((item, i) => /* @__PURE__ */ jsxs("span", { className: `plan-item-inline ${item.status}`, children: [
+        "[",
+        statusIcons[item.status],
+        " ",
+        item.text,
+        "]"
+      ] }, i)) })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs("div", { className: `plan-card ${status === "completed" ? "completed" : ""}`, children: [
+    /* @__PURE__ */ jsxs("div", { className: "plan-header", children: [
+      /* @__PURE__ */ jsxs("div", { className: "plan-title", children: [
+        /* @__PURE__ */ jsx("span", { className: "plan-icon", children: "\u{1F4CB}" }),
+        /* @__PURE__ */ jsx("span", { children: "\u4EFB\u52A1\u8BA1\u5212" })
+      ] }),
+      /* @__PURE__ */ jsxs("span", { className: "plan-progress", children: [
+        "(",
+        plan.progress.completed,
+        "/",
+        plan.progress.total,
+        ")"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx("ul", { className: "plan-items", children: plan.items.map((item, index) => /* @__PURE__ */ jsxs("li", { className: `plan-item ${item.status}`, children: [
+      /* @__PURE__ */ jsx("span", { className: "plan-item-icon", children: statusIcons[item.status] }),
+      /* @__PURE__ */ jsx("span", { className: "plan-item-text", children: item.text }),
+      item.status === "active" && /* @__PURE__ */ jsx("span", { className: "plan-item-status", children: "\u6267\u884C\u4E2D" })
+    ] }, index)) })
+  ] });
+};
+var PlanCard_default = PlanCard;
+
+// src/components/TodoCard.tsx
+import { useState as useState3, useCallback as useCallback3, useMemo } from "react";
+import { Fragment, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var STATUS_ICON = {
+  pending: "\u25CB",
+  in_progress: "\u2192",
+  completed: "\u2713",
+  blocked: "\u26A0"
+};
+var MAX_VISIBLE_ITEMS = 8;
+function flattenTasks(todo) {
+  const result = [];
+  for (const phase of todo.phases) {
+    for (const task of phase.tasks) {
+      result.push(task);
+    }
+    for (const group of phase.groups) {
+      for (const task of group.tasks) {
+        result.push(task);
+      }
+    }
+  }
+  return result;
+}
+function findCurrentTask(tasks) {
+  return tasks.find((t) => t.status === "in_progress") || null;
+}
+var TaskRow = ({ task, depth = 0 }) => {
+  const [expanded, setExpanded] = useState3(
+    task.status === "in_progress" && task.children.length > 0
+  );
+  const hasChildren = task.children.length > 0;
+  const toggle = useCallback3(() => setExpanded((v) => !v), []);
+  return /* @__PURE__ */ jsxs2(Fragment, { children: [
+    /* @__PURE__ */ jsxs2(
+      "div",
+      {
+        className: `todo-task-row todo-status-${task.status}`,
+        style: { paddingLeft: `${12 + depth * 16}px` },
+        onClick: hasChildren ? toggle : void 0,
+        role: hasChildren ? "button" : void 0,
+        children: [
+          /* @__PURE__ */ jsx2("span", { className: "todo-status-icon", children: STATUS_ICON[task.status] }),
+          hasChildren && /* @__PURE__ */ jsx2("span", { className: `todo-expand-arrow ${expanded ? "expanded" : ""}`, children: "\u25B8" }),
+          /* @__PURE__ */ jsx2("span", { className: "todo-task-desc", children: task.description })
+        ]
+      }
+    ),
+    expanded && task.children.map((child, i) => /* @__PURE__ */ jsx2(TaskRow, { task: child, depth: depth + 1 }, child.id || i))
+  ] });
+};
+var TodoCardCompact = ({ todo }) => {
+  const tasks = useMemo(() => flattenTasks(todo), [todo]);
+  const current = findCurrentTask(tasks);
+  const { stats } = todo;
+  return /* @__PURE__ */ jsxs2("div", { className: "todo-card-compact", children: [
+    /* @__PURE__ */ jsx2("span", { className: "todo-compact-icon", children: "\u2630" }),
+    /* @__PURE__ */ jsx2("span", { className: "todo-compact-title", children: todo.title }),
+    current && /* @__PURE__ */ jsxs2(Fragment, { children: [
+      /* @__PURE__ */ jsx2("span", { className: "todo-compact-sep", children: "\u2192" }),
+      /* @__PURE__ */ jsx2("span", { className: "todo-compact-current", children: current.description })
+    ] }),
+    /* @__PURE__ */ jsxs2("span", { className: "todo-compact-progress", children: [
+      "\u5DF2\u5B8C\u6210 ",
+      stats.completed,
+      "/",
+      stats.total
+    ] })
+  ] });
+};
+var TodoCard = ({ todo, compact = false }) => {
+  const [expanded, setExpanded] = useState3(false);
+  const [showAll, setShowAll] = useState3(false);
+  const tasks = useMemo(() => flattenTasks(todo), [todo]);
+  const { stats } = todo;
+  const progress = stats.total > 0 ? stats.completed / stats.total : 0;
+  if (compact) {
+    return /* @__PURE__ */ jsx2(TodoCardCompact, { todo });
+  }
+  const visibleTasks = showAll ? tasks : tasks.slice(0, MAX_VISIBLE_ITEMS);
+  const hiddenCount = tasks.length - MAX_VISIBLE_ITEMS;
+  const current = useMemo(() => findCurrentTask(tasks), [tasks]);
+  const isAllDone = stats.completed === stats.total && stats.total > 0;
+  const hasBlocked = stats.blocked > 0;
+  return /* @__PURE__ */ jsxs2("div", { className: "todo-card", children: [
+    /* @__PURE__ */ jsxs2("div", { className: "todo-header", onClick: () => setExpanded((v) => !v), role: "button", children: [
+      /* @__PURE__ */ jsxs2("div", { className: "todo-title", children: [
+        /* @__PURE__ */ jsx2("span", { className: `todo-header-arrow ${expanded ? "expanded" : ""}`, children: "\u25B8" }),
+        /* @__PURE__ */ jsx2("span", { className: "todo-title-icon", children: "\u2630" }),
+        /* @__PURE__ */ jsx2("span", { className: "todo-title-text", children: todo.title })
+      ] }),
+      !expanded && /* @__PURE__ */ jsx2("div", { className: "todo-header-status", children: isAllDone ? /* @__PURE__ */ jsx2("span", { className: "todo-header-done", children: "\u2713 \u5DF2\u5B8C\u6210" }) : hasBlocked ? /* @__PURE__ */ jsxs2("span", { className: "todo-header-blocked", children: [
+        "\u26A0 ",
+        stats.blocked,
+        " \u9879\u963B\u585E"
+      ] }) : current ? /* @__PURE__ */ jsxs2(Fragment, { children: [
+        /* @__PURE__ */ jsx2("span", { className: "todo-header-current-sep", children: "\u2192" }),
+        /* @__PURE__ */ jsx2("span", { className: "todo-header-current", children: current.description })
+      ] }) : null }),
+      /* @__PURE__ */ jsxs2("span", { className: "todo-header-count", children: [
+        "\u5DF2\u5B8C\u6210 ",
+        stats.completed,
+        "/",
+        stats.total
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx2("div", { className: "todo-progress-bar", children: /* @__PURE__ */ jsx2(
+      "div",
+      {
+        className: "todo-progress-fill",
+        style: { width: `${progress * 100}%` }
+      }
+    ) }),
+    expanded && /* @__PURE__ */ jsxs2(Fragment, { children: [
+      /* @__PURE__ */ jsx2("div", { className: "todo-list", children: visibleTasks.map((task, i) => /* @__PURE__ */ jsx2(TaskRow, { task }, task.id || i)) }),
+      !showAll && hiddenCount > 0 && /* @__PURE__ */ jsxs2("div", { className: "todo-more", onClick: () => setShowAll(true), children: [
+        "+ ",
+        hiddenCount,
+        " more"
+      ] })
+    ] })
+  ] });
+};
+var TodoCardMulti = ({ todoMap, compact = false }) => {
+  const entries = useMemo(() => Array.from(todoMap.entries()), [todoMap]);
+  const [activeId, setActiveId] = useState3(null);
+  if (entries.length === 0) return null;
+  if (entries.length === 1) {
+    return /* @__PURE__ */ jsx2(TodoCard, { todo: entries[0][1], compact });
+  }
+  const selectedId = activeId || entries[entries.length - 1][0];
+  const selectedTodo = todoMap.get(selectedId);
+  if (compact) {
+    return /* @__PURE__ */ jsx2("div", { className: "todo-multi-compact", children: entries.map(([id, todo]) => /* @__PURE__ */ jsx2(TodoCardCompact, { todo }, id)) });
+  }
+  return /* @__PURE__ */ jsxs2("div", { className: "todo-card", children: [
+    /* @__PURE__ */ jsx2("div", { className: "todo-multi-tabs", children: entries.map(([id, todo]) => /* @__PURE__ */ jsxs2(
+      "button",
+      {
+        className: `todo-tab ${id === selectedId ? "active" : ""}`,
+        onClick: () => setActiveId(id),
+        children: [
+          todo.title,
+          /* @__PURE__ */ jsxs2("span", { className: "todo-tab-progress", children: [
+            todo.stats.completed,
+            "/",
+            todo.stats.total
+          ] })
+        ]
+      },
+      id
+    )) }),
+    selectedTodo && /* @__PURE__ */ jsx2(TodoCard, { todo: selectedTodo })
+  ] });
+};
+var TodoCard_default = TodoCard;
+
+// src/components/PinnedArea.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var PinnedArea = ({
+  round,
+  isTransitioning,
+  todoMap
+}) => {
+  if (!round) return null;
+  const hasTodo = todoMap && todoMap.size > 0;
+  const formatTime = (timestamp) => {
+    try {
+      return new Date(timestamp).toLocaleTimeString("zh-CN", {
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit"
+      });
+    } catch {
+      return "";
+    }
+  };
+  return /* @__PURE__ */ jsxs3("div", { className: "chat-pinned-area", children: [
+    /* @__PURE__ */ jsxs3("div", { className: `pinned-content ${isTransitioning ? "fade-out" : ""}`, children: [
+      /* @__PURE__ */ jsx3("div", { className: "pinned-user-message", children: round.userMessage || "(\u65E0\u6D88\u606F\u5185\u5BB9)" }),
+      hasTodo && /* @__PURE__ */ jsx3(TodoCardMulti, { todoMap }),
+      !hasTodo && round.plan && /* @__PURE__ */ jsx3(
+        PlanCard_default,
+        {
+          plan: round.plan,
+          status: round.status
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx3("span", { className: "pinned-timestamp", children: formatTime(round.timestamp) })
+  ] });
+};
+var PinnedArea_default = PinnedArea;
+
+// src/components/RoundHeader.tsx
+import "react";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var RoundHeader = ({
+  round,
+  isPinned,
+  todoMap
+}) => {
+  const statusLabels = {
+    running: { icon: "\u23F3", text: "\u6267\u884C\u4E2D", className: "running" },
+    completed: { icon: "\u2713", text: "\u5DF2\u5B8C\u6210", className: "completed" },
+    error: { icon: "\u2717", text: "\u6267\u884C\u5931\u8D25", className: "error" }
+  };
+  const status = statusLabels[round.status];
+  const hasTodo = todoMap && todoMap.size > 0;
+  return /* @__PURE__ */ jsxs4("div", { className: `round-header ${isPinned ? "pinned" : ""}`, children: [
+    /* @__PURE__ */ jsxs4("div", { className: "round-header-title", children: [
+      /* @__PURE__ */ jsxs4("div", { className: "user-avatar", children: [
+        /* @__PURE__ */ jsx4("span", { className: "avatar-icon", children: "\u{1F464}" }),
+        /* @__PURE__ */ jsx4("span", { className: "user-message-text", children: round.userMessage || "(\u65E0\u6D88\u606F)" })
+      ] }),
+      /* @__PURE__ */ jsxs4("span", { className: `round-status ${status.className}`, children: [
+        status.icon,
+        " ",
+        status.text
+      ] })
+    ] }),
+    hasTodo && /* @__PURE__ */ jsx4(TodoCardMulti, { todoMap, compact: true }),
+    !hasTodo && round.plan && /* @__PURE__ */ jsx4(PlanCard_default, { plan: round.plan, status: round.status, compact: true })
+  ] });
+};
+var RoundHeader_default = RoundHeader;
+
+// src/components/MessageContent.tsx
+import { useEffect as useEffect2, useState as useState9, useRef as useRef4, memo as memo2 } from "react";
+import { Streamdown } from "streamdown";
+import { code } from "@streamdown/code";
+import { mermaid } from "@streamdown/mermaid";
+import { createMathPlugin } from "@streamdown/math";
+import { cjk } from "@streamdown/cjk";
+
+// src/components/SchemaFormRenderer.tsx
+import { useState as useState4, useCallback as useCallback4 } from "react";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+var renderNode = (node, values, onChange, errors) => {
+  if (!node) return null;
+  const { type, key, name, props, children, options, schema } = node;
+  const nodeKey = key || name || Math.random().toString();
+  switch (type) {
+    case "Card":
+      return /* @__PURE__ */ jsx5("div", { className: "schema-card", children: children?.map((child) => renderNode(child, values, onChange, errors)) }, nodeKey);
+    case "FormChunk":
+      if (schema) {
+        return renderNode(schema, values, onChange, errors);
+      }
+      return children?.map((child) => renderNode(child, values, onChange, errors));
+    case "Form":
+      return /* @__PURE__ */ jsx5("div", { className: "schema-form", children: children?.map((child) => renderNode(child, values, onChange, errors)) }, nodeKey);
+    case "FormItem": {
+      const label = props?.label || "";
+      const required = node.rules?.some((r) => r.required);
+      const error = name ? errors[name] : void 0;
+      return /* @__PURE__ */ jsxs5("div", { className: `schema-form-item ${error ? "has-error" : ""}`, children: [
+        /* @__PURE__ */ jsxs5("label", { className: "schema-form-label", children: [
+          required && /* @__PURE__ */ jsx5("span", { className: "required-mark", children: "*" }),
+          label
+        ] }),
+        /* @__PURE__ */ jsx5("div", { className: "schema-form-control", children: children?.map((child) => renderNode(
+          { ...child, name: name || child.name },
+          values,
+          onChange,
+          errors
+        )) }),
+        error && /* @__PURE__ */ jsx5("div", { className: "schema-form-error", children: error })
+      ] }, nodeKey);
+    }
+    case "RadioGroup": {
+      const fieldName = name || "";
+      const currentValue = values[fieldName];
+      return /* @__PURE__ */ jsx5("div", { className: "schema-radio-group", children: options?.map((option) => /* @__PURE__ */ jsxs5("label", { className: "schema-radio-option", children: [
+        /* @__PURE__ */ jsx5(
+          "input",
+          {
+            type: "radio",
+            name: fieldName,
+            value: option.value,
+            checked: currentValue === option.value,
+            onChange: () => onChange(fieldName, option.value)
+          }
+        ),
+        /* @__PURE__ */ jsx5("span", { className: "radio-checkmark" }),
+        /* @__PURE__ */ jsx5("span", { className: "radio-label", children: option.label })
+      ] }, option.value)) }, nodeKey);
+    }
+    case "CheckboxGroup": {
+      const fieldName = name || "";
+      const currentValues = values[fieldName] || [];
+      return /* @__PURE__ */ jsx5("div", { className: "schema-checkbox-group", children: options?.map((option) => /* @__PURE__ */ jsxs5("label", { className: "schema-checkbox-option", children: [
+        /* @__PURE__ */ jsx5(
+          "input",
+          {
+            type: "checkbox",
+            value: option.value,
+            checked: currentValues.includes(option.value),
+            onChange: (e) => {
+              const newValues = e.target.checked ? [...currentValues, option.value] : currentValues.filter((v) => v !== option.value);
+              onChange(fieldName, newValues);
+            }
+          }
+        ),
+        /* @__PURE__ */ jsx5("span", { className: "checkbox-checkmark" }),
+        /* @__PURE__ */ jsx5("span", { className: "checkbox-label", children: option.label })
+      ] }, option.value)) }, nodeKey);
+    }
+    case "Input": {
+      const fieldName = name || "";
+      const placeholder = props?.placeholder || "";
+      return /* @__PURE__ */ jsx5(
+        "input",
+        {
+          type: "text",
+          className: "schema-input",
+          placeholder,
+          value: values[fieldName] || "",
+          onChange: (e) => onChange(fieldName, e.target.value)
+        },
+        nodeKey
+      );
+    }
+    case "TextArea": {
+      const fieldName = name || "";
+      const placeholder = props?.placeholder || "";
+      const rows = props?.rows || 3;
+      return /* @__PURE__ */ jsx5(
+        "textarea",
+        {
+          className: "schema-textarea",
+          placeholder,
+          rows,
+          value: values[fieldName] || "",
+          onChange: (e) => onChange(fieldName, e.target.value)
+        },
+        nodeKey
+      );
+    }
+    case "Select": {
+      const fieldName = name || "";
+      const placeholder = props?.placeholder || "\u8BF7\u9009\u62E9";
+      return /* @__PURE__ */ jsxs5(
+        "select",
+        {
+          className: "schema-select",
+          value: values[fieldName] || "",
+          onChange: (e) => onChange(fieldName, e.target.value),
+          children: [
+            /* @__PURE__ */ jsx5("option", { value: "", disabled: true, children: placeholder }),
+            options?.map((option) => /* @__PURE__ */ jsx5("option", { value: option.value, children: option.label }, option.value))
+          ]
+        },
+        nodeKey
+      );
+    }
+    default:
+      if (children && children.length > 0) {
+        return children.map((child) => renderNode(child, values, onChange, errors));
+      }
+      return null;
+  }
+};
+var extractRules = (node) => {
+  const rules = {};
+  const traverse = (n) => {
+    if (n.name && n.rules) {
+      rules[n.name] = n.rules;
+    }
+    if (n.children) {
+      n.children.forEach(traverse);
+    }
+    if (n.schema) {
+      traverse(n.schema);
+    }
+  };
+  traverse(node);
+  return rules;
+};
+var SchemaFormRenderer = ({
+  schema,
+  onSubmit,
+  awaitCommandUuid
+}) => {
+  const [values, setValues] = useState4({});
+  const [errors, setErrors] = useState4({});
+  const [isSubmitting, setIsSubmitting] = useState4(false);
+  const handleChange = useCallback4((name, value) => {
+    setValues((prev) => ({ ...prev, [name]: value }));
+    setErrors((prev) => {
+      const newErrors = { ...prev };
+      delete newErrors[name];
+      return newErrors;
+    });
+  }, []);
+  const validate = useCallback4(() => {
+    const rules = extractRules(schema);
+    const newErrors = {};
+    Object.entries(rules).forEach(([fieldName, fieldRules]) => {
+      fieldRules.forEach((rule) => {
+        if (rule.required) {
+          const value = values[fieldName];
+          const isEmpty = value === void 0 || value === null || value === "" || Array.isArray(value) && value.length === 0;
+          if (isEmpty) {
+            newErrors[fieldName] = rule.message || "\u6B64\u9879\u4E3A\u5FC5\u586B\u9879";
+          }
+        }
+      });
+    });
+    setErrors(newErrors);
+    return Object.keys(newErrors).length === 0;
+  }, [schema, values]);
+  const handleSubmit = useCallback4(async () => {
+    if (!validate()) return;
+    setIsSubmitting(true);
+    try {
+      await onSubmit?.(values);
+    } finally {
+      setIsSubmitting(false);
+    }
+  }, [validate, values, onSubmit]);
+  return /* @__PURE__ */ jsxs5("div", { className: "schema-form-renderer", children: [
+    renderNode(schema, values, handleChange, errors),
+    /* @__PURE__ */ jsx5("div", { className: "schema-form-actions", children: /* @__PURE__ */ jsx5(
+      "button",
+      {
+        className: "schema-submit-btn",
+        onClick: handleSubmit,
+        disabled: isSubmitting,
+        children: isSubmitting ? "\u63D0\u4EA4\u4E2D..." : "\u63D0\u4EA4"
+      }
+    ) }),
+    awaitCommandUuid && /* @__PURE__ */ jsx5("div", { className: "schema-form-meta", children: /* @__PURE__ */ jsxs5("span", { className: "meta-uuid", children: [
+      "\u8BF7\u6C42 ID: ",
+      awaitCommandUuid.slice(0, 8),
+      "..."
+    ] }) })
+  ] });
+};
+var SchemaFormRenderer_default = SchemaFormRenderer;
+
+// src/components/ToolCardBuffering.tsx
+import { useMemo as useMemo3, useRef as useRef3, memo } from "react";
+
+// src/components/renderers/utils.tsx
+import "react";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+function parseArgsIncremental(argsPreview, cache) {
+  if (!argsPreview) return null;
+  try {
+    cache.current = null;
+    return JSON.parse(argsPreview);
+  } catch {
+  }
+  const prev = cache.current;
+  if (prev && prev.truncatedKey && prev.truncatedValueStart > 0 && argsPreview.length > prev.lastArgsLen) {
+    prev.lastArgsLen = argsPreview.length;
+    const rawValue = argsPreview.slice(prev.truncatedValueStart);
+    return { ...prev.stableFields, [prev.truncatedKey]: decodeJsonEscapes(rawValue) };
+  }
+  const meta = parsePartialJsonWithMeta(argsPreview);
+  if (!meta) return null;
+  const stableFields = { ...meta.fields };
+  if (meta.truncatedKey) {
+    delete stableFields[meta.truncatedKey];
+  }
+  cache.current = {
+    stableFields,
+    truncatedKey: meta.truncatedKey,
+    truncatedValueStart: meta.truncatedValueStart,
+    lastArgsLen: argsPreview.length
+  };
+  return meta.fields;
+}
+function parsePartialJsonWithMeta(raw) {
+  const fields = {};
+  let i = raw.indexOf("{");
+  if (i < 0) return null;
+  i++;
+  let foundAny = false;
+  let truncatedKey = null;
+  let truncatedValueStart = -1;
+  while (i < raw.length) {
+    while (i < raw.length && " 	\r\n,".includes(raw[i])) i++;
+    if (i >= raw.length || raw[i] === "}") break;
+    if (raw[i] !== '"') break;
+    const keyEnd = findClosingQuote(raw, i);
+    if (keyEnd < 0) break;
+    const key = raw.slice(i + 1, keyEnd);
+    i = keyEnd + 1;
+    while (i < raw.length && " 	\r\n".includes(raw[i])) i++;
+    if (i >= raw.length || raw[i] !== ":") break;
+    i++;
+    while (i < raw.length && " 	\r\n".includes(raw[i])) i++;
+    if (i >= raw.length) break;
+    const valueStartPos = raw[i] === '"' ? i + 1 : i;
+    const [value, nextPos, complete] = parseValue(raw, i);
+    if (value !== void 0) {
+      fields[key] = value;
+      foundAny = true;
+    }
+    if (!complete) {
+      truncatedKey = key;
+      truncatedValueStart = valueStartPos;
+      break;
+    }
+    i = nextPos;
+  }
+  return foundAny ? { fields, truncatedKey, truncatedValueStart } : null;
+}
+function decodeJsonEscapes(raw) {
+  let result = "";
+  let i = 0;
+  while (i < raw.length) {
+    if (raw[i] === "\\" && i + 1 < raw.length) {
+      const next = raw[i + 1];
+      switch (next) {
+        case "n":
+          result += "\n";
+          break;
+        case "t":
+          result += "	";
+          break;
+        case "r":
+          result += "\r";
+          break;
+        case '"':
+          result += '"';
+          break;
+        case "\\":
+          result += "\\";
+          break;
+        case "/":
+          result += "/";
+          break;
+        default:
+          result += "\\" + next;
+          break;
+      }
+      i += 2;
+    } else {
+      result += raw[i];
+      i++;
+    }
+  }
+  return result;
+}
+function findClosingQuote(s, openPos) {
+  let i = openPos + 1;
+  while (i < s.length) {
+    if (s[i] === "\\") {
+      i += 2;
+      continue;
+    }
+    if (s[i] === '"') return i;
+    i++;
+  }
+  return -1;
+}
+function parseValue(s, pos) {
+  if (pos >= s.length) return [void 0, pos, false];
+  const ch = s[pos];
+  if (ch === '"') {
+    const end = findClosingQuote(s, pos);
+    if (end < 0) {
+      return [decodeJsonEscapes(s.slice(pos + 1)), s.length, false];
+    }
+    try {
+      const val = JSON.parse(s.slice(pos, end + 1));
+      return [val, end + 1, true];
+    } catch {
+      return [decodeJsonEscapes(s.slice(pos + 1, end)), end + 1, true];
+    }
+  }
+  if ("-0123456789".includes(ch)) {
+    let end = pos + 1;
+    while (end < s.length && "0123456789.eE+-".includes(s[end])) end++;
+    const numStr = s.slice(pos, end);
+    const num = Number(numStr);
+    if (!isNaN(num) && numStr.length > 0) return [num, end, true];
+    return [void 0, end, end < s.length];
+  }
+  if (s.startsWith("true", pos)) return [true, pos + 4, true];
+  if (s.startsWith("false", pos)) return [false, pos + 5, true];
+  if (s.startsWith("null", pos)) return [null, pos + 4, true];
+  if (ch === "{" || ch === "[") {
+    const close = ch === "{" ? "}" : "]";
+    let depth = 1, j = pos + 1, inStr = false;
+    while (j < s.length && depth > 0) {
+      if (inStr) {
+        if (s[j] === "\\") {
+          j += 2;
+          continue;
+        }
+        if (s[j] === '"') inStr = false;
+      } else {
+        if (s[j] === '"') inStr = true;
+        else if (s[j] === ch) depth++;
+        else if (s[j] === close) depth--;
+      }
+      j++;
+    }
+    if (depth === 0) {
+      try {
+        return [JSON.parse(s.slice(pos, j)), j, true];
+      } catch {
+        return [s.slice(pos, j), j, true];
+      }
+    }
+    return [void 0, j, false];
+  }
+  return [void 0, pos + 1, false];
+}
+function extractField(args, fieldName) {
+  if (!args || !fieldName) return void 0;
+  return args[fieldName];
+}
+function formatValue(value) {
+  if (value === void 0 || value === null) return "";
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  return JSON.stringify(value, null, 2);
+}
+function buildCompactTags(args, compactFields, hideFields) {
+  if (!args || !compactFields) return [];
+  const hidden = new Set(hideFields || []);
+  return compactFields.filter((f) => !hidden.has(f) && args[f] !== void 0).map((f) => ({ key: f, value: formatValue(args[f]) }));
+}
+var phaseConfig = {
+  generating: { icon: "\u2699\uFE0F", label: "\u751F\u6210\u4E2D", className: "phase-generating" },
+  executing: { icon: "\u23F3", label: "\u6267\u884C\u4E2D", className: "phase-executing" },
+  complete: { icon: "\u2705", label: "\u5B8C\u6210", className: "phase-complete" },
+  error: { icon: "\u274C", label: "\u5931\u8D25", className: "phase-error" }
+};
+var PhaseLabel = ({ phase }) => {
+  const cfg = phaseConfig[phase];
+  return /* @__PURE__ */ jsxs6("span", { className: "tool-phase-label", children: [
+    cfg?.label || phase,
+    phase === "generating" && /* @__PURE__ */ jsxs6("span", { className: "tool-card-dots", children: [
+      /* @__PURE__ */ jsx6("span", {}),
+      /* @__PURE__ */ jsx6("span", {}),
+      /* @__PURE__ */ jsx6("span", {})
+    ] })
+  ] });
+};
+var CompactTags = ({ tags }) => /* @__PURE__ */ jsxs6("div", { className: "compact-tags", children: [
+  tags.slice(0, 5).map((t) => /* @__PURE__ */ jsxs6("span", { className: "compact-tag", children: [
+    t.key,
+    ": ",
+    t.value
+  ] }, t.key)),
+  tags.length > 5 && /* @__PURE__ */ jsxs6("span", { className: "compact-tag", children: [
+    "+",
+    tags.length - 5
+  ] })
+] });
+
+// src/components/renderers/ContentRenderer.tsx
+import { useState as useState5, useMemo as useMemo2 } from "react";
+import { Fragment as Fragment2, jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+var MAX_PREVIEW_LINES = 2;
+var ContentRenderer = ({ message, uiConfig, parsedArgs, phase }) => {
+  const [expanded, setExpanded] = useState5(false);
+  const headerValue = extractField(parsedArgs, uiConfig.header_field);
+  const primaryValue = extractField(parsedArgs, uiConfig.primary_field);
+  const toolName = message.toolName || "tool";
+  const taskPurpose = message.taskPurpose;
+  const isEdit = toolName === "edit" || toolName === "edit_block";
+  const contentStr = primaryValue ? formatValue(primaryValue) : "";
+  const hasContent = contentStr.length > 0;
+  const isGenerating = phase === "generating";
+  const shortPath = useMemo2(() => {
+    if (!headerValue) return void 0;
+    const full = String(headerValue);
+    const parts = full.split("/");
+    return parts.length > 2 ? `.../${parts.slice(-2).join("/")}` : full;
+  }, [headerValue]);
+  const { previewLines, totalLines } = useMemo2(() => {
+    if (!contentStr) return { previewLines: [], totalLines: 0 };
+    const lines = contentStr.split("\n").filter((l) => l.trim());
+    const total = lines.length;
+    if (isGenerating) {
+      return { previewLines: lines.slice(-MAX_PREVIEW_LINES), totalLines: total };
+    }
+    return { previewLines: lines.slice(0, MAX_PREVIEW_LINES), totalLines: total };
+  }, [contentStr, isGenerating]);
+  const oldValue = isEdit ? extractField(parsedArgs, "old_string") : void 0;
+  const oldPreviewLines = useMemo2(() => {
+    if (!oldValue) return [];
+    const s = formatValue(oldValue);
+    return s.split("\n").filter((l) => l.trim()).slice(0, 1);
+  }, [oldValue]);
+  return /* @__PURE__ */ jsxs7(Fragment2, { children: [
+    /* @__PURE__ */ jsxs7(
+      "div",
+      {
+        className: "tool-card-header",
+        onClick: () => hasContent && setExpanded(!expanded),
+        style: { cursor: hasContent ? "pointer" : "default" },
+        children: [
+          /* @__PURE__ */ jsx7("span", { className: "tool-phase-icon", children: "\u{1F4C4}" }),
+          taskPurpose ? /* @__PURE__ */ jsxs7(Fragment2, { children: [
+            /* @__PURE__ */ jsx7("span", { className: "tool-card-name", children: taskPurpose }),
+            /* @__PURE__ */ jsxs7("span", { className: "tool-card-fn", children: [
+              "(",
+              toolName,
+              ")"
+            ] })
+          ] }) : /* @__PURE__ */ jsx7("span", { className: "tool-card-name", children: toolName }),
+          shortPath && /* @__PURE__ */ jsx7("code", { className: "tool-card-path-inline", children: shortPath }),
+          /* @__PURE__ */ jsx7(PhaseLabel, { phase }),
+          hasContent && /* @__PURE__ */ jsx7("span", { className: "tool-card-expand", children: expanded ? "\u25BC" : "\u25B6" })
+        ]
+      }
+    ),
+    (hasContent || isGenerating) && !expanded && /* @__PURE__ */ jsxs7("div", { className: `content-diff-preview${isGenerating ? " streaming" : ""}`, children: [
+      isEdit && !isGenerating && oldPreviewLines.map((line, i) => /* @__PURE__ */ jsxs7("div", { className: "diff-line diff-remove", children: [
+        /* @__PURE__ */ jsx7("span", { className: "diff-sign", children: "-" }),
+        /* @__PURE__ */ jsx7("span", { className: "diff-text", children: line })
+      ] }, `old-${i}`)),
+      previewLines.length > 0 ? previewLines.map((line, i) => /* @__PURE__ */ jsxs7("div", { className: "diff-line diff-add", children: [
+        /* @__PURE__ */ jsx7("span", { className: "diff-sign", children: "+" }),
+        /* @__PURE__ */ jsxs7("span", { className: "diff-text", children: [
+          line,
+          isGenerating && i === previewLines.length - 1 && /* @__PURE__ */ jsx7("span", { className: "streaming-block-cursor" })
+        ] })
+      ] }, i)) : isGenerating && /* @__PURE__ */ jsxs7("div", { className: "diff-line diff-add", children: [
+        /* @__PURE__ */ jsx7("span", { className: "diff-sign", children: "+" }),
+        /* @__PURE__ */ jsx7("span", { className: "diff-text", children: /* @__PURE__ */ jsx7("span", { className: "streaming-block-cursor" }) })
+      ] }),
+      !isGenerating && totalLines > MAX_PREVIEW_LINES && /* @__PURE__ */ jsxs7("div", { className: "diff-more", children: [
+        "... +",
+        totalLines - MAX_PREVIEW_LINES,
+        " lines"
+      ] })
+    ] }),
+    expanded && /* @__PURE__ */ jsxs7("div", { className: "content-renderer-body", children: [
+      headerValue && /* @__PURE__ */ jsx7("div", { className: "content-renderer-path", children: headerValue }),
+      /* @__PURE__ */ jsx7("pre", { className: "content-renderer-code", children: contentStr })
+    ] })
+  ] });
+};
+var ContentRenderer_default = ContentRenderer;
+
+// src/components/renderers/CommandRenderer.tsx
+import "react";
+import { Fragment as Fragment3, jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
+var CommandRenderer = ({ message, uiConfig, parsedArgs, phase }) => {
+  const command = extractField(parsedArgs, uiConfig.primary_field);
+  const toolName = message.toolName || "tool";
+  const taskPurpose = message.taskPurpose;
+  return /* @__PURE__ */ jsxs8(Fragment3, { children: [
+    /* @__PURE__ */ jsxs8("div", { className: "tool-card-header", children: [
+      /* @__PURE__ */ jsx8("span", { className: "tool-phase-icon", children: "\u{1F4BB}" }),
+      taskPurpose ? /* @__PURE__ */ jsxs8(Fragment3, { children: [
+        /* @__PURE__ */ jsx8("span", { className: "tool-card-name", children: taskPurpose }),
+        /* @__PURE__ */ jsxs8("span", { className: "tool-card-fn", children: [
+          "(",
+          toolName,
+          ")"
+        ] })
+      ] }) : /* @__PURE__ */ jsx8("span", { className: "tool-card-name", children: toolName }),
+      /* @__PURE__ */ jsx8(PhaseLabel, { phase })
+    ] }),
+    command && /* @__PURE__ */ jsxs8("div", { className: "command-renderer-terminal", children: [
+      /* @__PURE__ */ jsx8("span", { className: "command-prompt", children: "$" }),
+      /* @__PURE__ */ jsx8("code", { className: "command-text", children: formatValue(command) })
+    ] })
+  ] });
+};
+var CommandRenderer_default = CommandRenderer;
+
+// src/components/renderers/BrowserRenderer.tsx
+import "react";
+import { Fragment as Fragment4, jsx as jsx9, jsxs as jsxs9 } from "react/jsx-runtime";
+var BROWSER_ICONS = {
+  browser_navigate: "\u{1F310}",
+  browser_navigate1: "\u{1F310}",
+  browser_click: "\u{1F5B1}\uFE0F",
+  browser_click1: "\u{1F5B1}\uFE0F",
+  browser_type: "\u2328\uFE0F",
+  browser_hover: "\u{1F446}",
+  browser_snapshot: "\u{1F4F8}",
+  browser_take_screenshot: "\u{1F4F8}",
+  browser_press_key: "\u2328\uFE0F",
+  browser_drag: "\u2194\uFE0F",
+  browser_tab_new: "\u2795",
+  browser_tab_close: "\u2716\uFE0F",
+  browser_wait: "\u23F1\uFE0F",
+  browser_wait_for: "\u23F1\uFE0F"
+};
+var BrowserRenderer = ({ message, uiConfig, parsedArgs, phase }) => {
+  const toolName = message.toolName || "";
+  const taskPurpose = message.taskPurpose;
+  const icon = BROWSER_ICONS[toolName] || "\u{1F310}";
+  const primaryValue = extractField(parsedArgs, uiConfig.primary_field);
+  return /* @__PURE__ */ jsx9(Fragment4, { children: /* @__PURE__ */ jsxs9("div", { className: "tool-card-header", children: [
+    /* @__PURE__ */ jsx9("span", { className: "tool-phase-icon", children: icon }),
+    taskPurpose ? /* @__PURE__ */ jsxs9(Fragment4, { children: [
+      /* @__PURE__ */ jsx9("span", { className: "tool-card-name", children: taskPurpose }),
+      /* @__PURE__ */ jsxs9("span", { className: "tool-card-fn", children: [
+        "(",
+        toolName,
+        ")"
+      ] })
+    ] }) : /* @__PURE__ */ jsx9("span", { className: "tool-card-name", children: toolName }),
+    primaryValue && /* @__PURE__ */ jsx9("span", { className: "browser-primary-value", children: formatValue(primaryValue) }),
+    /* @__PURE__ */ jsx9(PhaseLabel, { phase })
+  ] }) });
+};
+var BrowserRenderer_default = BrowserRenderer;
+
+// src/components/renderers/QueryRenderer.tsx
+import "react";
+import { Fragment as Fragment5, jsx as jsx10, jsxs as jsxs10 } from "react/jsx-runtime";
+var QueryRenderer = ({ message, uiConfig, parsedArgs, phase }) => {
+  const queryValue = extractField(parsedArgs, uiConfig.primary_field);
+  const headerValue = extractField(parsedArgs, uiConfig.header_field);
+  const toolName = message.toolName || "tool";
+  const taskPurpose = message.taskPurpose;
+  return /* @__PURE__ */ jsx10(Fragment5, { children: /* @__PURE__ */ jsxs10("div", { className: "tool-card-header", children: [
+    /* @__PURE__ */ jsx10("span", { className: "tool-phase-icon", children: "\u{1F50D}" }),
+    taskPurpose ? /* @__PURE__ */ jsxs10(Fragment5, { children: [
+      /* @__PURE__ */ jsx10("span", { className: "tool-card-name", children: taskPurpose }),
+      /* @__PURE__ */ jsxs10("span", { className: "tool-card-fn", children: [
+        "(",
+        toolName,
+        ")"
+      ] })
+    ] }) : /* @__PURE__ */ jsx10("span", { className: "tool-card-name", children: toolName }),
+    queryValue && /* @__PURE__ */ jsxs10("span", { className: "query-inline", children: [
+      '"',
+      formatValue(queryValue),
+      '"'
+    ] }),
+    headerValue && /* @__PURE__ */ jsxs10("span", { className: "query-scope-inline", children: [
+      "in ",
+      formatValue(headerValue)
+    ] }),
+    /* @__PURE__ */ jsx10(PhaseLabel, { phase })
+  ] }) });
+};
+var QueryRenderer_default = QueryRenderer;
+
+// src/components/renderers/PathRenderer.tsx
+import "react";
+import { Fragment as Fragment6, jsx as jsx11, jsxs as jsxs11 } from "react/jsx-runtime";
+var PathRenderer = ({ message, uiConfig, parsedArgs, phase }) => {
+  const pathValue = extractField(parsedArgs, uiConfig.primary_field);
+  const toolName = message.toolName || "tool";
+  const taskPurpose = message.taskPurpose;
+  const isDir = ["list_directory", "create_directory", "mkdir", "rmdir"].includes(toolName);
+  const icon = isDir ? "\u{1F4C2}" : "\u{1F4C4}";
+  return /* @__PURE__ */ jsx11(Fragment6, { children: /* @__PURE__ */ jsxs11("div", { className: "tool-card-header", children: [
+    /* @__PURE__ */ jsx11("span", { className: "tool-phase-icon", children: icon }),
+    taskPurpose ? /* @__PURE__ */ jsxs11(Fragment6, { children: [
+      /* @__PURE__ */ jsx11("span", { className: "tool-card-name", children: taskPurpose }),
+      /* @__PURE__ */ jsxs11("span", { className: "tool-card-fn", children: [
+        "(",
+        toolName,
+        ")"
+      ] })
+    ] }) : /* @__PURE__ */ jsx11("span", { className: "tool-card-name", children: toolName }),
+    pathValue && /* @__PURE__ */ jsx11("code", { className: "tool-card-path-inline", children: formatValue(pathValue) }),
+    /* @__PURE__ */ jsx11(PhaseLabel, { phase })
+  ] }) });
+};
+var PathRenderer_default = PathRenderer;
+
+// src/components/renderers/TriggerRenderer.tsx
+import { useState as useState6 } from "react";
+import { Fragment as Fragment7, jsx as jsx12, jsxs as jsxs12 } from "react/jsx-runtime";
+var TriggerRenderer = ({ message, uiConfig, parsedArgs, phase }) => {
+  const [expanded, setExpanded] = useState6(false);
+  const headerValue = extractField(parsedArgs, uiConfig.header_field);
+  const primaryValue = extractField(parsedArgs, uiConfig.primary_field);
+  const tags = buildCompactTags(parsedArgs, uiConfig.compact_fields, uiConfig.hide_fields);
+  const toolLabel = message.taskPurpose || message.toolName || "tool";
+  const hasDetail = !!parsedArgs && Object.keys(parsedArgs).length > 0;
+  return /* @__PURE__ */ jsxs12(Fragment7, { children: [
+    /* @__PURE__ */ jsxs12(
+      "div",
+      {
+        className: "tool-card-header",
+        onClick: () => hasDetail && setExpanded(!expanded),
+        style: { cursor: hasDetail ? "pointer" : "default" },
+        children: [
+          /* @__PURE__ */ jsx12("span", { className: "tool-phase-icon", children: "\u23F0" }),
+          /* @__PURE__ */ jsx12("span", { className: "tool-card-name", children: toolLabel }),
+          (headerValue || primaryValue) && /* @__PURE__ */ jsx12("span", { className: "trigger-title", children: formatValue(headerValue || primaryValue) }),
+          /* @__PURE__ */ jsx12(PhaseLabel, { phase }),
+          hasDetail && /* @__PURE__ */ jsx12("span", { className: "tool-card-expand", children: expanded ? "\u25BC" : "\u25B6" })
+        ]
+      }
+    ),
+    tags.length > 0 && /* @__PURE__ */ jsx12(CompactTags, { tags }),
+    expanded && parsedArgs && /* @__PURE__ */ jsx12("div", { className: "trigger-detail", children: Object.entries(parsedArgs).filter(([k]) => !uiConfig.hide_fields?.includes(k)).map(([k, v]) => /* @__PURE__ */ jsxs12("div", { className: "trigger-row", children: [
+      /* @__PURE__ */ jsx12("span", { className: "trigger-key", children: k }),
+      /* @__PURE__ */ jsx12("span", { className: "trigger-value", children: formatValue(v) })
+    ] }, k)) })
+  ] });
+};
+var TriggerRenderer_default = TriggerRenderer;
+
+// src/components/renderers/ThinkingRenderer.tsx
+import "react";
+import { Fragment as Fragment8, jsx as jsx13, jsxs as jsxs13 } from "react/jsx-runtime";
+var ThinkingRenderer = ({ message, uiConfig, parsedArgs, phase }) => {
+  const thought = extractField(parsedArgs, uiConfig.primary_field);
+  const stepInfo = parsedArgs ? `${parsedArgs.thoughtNumber || "?"}/${parsedArgs.totalThoughts || "?"}` : "";
+  return /* @__PURE__ */ jsxs13(Fragment8, { children: [
+    /* @__PURE__ */ jsxs13("div", { className: "tool-card-header", children: [
+      /* @__PURE__ */ jsx13("span", { className: "tool-phase-icon", children: "\u{1F4AD}" }),
+      /* @__PURE__ */ jsx13("span", { className: "tool-card-name", children: "\u601D\u8003\u63A8\u7406" }),
+      stepInfo && /* @__PURE__ */ jsxs13("span", { className: "thinking-step", children: [
+        "\u6B65\u9AA4 ",
+        stepInfo
+      ] }),
+      /* @__PURE__ */ jsx13(PhaseLabel, { phase })
+    ] }),
+    thought && /* @__PURE__ */ jsx13("div", { className: "thinking-bubble", children: formatValue(thought) })
+  ] });
+};
+var ThinkingRenderer_default = ThinkingRenderer;
+
+// src/components/renderers/ParamsRenderer.tsx
+import { useState as useState7 } from "react";
+import { Fragment as Fragment9, jsx as jsx14, jsxs as jsxs14 } from "react/jsx-runtime";
+var ParamsRenderer = ({ message, uiConfig, parsedArgs, phase }) => {
+  const [expanded, setExpanded] = useState7(false);
+  const headerValue = extractField(parsedArgs, uiConfig?.header_field);
+  const toolName = message.toolName || "tool";
+  const taskPurpose = message.taskPurpose;
+  const hasArgs = !!parsedArgs && Object.keys(parsedArgs).length > 0;
+  return /* @__PURE__ */ jsxs14(Fragment9, { children: [
+    /* @__PURE__ */ jsxs14(
+      "div",
+      {
+        className: "tool-card-header",
+        onClick: () => hasArgs && setExpanded(!expanded),
+        style: { cursor: hasArgs ? "pointer" : "default" },
+        children: [
+          /* @__PURE__ */ jsx14("span", { className: "tool-phase-icon", children: "\u2699\uFE0F" }),
+          taskPurpose ? /* @__PURE__ */ jsxs14(Fragment9, { children: [
+            /* @__PURE__ */ jsx14("span", { className: "tool-card-name", children: taskPurpose }),
+            /* @__PURE__ */ jsxs14("span", { className: "tool-card-fn", children: [
+              "(",
+              toolName,
+              ")"
+            ] })
+          ] }) : /* @__PURE__ */ jsx14("span", { className: "tool-card-name", children: toolName }),
+          headerValue && /* @__PURE__ */ jsx14("code", { className: "tool-card-path-inline", children: formatValue(headerValue) }),
+          /* @__PURE__ */ jsx14(PhaseLabel, { phase }),
+          hasArgs && /* @__PURE__ */ jsx14("span", { className: "tool-card-expand", children: expanded ? "\u25BC" : "\u25B6" })
+        ]
+      }
+    ),
+    expanded && parsedArgs && /* @__PURE__ */ jsx14("div", { className: "params-detail", children: Object.entries(parsedArgs).filter(([k]) => !uiConfig?.hide_fields?.includes(k)).map(([k, v]) => /* @__PURE__ */ jsxs14("div", { className: "params-row", children: [
+      /* @__PURE__ */ jsxs14("span", { className: "params-key", children: [
+        k,
+        ":"
+      ] }),
+      /* @__PURE__ */ jsx14("span", { className: "params-value", children: formatValue(v) })
+    ] }, k)) })
+  ] });
+};
+var ParamsRenderer_default = ParamsRenderer;
+
+// src/components/renderers/ToolResultRenderer.tsx
+import { useState as useState8 } from "react";
+import { jsx as jsx15, jsxs as jsxs15 } from "react/jsx-runtime";
+function tryParseJson(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function isSearchResultsShape(data) {
+  if (!data || typeof data !== "object") return false;
+  const obj = data;
+  const sr = obj.search_results;
+  return sr != null && Array.isArray(sr.results) && sr.results.length > 0;
+}
+function isScrapeResultShape(data) {
+  if (!data || typeof data !== "object") return false;
+  const obj = data;
+  return typeof obj.url === "string" && obj.url.length > 0 && !("search_results" in obj) && (typeof obj.title === "string" || typeof obj.snippet === "string");
+}
+var SearchResultsView = ({ query, results }) => /* @__PURE__ */ jsxs15("div", { className: "tool-result-search", children: [
+  query && /* @__PURE__ */ jsxs15("div", { className: "tool-result-search-query", children: [
+    "\u{1F50D} ",
+    query
+  ] }),
+  /* @__PURE__ */ jsxs15("div", { className: "tool-result-search-list", children: [
+    results.slice(0, 8).map((r, i) => /* @__PURE__ */ jsxs15(
+      "a",
+      {
+        className: "tool-result-search-item",
+        href: r.link,
+        target: "_blank",
+        rel: "noopener noreferrer",
+        children: [
+          /* @__PURE__ */ jsx15("div", { className: "search-item-title", children: r.title }),
+          /* @__PURE__ */ jsx15("div", { className: "search-item-snippet", children: r.snippet }),
+          r.date && /* @__PURE__ */ jsx15("span", { className: "search-item-date", children: r.date })
+        ]
+      },
+      i
+    )),
+    results.length > 8 && /* @__PURE__ */ jsxs15("div", { className: "search-item-more", children: [
+      "+",
+      results.length - 8,
+      " more"
+    ] })
+  ] })
+] });
+var ScrapeResultView = ({ result }) => /* @__PURE__ */ jsxs15("div", { className: "tool-result-scrape", children: [
+  /* @__PURE__ */ jsxs15(
+    "a",
+    {
+      className: "scrape-result-link",
+      href: result.url,
+      target: "_blank",
+      rel: "noopener noreferrer",
+      children: [
+        result.title && /* @__PURE__ */ jsx15("div", { className: "scrape-result-title", children: result.title }),
+        /* @__PURE__ */ jsx15("div", { className: "scrape-result-url", children: result.url })
+      ]
+    }
+  ),
+  result.snippet && /* @__PURE__ */ jsx15("div", { className: "scrape-result-snippet", children: result.snippet })
+] });
+var JsonView = ({ data }) => {
+  const formatted = JSON.stringify(data, null, 2);
+  const lines = formatted.split("\n");
+  const needsTruncation = lines.length > 12;
+  const [showAll, setShowAll] = useState8(false);
+  const display = showAll ? formatted : lines.slice(0, 12).join("\n");
+  return /* @__PURE__ */ jsxs15("div", { className: "tool-result-json", children: [
+    /* @__PURE__ */ jsx15("pre", { className: "tool-result-json-code", children: display }),
+    needsTruncation && !showAll && /* @__PURE__ */ jsxs15("div", { className: "tool-result-json-more", onClick: () => setShowAll(true), children: [
+      "\u5C55\u5F00\u5168\u90E8 (",
+      lines.length,
+      " \u884C)"
+    ] })
+  ] });
+};
+var ToolResultRenderer = ({ content, defaultExpanded = false }) => {
+  const [isExpanded, setIsExpanded] = useState8(defaultExpanded);
+  if (!content.trim()) return null;
+  const parsed = tryParseJson(content);
+  const summaryText = (() => {
+    if (parsed && isSearchResultsShape(parsed)) {
+      const count = parsed.search_results.results.length;
+      return `\u641C\u7D22\u7ED3\u679C \xB7 ${count} \u6761`;
+    }
+    if (parsed && isScrapeResultShape(parsed)) {
+      const title = parsed.title || new URL(parsed.url).hostname;
+      return `\u6293\u53D6\u7ED3\u679C \xB7 ${title}`;
+    }
+    if (parsed) {
+      const str = JSON.stringify(parsed);
+      return str.length > 60 ? str.slice(0, 60) + "\u2026" : str;
+    }
+    return content.length > 80 ? content.slice(0, 80) + "\u2026" : content;
+  })();
+  return /* @__PURE__ */ jsxs15("div", { className: "tool-result-section", children: [
+    /* @__PURE__ */ jsxs15("div", { className: "tool-result-header", onClick: () => setIsExpanded(!isExpanded), children: [
+      /* @__PURE__ */ jsx15("span", { className: "tool-result-label", children: "\u{1F4CB} \u6267\u884C\u7ED3\u679C" }),
+      /* @__PURE__ */ jsx15("span", { className: "tool-result-summary", children: summaryText }),
+      /* @__PURE__ */ jsx15("span", { className: `collapse-arrow ${isExpanded ? "expanded" : ""}`, children: "\u25BC" })
+    ] }),
+    isExpanded && /* @__PURE__ */ jsx15("div", { className: "tool-result-body", children: parsed && isSearchResultsShape(parsed) ? /* @__PURE__ */ jsx15(SearchResultsView, { query: parsed.query, results: parsed.search_results.results }) : parsed && isScrapeResultShape(parsed) ? /* @__PURE__ */ jsx15(ScrapeResultView, { result: parsed }) : parsed ? /* @__PURE__ */ jsx15(JsonView, { data: parsed }) : /* @__PURE__ */ jsx15("div", { className: "tool-result-text", children: content }) })
+  ] });
+};
+var ToolResultRenderer_default = ToolResultRenderer;
+
+// src/components/ToolCardBuffering.tsx
+import { jsx as jsx16, jsxs as jsxs16 } from "react/jsx-runtime";
+var renderers = {
+  content: ContentRenderer_default,
+  command: CommandRenderer_default,
+  browser: BrowserRenderer_default,
+  query: QueryRenderer_default,
+  path: PathRenderer_default,
+  trigger: TriggerRenderer_default,
+  thinking: ThinkingRenderer_default,
+  params: ParamsRenderer_default
+};
+var ToolCardBuffering = memo(({ message }) => {
+  const phase = message.toolPhase || "generating";
+  const config = phaseConfig[phase];
+  const uiConfig = message.uiConfig || { display_type: "params" };
+  const parseCacheRef = useRef3(null);
+  const parsedArgs = useMemo3(
+    () => parseArgsIncremental(message.argsPreview, parseCacheRef),
+    [message.argsPreview]
+  );
+  const displayType = uiConfig.display_type || "params";
+  const Renderer = renderers[displayType] || ParamsRenderer_default;
+  const resultContent = message.contentChunks.join("");
+  const hasResult = resultContent.trim().length > 0;
+  return /* @__PURE__ */ jsxs16("div", { className: `tool-card-buffering ${config.className}`, children: [
+    /* @__PURE__ */ jsx16(
+      Renderer,
+      {
+        message,
+        uiConfig,
+        parsedArgs,
+        phase
+      }
+    ),
+    hasResult && /* @__PURE__ */ jsx16(ToolResultRenderer_default, { content: resultContent })
+  ] });
+});
+var ToolCardBuffering_default = ToolCardBuffering;
+
+// src/components/MessageContent.tsx
+import { Fragment as Fragment10, jsx as jsx17, jsxs as jsxs17 } from "react/jsx-runtime";
+var math = createMathPlugin({ singleDollarTextMath: true });
+var streamdownPlugins = { code, mermaid, math, cjk };
+function countOccurrences(text, needle) {
+  let count = 0;
+  let pos = 0;
+  while (pos < text.length) {
+    const idx = text.indexOf(needle, pos);
+    if (idx === -1) break;
+    count++;
+    pos = idx + needle.length;
+  }
+  return count;
+}
+function snapToSafeBoundary(content, length) {
+  if (length >= content.length) return content.length;
+  if (length === 0) return 0;
+  const slice = content.slice(0, length);
+  const lastNL = slice.lastIndexOf("\n");
+  const currentLine = slice.slice(lastNL + 1);
+  if (/^`{3,}/.test(currentLine)) {
+    const lineEnd = content.indexOf("\n", lastNL + 1);
+    return lineEnd !== -1 ? lineEnd + 1 : content.length;
+  }
+  if (/`{1,2}$/.test(currentLine) && length < content.length && content[length] === "`") {
+    const lineEnd = content.indexOf("\n", lastNL + 1);
+    return lineEnd !== -1 ? lineEnd + 1 : content.length;
+  }
+  if (slice.endsWith("$") && length < content.length && content[length] === "$") {
+    return snapToSafeBoundary(content, length + 1);
+  }
+  const ddCount = countOccurrences(slice, "$$");
+  if (ddCount % 2 === 1) {
+    const closeIdx = content.indexOf("$$", length);
+    if (closeIdx !== -1) {
+      return Math.min(closeIdx + 2, content.length);
+    }
+  }
+  const totalDollars = countOccurrences(slice, "$");
+  const singleDollars = totalDollars - 2 * ddCount;
+  if (singleDollars % 2 === 1) {
+    let searchPos = length;
+    while (searchPos < content.length) {
+      const idx = content.indexOf("$", searchPos);
+      if (idx === -1) break;
+      if (idx + 1 < content.length && content[idx + 1] === "$") {
+        searchPos = idx + 2;
+        continue;
+      }
+      if (idx > 0 && content[idx - 1] === "$") {
+        searchPos = idx + 1;
+        continue;
+      }
+      return Math.min(idx + 1, content.length);
+    }
+  }
+  return length;
+}
+function useTypewriter(content, enabled, speed = 30) {
+  const [displayedLength, setDisplayedLength] = useState9(0);
+  const [isTyping, setIsTyping] = useState9(false);
+  const rafRef = useRef4(null);
+  const targetLengthRef = useRef4(0);
+  const displayedLengthRef = useRef4(0);
+  displayedLengthRef.current = displayedLength;
+  useEffect2(() => {
+    if (!enabled) {
+      setDisplayedLength(content.length);
+      targetLengthRef.current = content.length;
+      return;
+    }
+    targetLengthRef.current = content.length;
+    if (rafRef.current) return;
+    if (displayedLengthRef.current >= content.length) return;
+    setIsTyping(true);
+    let lastTime = performance.now();
+    const animate = (currentTime) => {
+      const deltaTime = currentTime - lastTime;
+      lastTime = currentTime;
+      const charsToAdd = Math.max(1, Math.ceil(deltaTime / speed));
+      const currentDisplayed = displayedLengthRef.current;
+      const target = targetLengthRef.current;
+      const raw = Math.min(currentDisplayed + charsToAdd, target);
+      const newLength = snapToSafeBoundary(content, raw);
+      setDisplayedLength(newLength);
+      displayedLengthRef.current = newLength;
+      if (newLength >= target) {
+        setIsTyping(false);
+        rafRef.current = null;
+      } else {
+        rafRef.current = requestAnimationFrame(animate);
+      }
+    };
+    rafRef.current = requestAnimationFrame(animate);
+    return () => {
+      if (rafRef.current) {
+        cancelAnimationFrame(rafRef.current);
+        rafRef.current = null;
+      }
+    };
+  }, [content, enabled, speed]);
+  return [content.slice(0, displayedLength), isTyping];
+}
+var MessageContent = memo2(({
+  message,
+  enableTypewriter = true,
+  typewriterSpeed = 30,
+  onArtifactClick
+}) => {
+  const content = message.contentChunks.join("");
+  const isTextType = message.contentType === "text";
+  const [displayedContent, isTyping] = useTypewriter(
+    content,
+    enableTypewriter && isTextType,
+    typewriterSpeed
+  );
+  if (message.contentType === "think") {
+    return /* @__PURE__ */ jsx17(ThinkChunk, { content, isThinking: isTyping });
+  }
+  if (message.contentType === "json_schema_wait" || message.contentType === "json_schema" || message.contentType === "html_schema") {
+    return /* @__PURE__ */ jsx17(HITLWaitCard, { content, hitlRequest: message.hitlRequest });
+  }
+  if (message.contentType === "artifact" && (message.artifacts || message.artifact)) {
+    const artifacts = message.artifacts || (message.artifact ? [message.artifact] : []);
+    return /* @__PURE__ */ jsx17("div", { className: "artifact-list", children: artifacts.map((artifact, index) => /* @__PURE__ */ jsx17(
+      ArtifactCard,
+      {
+        artifact,
+        onClick: () => onArtifactClick?.(artifact)
+      },
+      artifact.id || index
+    )) });
+  }
+  if (message.toolPhase) {
+    return /* @__PURE__ */ jsx17(ToolCardBuffering_default, { message });
+  }
+  const isMcpEvent = message.notificationType && ["mcp_start", "mcp_result", "mcp_end"].includes(message.notificationType);
+  if (isMcpEvent) {
+    const toolName = message.toolName || (() => {
+      const match = content.match(/[🔧\s]*(.+?)\s*\((\w+)\)/) || content.match(/[🔧\s]*execute tool:\s*(\S+)/);
+      return match ? match[2] || match[1] : null;
+    })();
+    const toolLabelMatch = content.match(/[🔧\s]*(.+?)\s*\(/);
+    const toolLabel = toolLabelMatch ? toolLabelMatch[1].trim() : message.taskPurpose || toolName || content;
+    let statusIcon = "\u{1F527}";
+    let statusClass = "";
+    let statusText = "";
+    if (message.notificationType === "mcp_start") {
+      statusIcon = "\u23F3";
+      statusClass = "tool-running";
+      statusText = "\u6267\u884C\u4E2D";
+    } else if (message.notificationType === "mcp_end") {
+      if (message.toolStatus === "error") {
+        statusIcon = "\u274C";
+        statusClass = "tool-error";
+        statusText = "\u5931\u8D25";
+      } else {
+        statusIcon = "\u2705";
+        statusClass = "tool-success";
+        statusText = "\u5B8C\u6210";
+      }
+    } else {
+      statusIcon = "\u{1F527}";
+      statusClass = "tool-running";
+    }
+    return /* @__PURE__ */ jsxs17("div", { className: `tool-execution ${statusClass}`, children: [
+      /* @__PURE__ */ jsx17("span", { className: "tool-icon", children: statusIcon }),
+      /* @__PURE__ */ jsxs17("span", { className: "tool-text", children: [
+        toolLabel,
+        toolName && toolName !== toolLabel ? ` (${toolName})` : ""
+      ] }),
+      statusText && /* @__PURE__ */ jsx17("span", { className: "tool-status", children: statusText })
+    ] });
+  }
+  const toolLineRegex = /^[🔧\s]*execute tool:\s*(\S+)\s*$/m;
+  const toolMatch = content.match(toolLineRegex);
+  if (toolMatch) {
+    const toolName = toolMatch[1];
+    const matchIndex = content.indexOf(toolMatch[0]);
+    const beforeContent = content.slice(0, matchIndex).trim();
+    const afterContent = content.slice(matchIndex + toolMatch[0].length).trim();
+    return /* @__PURE__ */ jsxs17(Fragment10, { children: [
+      beforeContent && /* @__PURE__ */ jsx17("div", { className: "sd-message", children: /* @__PURE__ */ jsx17(Streamdown, { plugins: streamdownPlugins, children: beforeContent }) }),
+      /* @__PURE__ */ jsxs17("div", { className: "tool-execution", children: [
+        /* @__PURE__ */ jsx17("span", { className: "tool-icon", children: "\u{1F527}" }),
+        /* @__PURE__ */ jsxs17("span", { className: "tool-text", children: [
+          "\u6267\u884C\u5DE5\u5177: ",
+          toolName
+        ] })
+      ] }),
+      afterContent && /* @__PURE__ */ jsx17("div", { className: "sd-message", children: /* @__PURE__ */ jsx17(Streamdown, { plugins: streamdownPlugins, children: afterContent }) })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs17("div", { className: "sd-message", children: [
+    /* @__PURE__ */ jsx17(
+      Streamdown,
+      {
+        plugins: streamdownPlugins,
+        isAnimating: isTyping,
+        children: displayedContent
+      }
+    ),
+    isTyping && /* @__PURE__ */ jsx17("span", { className: "streaming-cursor" })
+  ] });
+});
+var ThinkChunk = ({ content, isThinking = false }) => {
+  const [isExpanded, setIsExpanded] = useState9(false);
+  const [manualToggled, setManualToggled] = useState9(false);
+  const [prevContentLength, setPrevContentLength] = useState9(0);
+  const [thinking, setThinking] = useState9(true);
+  const previewRef = useRef4(null);
+  const isActive = thinking || isThinking;
+  const thinkingTimerRef = useRef4(null);
+  useEffect2(() => {
+    if (content.length > prevContentLength) {
+      setThinking(true);
+      setPrevContentLength(content.length);
+      if (thinkingTimerRef.current) {
+        clearTimeout(thinkingTimerRef.current);
+        thinkingTimerRef.current = null;
+      }
+    }
+    thinkingTimerRef.current = setTimeout(() => {
+      if (content.length === prevContentLength) {
+        setThinking(false);
+      }
+    }, 5e3);
+    return () => {
+      if (thinkingTimerRef.current) {
+        clearTimeout(thinkingTimerRef.current);
+      }
+    };
+  }, [content, prevContentLength]);
+  useEffect2(() => {
+    if (previewRef.current && isActive && !isExpanded) {
+      previewRef.current.scrollTop = previewRef.current.scrollHeight;
+    }
+  }, [content, isActive, isExpanded]);
+  const extractHeading = (text) => {
+    const match = text.match(/^#\s+(.+)$/m);
+    return match ? match[1].trim() : null;
+  };
+  const heading = extractHeading(content);
+  const displayText = heading ? heading : isActive ? "\u601D\u8003\u4E2D..." : "\u601D\u8003\u5B8C\u6210";
+  const showPreview = isActive && !manualToggled && !isExpanded && content.length > 0;
+  const [previewVisible, setPreviewVisible] = useState9(false);
+  useEffect2(() => {
+    if (showPreview) {
+      setPreviewVisible(true);
+    } else if (previewVisible) {
+      const t = setTimeout(() => setPreviewVisible(false), 600);
+      return () => clearTimeout(t);
+    }
+  }, [showPreview]);
+  const handleToggle = () => {
+    setManualToggled(true);
+    setPreviewVisible(false);
+    setIsExpanded(!isExpanded);
+  };
+  return /* @__PURE__ */ jsxs17("div", { className: `think-chunk ${isExpanded ? "expanded" : ""} ${isActive ? "thinking" : ""}`, children: [
+    /* @__PURE__ */ jsxs17(
+      "div",
+      {
+        className: "think-header",
+        onClick: handleToggle,
+        children: [
+          /* @__PURE__ */ jsxs17("div", { className: "think-title", children: [
+            /* @__PURE__ */ jsx17("span", { className: `think-icon ${isActive ? "thinking-animation" : ""}`, children: "\u{1F4AD}" }),
+            /* @__PURE__ */ jsx17("span", { className: "think-text", children: displayText }),
+            isActive && /* @__PURE__ */ jsxs17("span", { className: "thinking-dots", children: [
+              /* @__PURE__ */ jsx17("span", { children: "." }),
+              /* @__PURE__ */ jsx17("span", { children: "." }),
+              /* @__PURE__ */ jsx17("span", { children: "." })
+            ] })
+          ] }),
+          /* @__PURE__ */ jsx17("span", { className: `collapse-arrow ${isExpanded || previewVisible ? "expanded" : ""}`, children: "\u25BC" })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx17(
+      "div",
+      {
+        className: `think-preview ${previewVisible ? "think-preview-open" : "think-preview-closed"}`,
+        ref: previewRef,
+        children: /* @__PURE__ */ jsx17("div", { className: "sd-think", children: /* @__PURE__ */ jsx17(Streamdown, { plugins: streamdownPlugins, isAnimating: isActive, children: content }) })
+      }
+    ),
+    isExpanded && /* @__PURE__ */ jsx17("div", { className: "think-content", children: /* @__PURE__ */ jsx17("div", { className: "sd-think", children: /* @__PURE__ */ jsx17(Streamdown, { plugins: streamdownPlugins, children: content }) }) })
+  ] });
+};
+var HITLWaitCard = ({ content, hitlRequest }) => {
+  const parseFirstJson = (str) => {
+    try {
+      return JSON.parse(str);
+    } catch {
+      let depth = 0;
+      let start = -1;
+      for (let i = 0; i < str.length; i++) {
+        if (str[i] === "{") {
+          if (depth === 0) start = i;
+          depth++;
+        } else if (str[i] === "}") {
+          depth--;
+          if (depth === 0 && start !== -1) {
+            try {
+              return JSON.parse(str.slice(start, i + 1));
+            } catch {
+              start = -1;
+            }
+          }
+        }
+      }
+      return null;
+    }
+  };
+  const getDisplayText = () => {
+    const parsed = parseFirstJson(content);
+    if (!parsed) {
+      return content || "\u7B49\u5F85\u7528\u6237\u8F93\u5165...";
+    }
+    if (parsed.content !== void 0) {
+      let langContent = parsed.content;
+      if (typeof langContent === "string") {
+        try {
+          langContent = JSON.parse(langContent);
+        } catch {
+          return langContent || "\u7B49\u5F85\u7528\u6237\u8F93\u5165...";
+        }
+      }
+      if (typeof langContent === "object" && langContent !== null) {
+        const langObj = langContent;
+        return langObj.zh_CN || langObj.en_US || JSON.stringify(langContent);
+      }
+      return String(langContent) || "\u7B49\u5F85\u7528\u6237\u8F93\u5165...";
+    }
+    if (parsed.zh_CN || parsed.en_US) {
+      return parsed.zh_CN || parsed.en_US;
+    }
+    if (parsed.type && parsed.props?.title) {
+      return parsed.props.title;
+    }
+    return content;
+  };
+  const getFormSchema = () => {
+    const parsed = parseFirstJson(content);
+    if (parsed) {
+      if (parsed.type && (parsed.children || parsed.props)) {
+        return parsed;
+      }
+    }
+    if (hitlRequest?.schema) {
+      return hitlRequest.schema;
+    }
+    return null;
+  };
+  const displayText = getDisplayText();
+  const formSchema = getFormSchema();
+  if (formSchema) {
+    const schemaObj = formSchema;
+    const title = schemaObj.props?.title || hitlRequest?.title || "\u8BF7\u586B\u5199\u8868\u5355";
+    const handleFormSubmit = (values) => {
+      console.log("[HITL] \u8868\u5355\u63D0\u4EA4:", values, "await_command_uuid:", hitlRequest?.await_command_uuid);
+    };
+    return /* @__PURE__ */ jsxs17("div", { className: "hitl-form-card", children: [
+      /* @__PURE__ */ jsxs17("div", { className: "hitl-form-header", children: [
+        /* @__PURE__ */ jsx17("span", { className: "hitl-form-icon", children: "\u{1F4CB}" }),
+        /* @__PURE__ */ jsx17("span", { className: "hitl-form-title", children: title })
+      ] }),
+      /* @__PURE__ */ jsx17("div", { className: "hitl-form-body", children: /* @__PURE__ */ jsx17(
+        SchemaFormRenderer_default,
+        {
+          schema: formSchema,
+          onSubmit: handleFormSubmit,
+          awaitCommandUuid: hitlRequest?.await_command_uuid
+        }
+      ) })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs17("div", { className: "hitl-wait-card", children: [
+    /* @__PURE__ */ jsx17("div", { className: "hitl-icon", children: "\u23F3" }),
+    /* @__PURE__ */ jsxs17("div", { className: "hitl-content", children: [
+      /* @__PURE__ */ jsx17("div", { className: "hitl-text", children: displayText }),
+      hitlRequest?.await_command_uuid && /* @__PURE__ */ jsxs17("div", { className: "hitl-uuid", children: [
+        "ID: ",
+        hitlRequest.await_command_uuid.slice(0, 8),
+        "..."
+      ] })
+    ] })
+  ] });
+};
+var ArtifactCard = ({ artifact, onClick }) => {
+  const iconMap = {
+    "text/markdown": "\u{1F4DD}",
+    "text/plain": "\u{1F4C4}",
+    "application/json": "\u{1F4CA}",
+    "image/": "\u{1F5BC}\uFE0F",
+    "application/pdf": "\u{1F4D5}"
+  };
+  const icon = Object.entries(iconMap).find(
+    ([type]) => artifact.type.startsWith(type)
+  )?.[1] || "\u{1F4CE}";
+  return /* @__PURE__ */ jsxs17("div", { className: "artifact-card", onClick, children: [
+    /* @__PURE__ */ jsx17("span", { className: "artifact-icon", children: icon }),
+    /* @__PURE__ */ jsxs17("div", { className: "artifact-info", children: [
+      /* @__PURE__ */ jsx17("div", { className: "artifact-name", children: artifact.name }),
+      /* @__PURE__ */ jsx17("div", { className: "artifact-meta", children: artifact.type })
+    ] }),
+    artifact.size && /* @__PURE__ */ jsx17("span", { className: "artifact-size", children: artifact.size })
+  ] });
+};
+var MessageContent_default = MessageContent;
+
+// src/components/ChildAgentCard.tsx
+import { useState as useState10, useRef as useRef5, useEffect as useEffect3 } from "react";
+import { jsx as jsx18, jsxs as jsxs18 } from "react/jsx-runtime";
+var ChildAgentCard = ({
+  message,
+  children,
+  maxHeight = 200,
+  config,
+  onArtifactClick,
+  defaultExpanded = false,
+  parentTaskPurpose
+}) => {
+  const [isExpanded, setIsExpanded] = useState10(defaultExpanded);
+  const contentRef = useRef5(null);
+  const hasActiveContent = children.some(
+    (m) => m.contentType === "text" && m.contentChunks.join("").trim()
+  );
+  const status = hasActiveContent ? "completed" : "running";
+  useEffect3(() => {
+    if (isExpanded && contentRef.current) {
+      contentRef.current.scrollTop = contentRef.current.scrollHeight;
+    }
+  }, [isExpanded, children]);
+  const cardTitle = parentTaskPurpose || message.taskPurpose || message.agentName;
+  return /* @__PURE__ */ jsxs18("div", { className: `child-agent-card ${isExpanded ? "expanded" : ""}`, children: [
+    /* @__PURE__ */ jsxs18(
+      "div",
+      {
+        className: "child-agent-header",
+        onClick: () => setIsExpanded(!isExpanded),
+        children: [
+          /* @__PURE__ */ jsx18("div", { className: "child-agent-title", children: /* @__PURE__ */ jsx18("span", { className: "card-title", children: cardTitle }) }),
+          /* @__PURE__ */ jsxs18("div", { className: "child-agent-status", children: [
+            /* @__PURE__ */ jsxs18("span", { className: `status-badge status-${status}`, children: [
+              /* @__PURE__ */ jsx18("span", { className: `status-icon ${status === "running" ? "spinning" : ""}`, children: status === "running" ? "\u23F3" : "\u2713" }),
+              /* @__PURE__ */ jsx18("span", { className: "status-text", children: status === "running" ? "\u6267\u884C\u4E2D" : "\u5DF2\u5B8C\u6210" })
+            ] }),
+            /* @__PURE__ */ jsx18("span", { className: `collapse-arrow ${isExpanded ? "expanded" : ""}`, children: "\u25BC" })
+          ] })
+        ]
+      }
+    ),
+    isExpanded && /* @__PURE__ */ jsxs18(
+      "div",
+      {
+        className: "child-agent-content",
+        ref: contentRef,
+        style: { maxHeight },
+        children: [
+          /* @__PURE__ */ jsxs18("div", { className: "child-agent-inner", children: [
+            message.contentChunks.length > 0 && /* @__PURE__ */ jsx18(
+              MessageContent_default,
+              {
+                message,
+                enableTypewriter: config?.enableTypewriter,
+                typewriterSpeed: config?.typewriterSpeed,
+                onArtifactClick
+              },
+              message.id
+            ),
+            mergeConsecutiveThinkMessages(children).map((childMsg) => /* @__PURE__ */ jsx18(
+              MessageContent_default,
+              {
+                message: childMsg,
+                enableTypewriter: config?.enableTypewriter,
+                typewriterSpeed: config?.typewriterSpeed,
+                onArtifactClick
+              },
+              childMsg.id
+            ))
+          ] }),
+          /* @__PURE__ */ jsxs18("div", { className: "child-agent-footer", children: [
+            /* @__PURE__ */ jsx18("span", { className: "footer-agent-icon", children: "\u{1F916}" }),
+            /* @__PURE__ */ jsx18("span", { className: "footer-agent-name", children: message.agentName })
+          ] })
+        ]
+      }
+    )
+  ] });
+};
+var ChildAgentCard_default = ChildAgentCard;
+
+// src/ChatWidget.tsx
+import { jsx as jsx19, jsxs as jsxs19 } from "react/jsx-runtime";
+var HYSTERESIS_THRESHOLD = 30;
+var DEBOUNCE_DELAY = 150;
+var FADE_DURATION = 150;
+function convertTurnsToRounds(turns) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const t of turns) {
+    const iid = t.interaction_id;
+    if (!groups.has(iid)) groups.set(iid, []);
+    groups.get(iid).push(t);
+  }
+  const rounds = [];
+  let roundIdx = 0;
+  for (const [interactionId, group] of groups) {
+    const userTurn = group.find((t) => t.type === "user_input");
+    const userText = userTurn ? (userTurn.contents || []).map((c) => c.content || "").join("") : "(\u5386\u53F2\u6D88\u606F)";
+    const agentMessages = [];
+    for (const turn of group) {
+      if (turn.type === "user_input") continue;
+      const contents = turn.contents || [];
+      if (contents.length === 0 && !turn.type.startsWith("mcp_")) continue;
+      const ext = turn.ext || {};
+      if (contents.length > 0) {
+        for (let i = 0; i < contents.length; i++) {
+          const part = contents[i];
+          const partType = part.type || "text";
+          let contentType = "text";
+          if (partType === "think") contentType = "think";
+          else if (partType === "plan") contentType = "plan";
+          else if (partType === "artifact") contentType = "artifact";
+          else if (partType === "json_schema") contentType = "json_schema";
+          else if (partType === "html_schema") contentType = "html_schema";
+          agentMessages.push({
+            id: `hist-${turn.turn_id}-${i}`,
+            agentInstanceId: turn.agent_instance_id || 0,
+            callBatchId: String(turn.call_batch_id || 0),
+            parentCallBatchId: turn.parent_call_batch_id != null ? String(turn.parent_call_batch_id) : void 0,
+            level: turn.level ?? 0,
+            agentName: turn.card_title || turn.agent_id || "Assistant",
+            notificationType: turn.type,
+            toolName: ext.tool_name,
+            toolCallId: ext.tool_call_id,
+            toolStatus: ext.status,
+            taskPurpose: ext.task_purpose || ext._task_purpose,
+            uiConfig: ext.ui_config,
+            parentToolCallId: ext.parent_tool_call_id,
+            contentType,
+            contentChunks: [part.content || ""],
+            timestamp: String(turn.timestamp || ""),
+            toolPhase: turn.type.startsWith("mcp_") ? "complete" : void 0
+          });
+        }
+      } else {
+        agentMessages.push({
+          id: `hist-${turn.turn_id}`,
+          agentInstanceId: turn.agent_instance_id || 0,
+          callBatchId: String(turn.call_batch_id || 0),
+          parentCallBatchId: turn.parent_call_batch_id != null ? String(turn.parent_call_batch_id) : void 0,
+          level: turn.level ?? 0,
+          agentName: turn.card_title || turn.agent_id || "Assistant",
+          notificationType: turn.type,
+          toolName: ext.tool_name,
+          toolCallId: ext.tool_call_id,
+          toolStatus: ext.status,
+          taskPurpose: ext.task_purpose || ext._task_purpose,
+          uiConfig: ext.ui_config,
+          parentToolCallId: ext.parent_tool_call_id,
+          contentType: "text",
+          contentChunks: [],
+          timestamp: String(turn.timestamp || ""),
+          toolPhase: "complete"
+        });
+      }
+    }
+    roundIdx++;
+    const ts = group[0]?.timestamp_start || group[0]?.timestamp;
+    rounds.push({
+      interactionId,
+      index: roundIdx,
+      userMessage: userText,
+      timestamp: ts ? new Date(ts).toISOString() : (/* @__PURE__ */ new Date()).toISOString(),
+      status: "completed",
+      messages: agentMessages
+    });
+  }
+  return rounds;
+}
+var ChatWidget = ({
+  adapter,
+  sessionId: propSessionId,
+  initialMessages: _initialMessages,
+  config: userConfig,
+  renderHeaderExtra,
+  renderFooter,
+  onArtifactClick,
+  onHITLSubmit: _onHITLSubmit,
+  onStatusChange,
+  onError,
+  onReady,
+  className,
+  style,
+  height = 600
+}) => {
+  const config = useMemo5(() => ({
+    ...DEFAULT_CONFIG,
+    ...userConfig
+  }), [userConfig]);
+  const {
+    state: aggregatorState,
+    todoMap,
+    processMessage,
+    getRoundsList,
+    startNewRound,
+    loadRounds,
+    finalizeRound
+  } = useMessageAggregator();
+  const [pinnedInteractionId, setPinnedInteractionId] = useState11(null);
+  const [isTransitioning, setIsTransitioning] = useState11(false);
+  const [executionStatus, setExecutionStatus] = useState11("idle");
+  const [currentSessionId, setCurrentSessionId] = useState11(null);
+  const [sessionTitle, setSessionTitle] = useState11("");
+  const [displayedTitle, setDisplayedTitle] = useState11("");
+  const [isTitleAnimating, setIsTitleAnimating] = useState11(false);
+  const sessionTitleFetchedRef = useRef6(false);
+  const agentInstanceMapRef = useRef6(/* @__PURE__ */ new Map());
+  const currentAgentIdRef = useRef6("agent-666");
+  const historyLoadedRef = useRef6(false);
+  useEffect4(() => {
+    if (!propSessionId) return;
+    const numericId = typeof propSessionId === "string" ? parseInt(propSessionId, 10) : propSessionId;
+    if (isNaN(numericId)) return;
+    setCurrentSessionId(numericId);
+    if (historyLoadedRef.current) return;
+    historyLoadedRef.current = true;
+    const loadHistory = async () => {
+      try {
+        console.log("[ChatWidget] Loading session history for:", numericId);
+        const [turns, detail] = await Promise.all([
+          adapter.getSessionHistory(numericId),
+          adapter.getSessionDetail(numericId).catch(() => null)
+        ]);
+        if (detail?.session_title) {
+          setSessionTitle(detail.session_title);
+          sessionTitleFetchedRef.current = true;
+        }
+        if (!turns || turns.length === 0) return;
+        for (const t of turns) {
+          if ((t.level === 0 || t.level == null) && t.agent_instance_id && t.agent_id) {
+            agentInstanceMapRef.current.set(t.agent_id, t.agent_instance_id);
+          }
+        }
+        if (agentInstanceMapRef.current.size > 0) {
+          console.log("[ChatWidget] Restored agent instance map from history:", Object.fromEntries(agentInstanceMapRef.current));
+        }
+        const rounds2 = convertTurnsToRounds(turns);
+        if (rounds2.length > 0) {
+          loadRounds(rounds2);
+          setExecutionStatus("completed");
+          setPinnedInteractionId(rounds2[rounds2.length - 1].interactionId);
+        }
+        console.log("[ChatWidget] Loaded", rounds2.length, "history rounds from", turns.length, "turns");
+      } catch (err) {
+        console.warn("[ChatWidget] Failed to load session history:", err);
+      }
+    };
+    loadHistory();
+  }, [propSessionId, loadRounds]);
+  const handleSSEMessage = useCallback5((message) => {
+    if (message.type === "session_info" && message.session_id) {
+      setCurrentSessionId(message.session_id);
+      sessionTitleFetchedRef.current = false;
+      return;
+    }
+    if (message.notification_type === "session_title" && message.content) {
+      console.log("[ChatWidget] Received session_title:", message.content);
+      setSessionTitle(message.content);
+      sessionTitleFetchedRef.current = true;
+      return;
+    }
+    const msgType = message.type || message.notification_type;
+    if (msgType === "compression_started") {
+      setExecutionStatus("compressing");
+      return;
+    }
+    if (msgType === "compression_completed") {
+      setExecutionStatus("running");
+      return;
+    }
+    if (message.type === "finish") {
+      const iid = message.interaction_id || aggregatorState.currentInteractionId;
+      if (iid) {
+        finalizeRound(iid);
+      }
+      setExecutionStatus("completed");
+      return;
+    }
+    if (message.type === "error") {
+      setExecutionStatus("error");
+      onError?.(new Error(message.content || "Unknown error"));
+      return;
+    }
+    if (message.interaction_id && message.content_type) {
+      if (message.level === 0 && message.agent_instance_id) {
+        const prevId = agentInstanceMapRef.current.get(currentAgentIdRef.current);
+        if (prevId !== message.agent_instance_id) {
+          agentInstanceMapRef.current.set(currentAgentIdRef.current, message.agent_instance_id);
+          console.log("[ChatWidget] Captured level-0 agent instance:", currentAgentIdRef.current, "\u2192", message.agent_instance_id);
+        }
+      }
+      processMessage(message);
+    }
+  }, [processMessage, onError, finalizeRound, aggregatorState.currentInteractionId]);
+  const { status: connectionStatus, connect, disconnect: _disconnect } = useSSE({
+    adapter,
+    onMessage: handleSSEMessage,
+    onError
+  });
+  const [pendingScrollInteractionId, setPendingScrollInteractionId] = useState11(null);
+  const sendMessage = useCallback5((message, agentId = "agent-666") => {
+    const interactionId = crypto.randomUUID();
+    console.log("====== [sendMessage v2] \u53D1\u9001\u65B0\u6D88\u606F ======", { interactionId, message });
+    currentAgentIdRef.current = agentId;
+    sessionTitleFetchedRef.current = false;
+    startNewRound(interactionId, message);
+    console.log("[sendMessage] \u5207\u6362\u7F6E\u9876\u5230:", interactionId);
+    setPinnedInteractionId(interactionId);
+    isUserAtBottomRef.current = true;
+    setPendingScrollInteractionId(interactionId);
+    setExecutionStatus("running");
+    const knownInstanceId = agentInstanceMapRef.current.get(agentId);
+    if (knownInstanceId) {
+      console.log("[sendMessage] \u590D\u7528 agent \u5B9E\u4F8B:", agentId, "\u2192", knownInstanceId);
+    }
+    connect(adapter.getStreamUrl(), {
+      message,
+      agent_id: agentId,
+      agent_instance_id: knownInstanceId,
+      session_id: currentSessionId,
+      interaction_id: interactionId
+    });
+  }, [adapter, currentSessionId, startNewRound, connect]);
+  const messageListRef = useRef6(null);
+  const scrollDebounceTimer = useRef6(null);
+  const lastScrollTop = useRef6(0);
+  const isUserAtBottomRef = useRef6(true);
+  const isProgrammaticScrollRef = useRef6(false);
+  const clearScreenScrollTopRef = useRef6(null);
+  const rounds = useMemo5(() => getRoundsList(), [getRoundsList, aggregatorState]);
+  const getCurrentRound = useCallback5(() => {
+    if (rounds.length === 0) return null;
+    return rounds[rounds.length - 1];
+  }, [rounds]);
+  const pinnedRound = useMemo5(() => {
+    if (!pinnedInteractionId && rounds.length > 0) {
+      return rounds[rounds.length - 1];
+    }
+    return rounds.find((r) => r.interactionId === pinnedInteractionId) || null;
+  }, [rounds, pinnedInteractionId]);
+  const calculatePinnedRound = useCallback5(() => {
+    if (!messageListRef.current || rounds.length === 0) {
+      return rounds[rounds.length - 1]?.interactionId || null;
+    }
+    const listRect = messageListRef.current.getBoundingClientRect();
+    const viewportTop = listRect.top;
+    for (let i = rounds.length - 1; i >= 0; i--) {
+      const round = rounds[i];
+      const container = messageListRef.current.querySelector(
+        `[data-interaction-id="${round.interactionId}"]`
+      );
+      if (!container) continue;
+      const rect = container.getBoundingClientRect();
+      if (rect.top <= viewportTop + 50) {
+        return round.interactionId;
+      }
+      if (i > 0) {
+        if (rect.top <= viewportTop + 100) {
+          return rounds[i - 1].interactionId;
+        }
+      }
+    }
+    return rounds[0]?.interactionId || null;
+  }, [rounds]);
+  const updatePinnedArea = useCallback5((interactionId) => {
+    if (isTransitioning || interactionId === pinnedInteractionId) return;
+    setIsTransitioning(true);
+    setTimeout(() => {
+      setPinnedInteractionId(interactionId);
+      setTimeout(() => {
+        setIsTransitioning(false);
+      }, FADE_DURATION);
+    }, FADE_DURATION);
+  }, [isTransitioning, pinnedInteractionId]);
+  const handleScroll = useCallback5((e) => {
+    const target = e.currentTarget;
+    const currentScrollTop = target.scrollTop;
+    const scrollDelta = Math.abs(currentScrollTop - lastScrollTop.current);
+    if (isProgrammaticScrollRef.current) {
+      lastScrollTop.current = currentScrollTop;
+      return;
+    }
+    const scrollBottom = target.scrollHeight - target.scrollTop - target.clientHeight;
+    isUserAtBottomRef.current = scrollBottom < 50;
+    if (scrollBottom < 50 && clearScreenScrollTopRef.current !== null) {
+      clearScreenScrollTopRef.current = null;
+    }
+    if (scrollDebounceTimer.current) {
+      clearTimeout(scrollDebounceTimer.current);
+    }
+    const newPinnedRound = calculatePinnedRound();
+    if (isTransitioning) {
+      lastScrollTop.current = currentScrollTop;
+      return;
+    }
+    if (newPinnedRound !== pinnedInteractionId) {
+      if (scrollDelta >= HYSTERESIS_THRESHOLD) {
+        updatePinnedArea(newPinnedRound);
+        lastScrollTop.current = currentScrollTop;
+      } else {
+        scrollDebounceTimer.current = window.setTimeout(() => {
+          if (!isTransitioning && !isProgrammaticScrollRef.current) {
+            const confirmedRound = calculatePinnedRound();
+            if (confirmedRound !== pinnedInteractionId) {
+              updatePinnedArea(confirmedRound);
+            }
+          }
+          lastScrollTop.current = target.scrollTop;
+        }, DEBOUNCE_DELAY);
+      }
+    } else {
+      lastScrollTop.current = currentScrollTop;
+    }
+  }, [calculatePinnedRound, updatePinnedArea, isTransitioning, pinnedInteractionId]);
+  const organizeMessagesByLevel = useCallback5((messages) => {
+    const rootMessages = [];
+    const childrenMap = /* @__PURE__ */ new Map();
+    const isChildMessage = (msg) => {
+      const pcb = msg.parentCallBatchId;
+      if (pcb == null || pcb === "" || pcb === "-1") return false;
+      const pcbNum = Number(pcb);
+      if (pcbNum <= 0 || isNaN(pcbNum)) return false;
+      return true;
+    };
+    messages.forEach((msg) => {
+      if (isChildMessage(msg)) {
+        const key = msg.parentToolCallId || String(msg.parentCallBatchId);
+        const children = childrenMap.get(key) || [];
+        children.push(msg);
+        childrenMap.set(key, children);
+      } else {
+        rootMessages.push(msg);
+      }
+    });
+    return { rootMessages, childrenMap };
+  }, []);
+  const [viewerOpen, setViewerOpen] = useState11(false);
+  const [viewerLoading, setViewerLoading] = useState11(false);
+  const [viewerContent, setViewerContent] = useState11(null);
+  const [viewerError, setViewerError] = useState11(null);
+  const [viewerArtifact, setViewerArtifact] = useState11(null);
+  const handleArtifactClick = useCallback5((artifact) => {
+    onArtifactClick?.(artifact);
+    if (!currentSessionId) return;
+    setViewerArtifact(artifact);
+    setViewerOpen(true);
+    setViewerLoading(true);
+    setViewerContent(null);
+    setViewerError(null);
+    adapter.getResourceContent(currentSessionId, artifact.id).then((data) => {
+      setViewerContent(data);
+      setViewerLoading(false);
+    }).catch((err) => {
+      console.error("[ChatWidget] Failed to fetch resource content:", err);
+      setViewerError(err?.message || "\u65E0\u6CD5\u83B7\u53D6\u6587\u4EF6\u5185\u5BB9");
+      setViewerLoading(false);
+    });
+  }, [onArtifactClick, currentSessionId]);
+  const renderRoundMessages = useCallback5((round) => {
+    const { rootMessages: rawRootMessages, childrenMap } = organizeMessagesByLevel(round.messages);
+    const rootMessages = mergeConsecutiveThinkMessages(rawRootMessages);
+    const elements = [];
+    const renderedChildKeys = /* @__PURE__ */ new Set();
+    const isCallAgentToolCard = (msg) => {
+      if (!msg.toolPhase) return false;
+      const name = (msg.toolName || "").toLowerCase();
+      return name.includes("call_agent") || name.includes("callagent");
+    };
+    rootMessages.forEach((msg) => {
+      if (isCallAgentToolCard(msg)) {
+        const childKey = msg.toolCallId && childrenMap.has(msg.toolCallId) ? msg.toolCallId : childrenMap.has(String(msg.callBatchId)) ? String(msg.callBatchId) : null;
+        if (childKey && !renderedChildKeys.has(childKey)) {
+          renderedChildKeys.add(childKey);
+          const children = childrenMap.get(childKey);
+          const childGroups = /* @__PURE__ */ new Map();
+          children.forEach((child) => {
+            const group = childGroups.get(child.agentInstanceId) || [];
+            group.push(child);
+            childGroups.set(child.agentInstanceId, group);
+          });
+          childGroups.forEach((groupChildren, agentInstanceId) => {
+            const firstChild = groupChildren[0];
+            elements.push(
+              /* @__PURE__ */ jsx19(
+                ChildAgentCard_default,
+                {
+                  message: firstChild,
+                  children: groupChildren.slice(1),
+                  maxHeight: config.childAgentMaxHeight,
+                  config,
+                  onArtifactClick: handleArtifactClick,
+                  defaultExpanded: true,
+                  parentTaskPurpose: msg.taskPurpose
+                },
+                `child-${childKey}-${agentInstanceId}`
+              )
+            );
+          });
+          return;
+        }
+      }
+      elements.push(
+        /* @__PURE__ */ jsx19(
+          MessageContent_default,
+          {
+            message: msg,
+            enableTypewriter: config.enableTypewriter,
+            typewriterSpeed: config.typewriterSpeed,
+            onArtifactClick: handleArtifactClick
+          },
+          msg.id
+        )
+      );
+    });
+    return elements;
+  }, [organizeMessagesByLevel, config, handleArtifactClick]);
+  useEffect4(() => {
+    if (rounds.length > 0 && !pinnedInteractionId) {
+      setPinnedInteractionId(rounds[rounds.length - 1].interactionId);
+    }
+  }, [rounds, pinnedInteractionId]);
+  const [containerHeight, setContainerHeight] = useState11(0);
+  const [roundHeights, setRoundHeights] = useState11(/* @__PURE__ */ new Map());
+  useEffect4(() => {
+    if (!messageListRef.current) return;
+    const updateHeight = () => {
+      if (messageListRef.current) {
+        setContainerHeight(messageListRef.current.clientHeight);
+      }
+    };
+    updateHeight();
+    window.addEventListener("resize", updateHeight);
+    return () => window.removeEventListener("resize", updateHeight);
+  }, []);
+  useEffect4(() => {
+    if (!messageListRef.current) return;
+    const roundContainers = messageListRef.current.querySelectorAll(".round-container");
+    if (roundContainers.length === 0) return;
+    const resizeObserver = new ResizeObserver((entries) => {
+      const newHeights = new Map(roundHeights);
+      let changed = false;
+      entries.forEach((entry) => {
+        const interactionId = entry.target.dataset.interactionId;
+        if (interactionId) {
+          const height2 = entry.contentRect.height;
+          if (newHeights.get(interactionId) !== height2) {
+            newHeights.set(interactionId, height2);
+            changed = true;
+          }
+        }
+      });
+      if (changed) {
+        setRoundHeights(newHeights);
+      }
+    });
+    roundContainers.forEach((container) => {
+      resizeObserver.observe(container);
+    });
+    return () => resizeObserver.disconnect();
+  }, [rounds.length]);
+  const getSpacerHeight = useCallback5((interactionId) => {
+    const roundHeight = roundHeights.get(interactionId) || 0;
+    return Math.max(0, containerHeight - roundHeight);
+  }, [containerHeight, roundHeights]);
+  const processedScrollRef = useRef6(null);
+  useEffect4(() => {
+    if (!pendingScrollInteractionId || !messageListRef.current) return;
+    if (processedScrollRef.current === pendingScrollInteractionId) return;
+    const roundExists = rounds.some((r) => r.interactionId === pendingScrollInteractionId);
+    if (!roundExists) return;
+    const targetInteractionId = pendingScrollInteractionId;
+    processedScrollRef.current = targetInteractionId;
+    setPendingScrollInteractionId(null);
+    isProgrammaticScrollRef.current = true;
+    clearScreenScrollTopRef.current = 0;
+    const scrollToRoundTop = () => {
+      if (!messageListRef.current) return;
+      const container = messageListRef.current;
+      const roundElement = container.querySelector(
+        `[data-interaction-id="${targetInteractionId}"]`
+      );
+      if (roundElement) {
+        const targetScrollTop = roundElement.offsetTop - 16 + 20;
+        container.scrollTop = Math.max(0, targetScrollTop);
+        clearScreenScrollTopRef.current = container.scrollTop;
+      }
+    };
+    requestAnimationFrame(scrollToRoundTop);
+    setTimeout(() => {
+      isProgrammaticScrollRef.current = false;
+    }, 200);
+  }, [rounds, pendingScrollInteractionId]);
+  useEffect4(() => {
+    if (isProgrammaticScrollRef.current) return;
+    if (!messageListRef.current || executionStatus !== "running" && executionStatus !== "compressing") return;
+    requestAnimationFrame(() => {
+      if (!messageListRef.current || isProgrammaticScrollRef.current) return;
+      const container = messageListRef.current;
+      const maxScrollTop = container.scrollHeight - container.clientHeight;
+      const currentScrollTop = container.scrollTop;
+      if (clearScreenScrollTopRef.current !== null) {
+        const roundContainers = container.querySelectorAll(".round-container");
+        const currentRoundElement = roundContainers[roundContainers.length - 1];
+        if (currentRoundElement) {
+          const roundBottom = currentRoundElement.offsetTop + currentRoundElement.offsetHeight;
+          const visibleBottom = currentScrollTop + container.clientHeight;
+          if (roundBottom > visibleBottom) {
+            const targetScrollTop = roundBottom - container.clientHeight;
+            const finalScrollTop = Math.max(targetScrollTop, clearScreenScrollTopRef.current);
+            container.scrollTop = finalScrollTop;
+          }
+        }
+        return;
+      }
+      if (isUserAtBottomRef.current) {
+        container.scrollTop = maxScrollTop;
+      }
+    });
+  }, [aggregatorState, executionStatus]);
+  const scrollToBottom = useCallback5(() => {
+    if (!messageListRef.current) return;
+    messageListRef.current.scrollTop = messageListRef.current.scrollHeight;
+  }, []);
+  const getStatus = useCallback5(() => executionStatus, [executionStatus]);
+  const widgetAPI = useMemo5(() => ({
+    sendMessage,
+    getCurrentRound,
+    getAllRounds: getRoundsList,
+    scrollToBottom,
+    getStatus
+  }), [sendMessage, getCurrentRound, getRoundsList, scrollToBottom, getStatus]);
+  useEffect4(() => {
+    onReady?.(widgetAPI);
+  }, [onReady, widgetAPI]);
+  useEffect4(() => {
+    onStatusChange?.(executionStatus);
+  }, [executionStatus, onStatusChange]);
+  useEffect4(() => {
+    if (!sessionTitle) {
+      setDisplayedTitle("");
+      setIsTitleAnimating(false);
+      return;
+    }
+    if (sessionTitle !== displayedTitle) {
+      setIsTitleAnimating(true);
+      let currentIndex = 0;
+      const animateTitle = () => {
+        if (currentIndex <= sessionTitle.length) {
+          setDisplayedTitle(sessionTitle.slice(0, currentIndex));
+          currentIndex++;
+          requestAnimationFrame(() => {
+            setTimeout(animateTitle, 50);
+          });
+        } else {
+          setIsTitleAnimating(false);
+        }
+      };
+      setDisplayedTitle("");
+      requestAnimationFrame(animateTitle);
+    }
+  }, [sessionTitle]);
+  const fetchSessionTitle = useCallback5(async (sessionId) => {
+    if (sessionTitleFetchedRef.current) return;
+    try {
+      console.log("[ChatWidget] Fetching session title for session:", sessionId);
+      const detail = await adapter.getSessionDetail(sessionId);
+      if (detail.session_title) {
+        console.log("[ChatWidget] Fetched session title:", detail.session_title);
+        setSessionTitle(detail.session_title);
+        sessionTitleFetchedRef.current = true;
+      }
+    } catch (error) {
+      console.warn("[ChatWidget] Failed to fetch session title:", error);
+    }
+  }, []);
+  useEffect4(() => {
+    if (executionStatus === "completed" && currentSessionId && !sessionTitle && !sessionTitleFetchedRef.current) {
+      const timer = setTimeout(() => {
+        fetchSessionTitle(currentSessionId);
+      }, 500);
+      return () => clearTimeout(timer);
+    }
+  }, [executionStatus, currentSessionId, sessionTitle, fetchSessionTitle]);
+  useEffect4(() => {
+    if (connectionStatus === "connected") {
+      setExecutionStatus("running");
+    } else if (connectionStatus === "disconnected") {
+      setExecutionStatus("completed");
+    } else if (connectionStatus === "error") {
+      setExecutionStatus("error");
+    }
+  }, [connectionStatus]);
+  useEffect4(() => {
+    return () => {
+      if (scrollDebounceTimer.current) {
+        clearTimeout(scrollDebounceTimer.current);
+      }
+    };
+  }, []);
+  const getStatusDisplay = () => {
+    if (executionStatus === "compressing") {
+      return { icon: "\u{1F5DC}\uFE0F", text: "\u4E0A\u4E0B\u6587\u538B\u7F29\u4E2D..." };
+    }
+    switch (connectionStatus) {
+      case "connecting":
+        return { icon: "\u23F3", text: "\u8FDE\u63A5\u4E2D..." };
+      case "connected":
+        return { icon: "\u23F3", text: "\u6267\u884C\u4E2D..." };
+      case "error":
+        return { icon: "\u2717", text: "\u8FDE\u63A5\u9519\u8BEF" };
+      default:
+        return { icon: "\u25CB", text: "\u5F85\u547D" };
+    }
+  };
+  const statusDisplay = getStatusDisplay();
+  return /* @__PURE__ */ jsxs19(
+    "div",
+    {
+      className: `chat-widget ${config.theme} ${className || ""}`,
+      style: { ...style, height },
+      children: [
+        /* @__PURE__ */ jsxs19("div", { className: "chat-header", children: [
+          /* @__PURE__ */ jsxs19("div", { className: "chat-header-title", children: [
+            /* @__PURE__ */ jsx19("span", { className: "header-icon", children: "\u{1F916}" }),
+            /* @__PURE__ */ jsx19("span", { children: "AI \u52A9\u624B" })
+          ] }),
+          displayedTitle && /* @__PURE__ */ jsxs19("div", { className: `session-title ${isTitleAnimating ? "animating" : ""}`, children: [
+            /* @__PURE__ */ jsx19("span", { className: "session-title-text", children: displayedTitle }),
+            isTitleAnimating && /* @__PURE__ */ jsx19("span", { className: "title-cursor", children: "|" })
+          ] }),
+          /* @__PURE__ */ jsxs19("div", { style: { display: "flex", alignItems: "center", gap: 8 }, children: [
+            currentSessionId != null && renderHeaderExtra?.(currentSessionId),
+            /* @__PURE__ */ jsxs19("div", { className: `status-badge status-${connectionStatus}`, children: [
+              /* @__PURE__ */ jsx19("span", { className: "status-icon", children: statusDisplay.icon }),
+              /* @__PURE__ */ jsx19("span", { children: statusDisplay.text })
+            ] })
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs19("div", { className: "message-list-container", children: [
+          config.showPinnedArea && /* @__PURE__ */ jsx19(
+            PinnedArea_default,
+            {
+              round: pinnedRound,
+              isTransitioning,
+              config,
+              todoMap
+            }
+          ),
+          /* @__PURE__ */ jsxs19(
+            "div",
+            {
+              className: "message-list",
+              ref: messageListRef,
+              onScroll: handleScroll,
+              children: [
+                rounds.map((round, index) => /* @__PURE__ */ jsxs19(React19.Fragment, { children: [
+                  index > 0 && /* @__PURE__ */ jsx19("div", { className: "round-separator", children: "\u2191 \u4E0A\u4E00\u8F6E\u5BF9\u8BDD \u2191" }),
+                  /* @__PURE__ */ jsxs19(
+                    "div",
+                    {
+                      className: "round-container",
+                      "data-round": round.index,
+                      "data-interaction-id": round.interactionId,
+                      children: [
+                        /* @__PURE__ */ jsx19(
+                          RoundHeader_default,
+                          {
+                            round,
+                            isPinned: round.interactionId === pinnedInteractionId,
+                            config,
+                            todoMap
+                          }
+                        ),
+                        renderRoundMessages(round)
+                      ]
+                    }
+                  ),
+                  index > 0 && /* @__PURE__ */ jsx19(
+                    "div",
+                    {
+                      className: `clear-screen-spacer ${index < rounds.length - 1 || getSpacerHeight(round.interactionId) <= 0 ? "spacer-collapsed" : ""}`,
+                      style: { height: index < rounds.length - 1 ? 0 : Math.max(0, getSpacerHeight(round.interactionId)) },
+                      "data-spacer-for": round.interactionId
+                    }
+                  )
+                ] }, round.interactionId)),
+                rounds.length === 0 && /* @__PURE__ */ jsxs19("div", { className: "empty-state", children: [
+                  /* @__PURE__ */ jsx19("span", { className: "empty-icon", children: "\u{1F4AC}" }),
+                  /* @__PURE__ */ jsx19("span", { className: "empty-text", children: "\u7B49\u5F85\u5BF9\u8BDD\u5F00\u59CB..." })
+                ] })
+              ]
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx19("div", { className: "chat-footer", children: renderFooter ? renderFooter(widgetAPI) : "\u7531 JetAgents \u9A71\u52A8" }),
+        viewerOpen && /* @__PURE__ */ jsx19("div", { className: "artifact-viewer-overlay", onClick: () => setViewerOpen(false), children: /* @__PURE__ */ jsxs19("div", { className: "artifact-viewer-panel", onClick: (e) => e.stopPropagation(), children: [
+          /* @__PURE__ */ jsxs19("div", { className: "artifact-viewer-header", children: [
+            /* @__PURE__ */ jsxs19("div", { className: "artifact-viewer-title", children: [
+              /* @__PURE__ */ jsx19("span", { className: "artifact-viewer-icon", children: "\u{1F4C4}" }),
+              /* @__PURE__ */ jsx19("span", { children: viewerArtifact?.name || "\u6587\u4EF6\u5185\u5BB9" })
+            ] }),
+            /* @__PURE__ */ jsx19("button", { className: "artifact-viewer-close", onClick: () => setViewerOpen(false), children: "\u2715" })
+          ] }),
+          viewerContent && /* @__PURE__ */ jsxs19("div", { className: "artifact-viewer-meta", children: [
+            /* @__PURE__ */ jsx19("span", { children: viewerContent.mime_type || "\u672A\u77E5\u7C7B\u578B" }),
+            viewerContent.file_size != null && /* @__PURE__ */ jsx19("span", { children: viewerContent.file_size > 1024 ? `${(viewerContent.file_size / 1024).toFixed(1)} KB` : `${viewerContent.file_size} B` }),
+            /* @__PURE__ */ jsx19("span", { className: "artifact-viewer-path", children: viewerContent.git_path })
+          ] }),
+          /* @__PURE__ */ jsxs19("div", { className: "artifact-viewer-body", children: [
+            viewerLoading && /* @__PURE__ */ jsxs19("div", { className: "artifact-viewer-loading", children: [
+              /* @__PURE__ */ jsx19("span", { className: "loading-spinner" }),
+              /* @__PURE__ */ jsx19("span", { children: "\u52A0\u8F7D\u4E2D..." })
+            ] }),
+            viewerError && /* @__PURE__ */ jsx19("div", { className: "artifact-viewer-error", children: viewerError }),
+            viewerContent && !viewerContent.is_binary && /* @__PURE__ */ jsx19("pre", { className: "artifact-viewer-content", children: viewerContent.content }),
+            viewerContent?.is_binary && /* @__PURE__ */ jsx19("div", { className: "artifact-viewer-binary", children: "\u4E8C\u8FDB\u5236\u6587\u4EF6\uFF0C\u65E0\u6CD5\u76F4\u63A5\u9884\u89C8" })
+          ] })
+        ] }) })
+      ]
+    }
+  );
+};
+var ChatWidget_default = ChatWidget;
+
+// src/errors.ts
+var ChatWidgetAuthError = class extends Error {
+  name = "ChatWidgetAuthError";
+  constructor(message = "Authentication failed") {
+    super(message);
+  }
+};
+var ChatWidgetNetworkError = class extends Error {
+  constructor(message, statusCode) {
+    super(message);
+    this.statusCode = statusCode;
+  }
+  name = "ChatWidgetNetworkError";
+};
+
+// src/adapters/DefaultJetAgentsAdapter.ts
+var DefaultJetAgentsAdapter = class {
+  baseUrl;
+  options;
+  refreshPromise = null;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.options = options;
+  }
+  async createSession(agentId) {
+    const res = await this.fetchJSON(
+      "/api/session/create",
+      {
+        method: "POST",
+        body: JSON.stringify({ agent_id: agentId, type: "user_input", contents: [{ type: "text", content: "" }] })
+      }
+    );
+    return { sessionId: res.session_id, instanceId: res.user_caller_instance };
+  }
+  async getSessionDetail(sessionId) {
+    const res = await this.fetchJSON(`/api/session/detail/${sessionId}`);
+    return res;
+  }
+  async getSessionHistory(sessionId) {
+    const res = await this.fetchJSON(`/api/session/messages/${sessionId}`);
+    return res.turns ?? (Array.isArray(res) ? res : []);
+  }
+  async getResourceContent(sessionId, resourceId) {
+    const res = await this.fetchJSON(`/api/workspace/resource/${sessionId}/${resourceId}/content`);
+    return res.data ?? res;
+  }
+  async submitHITLResponse(response) {
+    await this.fetchJSON("/api/human-response", {
+      method: "POST",
+      body: JSON.stringify(response)
+    });
+  }
+  getStreamUrl() {
+    return `${this.baseUrl}/api/session/send_message`;
+  }
+  getAuthHeaders() {
+    const headers = {};
+    const token = this.options.getToken();
+    if (token) {
+      headers["Authorization"] = `Bearer ${token}`;
+    }
+    const orgId = this.options.getOrgId?.();
+    if (orgId) {
+      headers["X-Org-Id"] = orgId;
+    }
+    return headers;
+  }
+  onAuthFailure() {
+    this.options.onAuthFailure?.();
+  }
+  async refreshAuth() {
+    if (!this.options.refreshToken) return false;
+    if (this.refreshPromise) {
+      return this.refreshPromise;
+    }
+    this.refreshPromise = this.options.refreshToken().then((token) => token !== null).finally(() => {
+      this.refreshPromise = null;
+    });
+    return this.refreshPromise;
+  }
+  async fetchJSON(path, init) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = {
+      "Content-Type": "application/json",
+      ...this.getAuthHeaders()
+    };
+    const response = await fetch(url, {
+      ...init,
+      headers: { ...headers, ...init?.headers }
+    });
+    if (response.status === 401) {
+      const refreshed = await this.refreshAuth();
+      if (refreshed) {
+        const retryHeaders = {
+          "Content-Type": "application/json",
+          ...this.getAuthHeaders()
+        };
+        const retryResponse = await fetch(url, {
+          ...init,
+          headers: { ...retryHeaders, ...init?.headers }
+        });
+        if (retryResponse.ok) {
+          return retryResponse.json();
+        }
+      }
+      this.onAuthFailure();
+      throw new ChatWidgetAuthError("Authentication failed");
+    }
+    if (!response.ok) {
+      throw new ChatWidgetNetworkError(
+        `Request failed: ${response.status} ${response.statusText}`,
+        response.status
+      );
+    }
+    return response.json();
+  }
+};
+export {
+  ChatWidget_default as ChatWidget,
+  ChatWidgetAuthError,
+  ChatWidgetNetworkError,
+  ChildAgentCard_default as ChildAgentCard,
+  DEFAULT_CONFIG,
+  DefaultJetAgentsAdapter,
+  MessageContent_default as MessageContent,
+  PinnedArea_default as PinnedArea,
+  PlanCard_default as PlanCard,
+  RoundHeader_default as RoundHeader,
+  SchemaFormRenderer_default as SchemaFormRenderer,
+  TodoCard_default as TodoCard,
+  ToolCardBuffering_default as ToolCardBuffering,
+  isTodoNotificationContent,
+  mergeConsecutiveThinkMessages,
+  useMessageAggregator,
+  useSSE
+};
+//# sourceMappingURL=index.js.map