langchain_agentx_stream_ui 0.6.2 → 0.6.8

package/dist/{chunk-DJPNJBFL.js → chunk-UBYOUDQE.js}

@@ -15,7 +15,7 @@ import {
   extractLastToolInfoFromProgress,
   formatExploreSummaryText,
   formatThoughtDurationPrefix
-} from "./chunk-ZR37OKV6.js";
+} from "./chunk-7XSQYG3X.js";
 
 // src/types/tree.ts
 function createEmptyTree() {
@@ -85,6 +85,8 @@ var DEFAULT_EVENT_TIERS = {
   "task-progress": "debug",
   "task-notification-enqueued": "debug",
   "task-notification-consumed": "debug",
+  /** 与 subagent-end 同级 collapsed（不可当可丢 debug） */
+  "task-notification": "collapsed",
   "task-terminated": "debug",
   "task-list-snapshot": "state",
   error: "main",
@@ -113,7 +115,7 @@ function resolveToolParentId(event, ctx, eventIndex) {
   return toolNodeIdFromEvent(event, eventIndex);
 }
 function isSubagentFoldEvent(event) {
-  if (event.event_type === "subagent-start" || event.event_type === "subagent-end" || event.event_type === "subagent-tool-call" || event.event_type === "subagent-tool-result" || event.event_type === "subagent-transcript-message" || event.event_type === "subagent-model-step") {
+  if (event.event_type === "subagent-start" || event.event_type === "subagent-end" || event.event_type === "subagent-tool-call" || event.event_type === "subagent-tool-result" || event.event_type === "subagent-transcript-message" || event.event_type === "subagent-model-step" || event.event_type === "task-notification") {
     return true;
   }
   if (event.event_type === "tool-progress") {
@@ -124,7 +126,12 @@ function isSubagentFoldEvent(event) {
 }
 function resolveAgentToolParentId(event) {
   const data = event.data;
-  if (data.tool_call_id) return `tool:${data.tool_call_id}`;
+  if (typeof data.tool_call_id === "string" && data.tool_call_id) {
+    return `tool:${data.tool_call_id}`;
+  }
+  if (typeof data.tool_use_id === "string" && data.tool_use_id) {
+    return `tool:${data.tool_use_id}`;
+  }
   return void 0;
 }
 function classifyEvent(event, ctx, overrides, eventIndex = 0) {
@@ -525,6 +532,150 @@ function formatModelRetryCategoryLabel(category) {
   }
 }
 
+// src/core/finishCancel.ts
+var DEFAULT_DISPLAY_INTERRUPT_TEXT = "[Request interrupted by user]";
+var USER_CANCEL_TERMINAL_REASONS = /* @__PURE__ */ new Set([
+  "aborted_streaming",
+  "aborted_tools"
+]);
+function isUserCancelledFinish(data) {
+  if (data.error_kind === "hook_stopped") return false;
+  if (data.error_kind === "user_cancelled") return true;
+  const reason = typeof data.terminal_reason === "string" ? data.terminal_reason : "";
+  if (USER_CANCEL_TERMINAL_REASONS.has(reason)) return true;
+  return false;
+}
+function isHookStoppedFinish(data) {
+  return data.error_kind === "hook_stopped";
+}
+function classifyFinishErrorPresentation(data) {
+  if (isHookStoppedFinish(data)) return "hook_stopped";
+  if (isUserCancelledFinish(data)) return "interrupt";
+  return "error";
+}
+function resolveInterruptDisplayText(data) {
+  if (typeof data.display_interrupt_text === "string" && data.display_interrupt_text.trim()) {
+    return data.display_interrupt_text.trim();
+  }
+  return DEFAULT_DISPLAY_INTERRUPT_TEXT;
+}
+function resolveHookStoppedMessage(data) {
+  if (Array.isArray(data.errors) && data.errors.length > 0) {
+    return data.errors.map(String).join("\n");
+  }
+  return "Stopped by hook";
+}
+
+// src/core/taskNotification.ts
+function trimStr(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function markTaskNotificationClosed(tree, taskId) {
+  tree.meta.taskNotificationClosedIds = {
+    ...tree.meta.taskNotificationClosedIds ?? {},
+    [taskId]: true
+  };
+}
+function isTaskNotificationClosed(tree, taskId) {
+  return tree.meta.taskNotificationClosedIds?.[taskId] === true;
+}
+function findTaskNotificationTarget(tree, data) {
+  const toolUseId = trimStr(data.tool_use_id);
+  const agentId = trimStr(data.agent_id);
+  const taskId = trimStr(data.task_id);
+  if (toolUseId) {
+    const byTool = findAgentToolCallNodeByCallId(tree, toolUseId);
+    if (byTool) {
+      return { nodeId: byTool.id, agentId: agentId || taskId || null };
+    }
+  }
+  const sessionKey = agentId || taskId;
+  if (sessionKey) {
+    for (const node of Object.values(tree.byId)) {
+      if (node?.kind !== "tool_call" || node.toolName !== "Agent") continue;
+      if (node.subagentSessions?.[sessionKey]) {
+        return { nodeId: node.id, agentId: sessionKey };
+      }
+    }
+  }
+  if (taskId) {
+    const byTaskAsCall = findAgentToolCallNodeByCallId(tree, taskId);
+    if (byTaskAsCall) {
+      return { nodeId: byTaskAsCall.id, agentId: agentId || null };
+    }
+  }
+  return null;
+}
+function finalizeRunningProgressForAgent(tool, agentId, terminal) {
+  const progress = tool.subagentProgress;
+  if (!progress?.length || !agentId) return progress;
+  return progress.map(
+    (entry) => entry.agentId === agentId && entry.status === "running" ? { ...entry, status: terminal } : entry
+  );
+}
+function hasRunningSession(sessions) {
+  return Object.values(sessions).some((marker) => marker.status === "running");
+}
+function applyTaskNotification(tree, data, endedAt) {
+  const taskId = trimStr(data.task_id);
+  if (!taskId) return false;
+  if (isTaskNotificationClosed(tree, taskId)) return false;
+  const status = data.status;
+  if (status !== "stopped" && status !== "completed" && status !== "failed") {
+    return false;
+  }
+  const target = findTaskNotificationTarget(tree, data);
+  if (!target) return false;
+  const tool = tree.byId[target.nodeId];
+  if (!tool || tool.kind !== "tool_call") return false;
+  const agentKey = target.agentId;
+  let nextSessions = tool.subagentSessions ?? {};
+  let sessionChanged = false;
+  if (agentKey) {
+    const existing = nextSessions[agentKey];
+    if (!existing || existing.status === "running") {
+      nextSessions = upsertSubagentSession(nextSessions, {
+        agentId: agentKey,
+        subagentType: existing?.subagentType,
+        status: "done",
+        startedAt: existing?.startedAt ?? endedAt,
+        endedAt
+      });
+      sessionChanged = true;
+    }
+  }
+  const progressTerminal = status === "completed" ? "completed" : "error";
+  const hasRunningProgress = !!agentKey && !!tool.subagentProgress?.some(
+    (entry) => entry.agentId === agentKey && entry.status === "running"
+  );
+  const nextProgress = hasRunningProgress ? finalizeRunningProgressForAgent(tool, agentKey, progressTerminal) : tool.subagentProgress;
+  const progressChanged = nextProgress !== tool.subagentProgress;
+  let nextToolStatus = tool.status;
+  let nextEndedAt = tool.endedAt;
+  let toolStatusChanged = false;
+  if (tool.status === "running") {
+    const shouldCloseParent = !agentKey || !hasRunningSession(nextSessions);
+    if (shouldCloseParent) {
+      nextToolStatus = status === "completed" ? "done" : "failed";
+      nextEndedAt = endedAt;
+      toolStatusChanged = true;
+    }
+  }
+  if (!sessionChanged && !progressChanged && !toolStatusChanged) {
+    markTaskNotificationClosed(tree, taskId);
+    return false;
+  }
+  tree.byId[target.nodeId] = {
+    ...tool,
+    status: nextToolStatus,
+    endedAt: nextEndedAt,
+    subagentSessions: nextSessions,
+    subagentProgress: nextProgress
+  };
+  markTaskNotificationClosed(tree, taskId);
+  return true;
+}
+
 // src/core/reducer.ts
 function isInternalTool(toolName) {
   return INTERNAL_TOOL_NAMES.has(toolName);
@@ -722,17 +873,34 @@ function resolveFinishErrorMessage(data) {
   return "Agent finished with an error";
 }
 function appendFinishErrorNode(tree, event, data, seq) {
-  const { message, type } = resolveErrorEventFields({
-    message: resolveFinishErrorMessage(data),
-    type: typeof data.error_kind === "string" && data.error_kind || typeof data.terminal_reason === "string" && data.terminal_reason || void 0
-  });
+  const presentation = classifyFinishErrorPresentation(data);
+  let message;
+  let type;
+  let variant = "error";
+  if (presentation === "interrupt") {
+    message = resolveInterruptDisplayText(data);
+    type = typeof data.error_kind === "string" && data.error_kind || typeof data.terminal_reason === "string" && data.terminal_reason || "user_cancelled";
+    variant = "interrupt";
+  } else if (presentation === "hook_stopped") {
+    message = resolveHookStoppedMessage(data);
+    type = "hook_stopped";
+    variant = "hook_stopped";
+  } else {
+    const resolved = resolveErrorEventFields({
+      message: resolveFinishErrorMessage(data),
+      type: typeof data.error_kind === "string" && data.error_kind || typeof data.terminal_reason === "string" && data.terminal_reason || void 0
+    });
+    message = resolved.message;
+    type = resolved.type;
+  }
   const id = `finish-error:${seq}`;
   const node = {
     kind: "error",
     id,
     message,
     errorType: type,
-    startedAt: eventTimeToMs(event.timestamp)
+    startedAt: eventTimeToMs(event.timestamp),
+    variant
   };
   tree.byId[id] = node;
   appendMainStageChild(tree, id, event, seq);
@@ -1266,6 +1434,13 @@ function handleToolProgress(tree, event, parentNodeId, _seq) {
     }
   });
 }
+function handleTaskNotification(tree, event) {
+  applyTaskNotification(
+    tree,
+    event.data,
+    eventTimeToMs(event.timestamp)
+  );
+}
 function handleSubagentBoundaryStart(tree, event, parentNodeId, options) {
   const data = event.data;
   let parentId = parentNodeId;
@@ -1601,6 +1776,9 @@ function applyClassified(tree, classified, eventIndex, options) {
         break;
       case "subagent-model-step":
         break;
+      case "task-notification":
+        handleTaskNotification(tree, event);
+        break;
       case "start-step":
         handleStepStart(tree, event, parentNodeId, seq);
         break;
@@ -1806,6 +1984,9 @@ function resolveWorkflowBanner(state) {
     return { kind: "sync_failed", message: "\u540C\u6B65\u72B6\u6001\u5931\u8D25\uFF0C\u8BF7\u5237\u65B0" };
   }
   const auth = state.authority?.status;
+  if (auth === "canceled") {
+    return { kind: "canceled", message: "\u5DF2\u53D6\u6D88" };
+  }
   if (auth === "error") {
     return { kind: "authority_error", message: "Workflow \u6267\u884C\u5931\u8D25" };
   }
@@ -1834,6 +2015,12 @@ function resolveWorkflowBanner(state) {
       message: `\u4F20\u8F93\u5F02\u5E38\uFF0C\u5C55\u793A\u53EF\u80FD\u4E0D\u5B8C\u6574${suffix}`
     };
   }
+  if (state.meta.loopDisplayTruncated) {
+    return {
+      kind: "loop_display_truncated",
+      message: "\u8F83\u65E9\u7684\u65F6\u95F4\u7EBF\u5DF2\u622A\u65AD\u4EE5\u63A7\u5236\u5185\u5B58\uFF0C\u6700\u65B0\u5DE5\u5177\u6D3B\u52A8\u4ECD\u5728\u66F4\u65B0"
+    };
+  }
   if (state.display.terminalKind === "forced_closeout" && auth === "done") {
     return { kind: "forced_closeout", message: "Workflow \u5DF2\u7ED3\u675F\uFF08\u90E8\u5206\u5BB9\u5668\u672A\u6B63\u5E38\u5173\u95ED\uFF09" };
   }
@@ -4087,6 +4274,13 @@ function shouldShowAgentSpinner(state) {
   if (isAuthorityTerminalStatus(auth)) return false;
   return true;
 }
+function isAgentInputLocked(state) {
+  if (!state.authorityBindingActive) {
+    const status = state.tree.status;
+    return status === "running" || status === "connecting";
+  }
+  return !isAuthorityTerminalStatus(state.authority?.status);
+}
 
 // src/view/TaskList.tsx
 import { useEffect as useEffect3, useMemo as useMemo4, useRef as useRef2, useState as useState3 } from "react";
@@ -5694,6 +5888,7 @@ export {
   CollapsedExploreNode,
   SystemSummaryNode,
   shouldShowAgentSpinner,
+  isAgentInputLocked,
   TaskList,
   Spinner,
   formatTaskFooterLabel,
@@ -5707,4 +5902,4 @@ export {
   VirtualTimeline,
   SessionTimeline
 };
-//# sourceMappingURL=chunk-DJPNJBFL.js.map
+//# sourceMappingURL=chunk-UBYOUDQE.js.map