langchain_agentx_stream_ui 0.1.2 → 0.1.8

package/dist/chunk-WPW3TQQF.js

@@ -0,0 +1,1900 @@
+import {
+  InteractionBusContext,
+  ToolCallShell,
+  formatToolTitle,
+  getNoopInteractionBus,
+  resolveToolBody,
+  useInteractionBus
+} from "./chunk-6DYISADG.js";
+import {
+  DEFAULT_SESSION_VIEW_OPTIONS,
+  MultiSessionStoreContext,
+  NodeRegistryContext,
+  SessionStoreContext,
+  SessionTimeline,
+  SessionViewOptionsContext,
+  ToolDisplayOptionsContext,
+  createEmptyTree,
+  reduceTree,
+  replayEvents,
+  resolveEffectiveToolBodyMode,
+  useInternalErrors,
+  useNodeTyped,
+  usePendingPermissionForTool,
+  useSessionStatus,
+  useSessionViewOptions,
+  useToolDisplayOptions
+} from "./chunk-LBJFJF22.js";
+import {
+  createDefaultToolRegistry
+} from "./chunk-7CLAU74Y.js";
+import {
+  MarkdownRendererContext
+} from "./chunk-4RIOBLGB.js";
+
+// src/view/markdown/diagramSmartFit.ts
+function parseSvgLength(attr) {
+  if (!attr) return NaN;
+  const trimmed = attr.trim();
+  if (trimmed.endsWith("%")) return NaN;
+  const value = parseFloat(trimmed);
+  return Number.isFinite(value) && value > 0 ? value : NaN;
+}
+function resolveSvgContentSize(svg) {
+  const baseVal = svg.viewBox?.baseVal;
+  if (baseVal && baseVal.width > 0 && baseVal.height > 0) {
+    return { width: baseVal.width, height: baseVal.height };
+  }
+  const raw = svg.getAttribute("viewBox");
+  if (raw) {
+    const parts = raw.trim().split(/[\s,]+/).map(Number);
+    if (parts.length === 4 && parts[2] > 0 && parts[3] > 0) {
+      return { width: parts[2], height: parts[3] };
+    }
+  }
+  const parsedW = parseSvgLength(svg.getAttribute("width"));
+  const parsedH = parseSvgLength(svg.getAttribute("height"));
+  return {
+    width: Number.isFinite(parsedW) ? parsedW : svg.clientWidth || 0,
+    height: Number.isFinite(parsedH) ? parsedH : svg.clientHeight || 0
+  };
+}
+function prepareSvgForInteraction(svg, layout = "fill") {
+  svg.style.pointerEvents = "none";
+  svg.style.display = "block";
+  if (layout === "natural") {
+    svg.style.maxWidth = "100%";
+    svg.style.width = "auto";
+    svg.style.height = "auto";
+    return;
+  }
+  svg.style.maxWidth = "none";
+  const { width, height } = resolveSvgContentSize(svg);
+  const widthAttr = svg.getAttribute("width") ?? "";
+  const heightAttr = svg.getAttribute("height") ?? "";
+  if (width > 0 && (!widthAttr || widthAttr.includes("%"))) {
+    svg.setAttribute("width", String(width));
+    svg.style.width = `${width}px`;
+  }
+  if (height > 0 && (!heightAttr || heightAttr.includes("%"))) {
+    svg.setAttribute("height", String(height));
+    svg.style.height = `${height}px`;
+  }
+}
+function readElementLayoutSize(element) {
+  const rect = element.getBoundingClientRect();
+  if (rect.width > 1 && rect.height > 1) {
+    return { width: rect.width, height: rect.height };
+  }
+  if (element instanceof HTMLElement && element.offsetWidth > 1 && element.offsetHeight > 1) {
+    return { width: element.offsetWidth, height: element.offsetHeight };
+  }
+  return { width: 0, height: 0 };
+}
+function measureDiagramContentSize(svg, layout = "fill") {
+  prepareSvgForInteraction(svg, layout);
+  const host = svg.parentElement;
+  if (host instanceof HTMLElement) {
+    const hostSize = readElementLayoutSize(host);
+    if (hostSize.width > 1 && hostSize.height > 1) {
+      return hostSize;
+    }
+  }
+  const svgSize = readElementLayoutSize(svg);
+  if (svgSize.width > 1 && svgSize.height > 1) {
+    return svgSize;
+  }
+  return resolveSvgContentSize(svg);
+}
+function computeViewportFitTransform(container, svg, options = {}) {
+  const layout = options.layout ?? "fill";
+  const padding = options.padding ?? (layout === "natural" ? 1 : 0.96);
+  if (layout === "natural") {
+    prepareSvgForInteraction(svg, "natural");
+    return { scale: 1, x: 0, y: 0 };
+  }
+  const { width: contentW, height: contentH } = measureDiagramContentSize(svg, layout);
+  const cw = container.clientWidth;
+  const ch = container.clientHeight;
+  if (contentW < 1 || contentH < 1 || cw < 8 || ch < 32) {
+    return { x: 0, y: 0, scale: 1 };
+  }
+  const maxScale = options.maxScale ?? Number.POSITIVE_INFINITY;
+  const scaleX = cw * padding / contentW;
+  const scaleY = ch * padding / contentH;
+  const scale = Math.min(scaleX, scaleY, maxScale);
+  return {
+    scale,
+    x: (cw - contentW * scale) / 2,
+    y: (ch - contentH * scale) / 2
+  };
+}
+
+// src/view/markdown/DiagramZoomShell.tsx
+import {
+  useCallback,
+  useLayoutEffect,
+  useRef,
+  useState
+} from "react";
+import {
+  TransformComponent,
+  TransformWrapper
+} from "react-zoom-pan-pinch";
+
+// src/view/markdown/fitDiagramToContainer.ts
+function fitDiagramToContainer(ctx, container, options = {}) {
+  const svg = container.querySelector("svg");
+  if (!(svg instanceof SVGSVGElement)) return 1;
+  const measureContainer = container.querySelector(".react-transform-wrapper");
+  const target = measureContainer instanceof HTMLElement ? measureContainer : container;
+  const { x, y, scale } = computeViewportFitTransform(target, svg, options);
+  ctx.resetTransform(0);
+  ctx.setTransform(x, y, scale, 0);
+  return scale;
+}
+
+// src/view/markdown/DiagramZoomShell.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var MIN_VIEWPORT_PX = 8;
+var MAX_INITIAL_FIT_ATTEMPTS = 48;
+function DiagramZoomShell({
+  fixedSvg,
+  contentHash,
+  className = "",
+  layout = "fill",
+  viewportPointerHandlers,
+  toolbarExtra
+}) {
+  const viewportRef = useRef(null);
+  const transformRef = useRef(null);
+  const fittedForRef = useRef(null);
+  const fittingRef = useRef(false);
+  const [zoomPct, setZoomPct] = useState(100);
+  const isNatural = layout === "natural";
+  const wrapperStyle = isNatural ? { width: "100%", height: "auto" } : { width: "100%", height: "100%" };
+  const applyFit = useCallback(() => {
+    if (fittingRef.current) return;
+    const viewport = viewportRef.current;
+    const ctx = transformRef.current;
+    if (!viewport || !ctx) return;
+    fittingRef.current = true;
+    try {
+      const svg = viewport.querySelector("svg");
+      if (svg instanceof SVGSVGElement && isNatural) {
+        prepareSvgForInteraction(svg, "natural");
+      }
+      const scale = fitDiagramToContainer(ctx, viewport, {
+        layout,
+        maxScale: isNatural ? 1 : Number.POSITIVE_INFINITY
+      });
+      setZoomPct((prev) => {
+        const next = Math.round(scale * 100);
+        return prev === next ? prev : next;
+      });
+    } finally {
+      fittingRef.current = false;
+    }
+  }, [isNatural, layout]);
+  const runInitialFit = useCallback(() => {
+    if (fittedForRef.current === contentHash) return;
+    const viewport = viewportRef.current;
+    const ctx = transformRef.current;
+    const svg = viewport?.querySelector("svg");
+    const minH = isNatural ? MIN_VIEWPORT_PX : 32;
+    if (!viewport || !ctx || !(svg instanceof SVGSVGElement) || viewport.clientWidth < MIN_VIEWPORT_PX || !isNatural && viewport.clientHeight < minH) {
+      return;
+    }
+    applyFit();
+    fittedForRef.current = contentHash;
+  }, [applyFit, contentHash, isNatural]);
+  useLayoutEffect(() => {
+    fittedForRef.current = null;
+  }, [contentHash, fixedSvg, layout]);
+  useLayoutEffect(() => {
+    if (!fixedSvg) return;
+    let cancelled = false;
+    let attempts = 0;
+    const tryFit = () => {
+      if (cancelled || fittedForRef.current === contentHash) return;
+      runInitialFit();
+      if (fittedForRef.current === contentHash) return;
+      attempts += 1;
+      if (attempts < MAX_INITIAL_FIT_ATTEMPTS) window.requestAnimationFrame(tryFit);
+    };
+    tryFit();
+    return () => {
+      cancelled = true;
+    };
+  }, [fixedSvg, contentHash, layout, runInitialFit]);
+  const zoomIn = useCallback(() => {
+    transformRef.current?.zoomIn();
+  }, []);
+  const zoomOut = useCallback(() => {
+    transformRef.current?.zoomOut();
+  }, []);
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: [
+        "diagram-zoom-shell",
+        isNatural ? "diagram-zoom-shell--natural" : "diagram-zoom-shell--fill",
+        className
+      ].filter(Boolean).join(" "),
+      children: [
+        /* @__PURE__ */ jsxs(
+          "div",
+          {
+            className: "diagram-zoom-shell__toolbar",
+            onPointerDown: (event) => event.stopPropagation(),
+            onClick: (event) => event.stopPropagation(),
+            children: [
+              /* @__PURE__ */ jsx(ShellButton, { label: "Zoom in", onClick: zoomIn, children: "+" }),
+              /* @__PURE__ */ jsxs("span", { className: "diagram-zoom-shell__zoom", children: [
+                zoomPct,
+                "%"
+              ] }),
+              /* @__PURE__ */ jsx(ShellButton, { label: "Zoom out", onClick: zoomOut, children: "\u2212" }),
+              /* @__PURE__ */ jsx(ShellButton, { label: "Fit diagram", onClick: applyFit, children: "\u21BA" }),
+              toolbarExtra
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "div",
+          {
+            ref: viewportRef,
+            className: [
+              "diagram-zoom-shell__viewport",
+              isNatural ? "diagram-zoom-shell__viewport--natural" : ""
+            ].filter(Boolean).join(" "),
+            ...viewportPointerHandlers,
+            children: /* @__PURE__ */ jsx(
+              TransformWrapper,
+              {
+                minScale: 0.1,
+                maxScale: 4,
+                centerOnInit: false,
+                limitToBounds: false,
+                wheel: { step: 0.07 },
+                panning: { velocityDisabled: true },
+                doubleClick: { disabled: true },
+                onInit: (ctx) => {
+                  transformRef.current = ctx;
+                },
+                onTransformed: (_ctx, state) => {
+                  const next = Math.round(state.scale * 100);
+                  setZoomPct((prev) => prev === next ? prev : next);
+                },
+                children: /* @__PURE__ */ jsx(
+                  TransformComponent,
+                  {
+                    wrapperStyle,
+                    contentClass: "!block !w-fit !h-fit",
+                    children: /* @__PURE__ */ jsx(
+                      "div",
+                      {
+                        className: [
+                          "diagram-zoom-shell__content",
+                          isNatural ? "block w-full [&_svg]:mx-auto" : "inline-block [&_svg]:block [&_svg]:max-w-none"
+                        ].join(" "),
+                        dangerouslySetInnerHTML: { __html: fixedSvg }
+                      }
+                    )
+                  }
+                )
+              },
+              contentHash
+            )
+          }
+        )
+      ]
+    }
+  );
+}
+function ShellButton({
+  label,
+  onClick,
+  children
+}) {
+  return /* @__PURE__ */ jsx(
+    "button",
+    {
+      type: "button",
+      "aria-label": label,
+      title: label,
+      className: "diagram-zoom-shell__btn",
+      onClick,
+      children
+    }
+  );
+}
+
+// src/view/markdown/DiagramZoomView.tsx
+import { useState as useState2 } from "react";
+
+// src/view/markdown/DiagramZoomFullscreenOverlay.tsx
+import { useEffect } from "react";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function DiagramZoomFullscreenOverlay({
+  isOpen,
+  title,
+  onClose,
+  headerControls,
+  children
+}) {
+  useEffect(() => {
+    if (!isOpen) return;
+    const onKeyDown = (event) => {
+      if (event.key === "Escape") onClose();
+    };
+    const prevOverflow = document.body.style.overflow;
+    document.body.style.overflow = "hidden";
+    window.addEventListener("keydown", onKeyDown);
+    return () => {
+      window.removeEventListener("keydown", onKeyDown);
+      document.body.style.overflow = prevOverflow;
+    };
+  }, [isOpen, onClose]);
+  if (!isOpen) return null;
+  return /* @__PURE__ */ jsx2(
+    "div",
+    {
+      className: "diagram-zoom-fs-overlay",
+      role: "dialog",
+      "aria-modal": "true",
+      "aria-label": title,
+      onClick: (event) => {
+        if (event.target === event.currentTarget) onClose();
+      },
+      children: /* @__PURE__ */ jsxs2(
+        "div",
+        {
+          className: "diagram-zoom-fs-panel",
+          onClick: (event) => event.stopPropagation(),
+          children: [
+            /* @__PURE__ */ jsxs2("div", { className: "diagram-zoom-fs-header", children: [
+              /* @__PURE__ */ jsx2("span", { className: "diagram-zoom-fs-title", children: title }),
+              headerControls
+            ] }),
+            /* @__PURE__ */ jsx2("div", { className: "diagram-zoom-fs-stage", children })
+          ]
+        }
+      )
+    }
+  );
+}
+
+// src/view/markdown/usePointerClick.ts
+import { useRef as useRef2 } from "react";
+var DEFAULT_MOVE_THRESHOLD_PX = 6;
+function didPointerDrag(start, end, moveThresholdPx = DEFAULT_MOVE_THRESHOLD_PX) {
+  return Math.hypot(end.x - start.x, end.y - start.y) > moveThresholdPx;
+}
+function usePointerClick(onClick, moveThresholdPx = DEFAULT_MOVE_THRESHOLD_PX) {
+  const startRef = useRef2(null);
+  const movedRef = useRef2(false);
+  return {
+    onPointerDown(event) {
+      startRef.current = { x: event.clientX, y: event.clientY };
+      movedRef.current = false;
+    },
+    onPointerMove(event) {
+      const start = startRef.current;
+      if (!start) return;
+      const dx = event.clientX - start.x;
+      const dy = event.clientY - start.y;
+      if (Math.hypot(dx, dy) > moveThresholdPx) {
+        movedRef.current = true;
+      }
+    },
+    onPointerUp(event) {
+      const start = startRef.current;
+      if (start && didPointerDrag(start, { x: event.clientX, y: event.clientY }, moveThresholdPx)) {
+        movedRef.current = true;
+      }
+      if (!movedRef.current && startRef.current) {
+        onClick();
+      }
+      startRef.current = null;
+      movedRef.current = false;
+    },
+    onPointerCancel() {
+      startRef.current = null;
+      movedRef.current = false;
+    }
+  };
+}
+
+// src/view/markdown/DiagramZoomView.tsx
+import { Fragment, jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function DiagramZoomView({
+  fixedSvg,
+  contentHash,
+  title,
+  fullscreenEnabled = true,
+  className = ""
+}) {
+  const [isFullscreen, setIsFullscreen] = useState2(false);
+  const [inlineRestoreKey, setInlineRestoreKey] = useState2(0);
+  const openFullscreen = () => {
+    if (fixedSvg) setIsFullscreen(true);
+  };
+  const closeFullscreen = () => {
+    setIsFullscreen(false);
+    setInlineRestoreKey((key) => key + 1);
+  };
+  const canvasPointer = usePointerClick(openFullscreen);
+  return /* @__PURE__ */ jsxs3(Fragment, { children: [
+    /* @__PURE__ */ jsx3("div", { className: `diagram-zoom-inline ${className}`.trim(), children: /* @__PURE__ */ jsx3(
+      DiagramZoomShell,
+      {
+        fixedSvg,
+        contentHash,
+        layout: "natural",
+        viewportPointerHandlers: fullscreenEnabled ? canvasPointer : void 0,
+        toolbarExtra: fullscreenEnabled ? /* @__PURE__ */ jsx3(ShellIconButton, { label: "View fullscreen", onClick: openFullscreen, children: /* @__PURE__ */ jsx3(FullscreenIcon, {}) }) : void 0
+      },
+      `inline:${contentHash}:${inlineRestoreKey}`
+    ) }),
+    fullscreenEnabled ? /* @__PURE__ */ jsx3(
+      DiagramZoomFullscreenOverlay,
+      {
+        isOpen: isFullscreen,
+        title,
+        onClose: closeFullscreen,
+        headerControls: /* @__PURE__ */ jsx3(ShellIconButton, { label: "Close", onClick: closeFullscreen, children: "\xD7" }),
+        children: /* @__PURE__ */ jsx3(
+          DiagramZoomShell,
+          {
+            fixedSvg,
+            contentHash: `fs:${contentHash}`,
+            layout: "fill"
+          }
+        )
+      }
+    ) : null
+  ] });
+}
+function stopPointerPropagation(event) {
+  event.stopPropagation();
+}
+function ShellIconButton({
+  label,
+  onClick,
+  children
+}) {
+  return /* @__PURE__ */ jsx3(
+    "button",
+    {
+      type: "button",
+      "aria-label": label,
+      title: label,
+      className: "diagram-zoom-shell__btn",
+      onClick,
+      onPointerDown: stopPointerPropagation,
+      children
+    }
+  );
+}
+function FullscreenIcon() {
+  return /* @__PURE__ */ jsxs3(
+    "svg",
+    {
+      xmlns: "http://www.w3.org/2000/svg",
+      width: "14",
+      height: "14",
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      "aria-hidden": "true",
+      children: [
+        /* @__PURE__ */ jsx3("path", { d: "M8 3H5a2 2 0 0 0-2 2v3" }),
+        /* @__PURE__ */ jsx3("path", { d: "M21 8V5a2 2 0 0 0-2-2h-3" }),
+        /* @__PURE__ */ jsx3("path", { d: "M3 16v3a2 2 0 0 0 2 2h3" }),
+        /* @__PURE__ */ jsx3("path", { d: "M16 21h3a2 2 0 0 0 2-2v-3" })
+      ]
+    }
+  );
+}
+
+// src/view/markdown/fixDiagramSvg.ts
+function fixDiagramSvg(svg) {
+  if (!svg.includes("<svg")) return svg;
+  let result = svg;
+  if (!/pointer-events\s*:\s*none/i.test(result)) {
+    result = result.replace("<svg", '<svg style="pointer-events:none;"');
+  }
+  return normalizeSvgPercentDimensions(result);
+}
+function normalizeSvgPercentDimensions(svg) {
+  const openTagMatch = svg.match(/<svg\b([^>]*)>/i);
+  if (!openTagMatch) return svg;
+  const attrs = openTagMatch[1] ?? "";
+  const viewBoxMatch = attrs.match(/\bviewBox\s*=\s*["']([^"']+)["']/i);
+  if (!viewBoxMatch) return svg;
+  const parts = viewBoxMatch[1].trim().split(/[\s,]+/).map(Number);
+  if (parts.length !== 4 || parts[2] <= 0 || parts[3] <= 0) return svg;
+  const vbW = parts[2];
+  const vbH = parts[3];
+  let nextAttrs = attrs;
+  const widthMatch = nextAttrs.match(/\bwidth\s*=\s*["']([^"']*)["']/i);
+  if (!widthMatch || widthMatch[1].includes("%")) {
+    nextAttrs = widthMatch ? nextAttrs.replace(/\bwidth\s*=\s*["'][^"']*["']/i, `width="${vbW}"`) : `${nextAttrs} width="${vbW}"`;
+  }
+  const heightMatch = nextAttrs.match(/\bheight\s*=\s*["']([^"']*)["']/i);
+  if (!heightMatch || heightMatch[1].includes("%")) {
+    nextAttrs = heightMatch ? nextAttrs.replace(/\bheight\s*=\s*["'][^"']*["']/i, `height="${vbH}"`) : `${nextAttrs} height="${vbH}"`;
+  }
+  if (nextAttrs === attrs) return svg;
+  return svg.replace(openTagMatch[0], `<svg${nextAttrs}>`);
+}
+
+// src/view/markdown/mermaidTheme.ts
+var MERMAID_LIGHT_LABEL_COLOR = "#334155";
+var MERMAID_LIGHT_THEME_VARIABLES = {
+  darkMode: false,
+  background: "transparent",
+  /* flowchart 节点三档：muted indigo / sage / violet（仅 fill / stroke） */
+  primaryColor: "#eef2ff",
+  primaryTextColor: MERMAID_LIGHT_LABEL_COLOR,
+  primaryBorderColor: "#c7d2fe",
+  secondaryColor: "#ecfdf5",
+  secondaryTextColor: MERMAID_LIGHT_LABEL_COLOR,
+  secondaryBorderColor: "#a7f3d0",
+  tertiaryColor: "#f5f3ff",
+  tertiaryTextColor: MERMAID_LIGHT_LABEL_COLOR,
+  tertiaryBorderColor: "#ddd6fe",
+  mainBkg: "#eef2ff",
+  secondBkg: "#ecfdf5",
+  tertiaryBkg: "#f5f3ff",
+  /* 全局与连线标签 */
+  lineColor: "#94a3b8",
+  textColor: MERMAID_LIGHT_LABEL_COLOR,
+  titleColor: MERMAID_LIGHT_LABEL_COLOR,
+  edgeLabelBackground: "transparent",
+  /* subgraph / cluster */
+  clusterBkg: "#f8fafc",
+  clusterBorder: "#e2e8f0",
+  /* sequence */
+  actorBkg: "#f8fafc",
+  actorBorder: "#cbd5e1",
+  actorTextColor: MERMAID_LIGHT_LABEL_COLOR,
+  actorLineColor: "#94a3b8",
+  signalColor: "#64748b",
+  signalTextColor: MERMAID_LIGHT_LABEL_COLOR,
+  labelBoxBkgColor: "#f8fafc",
+  labelBoxBorderColor: "#e2e8f0",
+  labelTextColor: MERMAID_LIGHT_LABEL_COLOR,
+  noteBkgColor: "#f1f5f9",
+  noteTextColor: MERMAID_LIGHT_LABEL_COLOR,
+  noteBorderColor: "#cbd5e1"
+};
+var MERMAID_LABEL_TEXT_SELECTORS = `
+  .edgeLabel,
+  .edgeLabel span,
+  .edgeLabel p,
+  .label,
+  .nodeLabel,
+  .nodeLabel span,
+  .flowchart-label text,
+  .cluster-label,
+  .cluster-label span,
+  text.actor,
+  .messageText,
+  text.sequenceText,
+  .noteText,
+  .titleText
+`;
+var MERMAID_THEME_CSS = `
+  .edgeLabel,
+  .edgeLabel p {
+    background-color: transparent !important;
+  }
+
+  ${MERMAID_LABEL_TEXT_SELECTORS} {
+    fill: var(--lax-mermaid-label-color, var(--lax-foreground, ${MERMAID_LIGHT_LABEL_COLOR})) !important;
+    color: var(--lax-mermaid-label-color, var(--lax-foreground, ${MERMAID_LIGHT_LABEL_COLOR})) !important;
+  }
+
+  [data-theme="dark"] .node rect,
+  [data-theme="dark"] .node circle,
+  [data-theme="dark"] .node ellipse,
+  [data-theme="dark"] .node polygon,
+  [data-theme="dark"] .node path,
+  [data-theme="dark"] g.node rect,
+  [data-theme="dark"] g.node circle,
+  [data-theme="dark"] g.node ellipse,
+  [data-theme="dark"] g.node polygon,
+  [data-theme="dark"] g.node path {
+    fill: var(--lax-mermaid-node-fill, var(--lax-card-bg, var(--card-bg, transparent))) !important;
+    stroke: var(--lax-border-color, var(--border-color, currentColor)) !important;
+  }
+  [data-theme="dark"] .edgePath .path,
+  [data-theme="dark"] .flowchart-link,
+  [data-theme="dark"] .edgePaths path {
+    stroke: var(--lax-mermaid-edge-color, var(--lax-accent-primary, var(--accent-primary, currentColor))) !important;
+  }
+  [data-theme="dark"] .cluster rect,
+  [data-theme="dark"] .cluster polygon,
+  [data-theme="dark"] .actor {
+    fill: var(--lax-mermaid-node-fill, var(--lax-card-bg, var(--card-bg, transparent))) !important;
+    stroke: var(--lax-border-color, var(--border-color, currentColor)) !important;
+  }
+  [data-theme="dark"] .messageLine0,
+  [data-theme="dark"] .messageLine1 {
+    stroke: var(--lax-mermaid-edge-color, var(--lax-accent-primary, var(--accent-primary, currentColor))) !important;
+  }
+`;
+var DEFAULT_MERMAID_INIT = {
+  theme: "base",
+  maxTextSize: 1e5
+};
+var MERMAID_THEME_CSS_VAR_NAMES = [
+  "--lax-mermaid-node-fill",
+  "--lax-mermaid-label-color",
+  "--lax-mermaid-edge-color",
+  "--lax-bg-surface",
+  "--lax-diagram-bg",
+  "--lax-card-bg",
+  "--lax-foreground",
+  "--lax-border-color",
+  "--lax-accent-primary"
+];
+
+// src/view/markdown/initMermaid.ts
+var mermaidInitPromise = null;
+var activeInitOptions = { ...DEFAULT_MERMAID_INIT };
+function buildInitializeConfig(options) {
+  const theme = options.theme ?? DEFAULT_MERMAID_INIT.theme;
+  const useBasePalette = theme === "base";
+  return {
+    startOnLoad: false,
+    theme,
+    securityLevel: "strict",
+    suppressErrorRendering: true,
+    logLevel: "error",
+    maxTextSize: options.maxTextSize ?? DEFAULT_MERMAID_INIT.maxTextSize,
+    htmlLabels: true,
+    themeCSS: MERMAID_THEME_CSS,
+    ...useBasePalette && {
+      themeVariables: {
+        ...MERMAID_LIGHT_THEME_VARIABLES,
+        ...options.themeVariables
+      }
+    },
+    flowchart: {
+      htmlLabels: true,
+      curve: "basis",
+      nodeSpacing: 60,
+      rankSpacing: 60,
+      padding: 20
+    }
+  };
+}
+function configureMermaid(options) {
+  activeInitOptions = { ...DEFAULT_MERMAID_INIT, ...options };
+  mermaidInitPromise = null;
+}
+async function loadMermaid() {
+  if (typeof window === "undefined") return null;
+  if (!mermaidInitPromise) {
+    mermaidInitPromise = import("mermaid").then((mod) => {
+      const mermaid = mod.default;
+      mermaid.initialize(buildInitializeConfig(activeInitOptions));
+      return mermaid;
+    }).catch(() => null);
+  }
+  return mermaidInitPromise;
+}
+
+// src/view/markdown/MermaidDiagram.tsx
+import { useEffect as useEffect5, useId, useRef as useRef4, useState as useState6 } from "react";
+
+// src/view/markdown/mermaidDisplayUtils.ts
+import { useEffect as useEffect2, useState as useState3 } from "react";
+function isDarkMode() {
+  if (typeof document === "undefined") return false;
+  const root = document.documentElement;
+  const dataTheme = root.getAttribute("data-theme");
+  if (dataTheme === "dark") return true;
+  if (dataTheme === "light") return false;
+  if (root.classList.contains("dark")) return true;
+  if (typeof window === "undefined" || typeof window.matchMedia !== "function") {
+    return false;
+  }
+  return window.matchMedia("(prefers-color-scheme: dark)").matches;
+}
+function syncDarkThemeOnSvgElement(svg, dark) {
+  if (!svg) return;
+  if (dark) svg.setAttribute("data-theme", "dark");
+  else svg.removeAttribute("data-theme");
+}
+function syncMermaidThemeTokensOnSvgElement(svg, host, tokenNames) {
+  if (!svg || !host) return;
+  const computed = getComputedStyle(host);
+  for (const name of tokenNames) {
+    const value = computed.getPropertyValue(name).trim();
+    if (value) svg.style.setProperty(name, value);
+  }
+}
+function useDarkMode() {
+  const [dark, setDark] = useState3(false);
+  useEffect2(() => {
+    const update = () => setDark(isDarkMode());
+    update();
+    const mq = typeof window.matchMedia === "function" ? window.matchMedia("(prefers-color-scheme: dark)") : null;
+    mq?.addEventListener("change", update);
+    const observer = new MutationObserver(update);
+    observer.observe(document.documentElement, {
+      attributes: true,
+      attributeFilter: ["class", "data-theme"]
+    });
+    return () => {
+      mq?.removeEventListener("change", update);
+      observer.disconnect();
+    };
+  }, []);
+  return dark;
+}
+
+// src/view/markdown/useCopyText.ts
+import { useCallback as useCallback2, useEffect as useEffect3, useRef as useRef3, useState as useState4 } from "react";
+
+// src/view/markdown/copyToClipboard.ts
+async function copyToClipboard(text) {
+  if (typeof navigator !== "undefined" && navigator.clipboard?.writeText) {
+    try {
+      await navigator.clipboard.writeText(text);
+      return true;
+    } catch {
+    }
+  }
+  if (typeof document === "undefined") return false;
+  try {
+    const textArea = document.createElement("textarea");
+    textArea.value = text;
+    textArea.style.position = "fixed";
+    textArea.style.left = "-9999px";
+    document.body.appendChild(textArea);
+    textArea.select();
+    const ok = document.execCommand("copy");
+    document.body.removeChild(textArea);
+    return ok;
+  } catch {
+    return false;
+  }
+}
+
+// src/view/markdown/useCopyText.ts
+function useCopyText(text, resetMs = 2e3) {
+  const [copied, setCopied] = useState4(false);
+  const timerRef = useRef3();
+  useEffect3(() => {
+    return () => {
+      if (timerRef.current !== void 0) {
+        window.clearTimeout(timerRef.current);
+      }
+    };
+  }, []);
+  const copy = useCallback2(async () => {
+    const ok = await copyToClipboard(text);
+    if (!ok) return;
+    setCopied(true);
+    if (timerRef.current !== void 0) {
+      window.clearTimeout(timerRef.current);
+    }
+    timerRef.current = window.setTimeout(() => setCopied(false), resetMs);
+  }, [text, resetMs]);
+  return { copied, copy };
+}
+
+// src/view/markdown/useDebouncedValue.ts
+import { useEffect as useEffect4, useState as useState5 } from "react";
+function useDebouncedValue(value, delayMs) {
+  const [debounced, setDebounced] = useState5(value);
+  useEffect4(() => {
+    const timer = window.setTimeout(() => setDebounced(value), delayMs);
+    return () => window.clearTimeout(timer);
+  }, [value, delayMs]);
+  return debounced;
+}
+
+// src/view/markdown/MermaidDiagram.tsx
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var MERMAID_RENDER_DEBOUNCE_MS = 350;
+function MermaidDiagram({
+  chart,
+  className = "",
+  fullscreenEnabled = true
+}) {
+  const [rawSvg, setRawSvg] = useState6("");
+  const [error, setError] = useState6(null);
+  const { copied, copy } = useCopyText(chart);
+  const wrapRef = useRef4(null);
+  const rawSvgRef = useRef4("");
+  const reactId = useId().replace(/:/g, "");
+  const renderId = `lax-mermaid-${reactId}`;
+  const isDark = useDarkMode();
+  const debouncedChart = useDebouncedValue(chart.trim(), MERMAID_RENDER_DEBOUNCE_MS);
+  useEffect5(() => {
+    rawSvgRef.current = rawSvg;
+  }, [rawSvg]);
+  useEffect5(() => {
+    if (!debouncedChart) return;
+    let cancelled = false;
+    const renderChart = async () => {
+      const mermaid = await loadMermaid();
+      if (cancelled) return;
+      if (!mermaid) {
+        if (!rawSvgRef.current) {
+          setError("mermaid peer dependency is not installed");
+        }
+        return;
+      }
+      try {
+        setError(null);
+        const { svg: renderedSvg } = await mermaid.render(renderId, debouncedChart);
+        if (!cancelled) {
+          setRawSvg(renderedSvg);
+        }
+      } catch (err) {
+        if (!cancelled && !rawSvgRef.current) {
+          const message = err instanceof Error ? err.message : String(err);
+          setError(message);
+        }
+      }
+    };
+    void renderChart();
+    return () => {
+      cancelled = true;
+    };
+  }, [debouncedChart, renderId]);
+  const fixedSvg = rawSvg ? fixDiagramSvg(rawSvg) : "";
+  const contentHash = `mermaid:${debouncedChart}:${fixedSvg.length}`;
+  useEffect5(() => {
+    const host = wrapRef.current;
+    const svg = host?.querySelector("svg");
+    if (!(svg instanceof SVGSVGElement)) return;
+    syncDarkThemeOnSvgElement(svg, isDark);
+    syncMermaidThemeTokensOnSvgElement(svg, host, MERMAID_THEME_CSS_VAR_NAMES);
+  }, [isDark, fixedSvg]);
+  const handleCopy = () => void copy();
+  const toolbar = /* @__PURE__ */ jsxs4("div", { className: "lax-mermaid__toolbar", children: [
+    /* @__PURE__ */ jsx4("span", { className: "lax-mermaid__label", children: "Mermaid" }),
+    /* @__PURE__ */ jsx4("div", { className: "lax-mermaid__actions", children: /* @__PURE__ */ jsx4("button", { type: "button", className: "lax-mermaid__copy", onClick: handleCopy, children: copied ? "Copied" : "Copy" }) })
+  ] });
+  if (error) {
+    return /* @__PURE__ */ jsxs4("div", { className: `lax-mermaid lax-mermaid--error ${className}`.trim(), children: [
+      toolbar,
+      /* @__PURE__ */ jsx4("pre", { className: "lax-mermaid__fallback", children: chart }),
+      /* @__PURE__ */ jsx4("p", { className: "lax-mermaid__error-text", children: error })
+    ] });
+  }
+  if (!fixedSvg) {
+    return /* @__PURE__ */ jsxs4("div", { className: `lax-mermaid lax-mermaid--loading ${className}`.trim(), children: [
+      /* @__PURE__ */ jsxs4("span", { className: "lax-mermaid__loading-dots", "aria-hidden": "true", children: [
+        /* @__PURE__ */ jsx4("span", {}),
+        /* @__PURE__ */ jsx4("span", {}),
+        /* @__PURE__ */ jsx4("span", {})
+      ] }),
+      /* @__PURE__ */ jsx4("span", { className: "lax-mermaid__loading-text", children: "Rendering diagram\u2026" })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs4("div", { className: `lax-mermaid ${className}`.trim(), ref: wrapRef, children: [
+    toolbar,
+    /* @__PURE__ */ jsx4("div", { className: "lax-diagram-canvas-wrap", children: /* @__PURE__ */ jsx4(
+      DiagramZoomView,
+      {
+        fixedSvg,
+        contentHash,
+        title: "Diagram",
+        fullscreenEnabled
+      }
+    ) })
+  ] });
+}
+
+// src/view/markdown/PlantUMLBlock.tsx
+import { Prism as SyntaxHighlighter } from "react-syntax-highlighter";
+import { oneDark } from "react-syntax-highlighter/dist/esm/styles/prism";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function PlantUMLBlock({ content, className = "" }) {
+  const { copied, copy } = useCopyText(content);
+  return /* @__PURE__ */ jsxs5("div", { className: `lax-plantuml lax-code-block lax-code-block--rich ${className}`.trim(), children: [
+    /* @__PURE__ */ jsxs5("div", { className: "lax-code-block__header", children: [
+      /* @__PURE__ */ jsx5("span", { className: "lax-code-block__lang", children: "PlantUML" }),
+      /* @__PURE__ */ jsx5(
+        "button",
+        {
+          type: "button",
+          className: `lax-code-block__copy ${copied ? "lax-code-block__copy--copied" : ""}`,
+          onClick: () => void copy(),
+          children: copied ? "Copied" : "Copy"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx5(
+      SyntaxHighlighter,
+      {
+        language: "text",
+        style: oneDark,
+        customStyle: { margin: 0, padding: "0.75rem 1rem", background: "transparent" },
+        showLineNumbers: true,
+        wrapLongLines: true,
+        children: content
+      }
+    )
+  ] });
+}
+
+// src/view/markdown/plantumlConfig.ts
+var DEFAULT_PLANTUML_SERVER_URL = "https://kroki.io";
+var plantumlServerUrl = DEFAULT_PLANTUML_SERVER_URL;
+var configListeners = /* @__PURE__ */ new Set();
+function notifyConfigListeners() {
+  configListeners.forEach((listener) => listener());
+}
+function configurePlantumlServer(url) {
+  const next = url.replace(/\/$/, "");
+  if (next === plantumlServerUrl) return;
+  plantumlServerUrl = next;
+  notifyConfigListeners();
+}
+function getPlantumlServerUrl() {
+  return plantumlServerUrl;
+}
+function subscribePlantumlServerConfig(listener) {
+  configListeners.add(listener);
+  return () => {
+    configListeners.delete(listener);
+  };
+}
+
+// src/view/markdown/PlantUMLDiagram.tsx
+import { useEffect as useEffect6, useRef as useRef5, useState as useState7 } from "react";
+
+// src/view/markdown/plantumlRender.ts
+function normalizePlantumlSource(source) {
+  const trimmed = source.trim();
+  if (!trimmed) return trimmed;
+  if (trimmed.includes("@startuml")) return trimmed;
+  return `@startuml
+${trimmed}
+@enduml`;
+}
+async function fetchPlantumlSvg(source, serverUrl = getPlantumlServerUrl()) {
+  const base = serverUrl.replace(/\/$/, "");
+  const url = base.startsWith("/") ? base : `${base}/`;
+  const diagramSource = normalizePlantumlSource(source);
+  const res = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Accept: "image/svg+xml"
+    },
+    body: JSON.stringify({
+      diagram_source: diagramSource,
+      diagram_type: "plantuml",
+      output_format: "svg"
+    })
+  });
+  if (!res.ok) {
+    const detail = await res.text().catch(() => "");
+    const suffix = detail ? `: ${detail.slice(0, 200)}` : "";
+    throw new Error(`PlantUML render failed (${res.status})${suffix}`);
+  }
+  const svg = await res.text();
+  if (!svg.includes("<svg")) {
+    throw new Error("PlantUML render returned non-SVG response");
+  }
+  return fixDiagramSvg(svg);
+}
+
+// src/view/markdown/PlantUMLDiagram.tsx
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+var PLANTUML_RENDER_DEBOUNCE_MS = 350;
+function PlantUMLDiagram({
+  content,
+  className = "",
+  serverUrl,
+  fullscreenEnabled = true,
+  sourceOnly = false
+}) {
+  const [fixedSvg, setFixedSvg] = useState7("");
+  const [error, setError] = useState7(null);
+  const { copied, copy } = useCopyText(content);
+  const svgRef = useRef5("");
+  const debouncedContent = useDebouncedValue(content.trim(), PLANTUML_RENDER_DEBOUNCE_MS);
+  const [serverConfigRev, setServerConfigRev] = useState7(0);
+  useEffect6(() => subscribePlantumlServerConfig(() => {
+    setServerConfigRev((rev) => rev + 1);
+  }), []);
+  useEffect6(() => {
+    svgRef.current = fixedSvg;
+  }, [fixedSvg]);
+  useEffect6(() => {
+    if (!debouncedContent || sourceOnly) return;
+    let cancelled = false;
+    const render = async () => {
+      if (typeof window === "undefined") return;
+      try {
+        setError(null);
+        const rendered = await fetchPlantumlSvg(
+          debouncedContent,
+          serverUrl
+        );
+        if (!cancelled) setFixedSvg(rendered);
+      } catch (err) {
+        if (!cancelled) {
+          const message = err instanceof Error ? err.message : String(err);
+          setError(message);
+        }
+      }
+    };
+    void render();
+    return () => {
+      cancelled = true;
+    };
+  }, [debouncedContent, serverUrl, sourceOnly, serverConfigRev]);
+  if (sourceOnly) {
+    return /* @__PURE__ */ jsx6(PlantUMLBlock, { content, className });
+  }
+  const handleCopy = () => void copy();
+  const contentHash = `plantuml:${debouncedContent}:${fixedSvg.length}`;
+  const toolbar = /* @__PURE__ */ jsxs6("div", { className: "lax-plantuml__toolbar", children: [
+    /* @__PURE__ */ jsx6("span", { className: "lax-plantuml__label", children: "PlantUML" }),
+    /* @__PURE__ */ jsx6("div", { className: "lax-plantuml__actions", children: /* @__PURE__ */ jsx6("button", { type: "button", className: "lax-plantuml__copy", onClick: handleCopy, children: copied ? "Copied" : "Copy" }) })
+  ] });
+  if (error) {
+    return /* @__PURE__ */ jsxs6("div", { className: `lax-plantuml lax-plantuml--error ${className}`.trim(), children: [
+      toolbar,
+      /* @__PURE__ */ jsx6("pre", { className: "lax-plantuml__fallback", children: content }),
+      /* @__PURE__ */ jsx6("p", { className: "lax-plantuml__error-text", children: error })
+    ] });
+  }
+  if (!fixedSvg) {
+    return /* @__PURE__ */ jsxs6("div", { className: `lax-plantuml lax-plantuml--loading ${className}`.trim(), children: [
+      /* @__PURE__ */ jsxs6("span", { className: "lax-plantuml__loading-dots", "aria-hidden": "true", children: [
+        /* @__PURE__ */ jsx6("span", {}),
+        /* @__PURE__ */ jsx6("span", {}),
+        /* @__PURE__ */ jsx6("span", {})
+      ] }),
+      /* @__PURE__ */ jsx6("span", { className: "lax-plantuml__loading-text", children: "Rendering diagram\u2026" })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs6("div", { className: `lax-plantuml ${className}`.trim(), children: [
+    toolbar,
+    /* @__PURE__ */ jsx6("div", { className: "lax-diagram-canvas-wrap", children: /* @__PURE__ */ jsx6(
+      DiagramZoomView,
+      {
+        fixedSvg,
+        contentHash,
+        title: "PlantUML",
+        fullscreenEnabled
+      }
+    ) })
+  ] });
+}
+
+// src/view/markdown/RichMarkdown.tsx
+import { useMemo } from "react";
+import ReactMarkdown from "react-markdown";
+import remarkGfm from "remark-gfm";
+
+// src/view/markdown/markdownUtils.ts
+var MD_SYNTAX_RE = /[#*`|[>\-_~]|\n\n|^\d+\. |\n\d+\. /;
+function hasMarkdownSyntax(content) {
+  const sample = content.length > 500 ? content.slice(0, 500) : content;
+  return MD_SYNTAX_RE.test(sample);
+}
+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 collapseExcessiveBlankLines(text) {
+  return text.replace(/\n{3,}/g, "\n\n").trim();
+}
+function paragraphHasContent(children) {
+  if (children == null || children === false) return false;
+  if (typeof children === "string") return children.trim().length > 0;
+  if (typeof children === "number") return true;
+  if (Array.isArray(children)) return children.some(paragraphHasContent);
+  return true;
+}
+
+// src/view/markdown/RichMarkdownStreamContext.tsx
+import { createContext, useContext } from "react";
+var DEFAULT_OPTIONS = { deferDiagrams: false };
+var RichMarkdownStreamContext = createContext(DEFAULT_OPTIONS);
+function useRichMarkdownStream() {
+  return useContext(RichMarkdownStreamContext);
+}
+
+// src/view/markdown/richMarkdownComponents.tsx
+import { Prism as SyntaxHighlighter2 } from "react-syntax-highlighter";
+import { oneDark as oneDark2 } from "react-syntax-highlighter/dist/esm/styles/prism";
+
+// src/view/markdown/headingIds.ts
+var headingCounter = 0;
+function generateHeadingId(text) {
+  const slug = text.trim().toLowerCase().replace(/[^\w\u4e00-\u9fff]+/g, "-").replace(/^-+|-+$/g, "");
+  if (slug) return slug;
+  headingCounter += 1;
+  return `heading-${headingCounter}`;
+}
+
+// src/view/markdown/richMarkdownComponents.tsx
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+function RichCodeBlock({ language, content }) {
+  const { copied, copy } = useCopyText(content);
+  return /* @__PURE__ */ jsxs7("div", { className: "lax-code-block lax-code-block--rich", children: [
+    /* @__PURE__ */ jsxs7("div", { className: "lax-code-block__header", children: [
+      /* @__PURE__ */ jsx7("span", { className: "lax-code-block__lang", children: language || "code" }),
+      /* @__PURE__ */ jsx7(
+        "button",
+        {
+          type: "button",
+          className: `lax-code-block__copy ${copied ? "lax-code-block__copy--copied" : ""}`,
+          onClick: () => void copy(),
+          children: copied ? "Copied" : "Copy"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx7(
+      SyntaxHighlighter2,
+      {
+        language: language || "text",
+        style: oneDark2,
+        customStyle: { margin: 0, padding: "0.75rem 1rem", background: "transparent" },
+        showLineNumbers: true,
+        wrapLongLines: true,
+        children: content
+      }
+    )
+  ] });
+}
+function heading(children, level, className) {
+  const text = children != null ? String(children) : "";
+  const id = generateHeadingId(text);
+  const Tag = level;
+  return /* @__PURE__ */ jsx7(Tag, { id, className: `lax-markdown__heading ${className}`, children });
+}
+function RichMarkdownCode(props) {
+  const { deferDiagrams } = useRichMarkdownStream();
+  const { inline, className, children, ...rest } = props;
+  const match = /language-(\w+)/.exec(className || "");
+  const codeContent = children != null ? String(children).replace(/\n$/, "") : "";
+  if (!inline && match?.[1] === "mermaid" && codeContent.trim()) {
+    if (deferDiagrams) {
+      return /* @__PURE__ */ jsx7(RichCodeBlock, { language: "mermaid", content: codeContent });
+    }
+    return /* @__PURE__ */ jsx7(MermaidDiagram, { chart: codeContent });
+  }
+  if (!inline && match?.[1] === "plantuml" && codeContent.trim()) {
+    if (deferDiagrams) {
+      return /* @__PURE__ */ jsx7(RichCodeBlock, { language: "plantuml", content: codeContent });
+    }
+    return /* @__PURE__ */ jsx7(PlantUMLDiagram, { content: codeContent });
+  }
+  if (!inline && match) {
+    return /* @__PURE__ */ jsx7(RichCodeBlock, { language: match[1], content: codeContent });
+  }
+  return /* @__PURE__ */ jsx7("code", { className: "lax-markdown__inline-code", ...rest, children });
+}
+var RICH_MARKDOWN_COMPONENTS = {
+  code: RichMarkdownCode,
+  h1({ children }) {
+    return heading(children, "h1", "lax-markdown__h1");
+  },
+  h2({ children }) {
+    return heading(children, "h2", "lax-markdown__h2");
+  },
+  h3({ children }) {
+    return heading(children, "h3", "lax-markdown__h3");
+  },
+  h4({ children }) {
+    return heading(children, "h4", "lax-markdown__h4");
+  },
+  h5({ children }) {
+    return heading(children, "h5", "lax-markdown__h5");
+  },
+  h6({ children }) {
+    return heading(children, "h6", "lax-markdown__h6");
+  },
+  p({ children }) {
+    if (!paragraphHasContent(children)) return null;
+    return /* @__PURE__ */ jsx7("p", { className: "lax-markdown__paragraph", children });
+  },
+  ul({ children }) {
+    return /* @__PURE__ */ jsx7("ul", { className: "lax-markdown__list lax-markdown__ul", children });
+  },
+  ol({ children }) {
+    return /* @__PURE__ */ jsx7("ol", { className: "lax-markdown__list lax-markdown__ol", children });
+  },
+  li({ children }) {
+    return /* @__PURE__ */ jsx7("li", { className: "lax-markdown__li", children });
+  },
+  a({ children, href }) {
+    return /* @__PURE__ */ jsx7("a", { href, className: "lax-markdown__link", target: "_blank", rel: "noopener noreferrer", children });
+  },
+  blockquote({ children }) {
+    return /* @__PURE__ */ jsx7("blockquote", { className: "lax-markdown__blockquote", children });
+  },
+  table({ children }) {
+    return /* @__PURE__ */ jsx7("div", { className: "lax-markdown__table-wrapper", children: /* @__PURE__ */ jsx7("table", { className: "lax-markdown__table", children }) });
+  },
+  thead({ children }) {
+    return /* @__PURE__ */ jsx7("thead", { className: "lax-markdown__thead", children });
+  },
+  tbody({ children }) {
+    return /* @__PURE__ */ jsx7("tbody", { className: "lax-markdown__tbody", children });
+  },
+  tr({ children }) {
+    return /* @__PURE__ */ jsx7("tr", { className: "lax-markdown__tr", children });
+  },
+  th({ children }) {
+    return /* @__PURE__ */ jsx7("th", { className: "lax-markdown__th", children });
+  },
+  td({ children }) {
+    return /* @__PURE__ */ jsx7("td", { className: "lax-markdown__td", children });
+  },
+  hr() {
+    return /* @__PURE__ */ jsx7("hr", { className: "lax-markdown__hr" });
+  },
+  strong({ children }) {
+    return /* @__PURE__ */ jsx7("strong", { className: "lax-markdown__strong", children });
+  },
+  em({ children }) {
+    return /* @__PURE__ */ jsx7("em", { className: "lax-markdown__em", children });
+  }
+};
+
+// src/view/markdown/RichMarkdown.tsx
+import { jsx as jsx8 } from "react/jsx-runtime";
+function RichMarkdown({
+  content,
+  className = "",
+  deferDiagrams = false
+}) {
+  const processed = useMemo(() => collapseExcessiveBlankLines(content), [content]);
+  if (!processed) {
+    return null;
+  }
+  if (!hasMarkdownSyntax(processed)) {
+    return /* @__PURE__ */ jsx8("p", { className: `lax-markdown__paragraph ${className}`.trim(), children: processed });
+  }
+  return /* @__PURE__ */ jsx8(RichMarkdownStreamContext.Provider, { value: { deferDiagrams }, children: /* @__PURE__ */ jsx8("div", { className: className || void 0, children: /* @__PURE__ */ jsx8(ReactMarkdown, { remarkPlugins: [remarkGfm], components: RICH_MARKDOWN_COMPONENTS, children: processed }) }) });
+}
+
+// src/view/nodes/ReasoningNode.tsx
+import { jsx as jsx9, jsxs as jsxs8 } 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__ */ jsx9("div", { className: "lax-reasoning-bubble", "data-status": node.status, "data-round-id": node.roundId, children: /* @__PURE__ */ jsxs8("div", { className: "lax-reasoning-bubble__body", children: [
+    /* @__PURE__ */ jsx9("span", { className: "lax-reasoning-bubble__dot", "aria-hidden": "true", children: REASONING_DOT }),
+    /* @__PURE__ */ jsx9("span", { className: "lax-reasoning-bubble__content", children: node.accumulated })
+  ] }) });
+}
+
+// src/view/tools/presentation/StreamingMarkdown.tsx
+import { useRef as useRef6 } from "react";
+import { marked } from "marked";
+import { jsx as jsx10, jsxs as jsxs9 } from "react/jsx-runtime";
+var TOKEN_CACHE_MAX = 500;
+var tokenCache = /* @__PURE__ */ new Map();
+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;
+}
+function StreamingMarkdown({ children }) {
+  "use no memo";
+  const stablePrefixRef = useRef6("");
+  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__ */ jsxs9("div", { className: "lax-markdown lax-markdown--rich", children: [
+    stablePrefix ? /* @__PURE__ */ jsx10(RichMarkdown, { content: stablePrefix }, `stable-${hashContent(stablePrefix)}`) : null,
+    unstableSuffix ? /* @__PURE__ */ jsx10(
+      RichMarkdown,
+      {
+        content: unstableSuffix,
+        deferDiagrams: true
+      },
+      `unstable-${hashContent(unstableSuffix)}`
+    ) : null
+  ] });
+}
+
+// src/view/nodes/TextNode.tsx
+import { jsx as jsx11, jsxs as jsxs10 } from "react/jsx-runtime";
+function TextBubble({ nodeId }) {
+  const node = useNodeTyped(nodeId, "text");
+  if (!node) return null;
+  return /* @__PURE__ */ jsx11("div", { className: "lax-text-bubble", "data-status": node.status, children: /* @__PURE__ */ jsxs10("div", { className: "lax-text-bubble__body", children: [
+    /* @__PURE__ */ jsx11("span", { className: "lax-text-bubble__dot", "aria-hidden": "true", children: REASONING_DOT }),
+    /* @__PURE__ */ jsx11("div", { className: "lax-text-bubble__content lax-text-bubble__content--markdown", children: /* @__PURE__ */ jsx11(StreamingMarkdown, { children: node.accumulated }) })
+  ] }) });
+}
+
+// src/view/nodes/ToolCallNode.tsx
+import { useEffect as useEffect7, useState as useState8 } from "react";
+import { jsx as jsx12 } 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] = useState8(effectiveDefault);
+  useEffect7(() => {
+    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 hasSubagentTranscript = (node.subagentTranscript?.length ?? 0) > 0;
+  const showBody = hasSubagentProgress || hasSubagentTranscript || !(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,
+    subagentTranscript: node.subagentTranscript,
+    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__ */ jsx12(
+    ToolCallShell,
+    {
+      status: node.status,
+      title,
+      progress: node.progress ?? void 0,
+      errorMessage,
+      layout,
+      permissionWait,
+      permissionUiMode: viewOptions.permissionUiMode,
+      children: showBody ? /* @__PURE__ */ jsx12("div", { className: "lax-tool-shell__body", children: /* @__PURE__ */ jsx12(BodyComponent, { ...bodyProps }) }) : null
+    }
+  );
+}
+
+// src/view/nodes/StepNode.tsx
+import { jsx as jsx13 } from "react/jsx-runtime";
+function StepCard({ nodeId }) {
+  const node = useNodeTyped(nodeId, "step");
+  if (!node) return null;
+  return /* @__PURE__ */ jsx13("details", { className: "lax-step-card", "data-status": node.status, children: /* @__PURE__ */ jsx13("summary", { className: "lax-step-card__summary", children: node.label }) });
+}
+
+// src/view/nodes/ErrorNode.tsx
+import { jsx as jsx14, jsxs as jsxs11 } from "react/jsx-runtime";
+function ErrorCard({ nodeId }) {
+  const node = useNodeTyped(nodeId, "error");
+  if (!node) return null;
+  return /* @__PURE__ */ jsxs11("div", { className: "lax-error-card", role: "alert", children: [
+    /* @__PURE__ */ jsx14("div", { className: "lax-error-card__message", children: node.message }),
+    node.errorType ? /* @__PURE__ */ jsx14("div", { className: "lax-error-card__type", children: node.errorType }) : null
+  ] });
+}
+
+// src/view/nodes/UnknownNode.tsx
+import { jsx as jsx15, jsxs as jsxs12 } from "react/jsx-runtime";
+function UnknownCard({ nodeId }) {
+  const node = useNodeTyped(nodeId, "unknown");
+  if (!node) return null;
+  return /* @__PURE__ */ jsxs12("div", { className: "lax-unknown-card", children: [
+    /* @__PURE__ */ jsxs12("div", { className: "lax-unknown-card__type", children: [
+      "Unknown: ",
+      node.eventType
+    ] }),
+    /* @__PURE__ */ jsx15("pre", { className: "lax-unknown-card__data", children: JSON.stringify(node.rawData, null, 2) })
+  ] });
+}
+
+// src/view/nodes/PermissionNode.tsx
+import { useState as useState9 } from "react";
+import { jsx as jsx16, jsxs as jsxs13 } from "react/jsx-runtime";
+function PermissionCard({ nodeId }) {
+  const node = useNodeTyped(nodeId, "permission");
+  const bus = useInteractionBus();
+  const [resolvedLocally, setResolvedLocally] = useState9(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__ */ jsxs13(
+    "div",
+    {
+      className: "lax-permission-card",
+      "data-status": pending ? "pending" : "resolved",
+      "data-request-id": node.requestId,
+      children: [
+        /* @__PURE__ */ jsxs13("div", { className: "lax-permission-card__header", children: [
+          /* @__PURE__ */ jsx16("span", { className: "lax-permission-card__label", children: "Permission" }),
+          /* @__PURE__ */ jsx16("span", { className: "lax-permission-card__tool", children: node.toolName })
+        ] }),
+        /* @__PURE__ */ jsx16("div", { className: "lax-permission-card__message", children: node.message }),
+        node.askPrompt && node.askPrompt !== node.message ? /* @__PURE__ */ jsx16("div", { className: "lax-permission-card__prompt", children: node.askPrompt }) : null,
+        pending ? /* @__PURE__ */ jsxs13("div", { className: "lax-permission-card__actions", children: [
+          /* @__PURE__ */ jsx16("button", { type: "button", className: "lax-permission-card__allow", onClick: onAllow, children: "Allow" }),
+          /* @__PURE__ */ jsx16("button", { type: "button", className: "lax-permission-card__deny", onClick: onDeny, children: "Deny" })
+        ] }) : /* @__PURE__ */ jsx16("div", { className: "lax-permission-card__resolved", children: "Resolved" })
+      ]
+    }
+  );
+}
+
+// src/view/nodes/MemorySavedNode.tsx
+import { jsx as jsx17, jsxs as jsxs14 } 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__ */ jsxs14(
+    "details",
+    {
+      className: "lax-memory-saved",
+      "data-testid": "lax-memory-saved",
+      "data-node-id": nodeId,
+      children: [
+        /* @__PURE__ */ jsxs14("summary", { className: "lax-memory-saved__summary", children: [
+          /* @__PURE__ */ jsx17("span", { className: "lax-memory-saved__icon", "aria-hidden": "true", children: "\u{1F4BE}" }),
+          /* @__PURE__ */ jsx17("span", { className: "lax-memory-saved__hint", children: node.displayHint })
+        ] }),
+        hasPaths ? /* @__PURE__ */ jsx17("ul", { className: "lax-memory-saved__paths", children: node.writtenPaths.map((p) => /* @__PURE__ */ jsx17("li", { className: "lax-memory-saved__path", children: /* @__PURE__ */ jsx17("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 useEffect8, useMemo as useMemo2, useRef as useRef7 } from "react";
+import { jsx as jsx18, jsxs as jsxs15 } from "react/jsx-runtime";
+function DebugPanel() {
+  const status = useSessionStatus();
+  const errors = useInternalErrors();
+  if (errors.length === 0) return null;
+  return /* @__PURE__ */ jsxs15("div", { className: "lax-debug-panel", "data-testid": "lax-debug-panel", children: [
+    /* @__PURE__ */ jsxs15("div", { children: [
+      "status: ",
+      status
+    ] }),
+    /* @__PURE__ */ jsx18("ul", { children: errors.map((err, i) => /* @__PURE__ */ jsxs15("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 = useRef7(null);
+  const bridgeRef = useRef7(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]
+  );
+  useEffect8(() => {
+    if (controlledActiveId === void 0) return;
+    multiStoreRef.current.getState().setActiveSessionId(controlledActiveId);
+  }, [controlledActiveId]);
+  useEffect8(() => {
+    if (!onActiveSessionChange) return;
+    return multiStoreRef.current.subscribe((state) => {
+      onActiveSessionChange(state.activeSessionId);
+    });
+  }, [onActiveSessionChange]);
+  useEffect8(() => {
+    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__ */ jsx18(MultiSessionStoreContext.Provider, { value: multiStoreRef.current, children: /* @__PURE__ */ jsx18(SessionStoreContext.Provider, { value: bridgeRef.current, children: /* @__PURE__ */ jsx18(InteractionBusContext.Provider, { value: busRef, children: /* @__PURE__ */ jsx18(NodeRegistryContext.Provider, { value: registryRef, children: /* @__PURE__ */ jsx18(MarkdownRendererContext.Provider, { value: markdownRenderer, children: /* @__PURE__ */ jsx18(ToolDisplayOptionsContext.Provider, { value: toolDisplayRef, children: /* @__PURE__ */ jsx18(SessionViewOptionsContext.Provider, { value: sessionViewRef, children: /* @__PURE__ */ jsxs15("div", { className: "lax-agent-session lax-multi-agent-session", "data-testid": "lax-multi-agent-session", children: [
+    children ?? /* @__PURE__ */ jsx18(
+      SessionTimeline,
+      {
+        virtualized,
+        virtualizeThreshold,
+        groupParallelTools
+      }
+    ),
+    debug ? /* @__PURE__ */ jsx18(DebugPanel, {}) : null
+  ] }) }) }) }) }) }) }) });
+}
+
+export {
+  shouldSkipDuplicateEvent,
+  markEventIdSeen,
+  computeViewportFitTransform,
+  DiagramZoomShell,
+  DiagramZoomView,
+  fixDiagramSvg,
+  configureMermaid,
+  MermaidDiagram,
+  PlantUMLBlock,
+  configurePlantumlServer,
+  PlantUMLDiagram,
+  RichMarkdown,
+  ReasoningBubble,
+  TextBubble,
+  ToolCallCard,
+  StepCard,
+  ErrorCard,
+  UnknownCard,
+  PermissionCard,
+  NodeRegistry,
+  createDefaultRegistry,
+  createMultiSessionStore,
+  createActiveSessionBridge,
+  MultiAgentSession
+};
+//# sourceMappingURL=chunk-WPW3TQQF.js.map