langchain_agentx_stream_ui 0.1.9 → 0.2.0

package/dist/index.js

@@ -1169,17 +1169,24 @@ var WorkflowContainerStateMachine = class {
       (node) => workflowPath === node.workflow_path || workflowPath.startsWith(`${node.workflow_path}>`)
     );
     if (prefixCandidates.length > 0) {
-      const parent = prefixCandidates.reduce(
-        (best, node) => this.active.compareContainerRank(node.container_id, best.container_id) > 0 ? node : best
-      );
-      if (parent.workflow_path === workflowPath && parent.scope === "workflow") {
-        return parent.container_id;
-      }
-      if (workflowPath.startsWith(`${parent.workflow_path}>`)) {
-        return parent.container_id;
-      }
-      if (parent.workflow_path === workflowPath && parent.scope !== scope) {
-        return parent.container_id;
+      const parentCandidates = prefixCandidates.filter((node) => {
+        if (scope === "item") return node.scope !== "item";
+        if (scope === "aggregate") return node.scope !== "item" && node.scope !== "aggregate";
+        return node.scope !== scope;
+      });
+      if (parentCandidates.length > 0) {
+        const parent = parentCandidates.reduce(
+          (best, node) => this.active.compareContainerRank(node.container_id, best.container_id) > 0 ? node : best
+        );
+        if (parent.workflow_path === workflowPath && parent.scope === "workflow") {
+          return parent.container_id;
+        }
+        if (workflowPath.startsWith(`${parent.workflow_path}>`)) {
+          return parent.container_id;
+        }
+        if (parent.workflow_path === workflowPath && parent.scope !== scope) {
+          return parent.container_id;
+        }
       }
     }
     const workflowCandidates = openNodes.filter((node) => node.scope === "workflow");
@@ -1277,6 +1284,167 @@ function loopTaskScopeForStructureOpen(eventType) {
   return LOOP_TASK_OPEN_SCOPES[eventType];
 }
 
+// src/core/workflowStructureEvents.ts
+var WORKFLOW_STRUCTURE_EVENT_PREFIXES = [
+  "workflow-",
+  "stage-",
+  "parallel-",
+  "route-",
+  "subworkflow-"
+];
+var WORKFLOW_STRUCTURE_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "workflow-start",
+  "workflow-end",
+  "workflow-failed",
+  "subworkflow-start",
+  "subworkflow-end",
+  "stage-start",
+  "stage-done",
+  "stage-failed",
+  "parallel-item-start",
+  "parallel-item-done",
+  "parallel-item-failed",
+  "parallel-aggregate-start",
+  "parallel-aggregate-done",
+  "parallel-aggregate-failed",
+  "route-branch-start",
+  "route-branch-done",
+  "route-branch-failed"
+]);
+var AGENT_LOOP_REPLAY_EVENT_TYPES = new Set(
+  Object.keys(DEFAULT_EVENT_TIERS)
+);
+function isWorkflowStructureEventType(eventType) {
+  if (WORKFLOW_STRUCTURE_EVENT_TYPES.has(eventType)) return true;
+  return WORKFLOW_STRUCTURE_EVENT_PREFIXES.some((prefix) => eventType.startsWith(prefix));
+}
+function isAgentLoopReplayEventType(eventType) {
+  return AGENT_LOOP_REPLAY_EVENT_TYPES.has(eventType);
+}
+function filterAgentLoopReplayEvents(events) {
+  return events.filter(
+    (event) => isAgentLoopReplayEventType(event.event_type) && !isWorkflowStructureEventType(event.event_type)
+  );
+}
+
+// src/core/workflow/workflowPathUtils.ts
+function splitWorkflowPathSegments(workflowPath) {
+  return workflowPath.split(">").filter(Boolean);
+}
+function parentWorkflowPath(workflowPath) {
+  const segments = splitWorkflowPathSegments(workflowPath);
+  if (segments.length <= 1) return null;
+  return segments.slice(0, -1).join(">");
+}
+function lastWorkflowPathSegment(workflowPath) {
+  const segments = splitWorkflowPathSegments(workflowPath);
+  return segments.length > 0 ? segments[segments.length - 1] : null;
+}
+function isWorkflowPathUnderAncestor(workflowPath, ancestorPath) {
+  if (workflowPath === ancestorPath) return false;
+  const prefix = `${ancestorPath}>`;
+  return workflowPath.startsWith(prefix);
+}
+function isWorkflowPathEqualOrUnder(workflowPath, ancestorPath) {
+  return workflowPath === ancestorPath || isWorkflowPathUnderAncestor(workflowPath, ancestorPath);
+}
+
+// src/core/workflow/nativeNestedUtils.ts
+function readString3(data, key) {
+  const value = data[key];
+  return typeof value === "string" ? value : void 0;
+}
+function readNumber(data, key) {
+  const value = data[key];
+  return typeof value === "number" ? value : void 0;
+}
+function isNativeNestedStructureEvent(event) {
+  if (!isWorkflowStructureEventType(event.event_type)) return false;
+  const data = event.data ?? {};
+  const path = readString3(data, "workflow_path") ?? "";
+  const depth = readNumber(data, "workflow_depth") ?? 0;
+  return depth >= 1 && path.includes(">");
+}
+function resolveHostStageContainerId(tree, workflowPath) {
+  const parentPath = parentWorkflowPath(workflowPath);
+  const childSegment = lastWorkflowPathSegment(workflowPath);
+  if (!parentPath || !childSegment) return null;
+  const stageId = buildContainerId(parentPath, "stage", childSegment);
+  return tree.containersById[stageId] != null ? stageId : null;
+}
+function isHostStageNestedChildPath(tree, workflowPath) {
+  return resolveHostStageContainerId(tree, workflowPath) != null;
+}
+function hasNativeNestedStructureInTree(tree) {
+  for (const node of Object.values(tree.containersById)) {
+    if (node.workflow_depth < 1) continue;
+    if (!node.workflow_path.includes(">")) continue;
+    if (isHostStageNestedChildPath(tree, node.workflow_path)) {
+      return true;
+    }
+  }
+  return false;
+}
+function clearHostStageLoopSession(tree, hostStageId) {
+  if (!hostStageId) return tree;
+  const hostStage = tree.containersById[hostStageId];
+  if (!hostStage || hostStage.scope !== "stage" || !hostStage.loopSessionId) return tree;
+  return {
+    ...tree,
+    containersById: {
+      ...tree.containersById,
+      [hostStageId]: { ...hostStage, loopSessionId: null }
+    }
+  };
+}
+function isNestedHostStageShell(tree, stageNode) {
+  if (stageNode.scope !== "stage") return false;
+  return Object.values(tree.containersById).some(
+    (node) => node.scope === "subworkflow" && node.parent_container_id === stageNode.container_id
+  );
+}
+function clearHostStageLoopOnNestedChildOpen(tree, event) {
+  const eventType = event.event_type;
+  if (eventType !== "subworkflow-start" && eventType !== "parallel-item-start") return tree;
+  const data = event.data ?? {};
+  const workflowPath = readString3(data, "workflow_path");
+  if (!workflowPath) return tree;
+  if (eventType === "subworkflow-start") {
+    const childWorkflowId = readString3(data, "child_workflow_id");
+    if (!childWorkflowId) return tree;
+    const subId = buildContainerId(workflowPath, "subworkflow", childWorkflowId);
+    const sub = tree.containersById[subId];
+    const hostStageId = sub?.parent_container_id ?? resolveHostStageContainerId(tree, workflowPath);
+    return clearHostStageLoopSession(tree, hostStageId);
+  }
+  return clearHostStageLoopSession(tree, resolveHostStageContainerId(tree, workflowPath));
+}
+function dropStaleEmbeddedPathsOnNativeSubworkflowStart(tree, event) {
+  if (event.event_type !== "subworkflow-start" || !isNativeNestedStructureEvent(event)) {
+    return tree;
+  }
+  const data = event.data ?? {};
+  const nativeChildPath = readString3(data, "workflow_path");
+  if (!nativeChildPath) return tree;
+  const rootAnchor = splitWorkflowPathSegments(nativeChildPath)[0];
+  if (!rootAnchor) return tree;
+  let changed = false;
+  const containersById = { ...tree.containersById };
+  let activeContainerIds = [...tree.activeContainerIds];
+  for (const [id, node] of Object.entries(tree.containersById)) {
+    if (node.workflow_depth < 1) continue;
+    if (!node.workflow_path.startsWith(`${rootAnchor}>`)) continue;
+    if (node.workflow_path === nativeChildPath || isWorkflowPathEqualOrUnder(node.workflow_path, nativeChildPath)) {
+      continue;
+    }
+    if (isHostStageNestedChildPath(tree, node.workflow_path)) continue;
+    delete containersById[id];
+    activeContainerIds = activeContainerIds.filter((cid) => cid !== id);
+    changed = true;
+  }
+  return changed ? { ...tree, containersById, activeContainerIds } : tree;
+}
+
 // src/core/workflow/embeddedSubworkflowUtils.ts
 function parseLoopSessionParts(sessionId) {
   const trimmed = sessionId.trim();
@@ -1378,7 +1546,20 @@ function completeOpenItemsUnderSubworkflow(tree, subworkflowId) {
 function resolveLeafScope(taskKey) {
   return taskKey === "aggregate" ? "aggregate" : "item";
 }
+function shouldUseEmbeddedSynthesis(treeOrState, pendingEvent) {
+  const tree = "containerTree" in treeOrState ? treeOrState.containerTree : treeOrState;
+  if (pendingEvent && isNativeNestedStructureEvent(pendingEvent)) {
+    return false;
+  }
+  if (hasNativeNestedStructureInTree(tree)) {
+    return false;
+  }
+  return true;
+}
 function ensureEmbeddedSubworkflowContainers(tree, loopSessionId) {
+  if (!shouldUseEmbeddedSynthesis(tree)) {
+    return tree;
+  }
   const root = resolveRootWorkflow(tree);
   const parts = parseLoopSessionParts(loopSessionId);
   if (!root || !parts || !isEmbeddedChildLoopSession(loopSessionId, root.workflowId)) {
@@ -1461,11 +1642,39 @@ function findContainerIdByLoopSession(tree, loopSessionId) {
   }
   return null;
 }
+var PARALLEL_ITEM_STRUCTURE_EVENTS = /* @__PURE__ */ new Set([
+  "parallel-item-start",
+  "parallel-item-done",
+  "parallel-item-failed"
+]);
+function readItemKey(data) {
+  const value = data.item_key;
+  return typeof value === "string" ? value : void 0;
+}
+function resolveParallelItemLoopSessionId(eventType, eventSessionId, derivedLoopSessionId, data) {
+  if (!PARALLEL_ITEM_STRUCTURE_EVENTS.has(eventType) || !eventSessionId) return null;
+  if (eventSessionId === derivedLoopSessionId) return null;
+  const itemKey = readItemKey(data);
+  const parsed = parseLoopSessionParts(eventSessionId);
+  if (itemKey && parsed?.taskKey === itemKey) {
+    return eventSessionId;
+  }
+  return null;
+}
 function resolveStructureOpenLoopSessionId(eventType, eventSessionId, derivedLoopSessionId, data) {
   const rootWorkflowId = readWorkflowId(data) ?? "";
   if ((eventType === "parallel-aggregate-start" || eventType === "parallel-aggregate-done" || eventType === "parallel-aggregate-failed") && eventSessionId && isEmbeddedChildLoopSession(eventSessionId, rootWorkflowId)) {
     return eventSessionId;
   }
+  const parallelItemSessionId = resolveParallelItemLoopSessionId(
+    eventType,
+    eventSessionId,
+    derivedLoopSessionId,
+    data
+  );
+  if (parallelItemSessionId) {
+    return parallelItemSessionId;
+  }
   return derivedLoopSessionId;
 }
 var EMBEDDED_AGGREGATE_STRUCTURE_EVENTS = /* @__PURE__ */ new Set([
@@ -1483,7 +1692,7 @@ function patchEmbeddedStructureEvent(event, rootWorkflowId) {
   const parts = parseLoopSessionParts(event.session_id);
   if (!parts) return event;
   const data = event.data ?? {};
-  const rootPath = readString3(data, "workflow_path") ?? rootWorkflowId;
+  const rootPath = readString4(data, "workflow_path") ?? rootWorkflowId;
   const childPath = `${rootPath}>${parts.workflowId}`;
   const workflowDepth = typeof data.workflow_depth === "number" ? data.workflow_depth + 1 : 1;
   return {
@@ -1495,14 +1704,17 @@ function patchEmbeddedStructureEvent(event, rootWorkflowId) {
     }
   };
 }
-function readString3(data, key) {
+function readString4(data, key) {
   const value = data[key];
   return typeof value === "string" ? value : void 0;
 }
 function isDescendantOf(containersById, ancestorId, nodeId) {
+  const seen = /* @__PURE__ */ new Set();
   let current = containersById[nodeId]?.parent_container_id ?? null;
   while (current) {
     if (current === ancestorId) return true;
+    if (seen.has(current)) return false;
+    seen.add(current);
     current = containersById[current]?.parent_container_id ?? null;
   }
   return false;
@@ -1530,51 +1742,8 @@ function readWorkflowId(data) {
   return readWorkflowIdFromData(data);
 }
 
-// src/core/workflowStructureEvents.ts
-var WORKFLOW_STRUCTURE_EVENT_PREFIXES = [
-  "workflow-",
-  "stage-",
-  "parallel-",
-  "route-",
-  "subworkflow-"
-];
-var WORKFLOW_STRUCTURE_EVENT_TYPES = /* @__PURE__ */ new Set([
-  "workflow-start",
-  "workflow-end",
-  "workflow-failed",
-  "subworkflow-start",
-  "subworkflow-end",
-  "stage-start",
-  "stage-done",
-  "stage-failed",
-  "parallel-item-start",
-  "parallel-item-done",
-  "parallel-item-failed",
-  "parallel-aggregate-start",
-  "parallel-aggregate-done",
-  "parallel-aggregate-failed",
-  "route-branch-start",
-  "route-branch-done",
-  "route-branch-failed"
-]);
-var AGENT_LOOP_REPLAY_EVENT_TYPES = new Set(
-  Object.keys(DEFAULT_EVENT_TIERS)
-);
-function isWorkflowStructureEventType(eventType) {
-  if (WORKFLOW_STRUCTURE_EVENT_TYPES.has(eventType)) return true;
-  return WORKFLOW_STRUCTURE_EVENT_PREFIXES.some((prefix) => eventType.startsWith(prefix));
-}
-function isAgentLoopReplayEventType(eventType) {
-  return AGENT_LOOP_REPLAY_EVENT_TYPES.has(eventType);
-}
-function filterAgentLoopReplayEvents(events) {
-  return events.filter(
-    (event) => isAgentLoopReplayEventType(event.event_type) && !isWorkflowStructureEventType(event.event_type)
-  );
-}
-
 // src/core/workflowReducer.ts
-function readString4(data, key) {
+function readString5(data, key) {
   const value = data[key];
   return typeof value === "string" ? value : void 0;
 }
@@ -1673,7 +1842,7 @@ function prebindLoopSessionFromStructureOpen(tree, event) {
     loopSessionId = derivedLoopSessionId;
   }
   let nextTree = event.event_type === "parallel-aggregate-start" ? ensureEmbeddedSubworkflowContainers(tree, loopSessionId) : tree;
-  const workflowPath = readString4(data, "workflow_path") ?? "";
+  const workflowPath = readString5(data, "workflow_path") ?? "";
   const scopeKey = resolveScopeKey(event.event_type, data);
   const containerId = buildContainerId(workflowPath, scope, scopeKey);
   let targetId = containerId;
@@ -1754,7 +1923,7 @@ function bindLoopSessionToContainerTree(tree, event, activeLoopSessionId) {
   let nextTree = ensureEmbeddedSubworkflowContainers(tree, sessionId);
   if (findContainerByLoopSession(nextTree, sessionId)) return nextTree;
   const data = event.data ?? {};
-  const workflowPath = readString4(data, "workflow_path") ?? null;
+  const workflowPath = readString5(data, "workflow_path") ?? null;
   const scopeKey = resolveContentScopeKey(data);
   let targetId = findContainerByLoopSession(nextTree, sessionId);
   if (!targetId && scopeKey) {
@@ -1765,12 +1934,17 @@ function bindLoopSessionToContainerTree(tree, event, activeLoopSessionId) {
     );
   }
   if (!targetId) {
-    for (const containerId of nextTree.activeContainerIds) {
-      const node2 = nextTree.containersById[containerId];
-      if ((node2?.scope === "item" || node2?.scope === "stage" || node2?.scope === "aggregate") && !node2.loopSessionId) {
+    const fallbackScopes = ["item", "aggregate", "stage"];
+    for (const scope of fallbackScopes) {
+      for (const containerId of nextTree.activeContainerIds) {
+        const node2 = nextTree.containersById[containerId];
+        if (!node2 || node2.loopSessionId) continue;
+        if (node2.scope !== scope) continue;
+        if (node2.scope === "stage" && isNestedHostStageShell(nextTree, node2)) continue;
         targetId = containerId;
         break;
       }
+      if (targetId) break;
     }
   }
   if (!targetId) {
@@ -1783,6 +1957,9 @@ function bindLoopSessionToContainerTree(tree, event, activeLoopSessionId) {
   if (!targetId) return nextTree;
   const node = nextTree.containersById[targetId];
   if (!node || node.loopSessionId) return nextTree;
+  if (node.scope === "stage" && isNestedHostStageShell(nextTree, node)) {
+    return nextTree;
+  }
   if (node.scope !== "stage" && node.scope !== "item" && node.scope !== "branch" && node.scope !== "aggregate") {
     return nextTree;
   }
@@ -1882,8 +2059,15 @@ function finalizeLoopTreeOnStructureClose(state, event) {
 }
 function applyStructureEvent(state, event) {
   const rootWorkflowId = resolveRootWorkflowId(state.containerTree);
-  const projectedEvent = rootWorkflowId != null ? patchEmbeddedStructureEvent(event, rootWorkflowId) : event;
+  const useEmbeddedSynthesis = shouldUseEmbeddedSynthesis(state, event);
+  const projectedEvent = rootWorkflowId != null && useEmbeddedSynthesis ? patchEmbeddedStructureEvent(event, rootWorkflowId) : event;
   let containerTree = applyStructureToContainerTree(state.containerTree, projectedEvent);
+  if (projectedEvent.event_type === "subworkflow-start" || projectedEvent.event_type === "parallel-item-start") {
+    containerTree = clearHostStageLoopOnNestedChildOpen(containerTree, projectedEvent);
+  }
+  if (projectedEvent.event_type === "subworkflow-start") {
+    containerTree = dropStaleEmbeddedPathsOnNativeSubworkflowStart(containerTree, projectedEvent);
+  }
   const derivedLoopSessionId = deriveLoopSessionIdFromStructureOpen(projectedEvent);
   const structureData = projectedEvent.data ?? {};
   const structureLoopSessionId = derivedLoopSessionId ? resolveStructureOpenLoopSessionId(
@@ -1892,13 +2076,13 @@ function applyStructureEvent(state, event) {
     derivedLoopSessionId,
     structureData
   ) : null;
-  if (structureLoopSessionId) {
+  if (structureLoopSessionId && useEmbeddedSynthesis) {
     containerTree = ensureEmbeddedSubworkflowContainers(containerTree, structureLoopSessionId);
   }
   containerTree = prebindLoopSessionFromStructureOpen(containerTree, projectedEvent);
   if (projectedEvent.event_type === "stage-done" || projectedEvent.event_type === "stage-failed") {
-    const stageKey = readString4(structureData, "stage_key");
-    const workflowPath = readString4(structureData, "workflow_path") ?? "";
+    const stageKey = readString5(structureData, "stage_key");
+    const workflowPath = readString5(structureData, "workflow_path") ?? "";
     if (stageKey) {
       const stageId = buildContainerId(workflowPath, "stage", stageKey);
       if (containerTree.containersById[stageId]) {
@@ -2154,6 +2338,18 @@ function evictCompletedLoopOverflow(state, maxHydratedCompletedLoops) {
 }
 
 // src/core/workflowSessionStore.ts
+var DEFAULT_HYDRATE_CHUNK_SIZE = 50;
+function nextAnimationFrame() {
+  return new Promise((resolve) => {
+    requestAnimationFrame(() => resolve());
+  });
+}
+function withoutHydrating(ids, loopSessionId) {
+  if (!ids[loopSessionId]) return ids;
+  const next = { ...ids };
+  delete next[loopSessionId];
+  return next;
+}
 function safeReduceWorkflow(state, event, eventIndex, options) {
   try {
     return { state: reduceWorkflowSession(state, event, eventIndex, options) };
@@ -2174,6 +2370,39 @@ function safeReduceWorkflow(state, event, eventIndex, options) {
     };
   }
 }
+function finalizeWorkflowSessionOnStreamError(state, message, eventIndex, stack) {
+  const containersById = {
+    ...state.containerTree.containersById
+  };
+  for (const [id, node] of Object.entries(containersById)) {
+    if (node.status === "running" || node.status === "pending") {
+      containersById[id] = { ...node, status: "failed", is_open: false };
+    }
+  }
+  const loopTreesBySessionId = { ...state.loopTreesBySessionId };
+  for (const [loopSessionId, tree] of Object.entries(loopTreesBySessionId)) {
+    if (tree.status === "running" || tree.status === "connecting") {
+      loopTreesBySessionId[loopSessionId] = finalizeWorkflowLoopTree(tree, "error");
+    }
+  }
+  return {
+    ...state,
+    status: "error",
+    containerTree: {
+      ...state.containerTree,
+      containersById,
+      activeContainerIds: state.containerTree.activeContainerIds.filter(
+        (id) => containersById[id]?.is_open
+      )
+    },
+    loopTreesBySessionId,
+    activeLoopSessionId: null,
+    internalErrors: [
+      ...state.internalErrors,
+      { eventIndex, eventType: "stream-error", message, stack }
+    ]
+  };
+}
 function createWorkflowSessionStore(initialState = createEmptyWorkflowSessionState(), storeOptions) {
   const reduceOpts = {
     tierOverrides: storeOptions?.tierOverrides
@@ -2190,6 +2419,7 @@ function createWorkflowSessionStore(initialState = createEmptyWorkflowSessionSta
   return createStore2((set, get) => ({
     state: initialState,
     eventCount: initialEventCount,
+    hydratingLoopSessionIds: {},
     applyEvent(event, ctx) {
       const sseEventId = ctx?.sseEventId;
       if (shouldSkipDuplicateEvent(seenEventIds, sseEventId)) return;
@@ -2216,26 +2446,20 @@ function createWorkflowSessionStore(initialState = createEmptyWorkflowSessionSta
       seenEventIds.clear();
       set({
         state: createEmptyWorkflowSessionState(),
-        eventCount: 0
+        eventCount: 0,
+        hydratingLoopSessionIds: {}
       });
     },
     markAsError(error) {
-      const { state } = get();
+      const { state, eventCount } = get();
       const message = error?.message ?? "Workflow stream error";
       set({
-        state: {
-          ...state,
-          status: "error",
-          internalErrors: [
-            ...state.internalErrors,
-            {
-              eventIndex: get().eventCount,
-              eventType: "stream-error",
-              message,
-              stack: error?.stack
-            }
-          ]
-        }
+        state: finalizeWorkflowSessionOnStreamError(
+          state,
+          message,
+          eventCount,
+          error?.stack
+        )
       });
     },
     /**
@@ -2275,6 +2499,71 @@ function createWorkflowSessionStore(initialState = createEmptyWorkflowSessionSta
         next = finalizeState(next);
         return { state: next };
       });
+    },
+    async hydrateLoopSessionAsync(loopSessionId, events, options) {
+      const { hydratingLoopSessionIds } = get();
+      if (hydratingLoopSessionIds[loopSessionId]) return;
+      const filtered = filterAgentLoopReplayEvents(events);
+      if (filtered.length === 0) return;
+      const chunkSize = options?.chunkSize ?? DEFAULT_HYDRATE_CHUNK_SIZE;
+      const signal = options?.signal;
+      set((current) => ({
+        hydratingLoopSessionIds: {
+          ...current.hydratingLoopSessionIds,
+          [loopSessionId]: true
+        }
+      }));
+      try {
+        let tree = get().state.loopTreesBySessionId[loopSessionId] ?? createEmptyTree();
+        let idx = get().eventCount;
+        for (let offset = 0; offset < filtered.length; offset += chunkSize) {
+          if (signal?.aborted) {
+            throw new DOMException("Hydrate aborted", "AbortError");
+          }
+          const chunk = filtered.slice(offset, offset + chunkSize);
+          for (const event of chunk) {
+            tree = reduceTree(tree, event, idx, reduceOpts);
+            idx += 1;
+          }
+          const isLastChunk = offset + chunkSize >= filtered.length;
+          set((current) => {
+            let next = {
+              ...current.state,
+              loopTreesBySessionId: {
+                ...current.state.loopTreesBySessionId,
+                [loopSessionId]: tree
+              }
+            };
+            if (isLastChunk) {
+              next = touchCompletedLoopSession(next, loopSessionId);
+              next = evictCompletedLoopOverflow(next, maxHydratedCompletedLoops);
+            }
+            next = finalizeState(next);
+            return { state: next };
+          });
+          if (!isLastChunk) {
+            await nextAnimationFrame();
+          }
+        }
+      } catch {
+        set((current) => {
+          const { [loopSessionId]: _removed, ...restLoops } = current.state.loopTreesBySessionId;
+          return {
+            state: { ...current.state, loopTreesBySessionId: restLoops },
+            hydratingLoopSessionIds: withoutHydrating(
+              current.hydratingLoopSessionIds,
+              loopSessionId
+            )
+          };
+        });
+        return;
+      }
+      set((current) => ({
+        hydratingLoopSessionIds: withoutHydrating(
+          current.hydratingLoopSessionIds,
+          loopSessionId
+        )
+      }));
     }
   }));
 }
@@ -2283,7 +2572,7 @@ function createWorkflowSessionStore(initialState = createEmptyWorkflowSessionSta
 import { useMemo as useMemo7, useState as useState6 } from "react";
 
 // src/view/workflow/WorkflowAggregateContainer.tsx
-import { useCallback, useEffect as useEffect3, useMemo as useMemo2, useState } from "react";
+import { useCallback, useEffect as useEffect3, useMemo as useMemo2, useState, memo } from "react";
 
 // src/view/workflow/WorkflowContainerLine.tsx
 import { Fragment, jsx as jsx5, jsxs as jsxs2 } from "react/jsx-runtime";
@@ -2551,6 +2840,29 @@ function mapAggregateUiStatus(node) {
   return mapContainerUiStatus(node.status);
 }
 
+// src/view/workflow/workflowContainerMemo.ts
+function displayVisualEqual(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null) return false;
+  if (a.progress_current !== b.progress_current) return false;
+  if (a.status !== b.status) return false;
+  return true;
+}
+function workflowContainerNodeVisualEqual(a, b) {
+  if (a.container_id !== b.container_id) return false;
+  if (a.status !== b.status) return false;
+  if (a.is_open !== b.is_open) return false;
+  if (a.loopSessionId !== b.loopSessionId) return false;
+  if (a.title !== b.title) return false;
+  if (a.subtitle !== b.subtitle) return false;
+  if (a.content_blocks.length !== b.content_blocks.length) return false;
+  if (!displayVisualEqual(a.display, b.display)) return false;
+  return true;
+}
+function workflowContainerViewPropsEqual(prev, next) {
+  return prev.depth === next.depth && prev.virtualized === next.virtualized && prev.virtualizeThreshold === next.virtualizeThreshold && prev.groupParallelTools === next.groupParallelTools;
+}
+
 // src/view/workflow/WorkflowAggregateContainer.tsx
 import { jsx as jsx8, jsxs as jsxs4 } from "react/jsx-runtime";
 function mergeContentPreview(node) {
@@ -2558,7 +2870,7 @@ function mergeContentPreview(node) {
   if (blocks.length === 0) return "";
   return blocks.map((block) => block.preview?.trim() ?? "").filter(Boolean).join("\n\n");
 }
-function WorkflowAggregateContainer({
+function WorkflowAggregateContainerInner({
   node,
   loopTree,
   siblingItems = [],
@@ -2678,9 +2990,24 @@ function WorkflowAggregateContainer({
     }
   );
 }
+function workflowAggregateContainerPropsEqual(prev, next) {
+  if (prev.loopTree !== next.loopTree) return false;
+  if (!workflowContainerViewPropsEqual(prev, next)) return false;
+  if (prev.siblingItems.length !== next.siblingItems.length) return false;
+  for (let i = 0; i < prev.siblingItems.length; i += 1) {
+    if (!workflowContainerNodeVisualEqual(prev.siblingItems[i], next.siblingItems[i])) {
+      return false;
+    }
+  }
+  return workflowContainerNodeVisualEqual(prev.node, next.node);
+}
+var WorkflowAggregateContainer = memo(
+  WorkflowAggregateContainerInner,
+  workflowAggregateContainerPropsEqual
+);
 
 // src/view/workflow/WorkflowParallelGroup.tsx
-import { useCallback as useCallback3, useEffect as useEffect5, useMemo as useMemo4, useState as useState3 } from "react";
+import { useCallback as useCallback3, useEffect as useEffect5, useMemo as useMemo4, useState as useState3, memo as memo3 } from "react";
 import { useStore as useStore3 } from "zustand";
 
 // src/core/workflow/workflowParallelGroupMetrics.ts
@@ -2747,7 +3074,7 @@ function formatParallelGroupSummary(metrics) {
 }
 
 // src/view/workflow/WorkflowStageContainer.tsx
-import { useCallback as useCallback2, useEffect as useEffect4, useMemo as useMemo3, useState as useState2 } from "react";
+import { useCallback as useCallback2, useEffect as useEffect4, useMemo as useMemo3, useState as useState2, memo as memo2 } from "react";
 import { useStore as useStore2 } from "zustand";
 
 // src/core/workflow/loopTreeUtils.ts
@@ -2822,6 +3149,9 @@ function partitionWorkflowStages(stages, maxVisibleDoneCount) {
 }
 function isActiveWorkflowContainer(node, activeLoopSessionId, activeContainerIds) {
   if (activeContainerIds.includes(node.container_id)) return true;
+  if (node.status === "completed" || node.status === "failed" || node.status === "skipped") {
+    return false;
+  }
   if (node.loopSessionId && node.loopSessionId === activeLoopSessionId) return true;
   return false;
 }
@@ -2837,13 +3167,14 @@ function bodyTestId(node) {
   if (node.scope === "item") return `lax-workflow-parallel-body-${node.scope_key}`;
   return `lax-workflow-stage-body-${node.scope_key}`;
 }
-function WorkflowStageContainer({
+function WorkflowStageContainerInner({
   node,
   loopTree,
   depth = 0,
   virtualized,
   virtualizeThreshold,
-  groupParallelTools
+  groupParallelTools,
+  suppressHostScopedLoop = false
 }) {
   const { verbose } = useSessionViewOptions();
   const scale = useWorkflowScaleOptions();
@@ -2906,13 +3237,13 @@ function WorkflowStageContainer({
     return () => window.removeEventListener("keydown", onKeyDown);
   }, [requestLoopHydration]);
   const displayTitle = node.title;
-  const usesScopedLoop = Boolean(node.loopSessionId);
+  const usesScopedLoop = Boolean(node.loopSessionId) && !suppressHostScopedLoop;
   const runningLoopTree = loopTree ?? (usesScopedLoop && isRunning && isActive ? createWorkflowRunningLoopTree() : void 0);
   const staticContentTeaser = !usesScopedLoop && !loopTree && node.content_blocks.length > 0 ? node.content_blocks[node.content_blocks.length - 1].preview : "";
   const teaserText = doneSummary?.teaser || staticContentTeaser;
   const expandHint = doneSummary ? formatTeaserExpandHint(doneSummary.extraLines, verbose) : null;
   const doneLabel = doneSummary?.label ?? "done";
-  const statusLabel = isDone ? doneLabel : mapContainerStatusLabel(node.status);
+  const statusLabel = isDone ? doneLabel : suppressHostScopedLoop && isRunning ? "running" : mapContainerStatusLabel(node.status);
   const testId = containerTestId(node);
   const isItem = node.scope === "item";
   const canToggleShell = isRunning && !isSkipped || isDone;
@@ -3016,6 +3347,13 @@ function WorkflowStageContainer({
     }
   );
 }
+function workflowStageContainerPropsEqual(prev, next) {
+  if (prev.suppressHostScopedLoop !== next.suppressHostScopedLoop) return false;
+  if (prev.loopTree !== next.loopTree) return false;
+  if (!workflowContainerViewPropsEqual(prev, next)) return false;
+  return workflowContainerNodeVisualEqual(prev.node, next.node);
+}
+var WorkflowStageContainer = memo2(WorkflowStageContainerInner, workflowStageContainerPropsEqual);
 
 // src/view/workflow/WorkflowParallelGroup.tsx
 import { jsx as jsx11, jsxs as jsxs6 } from "react/jsx-runtime";
@@ -3023,7 +3361,7 @@ function resolveLoopTree(node, loopTreesBySessionId) {
   if (!node.loopSessionId) return void 0;
   return loopTreesBySessionId[node.loopSessionId];
 }
-function WorkflowParallelGroup({
+function WorkflowParallelGroupInner({
   groupKey,
   items,
   loopTreesBySessionId,
@@ -3039,12 +3377,13 @@ function WorkflowParallelGroup({
   const metrics = useMemo4(() => computeParallelGroupMetrics(items), [items]);
   const summary = formatParallelGroupSummary(metrics);
   const hasRunning = metrics.running > 0;
+  const isNestedGroup = groupKey.includes(">");
   const hasActiveItem = useMemo4(
     () => items.some((item) => isActiveWorkflowContainer(item, activeLoopSessionId, activeContainerIds)),
     [items, activeLoopSessionId, activeContainerIds]
   );
   const allSettled = metrics.total > 0 && metrics.running === 0 && metrics.completed + metrics.failed >= metrics.total;
-  const shouldAutoExpandGroup = hasRunning && (!scale.onlyExpandActiveRunning || hasActiveItem);
+  const shouldAutoExpandGroup = hasRunning && (isNestedGroup || !scale.onlyExpandActiveRunning || hasActiveItem);
   const [expanded, setExpanded] = useState3(shouldAutoExpandGroup);
   useEffect5(() => {
     if (shouldAutoExpandGroup) {
@@ -3095,7 +3434,7 @@ function WorkflowParallelGroup({
           WorkflowExpandTrigger,
           {
             summary,
-            expandHint: !expanded && !hasRunning ? "(ctrl+o to expand)" : null,
+            expandHint: !expanded && hasRunning ? "(click to expand agents)" : !expanded && !hasRunning ? "(ctrl+o to expand)" : null,
             onToggle: toggleExpanded,
             expanded,
             testId: `lax-workflow-parallel-group-summary-${groupKey}`,
@@ -3107,6 +3446,24 @@ function WorkflowParallelGroup({
     }
   );
 }
+function workflowParallelGroupPropsEqual(prev, next) {
+  if (prev.groupKey !== next.groupKey) return false;
+  if (!workflowContainerViewPropsEqual(prev, next)) return false;
+  if (prev.items.length !== next.items.length) return false;
+  for (let i = 0; i < prev.items.length; i += 1) {
+    const prevItem = prev.items[i];
+    const nextItem = next.items[i];
+    if (!workflowContainerNodeVisualEqual(prevItem, nextItem)) return false;
+    const loopSessionId = prevItem.loopSessionId;
+    if (loopSessionId) {
+      if (prev.loopTreesBySessionId[loopSessionId] !== next.loopTreesBySessionId[loopSessionId]) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+var WorkflowParallelGroup = memo3(WorkflowParallelGroupInner, workflowParallelGroupPropsEqual);
 
 // src/view/workflow/WorkflowRootContainer.tsx
 import { jsx as jsx12, jsxs as jsxs7 } from "react/jsx-runtime";
@@ -3313,15 +3670,16 @@ function WorkflowSubworkflowContainer({
             children
           }
         ) : null,
-        isDone && !expanded ? /* @__PURE__ */ jsx14(
+        !expanded && children ? /* @__PURE__ */ jsx14(
           WorkflowExpandTrigger,
           {
-            summary: `${node.title} \xB7 ${buildDoneSummary(node)}`,
+            summary: `${node.title} \xB7 ${isDone ? buildDoneSummary(node) : "running"}`,
             summaryTestId: `${testId}-title`,
             teaser: teaser || void 0,
+            expandHint: isRunning ? "(click to expand subworkflow)" : void 0,
             onToggle: () => setExpanded(true),
             expanded: false,
-            testId: `${testId}-done`,
+            testId: isDone ? `${testId}-done` : `${testId}-running-collapsed`,
             teaserTestId: teaser ? `${testId}-teaser` : void 0
           }
         ) : null
@@ -3345,7 +3703,7 @@ function collectSiblingItems(node, containersById) {
     (child) => child.scope === "item"
   );
 }
-function renderLeafContainer(node, depth, containerTree, loopTreesBySessionId, viewProps) {
+function renderLeafContainer(node, depth, containerTree, loopTreesBySessionId, viewProps, options) {
   const loopTree = resolveLoopTree2(node, loopTreesBySessionId);
   switch (node.scope) {
     case "aggregate":
@@ -3378,6 +3736,7 @@ function renderLeafContainer(node, depth, containerTree, loopTreesBySessionId, v
           node,
           loopTree,
           depth,
+          suppressHostScopedLoop: options?.suppressHostScopedLoop,
           ...viewProps
         },
         node.container_id
@@ -3402,6 +3761,11 @@ function renderItemSiblings(items, groupKey, depth, containerTree, loopTreesBySe
   }
   return null;
 }
+function stageHasSubworkflowChild(stageId, containerTree) {
+  return collectChildContainers(containerTree.containersById, stageId).some(
+    (node) => node.scope === "subworkflow"
+  );
+}
 function renderContainerChildren(parentId, containerTree, loopTreesBySessionId, viewProps, depth) {
   const children = collectChildContainers(containerTree.containersById, parentId);
   const items = children.filter((node) => node.scope === "item");
@@ -3432,13 +3796,21 @@ function renderContainerNode(node, containerTree, loopTreesBySessionId, viewProp
     );
   }
   if (node.scope === "stage") {
+    const suppressHostScopedLoop = stageHasSubworkflowChild(node.container_id, containerTree);
     return /* @__PURE__ */ jsxs10(
       "div",
       {
         className: "lax-workflow-nested-block",
         "data-testid": `lax-workflow-nested-${node.scope}-${node.scope_key}`,
         children: [
-          renderLeafContainer(node, depth, containerTree, loopTreesBySessionId, viewProps),
+          renderLeafContainer(
+            node,
+            depth,
+            containerTree,
+            loopTreesBySessionId,
+            viewProps,
+            { suppressHostScopedLoop }
+          ),
           hasNested ? /* @__PURE__ */ jsx15("div", { className: "lax-workflow-container-children", children: nested }) : null
         ]
       },
@@ -3788,6 +4160,14 @@ function WorkflowSession({
     storeRef.current,
     (s) => s.state.loopTreesBySessionId
   );
+  const sessionStatus = useStore5(
+    storeRef.current,
+    (s) => s.state.status
+  );
+  const internalErrors = useStore5(
+    storeRef.current,
+    (s) => s.state.internalErrors
+  );
   useEffect8(() => {
     const store = storeRef.current;
     const controller = new AbortController();
@@ -3795,10 +4175,10 @@ function WorkflowSession({
       store.getState().applyEvent(event, ctx);
     }, controller.signal).catch((err) => {
       if (err instanceof SseTransportTerminalError) {
-        const { state } = store.getState();
-        if (state.status === "running") {
-          store.setState({ state: { ...state, status: "error" } });
-        }
+        store.getState().markAsError(err);
+        onError?.(err);
+      } else if (err instanceof Error) {
+        onError?.(err);
       }
     });
     return () => {
@@ -3811,6 +4191,15 @@ function WorkflowSession({
       className: "lax-agent-session lax-workflow-session",
       "data-testid": "lax-workflow-session",
       children: [
+        sessionStatus === "error" || internalErrors.length > 0 ? /* @__PURE__ */ jsx17(
+          "div",
+          {
+            className: "lax-workflow-error",
+            "data-testid": "lax-workflow-error",
+            role: "alert",
+            children: internalErrors[internalErrors.length - 1]?.message ?? "Workflow stream error"
+          }
+        ) : null,
         /* @__PURE__ */ jsx17(
           WorkflowChrome,
           {