langchain_agentx_stream_ui 0.1.0

package/dist/index.js

@@ -0,0 +1,743 @@
+import {
+  ErrorCard,
+  MultiAgentSession,
+  NodeRegistry,
+  PermissionCard,
+  ReasoningBubble,
+  StepCard,
+  TextBubble,
+  ToolCallCard,
+  UnknownCard,
+  createActiveSessionBridge,
+  createDefaultRegistry,
+  createMultiSessionStore,
+  markEventIdSeen,
+  shouldSkipDuplicateEvent
+} from "./chunk-W6QQHTJ4.js";
+import {
+  DefaultToolBody,
+  InteractionBusContext,
+  createInteractionBus,
+  formatToolTitle,
+  getNoopInteractionBus,
+  resolveToolBody,
+  useInteractionBus
+} from "./chunk-WM6Y6APP.js";
+import "./chunk-DP7V33X7.js";
+import {
+  CollapseKind,
+  CollapsedExploreNode,
+  DEFAULT_ESTIMATE_SIZE,
+  DEFAULT_EVENT_TIERS,
+  DEFAULT_SESSION_VIEW_OPTIONS,
+  DEFAULT_VIRTUALIZE_THRESHOLD,
+  ExploreCollapseAccumulator,
+  GROUPABLE_TOOL_NAMES,
+  GroupedToolUseAccumulator,
+  MIN_HINT_DISPLAY_MS,
+  NodeRegistryContext,
+  ProjectionContext,
+  RenderableTimelineProjector,
+  SHELL_PROGRESS_MIN_ELAPSED_SECONDS,
+  SessionStoreContext,
+  SessionTimeline,
+  SessionViewOptionsContext,
+  Spinner,
+  SystemSummaryAccumulator,
+  SystemSummaryNode,
+  TaskList,
+  TaskListFooter,
+  Timeline,
+  TimelineItem,
+  ToolDisplayOptionsContext,
+  ToolProjectionClassifier,
+  VirtualTimeline,
+  buildCanonicalFromTree,
+  buildProjectionContext,
+  buildProjectionViewContext,
+  buildRelevantMemoriesCanonical,
+  buildSystemEventCanonical,
+  classifyEvent,
+  commandAsHint,
+  createEmptyTree,
+  createProjectionContext,
+  entryKey,
+  formatExploreSummaryText,
+  formatHookFinishedSummary,
+  formatShellProgressSuffix,
+  formatTaskFooterLabel,
+  getChildIds,
+  getMainStageIds,
+  isGitOperationCommand,
+  isGroupableToolName,
+  isMcpToolName,
+  iterMountCandidates,
+  projectCanonical,
+  projectTimeline,
+  reduceEvents,
+  reduceTree,
+  replayEvents,
+  replayTree,
+  resolveEffectiveToolBodyMode,
+  resolveEventTier,
+  resolveResponseId,
+  resolveShellProgressFromPayload,
+  shouldApplyGrouping,
+  shouldShowExploreDetail,
+  shouldShowTaskListFooter,
+  streamChunk,
+  useActiveSession,
+  useChildren,
+  useInternalErrors,
+  useMinDisplayTime,
+  useNode,
+  useNodeRegistry,
+  useNodeTyped,
+  useProjectedTimeline,
+  useReplayTree,
+  useSessionIds,
+  useSessionMeta,
+  useSessionStatus,
+  useTimeline
+} from "./chunk-G2KYJCMM.js";
+import {
+  Agent,
+  AgentToolBody,
+  AskUserQuestion,
+  AskUserQuestionToolBody,
+  Bash,
+  BashToolBody,
+  Edit,
+  EditToolBody,
+  Glob,
+  GlobToolBody,
+  Grep,
+  GrepToolBody,
+  Read,
+  ReadToolBody,
+  Skill,
+  SkillToolBody,
+  ToolDisplayRegistry,
+  WebFetch,
+  WebFetchToolBody,
+  WebSearch,
+  WebSearchToolBody,
+  Write,
+  WriteToolBody,
+  createDefaultToolRegistry,
+  formatAgentTitle
+} from "./chunk-MHK53ZHC.js";
+import {
+  BodyBlockList,
+  DiffView,
+  MAX_PREVIEW_LINES,
+  MarkdownBlock,
+  MarkdownRendererContext,
+  TruncatedContent,
+  buildBashBodyBlocks,
+  displayPath,
+  formatDiffFromStrings,
+  formatPatternTitle,
+  formatSearchResultBody,
+  formatTimeoutFooter,
+  parseDiffText,
+  truncateCommand
+} from "./chunk-4RIOBLGB.js";
+
+// src/view/AgentSession.tsx
+import { useEffect, useMemo, useRef } from "react";
+
+// src/core/store.ts
+import { createStore } from "zustand/vanilla";
+function safeReduce(tree, event, eventIndex, options) {
+  try {
+    return { tree: reduceTree(tree, event, eventIndex, options) };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const stack = err instanceof Error ? err.stack : void 0;
+    if (import.meta.env?.DEV) {
+      console.error("[langchain_agentx_stream_ui] reducer error:", err);
+    }
+    return {
+      tree: {
+        ...tree,
+        internalErrors: [
+          ...tree.internalErrors,
+          { eventIndex, eventType: event.event_type, message, stack }
+        ]
+      }
+    };
+  }
+}
+function createSessionStore(initialTree = createEmptyTree(), storeOptions) {
+  const reduceOpts = {
+    tierOverrides: storeOptions?.tierOverrides,
+    collectDebug: storeOptions?.debug === true
+  };
+  const initialEventCount = storeOptions?.initialEventCount ?? 0;
+  const seenEventIds = new Set(storeOptions?.initialSeenEventIds);
+  return createStore((set, get) => ({
+    tree: initialTree,
+    eventCount: initialEventCount,
+    applyEvent(event, ctx) {
+      const sseEventId = ctx?.sseEventId;
+      if (shouldSkipDuplicateEvent(seenEventIds, sseEventId)) return;
+      const { tree, eventCount } = get();
+      const { tree: reduced } = safeReduce(tree, event, eventCount, reduceOpts);
+      const nextTree = sseEventId ? {
+        ...reduced,
+        meta: { ...reduced.meta, lastEventId: sseEventId }
+      } : reduced;
+      markEventIdSeen(seenEventIds, sseEventId);
+      set({ tree: nextTree, eventCount: eventCount + 1 });
+    },
+    applyEvents(events) {
+      let { tree, eventCount } = get();
+      for (const event of events) {
+        const result = safeReduce(tree, event, eventCount, reduceOpts);
+        tree = result.tree;
+        eventCount += 1;
+      }
+      set({ tree, eventCount });
+    },
+    reset() {
+      seenEventIds.clear();
+      set({ tree: createEmptyTree(), eventCount: 0 });
+    },
+    markAsError(error) {
+      const { tree } = get();
+      set({
+        tree: {
+          ...tree,
+          status: "error",
+          internalErrors: error ? [
+            ...tree.internalErrors,
+            {
+              eventIndex: -1,
+              eventType: "sse_connection_failed",
+              message: error.message,
+              stack: error.stack
+            }
+          ] : tree.internalErrors
+        }
+      });
+    }
+  }));
+}
+
+// src/view/AgentSession.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function DebugPanel() {
+  const status = useSessionStatus();
+  const errors = useInternalErrors();
+  if (errors.length === 0) return null;
+  return /* @__PURE__ */ jsxs("div", { className: "lax-debug-panel", "data-testid": "lax-debug-panel", children: [
+    /* @__PURE__ */ jsxs("div", { children: [
+      "status: ",
+      status
+    ] }),
+    /* @__PURE__ */ jsx("ul", { children: errors.map((err, i) => /* @__PURE__ */ jsxs("li", { children: [
+      "[",
+      err.eventType,
+      "] ",
+      err.message
+    ] }, `${err.eventIndex}-${i}`)) })
+  ] });
+}
+function AgentSession({
+  source,
+  initialEvents,
+  registry,
+  tierOverrides: _tierOverrides,
+  onError,
+  autoReconnect: _autoReconnect,
+  debug = false,
+  virtualized = false,
+  virtualizeThreshold,
+  interactionBus,
+  toolDisplayRegistry,
+  defaultBodyMode = "preview",
+  groupParallelTools = false,
+  permissionUiMode = "standalone",
+  markdownRenderer,
+  displayMode = "normal",
+  verbose = false,
+  exploreFullscreenBash = true,
+  memoryDir = null,
+  workspaceRoot = null,
+  children
+}) {
+  const storeRef = useRef(null);
+  if (storeRef.current === null) {
+    const replayOpts = {
+      tierOverrides: _tierOverrides,
+      collectDebug: debug
+    };
+    const initialTree = initialEvents && initialEvents.length > 0 ? replayEvents(initialEvents, replayOpts) : void 0;
+    storeRef.current = createSessionStore(initialTree, {
+      tierOverrides: _tierOverrides,
+      debug,
+      initialEventCount: initialEvents?.length ?? 0
+    });
+  }
+  const registryRef = useMemo(() => registry ?? createDefaultRegistry(), [registry]);
+  const busRef = useMemo(
+    () => interactionBus ?? getNoopInteractionBus(),
+    [interactionBus]
+  );
+  const toolDisplayRef = useMemo(
+    () => ({
+      registry: toolDisplayRegistry ?? createDefaultToolRegistry(),
+      defaultBodyMode
+    }),
+    [toolDisplayRegistry, defaultBodyMode]
+  );
+  const sessionViewRef = useMemo(
+    () => ({
+      ...DEFAULT_SESSION_VIEW_OPTIONS,
+      groupParallelTools,
+      permissionUiMode,
+      verboseReasoning: debug,
+      displayMode,
+      verbose,
+      exploreFullscreenBash,
+      memoryDir,
+      workspaceRoot
+    }),
+    [
+      groupParallelTools,
+      permissionUiMode,
+      debug,
+      displayMode,
+      verbose,
+      exploreFullscreenBash,
+      memoryDir,
+      workspaceRoot
+    ]
+  );
+  useEffect(() => {
+    const store = storeRef.current;
+    const controller = new AbortController();
+    void source.start((event, ctx) => {
+      store.getState().applyEvent(event, ctx);
+    }, controller.signal).catch((err) => {
+      const error = err instanceof Error ? err : new Error(String(err));
+      store.getState().markAsError(error);
+      onError?.(error);
+    });
+    return () => {
+      controller.abort();
+    };
+  }, [source, onError]);
+  return /* @__PURE__ */ jsx(SessionStoreContext.Provider, { value: storeRef.current, children: /* @__PURE__ */ jsx(InteractionBusContext.Provider, { value: busRef, children: /* @__PURE__ */ jsx(NodeRegistryContext.Provider, { value: registryRef, children: /* @__PURE__ */ jsx(MarkdownRendererContext.Provider, { value: markdownRenderer, children: /* @__PURE__ */ jsx(ToolDisplayOptionsContext.Provider, { value: toolDisplayRef, children: /* @__PURE__ */ jsx(SessionViewOptionsContext.Provider, { value: sessionViewRef, children: /* @__PURE__ */ jsxs("div", { className: "lax-agent-session", "data-testid": "lax-agent-session", children: [
+    children ?? /* @__PURE__ */ jsx(
+      SessionTimeline,
+      {
+        virtualized,
+        virtualizeThreshold,
+        groupParallelTools
+      }
+    ),
+    debug ? /* @__PURE__ */ jsx(DebugPanel, {}) : null
+  ] }) }) }) }) }) }) });
+}
+
+// src/view/tools/groupParallelTools.ts
+function buildTimelineEntries(rootIds, byId, options = {}) {
+  const filtered = options.hideStandalonePermissions ? rootIds.filter((id) => byId[id]?.kind !== "permission") : [...rootIds];
+  if (!options.groupParallelTools) {
+    return filtered.map((nodeId) => ({ kind: "node", nodeId }));
+  }
+  const entries = [];
+  let i = 0;
+  while (i < filtered.length) {
+    const id = filtered[i];
+    const node = byId[id];
+    if (node?.kind !== "tool_call") {
+      entries.push({ kind: "node", nodeId: id });
+      i += 1;
+      continue;
+    }
+    const toolName = node.toolName;
+    const groupIds = [id];
+    let j = i + 1;
+    while (j < filtered.length) {
+      const nextId = filtered[j];
+      const next = byId[nextId];
+      if (next?.kind !== "tool_call" || next.toolName !== toolName) break;
+      groupIds.push(nextId);
+      j += 1;
+    }
+    if (groupIds.length >= 2) {
+      entries.push({ kind: "tool_group", toolName, nodeIds: groupIds });
+    } else {
+      entries.push({ kind: "node", nodeId: id });
+    }
+    i = j;
+  }
+  return entries;
+}
+
+// src/view/nodes/SubAgentNode.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function SubAgentBlock({ nodeId }) {
+  const node = useNodeTyped(nodeId, "subagent");
+  const childIds = useChildren(nodeId);
+  const registry = useNodeRegistry();
+  if (!node) return null;
+  return /* @__PURE__ */ jsxs2("div", { className: "lax-subagent-block", "data-status": node.status, children: [
+    /* @__PURE__ */ jsxs2("div", { className: "lax-subagent-block__header", children: [
+      "SubAgent: ",
+      node.subagentId
+    ] }),
+    /* @__PURE__ */ jsx2("div", { className: "lax-subagent-block__children", children: childIds.map((childId) => /* @__PURE__ */ jsx2(TimelineItem, { nodeId: childId, registry }, childId)) })
+  ] });
+}
+
+// src/transport/createAgentxSseSource.ts
+var EXPECTED_PROTOCOL_VERSION = "1";
+function defaultOnError(error) {
+  console.error("[langchain_agentx_stream_ui] SSE error:", error);
+}
+function buildResumeStreamUrl(baseUrl, lastEventId, queryParam = "last_event_id") {
+  if (!lastEventId) return baseUrl;
+  const sep = baseUrl.includes("?") ? "&" : "?";
+  return `${baseUrl}${sep}${encodeURIComponent(queryParam)}=${encodeURIComponent(lastEventId)}`;
+}
+function createAgentxSseSource(options) {
+  const {
+    url,
+    onError = defaultOnError,
+    autoReconnect = true,
+    reconnectDelayMs = 1e3,
+    onLastEventId,
+    EventSourceImpl = EventSource
+  } = options;
+  return {
+    start(handler, signal) {
+      return new Promise((resolve, reject) => {
+        let es = null;
+        let handshakeOk = false;
+        let lastEventId = null;
+        let fatal = false;
+        let bufferedDelta = null;
+        let flushTimer = null;
+        const flushBufferedDelta = () => {
+          if (flushTimer) {
+            clearTimeout(flushTimer);
+            flushTimer = null;
+          }
+          if (!bufferedDelta) return;
+          handler(bufferedDelta.event, bufferedDelta.ctx);
+          bufferedDelta = null;
+        };
+        const isBufferedDeltaEvent = (event) => event.event_type === "text-delta" || event.event_type === "reasoning-delta";
+        const mergeDeltaEvent = (prev, next) => {
+          if (prev.event_type !== next.event_type) return null;
+          if (prev.step_index !== next.step_index) return null;
+          if (prev.tool_name !== next.tool_name) return null;
+          if (prev.session_id !== next.session_id) return null;
+          const prevData = prev.data;
+          const nextData = next.data;
+          const prevChunk = prevData.delta ?? prevData.text ?? prevData.content ?? "";
+          const nextChunk = nextData.delta ?? nextData.text ?? nextData.content ?? "";
+          return {
+            ...next,
+            data: {
+              ...next.data,
+              text: `${prevChunk}${nextChunk}`
+            }
+          };
+        };
+        const cleanup = () => {
+          es?.close();
+          es = null;
+        };
+        const finish = (error) => {
+          flushBufferedDelta();
+          cleanup();
+          if (error) reject(error);
+          else resolve();
+        };
+        const connect = (resumeFromId) => {
+          if (signal.aborted || fatal) {
+            finish();
+            return;
+          }
+          const connectUrl = resumeFromId != null && resumeFromId !== "" ? buildResumeStreamUrl(url, resumeFromId) : url;
+          es = new EventSourceImpl(connectUrl);
+          handshakeOk = false;
+          es.addEventListener("meta", (event) => {
+            try {
+              const meta = JSON.parse(event.data);
+              if (meta.protocol_version !== EXPECTED_PROTOCOL_VERSION) {
+                fatal = true;
+                const error = new Error(
+                  `Unsupported protocol_version: ${meta.protocol_version}`
+                );
+                onError(error);
+                cleanup();
+                finish(error);
+                return;
+              }
+              handshakeOk = true;
+            } catch (err) {
+              fatal = true;
+              const error = err instanceof Error ? err : new Error("Failed to decode meta frame");
+              onError(error);
+              cleanup();
+              finish(error);
+            }
+          });
+          es.addEventListener("agentx", (event) => {
+            if (!handshakeOk) {
+              fatal = true;
+              const error = new Error("Received agentx frame before meta handshake");
+              onError(error);
+              cleanup();
+              finish(error);
+              return;
+            }
+            try {
+              const agentEvent = JSON.parse(event.data);
+              const sseEventId = event.lastEventId || void 0;
+              if (sseEventId) {
+                lastEventId = sseEventId;
+                onLastEventId?.(sseEventId);
+              }
+              const ctx = sseEventId ? { sseEventId } : void 0;
+              if (isBufferedDeltaEvent(agentEvent)) {
+                if (bufferedDelta) {
+                  const merged = mergeDeltaEvent(bufferedDelta.event, agentEvent);
+                  if (merged) {
+                    bufferedDelta = { event: merged, ctx };
+                  } else {
+                    flushBufferedDelta();
+                    bufferedDelta = { event: agentEvent, ctx };
+                  }
+                } else {
+                  bufferedDelta = { event: agentEvent, ctx };
+                }
+                if (!flushTimer) {
+                  flushTimer = setTimeout(() => {
+                    flushBufferedDelta();
+                  }, 16);
+                }
+              } else {
+                flushBufferedDelta();
+                handler(agentEvent, ctx);
+              }
+            } catch (err) {
+              onError(
+                new Error(
+                  err instanceof Error ? `Failed to decode agentx frame: ${err.message}` : "Failed to decode agentx frame"
+                )
+              );
+            }
+          });
+          es.onerror = () => {
+            flushBufferedDelta();
+            if (signal.aborted || fatal) {
+              cleanup();
+              finish();
+              return;
+            }
+            if (!autoReconnect) {
+              fatal = true;
+              const error = new Error("SSE connection error");
+              onError(error);
+              cleanup();
+              finish(error);
+              return;
+            }
+            cleanup();
+            setTimeout(() => connect(lastEventId), reconnectDelayMs);
+          };
+        };
+        signal.addEventListener("abort", () => {
+          flushBufferedDelta();
+          fatal = true;
+          finish();
+        }, { once: true });
+        connect();
+      });
+    }
+  };
+}
+function createMockSource(events) {
+  return {
+    async start(handler, signal) {
+      for (const event of events) {
+        if (signal.aborted) break;
+        handler(event);
+      }
+    }
+  };
+}
+
+// src/transport/createReplaySource.ts
+function sleep(ms, signal) {
+  if (ms <= 0) return Promise.resolve();
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    signal.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(timer);
+        resolve();
+      },
+      { once: true }
+    );
+  });
+}
+function createReplaySource(events, opts) {
+  const delayMs = opts?.delayMs ?? 0;
+  return {
+    async start(handler, signal) {
+      for (const event of events) {
+        if (signal.aborted) break;
+        handler(event);
+        if (delayMs > 0) {
+          await sleep(delayMs, signal);
+        }
+      }
+    }
+  };
+}
+export {
+  Agent,
+  AgentSession,
+  AgentToolBody,
+  AskUserQuestion,
+  AskUserQuestionToolBody,
+  Bash,
+  BashToolBody,
+  BodyBlockList,
+  CollapseKind,
+  CollapsedExploreNode,
+  DEFAULT_ESTIMATE_SIZE,
+  DEFAULT_EVENT_TIERS,
+  DEFAULT_SESSION_VIEW_OPTIONS,
+  DEFAULT_VIRTUALIZE_THRESHOLD,
+  DefaultToolBody,
+  DiffView,
+  EXPECTED_PROTOCOL_VERSION,
+  Edit,
+  EditToolBody,
+  ErrorCard,
+  ExploreCollapseAccumulator,
+  GROUPABLE_TOOL_NAMES,
+  Glob,
+  GlobToolBody,
+  Grep,
+  GrepToolBody,
+  GroupedToolUseAccumulator,
+  MAX_PREVIEW_LINES,
+  MIN_HINT_DISPLAY_MS,
+  MarkdownBlock,
+  MultiAgentSession,
+  NodeRegistry,
+  PermissionCard,
+  ProjectionContext,
+  Read,
+  ReadToolBody,
+  ReasoningBubble,
+  RenderableTimelineProjector,
+  SHELL_PROGRESS_MIN_ELAPSED_SECONDS,
+  SessionTimeline,
+  Skill,
+  SkillToolBody,
+  Spinner,
+  StepCard,
+  SubAgentBlock,
+  SystemSummaryAccumulator,
+  SystemSummaryNode,
+  TaskList,
+  TaskListFooter,
+  TextBubble,
+  Timeline,
+  TimelineItem,
+  ToolCallCard,
+  ToolDisplayRegistry,
+  ToolProjectionClassifier,
+  TruncatedContent,
+  UnknownCard,
+  VirtualTimeline,
+  WebFetch,
+  WebFetchToolBody,
+  WebSearch,
+  WebSearchToolBody,
+  Write,
+  WriteToolBody,
+  buildBashBodyBlocks,
+  buildCanonicalFromTree,
+  buildProjectionContext,
+  buildProjectionViewContext,
+  buildRelevantMemoriesCanonical,
+  buildResumeStreamUrl,
+  buildSystemEventCanonical,
+  buildTimelineEntries,
+  classifyEvent,
+  commandAsHint,
+  createActiveSessionBridge,
+  createAgentxSseSource,
+  createDefaultRegistry,
+  createDefaultToolRegistry,
+  createEmptyTree,
+  createInteractionBus,
+  createMockSource,
+  createMultiSessionStore,
+  createProjectionContext,
+  createReplaySource,
+  createSessionStore,
+  displayPath,
+  entryKey,
+  formatAgentTitle,
+  formatDiffFromStrings,
+  formatExploreSummaryText,
+  formatHookFinishedSummary,
+  formatPatternTitle,
+  formatSearchResultBody,
+  formatShellProgressSuffix,
+  formatTaskFooterLabel,
+  formatTimeoutFooter,
+  formatToolTitle,
+  getChildIds,
+  getMainStageIds,
+  getNoopInteractionBus,
+  isGitOperationCommand,
+  isGroupableToolName,
+  isMcpToolName,
+  iterMountCandidates,
+  parseDiffText,
+  projectCanonical,
+  projectTimeline,
+  reduceEvents,
+  reduceTree,
+  replayEvents,
+  replayTree,
+  resolveEffectiveToolBodyMode,
+  resolveEventTier,
+  resolveResponseId,
+  resolveShellProgressFromPayload,
+  resolveToolBody,
+  shouldApplyGrouping,
+  shouldShowExploreDetail,
+  shouldShowTaskListFooter,
+  streamChunk,
+  truncateCommand,
+  useActiveSession,
+  useChildren,
+  useInteractionBus,
+  useInternalErrors,
+  useMinDisplayTime,
+  useNode,
+  useNodeTyped,
+  useProjectedTimeline,
+  useReplayTree,
+  useSessionIds,
+  useSessionMeta,
+  useSessionStatus,
+  useTimeline
+};
+//# sourceMappingURL=index.js.map