langchain_agentx_stream_ui 0.1.0

package/dist/chunk-W6QQHTJ4.js

@@ -0,0 +1,785 @@
+import {
+  InteractionBusContext,
+  ToolCallShell,
+  formatToolTitle,
+  getNoopInteractionBus,
+  resolveToolBody,
+  useInteractionBus
+} from "./chunk-WM6Y6APP.js";
+import {
+  DEFAULT_SESSION_VIEW_OPTIONS,
+  MultiSessionStoreContext,
+  NodeRegistryContext,
+  SessionStoreContext,
+  SessionTimeline,
+  SessionViewOptionsContext,
+  ToolDisplayOptionsContext,
+  createEmptyTree,
+  reduceTree,
+  replayEvents,
+  resolveEffectiveToolBodyMode,
+  useInternalErrors,
+  useNodeTyped,
+  usePendingPermissionForTool,
+  useSessionStatus,
+  useSessionViewOptions,
+  useToolDisplayOptions
+} from "./chunk-G2KYJCMM.js";
+import {
+  createDefaultToolRegistry
+} from "./chunk-MHK53ZHC.js";
+import {
+  MarkdownRendererContext
+} from "./chunk-4RIOBLGB.js";
+
+// src/view/nodes/ReasoningNode.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var REASONING_DOT = "\u25CF";
+function ReasoningBubble({ nodeId }) {
+  const node = useNodeTyped(nodeId, "reasoning");
+  if (!node) return null;
+  const text = node.accumulated.trim();
+  if (!text) return null;
+  return /* @__PURE__ */ jsx("div", { className: "lax-reasoning-bubble", "data-status": node.status, "data-round-id": node.roundId, children: /* @__PURE__ */ jsxs("div", { className: "lax-reasoning-bubble__body", children: [
+    /* @__PURE__ */ jsx("span", { className: "lax-reasoning-bubble__dot", "aria-hidden": "true", children: REASONING_DOT }),
+    /* @__PURE__ */ jsx("span", { className: "lax-reasoning-bubble__content", children: node.accumulated })
+  ] }) });
+}
+
+// src/view/tools/presentation/StreamingMarkdown.tsx
+import { useRef, useMemo, useState } from "react";
+import { marked } from "marked";
+import ReactMarkdown from "react-markdown";
+import remarkGfm from "remark-gfm";
+import { Prism as SyntaxHighlighter } from "react-syntax-highlighter";
+import { oneDark } from "react-syntax-highlighter/dist/esm/styles/prism";
+import { Fragment, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var TOKEN_CACHE_MAX = 500;
+var tokenCache = /* @__PURE__ */ new Map();
+var MD_SYNTAX_RE = /[#*`|\[>\\\-~]|\n\n|^\d+\. |\n\d+\. /;
+function hasMarkdownSyntax(s) {
+  return MD_SYNTAX_RE.test(s.length > 500 ? s.slice(0, 500) : s);
+}
+function hashContent(content) {
+  let hash = 5381;
+  for (let i = 0; i < content.length; i++) {
+    hash = (hash << 5) + hash + content.charCodeAt(i) & 4294967295;
+  }
+  return hash.toString(36);
+}
+function cachedLexer(content) {
+  if (!hasMarkdownSyntax(content)) {
+    return [{
+      type: "paragraph",
+      raw: content,
+      text: content,
+      tokens: [{
+        type: "text",
+        raw: content,
+        text: content
+      }]
+    }];
+  }
+  const key = hashContent(content);
+  const hit = tokenCache.get(key);
+  if (hit) {
+    tokenCache.delete(key);
+    tokenCache.set(key, hit);
+    return hit;
+  }
+  const tokens = marked.lexer(content);
+  if (tokenCache.size >= TOKEN_CACHE_MAX) {
+    const first = tokenCache.keys().next().value;
+    if (first !== void 0) tokenCache.delete(first);
+  }
+  tokenCache.set(key, tokens);
+  return tokens;
+}
+var MARKDOWN_COMPONENTS = {
+  code({ node, className, children, ...props }) {
+    const match = /language-(\w+)/.exec(className || "");
+    const codeContent = String(children).replace(/\n$/, "");
+    const inline = !className;
+    if (!inline && match) {
+      return /* @__PURE__ */ jsx2(CodeBlock, { language: match[1], content: codeContent });
+    }
+    return /* @__PURE__ */ jsx2("code", { className: "lax-markdown__inline-code", ...props, children });
+  },
+  h1({ children }) {
+    return /* @__PURE__ */ jsx2("h1", { className: "lax-markdown__heading lax-markdown__h1", children });
+  },
+  h2({ children }) {
+    return /* @__PURE__ */ jsx2("h2", { className: "lax-markdown__heading lax-markdown__h2", children });
+  },
+  h3({ children }) {
+    return /* @__PURE__ */ jsx2("h3", { className: "lax-markdown__heading lax-markdown__h3", children });
+  },
+  h4({ children }) {
+    return /* @__PURE__ */ jsx2("h4", { className: "lax-markdown__heading lax-markdown__h4", children });
+  },
+  h5({ children }) {
+    return /* @__PURE__ */ jsx2("h5", { className: "lax-markdown__heading lax-markdown__h5", children });
+  },
+  h6({ children }) {
+    return /* @__PURE__ */ jsx2("h6", { className: "lax-markdown__heading lax-markdown__h6", children });
+  },
+  p({ children }) {
+    return /* @__PURE__ */ jsx2("p", { className: "lax-markdown__paragraph", children });
+  },
+  ul({ children }) {
+    return /* @__PURE__ */ jsx2("ul", { className: "lax-markdown__list lax-markdown__ul", children });
+  },
+  ol({ children }) {
+    return /* @__PURE__ */ jsx2("ol", { className: "lax-markdown__list lax-markdown__ol", children });
+  },
+  li({ children }) {
+    return /* @__PURE__ */ jsx2("li", { className: "lax-markdown__li", children });
+  },
+  a({ children, href }) {
+    return /* @__PURE__ */ jsx2("a", { href, className: "lax-markdown__link", target: "_blank", rel: "noopener noreferrer", children });
+  },
+  blockquote({ children }) {
+    return /* @__PURE__ */ jsx2("blockquote", { className: "lax-markdown__blockquote", children });
+  },
+  table({ children }) {
+    return /* @__PURE__ */ jsx2("div", { className: "lax-markdown__table-wrapper", children: /* @__PURE__ */ jsx2("table", { className: "lax-markdown__table", children }) });
+  },
+  thead({ children }) {
+    return /* @__PURE__ */ jsx2("thead", { className: "lax-markdown__thead", children });
+  },
+  tbody({ children }) {
+    return /* @__PURE__ */ jsx2("tbody", { className: "lax-markdown__tbody", children });
+  },
+  tr({ children }) {
+    return /* @__PURE__ */ jsx2("tr", { className: "lax-markdown__tr", children });
+  },
+  th({ children }) {
+    return /* @__PURE__ */ jsx2("th", { className: "lax-markdown__th", children });
+  },
+  td({ children }) {
+    return /* @__PURE__ */ jsx2("td", { className: "lax-markdown__td", children });
+  },
+  hr() {
+    return /* @__PURE__ */ jsx2("hr", { className: "lax-markdown__hr" });
+  },
+  strong({ children }) {
+    return /* @__PURE__ */ jsx2("strong", { className: "lax-markdown__strong", children });
+  },
+  em({ children }) {
+    return /* @__PURE__ */ jsx2("em", { className: "lax-markdown__em", children });
+  }
+};
+function CodeBlock({ language, content }) {
+  const [copied, setCopied] = useState(false);
+  const handleCopy = async () => {
+    try {
+      await navigator.clipboard.writeText(content);
+      setCopied(true);
+      setTimeout(() => setCopied(false), 2e3);
+    } catch (err) {
+      console.error("Failed to copy:", err);
+    }
+  };
+  return /* @__PURE__ */ jsxs2("div", { className: "lax-code-block", children: [
+    /* @__PURE__ */ jsxs2("div", { className: "lax-code-block__header", children: [
+      /* @__PURE__ */ jsx2("span", { className: "lax-code-block__lang", children: language || "code" }),
+      /* @__PURE__ */ jsx2(
+        "button",
+        {
+          type: "button",
+          className: `lax-code-block__copy ${copied ? "lax-code-block__copy--copied" : ""}`,
+          onClick: handleCopy,
+          title: copied ? "\u5DF2\u62F7\u8D1D\uFF01" : "\u62F7\u8D1D\u4EE3\u7801",
+          children: copied ? /* @__PURE__ */ jsxs2(Fragment, { children: [
+            /* @__PURE__ */ jsx2("svg", { className: "lax-code-block__icon", fill: "none", viewBox: "0 0 24 24", stroke: "currentColor", strokeWidth: 3, children: /* @__PURE__ */ jsx2("path", { strokeLinecap: "round", strokeLinejoin: "round", d: "M5 13l4 4L19 7" }) }),
+            /* @__PURE__ */ jsx2("span", { children: "\u5DF2\u62F7\u8D1D" })
+          ] }) : /* @__PURE__ */ jsxs2(Fragment, { children: [
+            /* @__PURE__ */ jsx2("svg", { className: "lax-code-block__icon", fill: "none", viewBox: "0 0 24 24", stroke: "currentColor", strokeWidth: 2, children: /* @__PURE__ */ jsx2(
+              "path",
+              {
+                strokeLinecap: "round",
+                strokeLinejoin: "round",
+                d: "M8 16H6a2 2 0 01-2-2V6a2 2 0 012-2h8a2 2 0 012 2v2m-6 12h8a2 2 0 002-2v-8a2 2 0 00-2-2h-8a2 2 0 00-2 2v8a2 2 0 002 2z"
+              }
+            ) }),
+            /* @__PURE__ */ jsx2("span", { children: "\u62F7\u8D1D" })
+          ] })
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx2(
+      SyntaxHighlighter,
+      {
+        language,
+        style: oneDark,
+        customStyle: {
+          margin: 0,
+          padding: 0,
+          background: "transparent"
+        },
+        showLineNumbers: false,
+        wrapLongLines: true,
+        children: content
+      }
+    )
+  ] });
+}
+function MarkdownRenderer({ content }) {
+  if (!content.trim()) {
+    return null;
+  }
+  const elements = useMemo(() => {
+    const hash = hashContent(content);
+    if (!hasMarkdownSyntax(content)) {
+      return /* @__PURE__ */ jsx2("p", { className: "lax-markdown__paragraph", children: content }, hash.toString(36));
+    }
+    return /* @__PURE__ */ jsx2(
+      ReactMarkdown,
+      {
+        remarkPlugins: [remarkGfm],
+        components: MARKDOWN_COMPONENTS,
+        children: content
+      },
+      hash.toString(36)
+    );
+  }, [content]);
+  return /* @__PURE__ */ jsx2(Fragment, { children: elements });
+}
+function StreamingMarkdown({ children }) {
+  "use no memo";
+  const stablePrefixRef = useRef("");
+  if (!children.startsWith(stablePrefixRef.current)) {
+    stablePrefixRef.current = "";
+  }
+  const boundary = stablePrefixRef.current.length;
+  const tokens = cachedLexer(children.substring(boundary));
+  let lastContentIdx = tokens.length - 1;
+  while (lastContentIdx >= 0 && tokens[lastContentIdx].type === "space") {
+    lastContentIdx--;
+  }
+  let advance = 0;
+  for (let i = 0; i < lastContentIdx; i++) {
+    advance += tokens[i].raw.length;
+  }
+  if (advance > 0) {
+    stablePrefixRef.current = children.substring(0, boundary + advance);
+  }
+  const stablePrefix = stablePrefixRef.current;
+  const unstableSuffix = children.substring(stablePrefix.length);
+  return /* @__PURE__ */ jsxs2("div", { className: "lax-markdown", children: [
+    stablePrefix && /* @__PURE__ */ jsx2(MarkdownRenderer, { content: stablePrefix }, `stable-${hashContent(stablePrefix)}`),
+    unstableSuffix && /* @__PURE__ */ jsx2(MarkdownRenderer, { content: unstableSuffix }, `unstable-${hashContent(unstableSuffix)}`)
+  ] });
+}
+
+// src/view/nodes/TextNode.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function TextBubble({ nodeId }) {
+  const node = useNodeTyped(nodeId, "text");
+  if (!node) return null;
+  return /* @__PURE__ */ jsx3("div", { className: "lax-text-bubble", "data-status": node.status, children: /* @__PURE__ */ jsxs3("div", { className: "lax-text-bubble__body", children: [
+    /* @__PURE__ */ jsx3("span", { className: "lax-text-bubble__dot", "aria-hidden": "true", children: REASONING_DOT }),
+    /* @__PURE__ */ jsx3("div", { className: "lax-text-bubble__content lax-text-bubble__content--markdown", children: /* @__PURE__ */ jsx3(StreamingMarkdown, { children: node.accumulated }) })
+  ] }) });
+}
+
+// src/view/nodes/ToolCallNode.tsx
+import { useEffect, useState as useState2 } from "react";
+import { jsx as jsx4 } from "react/jsx-runtime";
+function ToolCallCard({ nodeId, layout = "default" }) {
+  const node = useNodeTyped(nodeId, "tool_call");
+  const { registry, defaultBodyMode } = useToolDisplayOptions();
+  const viewOptions = useSessionViewOptions();
+  const pendingPermission = usePendingPermissionForTool(node?.toolName ?? "");
+  const effectiveDefault = resolveEffectiveToolBodyMode(viewOptions, defaultBodyMode);
+  const [bodyMode, setBodyMode] = useState2(effectiveDefault);
+  useEffect(() => {
+    setBodyMode(resolveEffectiveToolBodyMode(viewOptions, defaultBodyMode));
+  }, [viewOptions.displayMode, viewOptions.verbose, defaultBodyMode]);
+  if (!node) return null;
+  if (node.hidden) return null;
+  const details = node.details;
+  const inputStream = details?.inputStream ?? node.inputDelta;
+  const result = node.result;
+  const displayBody = result?.display ?? null;
+  const hasSubagentProgress = (node.subagentProgress?.length ?? 0) > 0;
+  const showBody = hasSubagentProgress || !(node.status === "running" && result == null);
+  const BodyComponent = resolveToolBody(node.toolName, displayBody, registry);
+  const title = formatToolTitle(
+    node.toolName,
+    details?.input ?? node.input,
+    displayBody,
+    result?.summary,
+    result?.meta
+  );
+  const bodyProps = {
+    nodeId,
+    toolName: node.toolName,
+    status: node.status,
+    input: details?.input ?? node.input,
+    inputStream,
+    result,
+    progress: node.progress ?? void 0,
+    subagentProgress: node.subagentProgress,
+    subagentSessions: node.subagentSessions,
+    bodyMode,
+    onBodyModeChange: setBodyMode
+  };
+  const errorMessage = result?.error?.message ?? null;
+  const permissionWait = viewOptions.permissionUiMode !== "standalone" && node.status === "running" ? pendingPermission : void 0;
+  return /* @__PURE__ */ jsx4(
+    ToolCallShell,
+    {
+      status: node.status,
+      title,
+      progress: node.progress ?? void 0,
+      errorMessage,
+      layout,
+      permissionWait,
+      permissionUiMode: viewOptions.permissionUiMode,
+      children: showBody ? /* @__PURE__ */ jsx4("div", { className: "lax-tool-shell__body", children: /* @__PURE__ */ jsx4(BodyComponent, { ...bodyProps }) }) : null
+    }
+  );
+}
+
+// src/view/nodes/StepNode.tsx
+import { jsx as jsx5 } from "react/jsx-runtime";
+function StepCard({ nodeId }) {
+  const node = useNodeTyped(nodeId, "step");
+  if (!node) return null;
+  return /* @__PURE__ */ jsx5("details", { className: "lax-step-card", "data-status": node.status, children: /* @__PURE__ */ jsx5("summary", { className: "lax-step-card__summary", children: node.label }) });
+}
+
+// src/view/nodes/ErrorNode.tsx
+import { jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
+function ErrorCard({ nodeId }) {
+  const node = useNodeTyped(nodeId, "error");
+  if (!node) return null;
+  return /* @__PURE__ */ jsxs4("div", { className: "lax-error-card", role: "alert", children: [
+    /* @__PURE__ */ jsx6("div", { className: "lax-error-card__message", children: node.message }),
+    node.errorType ? /* @__PURE__ */ jsx6("div", { className: "lax-error-card__type", children: node.errorType }) : null
+  ] });
+}
+
+// src/view/nodes/UnknownNode.tsx
+import { jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
+function UnknownCard({ nodeId }) {
+  const node = useNodeTyped(nodeId, "unknown");
+  if (!node) return null;
+  return /* @__PURE__ */ jsxs5("div", { className: "lax-unknown-card", children: [
+    /* @__PURE__ */ jsxs5("div", { className: "lax-unknown-card__type", children: [
+      "Unknown: ",
+      node.eventType
+    ] }),
+    /* @__PURE__ */ jsx7("pre", { className: "lax-unknown-card__data", children: JSON.stringify(node.rawData, null, 2) })
+  ] });
+}
+
+// src/view/nodes/PermissionNode.tsx
+import { useState as useState3 } from "react";
+import { jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
+function PermissionCard({ nodeId }) {
+  const node = useNodeTyped(nodeId, "permission");
+  const bus = useInteractionBus();
+  const [resolvedLocally, setResolvedLocally] = useState3(false);
+  if (!node) return null;
+  const pending = node.status === "pending" && !resolvedLocally;
+  const onAllow = () => {
+    void bus.resolvePermission({ requestId: node.requestId, allow: true });
+    setResolvedLocally(true);
+  };
+  const onDeny = () => {
+    void bus.resolvePermission({ requestId: node.requestId, allow: false });
+    setResolvedLocally(true);
+  };
+  return /* @__PURE__ */ jsxs6(
+    "div",
+    {
+      className: "lax-permission-card",
+      "data-status": pending ? "pending" : "resolved",
+      "data-request-id": node.requestId,
+      children: [
+        /* @__PURE__ */ jsxs6("div", { className: "lax-permission-card__header", children: [
+          /* @__PURE__ */ jsx8("span", { className: "lax-permission-card__label", children: "Permission" }),
+          /* @__PURE__ */ jsx8("span", { className: "lax-permission-card__tool", children: node.toolName })
+        ] }),
+        /* @__PURE__ */ jsx8("div", { className: "lax-permission-card__message", children: node.message }),
+        node.askPrompt && node.askPrompt !== node.message ? /* @__PURE__ */ jsx8("div", { className: "lax-permission-card__prompt", children: node.askPrompt }) : null,
+        pending ? /* @__PURE__ */ jsxs6("div", { className: "lax-permission-card__actions", children: [
+          /* @__PURE__ */ jsx8("button", { type: "button", className: "lax-permission-card__allow", onClick: onAllow, children: "Allow" }),
+          /* @__PURE__ */ jsx8("button", { type: "button", className: "lax-permission-card__deny", onClick: onDeny, children: "Deny" })
+        ] }) : /* @__PURE__ */ jsx8("div", { className: "lax-permission-card__resolved", children: "Resolved" })
+      ]
+    }
+  );
+}
+
+// src/view/nodes/MemorySavedNode.tsx
+import { jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
+function MemorySavedRow({ nodeId }) {
+  const node = useNodeTyped(nodeId, "memory_saved");
+  if (!node) return null;
+  const hasPaths = node.writtenPaths.length > 0;
+  return /* @__PURE__ */ jsxs7(
+    "details",
+    {
+      className: "lax-memory-saved",
+      "data-testid": "lax-memory-saved",
+      "data-node-id": nodeId,
+      children: [
+        /* @__PURE__ */ jsxs7("summary", { className: "lax-memory-saved__summary", children: [
+          /* @__PURE__ */ jsx9("span", { className: "lax-memory-saved__icon", "aria-hidden": "true", children: "\u{1F4BE}" }),
+          /* @__PURE__ */ jsx9("span", { className: "lax-memory-saved__hint", children: node.displayHint })
+        ] }),
+        hasPaths ? /* @__PURE__ */ jsx9("ul", { className: "lax-memory-saved__paths", children: node.writtenPaths.map((p) => /* @__PURE__ */ jsx9("li", { className: "lax-memory-saved__path", children: /* @__PURE__ */ jsx9("code", { children: p }) }, p)) }) : null
+      ]
+    }
+  );
+}
+
+// src/view/NodeRegistry.ts
+var DEFAULT_WIDGETS = /* @__PURE__ */ new Map([
+  ["text", TextBubble],
+  ["reasoning", ReasoningBubble],
+  ["tool_call", ToolCallCard],
+  ["step", StepCard],
+  ["error", ErrorCard],
+  ["unknown", UnknownCard],
+  ["permission", PermissionCard],
+  ["memory_saved", MemorySavedRow]
+]);
+var NodeRegistry = class _NodeRegistry {
+  widgets;
+  constructor(widgets) {
+    this.widgets = widgets;
+  }
+  static default() {
+    return new _NodeRegistry(new Map(DEFAULT_WIDGETS));
+  }
+  override(kind, widget) {
+    const next = new Map(this.widgets);
+    next.set(kind, widget);
+    return new _NodeRegistry(next);
+  }
+  register(kind, widget) {
+    return this.override(kind, widget);
+  }
+  get(kind) {
+    return this.widgets.get(kind);
+  }
+  has(kind) {
+    return this.widgets.has(kind);
+  }
+};
+
+// src/view/defaultRegistry.ts
+function createDefaultRegistry() {
+  return NodeRegistry.default();
+}
+
+// src/core/sessionStore.ts
+import { createStore } from "zustand/vanilla";
+
+// src/core/dedupe.ts
+function shouldSkipDuplicateEvent(seenEventIds, sseEventId) {
+  if (!sseEventId) return false;
+  return seenEventIds.has(sseEventId);
+}
+function markEventIdSeen(seenEventIds, sseEventId) {
+  if (sseEventId) seenEventIds.add(sseEventId);
+}
+
+// src/core/sessionStore.ts
+var DEFAULT_MAX_SESSIONS = 10;
+function touchOrder(order, sessionId) {
+  return [...order.filter((id) => id !== sessionId), sessionId];
+}
+function safeReduce(tree, event, eventIndex, options) {
+  try {
+    return 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);
+    }
+    const reducerError = {
+      eventIndex,
+      eventType: event.event_type,
+      message,
+      stack
+    };
+    return {
+      ...tree,
+      internalErrors: [...tree.internalErrors, reducerError]
+    };
+  }
+}
+function evictSessions(sessions, order, maxSessions, activeSessionId) {
+  let nextSessions = { ...sessions };
+  let nextOrder = [...order];
+  while (nextOrder.length > maxSessions) {
+    const candidate = nextOrder.find((id) => id !== activeSessionId) ?? nextOrder[0];
+    if (!candidate) break;
+    const { [candidate]: _removed, ...rest } = nextSessions;
+    nextSessions = rest;
+    nextOrder = nextOrder.filter((id) => id !== candidate);
+  }
+  return { sessions: nextSessions, order: nextOrder };
+}
+function createMultiSessionStore(options) {
+  const maxSessions = options?.maxSessions ?? DEFAULT_MAX_SESSIONS;
+  const reduceOpts = {
+    tierOverrides: options?.tierOverrides,
+    collectDebug: options?.debug === true
+  };
+  const replayOpts = {
+    tierOverrides: options?.tierOverrides,
+    collectDebug: options?.debug === true
+  };
+  const seenBySession = /* @__PURE__ */ new Map();
+  function getSeenSet(sessionId) {
+    let set = seenBySession.get(sessionId);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      seenBySession.set(sessionId, set);
+    }
+    return set;
+  }
+  return createStore((set, get) => ({
+    sessions: {},
+    activeSessionId: options?.activeSessionId ?? null,
+    order: [],
+    getSessionTree(sessionId) {
+      return get().sessions[sessionId]?.tree;
+    },
+    ensureSession(sessionId, initialEvents) {
+      const state = get();
+      if (state.sessions[sessionId]) return;
+      const tree = initialEvents && initialEvents.length > 0 ? replayEvents(initialEvents, replayOpts) : createEmptyTree();
+      const slice = {
+        tree,
+        eventCount: initialEvents?.length ?? 0
+      };
+      let order = touchOrder(state.order, sessionId);
+      let sessions = { ...state.sessions, [sessionId]: slice };
+      ({ sessions, order } = evictSessions(sessions, order, maxSessions, state.activeSessionId));
+      set({
+        sessions,
+        order,
+        activeSessionId: state.activeSessionId ?? sessionId
+      });
+    },
+    applyEvent(sessionId, event, ctx) {
+      const sseEventId = ctx?.sseEventId;
+      const seen = getSeenSet(sessionId);
+      if (shouldSkipDuplicateEvent(seen, sseEventId)) return;
+      const state = get();
+      let slice = state.sessions[sessionId];
+      if (!slice) {
+        get().ensureSession(sessionId);
+        slice = get().sessions[sessionId];
+      }
+      const reduced = safeReduce(slice.tree, event, slice.eventCount, reduceOpts);
+      const nextTree = sseEventId ? { ...reduced, meta: { ...reduced.meta, lastEventId: sseEventId } } : reduced;
+      const nextSlice = {
+        tree: nextTree,
+        eventCount: slice.eventCount + 1
+      };
+      markEventIdSeen(seen, sseEventId);
+      let sessions = { ...state.sessions, [sessionId]: nextSlice };
+      let order = touchOrder(state.order, sessionId);
+      ({ sessions, order } = evictSessions(sessions, order, maxSessions, state.activeSessionId));
+      set({ sessions, order });
+    },
+    applyEvents(sessionId, events) {
+      for (const event of events) {
+        get().applyEvent(sessionId, event);
+      }
+    },
+    setActiveSessionId(id) {
+      set({ activeSessionId: id });
+    },
+    removeSession(sessionId) {
+      const state = get();
+      if (!state.sessions[sessionId]) return;
+      seenBySession.delete(sessionId);
+      const { [sessionId]: _removed, ...sessions } = state.sessions;
+      const order = state.order.filter((id) => id !== sessionId);
+      const activeSessionId = state.activeSessionId === sessionId ? order[order.length - 1] ?? null : state.activeSessionId;
+      set({ sessions, order, activeSessionId });
+    },
+    replaySession(sessionId, events) {
+      const tree = replayEvents(events, replayOpts);
+      const slice = { tree, eventCount: events.length };
+      const state = get();
+      let order = touchOrder(state.order, sessionId);
+      let sessions = { ...state.sessions, [sessionId]: slice };
+      ({ sessions, order } = evictSessions(sessions, order, maxSessions, state.activeSessionId));
+      set({ sessions, order });
+    }
+  }));
+}
+function createActiveSessionBridge(multiStore) {
+  const bridge = createStore(() => ({
+    tree: createEmptyTree(),
+    eventCount: 0,
+    applyEvent(event, ctx) {
+      const id = multiStore.getState().activeSessionId;
+      if (id) multiStore.getState().applyEvent(id, event, ctx);
+    },
+    applyEvents(events) {
+      const id = multiStore.getState().activeSessionId;
+      if (id) multiStore.getState().applyEvents(id, events);
+    },
+    reset() {
+      const id = multiStore.getState().activeSessionId;
+      if (id) multiStore.getState().replaySession(id, []);
+    }
+  }));
+  const sync = () => {
+    const { activeSessionId, sessions } = multiStore.getState();
+    const slice = activeSessionId ? sessions[activeSessionId] : void 0;
+    bridge.setState({
+      tree: slice?.tree ?? createEmptyTree(),
+      eventCount: slice?.eventCount ?? 0
+    });
+  };
+  multiStore.subscribe(sync);
+  sync();
+  return bridge;
+}
+
+// src/view/MultiAgentSession.tsx
+import { useEffect as useEffect2, useMemo as useMemo2, useRef as useRef2 } from "react";
+import { jsx as jsx10, jsxs as jsxs8 } from "react/jsx-runtime";
+function DebugPanel() {
+  const status = useSessionStatus();
+  const errors = useInternalErrors();
+  if (errors.length === 0) return null;
+  return /* @__PURE__ */ jsxs8("div", { className: "lax-debug-panel", "data-testid": "lax-debug-panel", children: [
+    /* @__PURE__ */ jsxs8("div", { children: [
+      "status: ",
+      status
+    ] }),
+    /* @__PURE__ */ jsx10("ul", { children: errors.map((err, i) => /* @__PURE__ */ jsxs8("li", { children: [
+      "[",
+      err.eventType,
+      "] ",
+      err.message
+    ] }, `${err.eventIndex}-${i}`)) })
+  ] });
+}
+function MultiAgentSession({
+  sessions,
+  activeSessionId: controlledActiveId,
+  defaultActiveSessionId,
+  onActiveSessionChange,
+  maxSessions,
+  tierOverrides,
+  debug = false,
+  registry,
+  onError,
+  virtualized = false,
+  virtualizeThreshold,
+  interactionBus,
+  toolDisplayRegistry,
+  defaultBodyMode = "preview",
+  groupParallelTools = false,
+  permissionUiMode = "standalone",
+  markdownRenderer,
+  children
+}) {
+  const multiStoreRef = useRef2(null);
+  const bridgeRef = useRef2(null);
+  if (multiStoreRef.current === null) {
+    const defaultId = defaultActiveSessionId ?? controlledActiveId ?? sessions[0]?.sessionId ?? null;
+    multiStoreRef.current = createMultiSessionStore({
+      maxSessions,
+      tierOverrides,
+      debug,
+      activeSessionId: defaultId
+    });
+    bridgeRef.current = createActiveSessionBridge(multiStoreRef.current);
+    for (const cfg of sessions) {
+      multiStoreRef.current.getState().ensureSession(cfg.sessionId, cfg.initialEvents);
+    }
+  }
+  const registryRef = useMemo2(() => registry ?? createDefaultRegistry(), [registry]);
+  const busRef = useMemo2(
+    () => interactionBus ?? getNoopInteractionBus(),
+    [interactionBus]
+  );
+  const toolDisplayRef = useMemo2(
+    () => ({
+      registry: toolDisplayRegistry ?? createDefaultToolRegistry(),
+      defaultBodyMode
+    }),
+    [toolDisplayRegistry, defaultBodyMode]
+  );
+  const sessionViewRef = useMemo2(
+    () => ({
+      ...DEFAULT_SESSION_VIEW_OPTIONS,
+      groupParallelTools,
+      permissionUiMode,
+      verboseReasoning: debug
+    }),
+    [groupParallelTools, permissionUiMode, debug]
+  );
+  useEffect2(() => {
+    if (controlledActiveId === void 0) return;
+    multiStoreRef.current.getState().setActiveSessionId(controlledActiveId);
+  }, [controlledActiveId]);
+  useEffect2(() => {
+    if (!onActiveSessionChange) return;
+    return multiStoreRef.current.subscribe((state) => {
+      onActiveSessionChange(state.activeSessionId);
+    });
+  }, [onActiveSessionChange]);
+  useEffect2(() => {
+    const multiStore = multiStoreRef.current;
+    const controllers = sessions.map((cfg) => {
+      const controller = new AbortController();
+      multiStore.getState().ensureSession(cfg.sessionId, cfg.initialEvents);
+      void cfg.source.start((event, ctx) => {
+        multiStore.getState().applyEvent(cfg.sessionId, event, ctx);
+      }, controller.signal).catch((err) => {
+        const error = err instanceof Error ? err : new Error(String(err));
+        onError?.(error, cfg.sessionId);
+      });
+      return controller;
+    });
+    return () => {
+      for (const c of controllers) c.abort();
+    };
+  }, [sessions, onError]);
+  return /* @__PURE__ */ jsx10(MultiSessionStoreContext.Provider, { value: multiStoreRef.current, children: /* @__PURE__ */ jsx10(SessionStoreContext.Provider, { value: bridgeRef.current, children: /* @__PURE__ */ jsx10(InteractionBusContext.Provider, { value: busRef, children: /* @__PURE__ */ jsx10(NodeRegistryContext.Provider, { value: registryRef, children: /* @__PURE__ */ jsx10(MarkdownRendererContext.Provider, { value: markdownRenderer, children: /* @__PURE__ */ jsx10(ToolDisplayOptionsContext.Provider, { value: toolDisplayRef, children: /* @__PURE__ */ jsx10(SessionViewOptionsContext.Provider, { value: sessionViewRef, children: /* @__PURE__ */ jsxs8("div", { className: "lax-agent-session lax-multi-agent-session", "data-testid": "lax-multi-agent-session", children: [
+    children ?? /* @__PURE__ */ jsx10(
+      SessionTimeline,
+      {
+        virtualized,
+        virtualizeThreshold,
+        groupParallelTools
+      }
+    ),
+    debug ? /* @__PURE__ */ jsx10(DebugPanel, {}) : null
+  ] }) }) }) }) }) }) }) });
+}
+
+export {
+  shouldSkipDuplicateEvent,
+  markEventIdSeen,
+  ReasoningBubble,
+  TextBubble,
+  ToolCallCard,
+  StepCard,
+  ErrorCard,
+  UnknownCard,
+  PermissionCard,
+  NodeRegistry,
+  createDefaultRegistry,
+  createMultiSessionStore,
+  createActiveSessionBridge,
+  MultiAgentSession
+};
+//# sourceMappingURL=chunk-W6QQHTJ4.js.map