langchain_agentx_stream_ui 0.6.4 → 0.7.0

package/dist/{chunk-O5GERXTY.js → chunk-EFJMU4WW.js}

@@ -10,12 +10,18 @@ import {
   SILENT_TASK_TOOL_NAMES,
   SubagentTranscriptBlock,
   Write,
+  classifyFinishErrorPresentation,
+  classifyToolCancelSoftKind,
   coerceSubagentProgressEntries,
   createDefaultToolRegistry,
   extractLastToolInfoFromProgress,
+  extractToolCancelSignals,
   formatExploreSummaryText,
-  formatThoughtDurationPrefix
-} from "./chunk-GYFC2DI7.js";
+  formatThoughtDurationPrefix,
+  resolveHookStoppedMessage,
+  resolveInterruptDisplayText,
+  resolveToolCancelDisplayText
+} from "./chunk-GLUQUP3A.js";
 
 // src/types/tree.ts
 function createEmptyTree() {
@@ -85,6 +91,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 +121,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 +132,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) {
@@ -288,7 +301,7 @@ function updateParallelAgentTextGate(tree) {
   }
   const allTerminal = ids.every((id) => {
     const node = findAgentToolCallNodeByCallId(tree, id);
-    return node != null && (node.status === "done" || node.status === "failed");
+    return node != null && (node.status === "done" || node.status === "failed" || node.status === "cancelled");
   });
   if (allTerminal) {
     return { ...tree, parallelAgentTextGateCallIds: null };
@@ -525,6 +538,116 @@ function formatModelRetryCategoryLabel(category) {
   }
 }
 
+// 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 +845,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);
@@ -1183,22 +1323,47 @@ function handleToolResult(tree, event, seq) {
 }
 function handleToolError(tree, event, seq) {
   const id = toolNodeId(tree, event);
-  const data = event.data;
+  const raw = event.data ?? {};
   const existing = tree.byId[id];
-  const toolName = resolveToolName(event, data, existing);
-  const dataRecord = data;
+  const toolName = resolveToolName(event, raw, existing);
+  const dataRecord = raw;
   const isSubagentLeak = resolveSubagentToolLeak(tree, dataRecord, toolName, existing);
   const isHidden = isInternalTool(toolName) || existing?.hidden === true || isSubagentLeak;
-  const failedResult = {
+  const cancelSignals = extractToolCancelSignals(raw);
+  const softKind = classifyToolCancelSoftKind(cancelSignals);
+  const cancelled = softKind != null;
+  const message = cancelSignals.message || typeof raw.message === "string" && raw.message || typeof raw.error === "string" && raw.error || "Unknown error";
+  const errType = cancelSignals.error_type || cancelSignals.type || (typeof raw.type === "string" ? raw.type : void 0);
+  const failedResult = cancelled ? {
+    schema_version: "2",
+    status: "error",
+    summary: resolveToolCancelDisplayText(softKind),
+    payload: cancelSignals.payload ?? message,
+    blocks: [],
+    artifacts: [],
+    hints: null,
+    meta: {
+      error_kind: cancelSignals.error_kind ?? (softKind === "canceled" ? "user_cancelled" : "aborted"),
+      terminal_state: "cancelled",
+      cancel_ui_kind: softKind
+    },
+    // 保留 type=cancelled，供 AgentToolBody / finalize 识别；文案用 soft Interrupted
+    error: {
+      message: resolveToolCancelDisplayText(softKind),
+      type: "cancelled"
+    },
+    truncated: false,
+    overflow_file: null
+  } : {
     schema_version: "1",
     status: "failed",
-    summary: data.message,
+    summary: message,
     payload: null,
     blocks: [],
     artifacts: [],
     hints: null,
     meta: null,
-    error: { message: data.message, type: data.type },
+    error: { message, type: errType },
     truncated: false,
     overflow_file: null
   };
@@ -1207,7 +1372,7 @@ function handleToolError(tree, event, seq) {
     id,
     event,
     {
-      status: "failed",
+      status: cancelled ? "cancelled" : "failed",
       endedAt: eventTimeToMs(event.timestamp),
       result: failedResult,
       hidden: isHidden || void 0
@@ -1266,6 +1431,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 +1773,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;
@@ -1681,13 +1856,17 @@ function applyClassified(tree, classified, eventIndex, options) {
     case "error": {
       const data = event.data;
       const { message, type } = resolveErrorEventFields(data);
+      const softKind = classifyToolCancelSoftKind(
+        extractToolCancelSignals(data)
+      );
       const id = `error:${seq}`;
       const node = {
         kind: "error",
         id,
-        message,
-        errorType: type,
-        startedAt: eventTimeToMs(event.timestamp)
+        message: softKind ? resolveToolCancelDisplayText(softKind) : message,
+        errorType: softKind ? "cancelled" : type,
+        startedAt: eventTimeToMs(event.timestamp),
+        ...softKind ? { variant: "interrupt" } : {}
       };
       tree.byId[id] = node;
       appendMainStageChild(tree, id, event, seq);
@@ -1806,6 +1985,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" };
   }
@@ -3089,10 +3271,10 @@ function toolUseEntry(entry) {
 }
 function isResolved(payload) {
   const status = payload.status;
-  return status === "done" || status === "failed";
+  return status === "done" || status === "failed" || status === "cancelled";
 }
 function isErrored(payload) {
-  return payload.status === "failed" || payload.is_error === true || payload.error != null;
+  return (payload.status === "failed" || payload.is_error === true || payload.error != null) && payload.status !== "cancelled";
 }
 var GroupedToolUseAccumulator = class {
   group(entries) {
@@ -4093,6 +4275,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";
@@ -5700,6 +5889,7 @@ export {
   CollapsedExploreNode,
   SystemSummaryNode,
   shouldShowAgentSpinner,
+  isAgentInputLocked,
   TaskList,
   Spinner,
   formatTaskFooterLabel,
@@ -5713,4 +5903,4 @@ export {
   VirtualTimeline,
   SessionTimeline
 };
-//# sourceMappingURL=chunk-O5GERXTY.js.map
+//# sourceMappingURL=chunk-EFJMU4WW.js.map