@blade-hq/agent-react 2610.0.1 → 2612.0.0-beta.1

package/dist/internal.js

@@ -0,0 +1,656 @@
+import {
+  AgentChat,
+  BackgroundWakeNotice,
+  ChatView,
+  ContextCard,
+  ContextGroupCard,
+  DEFAULT_ALLOWED_TAGS,
+  LlmChat,
+  MarkdownContent,
+  MarkdownRenderer,
+  McpAppCard,
+  MessageImage,
+  ReplayBar,
+  ReplayMismatchPrompt,
+  SessionPluginSelector,
+  SessionQueuePanel,
+  TURN_NAV_HIGHLIGHT_CLASS,
+  ToolUiCardView,
+  WhatIfUserBubble,
+  isQueuePanelVisible,
+  latestUserSpeechEntryId,
+  parseWhatIfPrompt,
+  turnNavItemsFromMessages,
+  useAgentSession,
+  useLlmChat,
+  useMessagePin,
+  useReplay,
+  useTurnNavigation,
+  useTypewriterReveal
+} from "./chunk-6ZDOQEWK.js";
+import {
+  ConnectorPanel,
+  PluginTriggerStack,
+  TRIGGER_ICON_LIMIT,
+  selectionFromItem,
+  triggerSummary
+} from "./chunk-WCMGQJLE.js";
+import {
+  BladeProvider,
+  Content2,
+  PLAN_AUTO_COLLAPSE_MS,
+  PlanUpdateBlock,
+  PluginConnectorList,
+  Portal,
+  Provider,
+  Root3,
+  SessionPluginConfigDialog,
+  SessionPluginConfigForm,
+  SessionPluginIcon,
+  Trigger,
+  catalogToConnectorItems,
+  cn,
+  filterConnectorItems,
+  getPlanUpdateDisplayState,
+  isPlanUpdateTool,
+  mergeConnectorItems,
+  parsePlanUpdate,
+  pickCurrentPlanStep,
+  sessionPluginLabel,
+  useBladeClient,
+  useBladeHost,
+  useOptionalBladeClient,
+  useSessionPluginActivation
+} from "./chunk-FQQJP2GJ.js";
+import "./chunk-PR4QN5HX.js";
+
+// src/internal.ts
+export * from "./chat-OCLOVB3H.css";
+
+// src/lib/mount-renderers.tsx
+import { createContext, useContext, useId, useLayoutEffect, useRef } from "react";
+import { jsx } from "react/jsx-runtime";
+var MountHostContext = createContext(null);
+function normalizeResult(result) {
+  if (typeof result === "function") return { destroy: result };
+  if (result && typeof result === "object") return result;
+  return { destroy: () => {
+  } };
+}
+function toObject(renderer) {
+  return typeof renderer === "function" ? { mount: renderer } : renderer;
+}
+function sameData(a, b) {
+  const aKeys = Object.keys(a);
+  if (aKeys.length !== Object.keys(b).length) return false;
+  return aKeys.every((key) => Object.is(a[key], b[key]));
+}
+function MountSlot({ renderer, data }) {
+  const host = useContext(MountHostContext);
+  const slotName = `blade-mount-${useId().replace(/[^a-zA-Z0-9_-]/g, "")}`;
+  const localRef = useRef(null);
+  const dataRef = useRef(data);
+  const mountedRef = useRef(null);
+  useLayoutEffect(() => {
+    dataRef.current = data;
+  });
+  useLayoutEffect(() => {
+    let target;
+    if (host) {
+      target = document.createElement("div");
+      target.slot = slotName;
+      host.appendChild(target);
+    } else {
+      if (!localRef.current) return;
+      target = localRef.current;
+    }
+    const initial = dataRef.current;
+    mountedRef.current = { target, handle: normalizeResult(renderer.mount(target, initial)), data: initial };
+    return () => {
+      const mounted = mountedRef.current;
+      mountedRef.current = null;
+      mounted?.handle.destroy();
+      if (host) target.remove();
+      else target.replaceChildren();
+    };
+  }, [host, renderer, slotName]);
+  useLayoutEffect(() => {
+    const mounted = mountedRef.current;
+    if (!mounted || sameData(mounted.data, data)) return;
+    mounted.data = data;
+    if (mounted.handle.update) {
+      mounted.handle.update(data);
+      return;
+    }
+    mounted.handle.destroy();
+    mounted.target.replaceChildren();
+    mounted.handle = normalizeResult(renderer.mount(mounted.target, data));
+  }, [data, renderer]);
+  return host ? /* @__PURE__ */ jsx("slot", { name: slotName }) : /* @__PURE__ */ jsx("div", { ref: localRef, "data-blade-mount": "" });
+}
+function slotFor(renderer, data) {
+  if (renderer.match && !renderer.match(data)) return null;
+  return /* @__PURE__ */ jsx(MountSlot, { renderer, data });
+}
+function mountRenderersToReact(renderers, context = {}) {
+  if (!renderers) return void 0;
+  const result = {};
+  if (renderers.toolCall) {
+    const renderer = toObject(renderers.toolCall);
+    result.toolCall = (toolCall) => slotFor(renderer, { toolCall, sessionId: context.sessionId });
+  }
+  if (renderers.userMessage) {
+    const renderer = toObject(renderers.userMessage);
+    result.userMessage = ({ message }) => slotFor(renderer, { message });
+  }
+  if (renderers.assistantText) {
+    const renderer = toObject(renderers.assistantText);
+    result.assistantText = ({ message, streaming, compact, sessionId }) => slotFor(renderer, { message, streaming, compact, sessionId });
+  }
+  return result;
+}
+
+// src/components/SessionMemoryToggle.tsx
+import { useCallback, useEffect, useRef as useRef2, useState, useSyncExternalStore } from "react";
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+var saveStates = /* @__PURE__ */ new WeakMap();
+function getSaveState(client, sessionId) {
+  let clientStates = saveStates.get(client);
+  if (!clientStates) {
+    clientStates = /* @__PURE__ */ new Map();
+    saveStates.set(client, clientStates);
+  }
+  let state = clientStates.get(sessionId);
+  if (!state) {
+    state = { saving: false, listeners: /* @__PURE__ */ new Set() };
+    clientStates.set(sessionId, state);
+  }
+  return state;
+}
+function notify(state) {
+  for (const listener of state.listeners) listener();
+}
+function cleanupSaveState(client, sessionId, state) {
+  if (state.saving || state.listeners.size > 0) return;
+  const clientStates = saveStates.get(client);
+  if (clientStates?.get(sessionId) === state) clientStates.delete(sessionId);
+}
+function SessionMemoryToggle({
+  sessionId,
+  enabled,
+  client: clientProp,
+  disabled = false,
+  label = "\u5F53\u524D\u4F1A\u8BDD\u4F7F\u7528\u8BB0\u5FC6",
+  className,
+  labelClassName,
+  inputClassName,
+  onSaved,
+  onError
+}) {
+  const contextClient = useOptionalBladeClient();
+  const client = clientProp ?? contextClient;
+  if (!client) {
+    throw new Error("SessionMemoryToggle \u5FC5\u987B\u5728 <BladeProvider> \u5185\u4F7F\u7528\u6216\u663E\u5F0F\u4F20\u5165 client");
+  }
+  const saveState = getSaveState(client, sessionId);
+  const subscribe = useCallback(
+    (listener) => {
+      saveState.listeners.add(listener);
+      return () => {
+        saveState.listeners.delete(listener);
+        cleanupSaveState(client, sessionId, saveState);
+      };
+    },
+    [client, saveState, sessionId]
+  );
+  const getSaving = useCallback(() => saveState.saving, [saveState]);
+  const saving = useSyncExternalStore(
+    subscribe,
+    getSaving,
+    getSaving
+  );
+  const [draftEnabled, setDraftEnabled] = useState(enabled);
+  const activeSessionIdRef = useRef2(sessionId);
+  activeSessionIdRef.current = sessionId;
+  useEffect(() => {
+    setDraftEnabled(enabled);
+  }, [enabled, sessionId]);
+  const update = useCallback(
+    (nextEnabled) => {
+      const currentSaveState = getSaveState(client, sessionId);
+      if (currentSaveState.saving) return;
+      currentSaveState.saving = true;
+      notify(currentSaveState);
+      setDraftEnabled(nextEnabled);
+      void client.sessions.updateSessionMemory(sessionId, nextEnabled).then(
+        (updated) => {
+          if (activeSessionIdRef.current === sessionId) {
+            setDraftEnabled(updated.memory_enabled);
+          }
+          onSaved?.(sessionId, updated.memory_enabled);
+        },
+        (error) => {
+          if (activeSessionIdRef.current === sessionId) setDraftEnabled(enabled);
+          onError?.(error);
+        }
+      ).finally(() => {
+        currentSaveState.saving = false;
+        notify(currentSaveState);
+        cleanupSaveState(client, sessionId, currentSaveState);
+      });
+    },
+    [client, enabled, onError, onSaved, sessionId]
+  );
+  return /* @__PURE__ */ jsxs("label", { className: cn("flex items-center justify-between", className), children: [
+    /* @__PURE__ */ jsx2("span", { className: labelClassName, children: label }),
+    /* @__PURE__ */ jsx2(
+      "input",
+      {
+        type: "checkbox",
+        checked: draftEnabled,
+        onChange: (event) => update(event.target.checked),
+        disabled: disabled || saving,
+        className: inputClassName
+      }
+    )
+  ] });
+}
+
+// src/lib/agent-computer-command.ts
+var COMPUTER_LAUNCH_COMMAND_PATTERN = /(?:^|[\n;&|(]\s*)computer\s+launch(?:\s|$)/;
+function isAgentComputerCommand(command) {
+  return COMPUTER_LAUNCH_COMMAND_PATTERN.test(command);
+}
+function isAgentComputerToolCall(argumentsJson) {
+  if (!argumentsJson) return false;
+  let command;
+  try {
+    const parsed = JSON.parse(argumentsJson);
+    if (typeof parsed !== "object" || parsed === null) return false;
+    command = parsed.command;
+  } catch {
+    return false;
+  }
+  return typeof command === "string" && isAgentComputerCommand(command);
+}
+var LAUNCH_SUCCESS_MARKER = "\u5DF2\u542F\u52A8 ";
+function resultContainsLaunchSuccessMarker(result, depth = 0) {
+  if (depth > 2) return false;
+  if (typeof result === "string") {
+    if (result.includes(LAUNCH_SUCCESS_MARKER)) return true;
+    try {
+      return resultContainsLaunchSuccessMarker(JSON.parse(result), depth + 1);
+    } catch {
+      return false;
+    }
+  }
+  if (typeof result === "object" && result !== null) {
+    for (const value of Object.values(result)) {
+      if (typeof value === "string" && value.includes(LAUNCH_SUCCESS_MARKER)) return true;
+    }
+  }
+  return false;
+}
+function classifyAgentComputerLaunchOutcome(toolCall) {
+  if (toolCall.status === "error" || toolCall.status === "cancelled") return "failed";
+  if (toolCall.status !== "done") return "pending";
+  if (toolCall.result === void 0 || toolCall.result === null) return "unknown";
+  return resultContainsLaunchSuccessMarker(toolCall.result) ? "succeeded" : "failed";
+}
+
+// src/components/SessionBranchPicker.tsx
+import { useMemo, useState as useState2 } from "react";
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+var ROW_HEIGHT = 32;
+var SVG_WIDTH = 44;
+function SessionBranchPicker({
+  tree,
+  disabled = false,
+  onCheckout
+}) {
+  const [checkoutError, setCheckoutError] = useState2(null);
+  const [pendingNodeId, setPendingNodeId] = useState2(null);
+  const hasHistory = tree.nodes.length > 0;
+  const layout = useMemo(() => buildLayoutNodes(tree), [tree]);
+  const nodeMap = useMemo(() => new Map(tree.nodes.map((node) => [node.id, node])), [tree]);
+  const isBusy = disabled || pendingNodeId !== null;
+  const graphHeight = Math.max((layout.maxRow + 1) * ROW_HEIGHT, ROW_HEIGHT);
+  const graphWidth = Math.max(SVG_WIDTH, getColumnX(layout.maxColumn) + 12);
+  async function checkoutNode(node, position) {
+    if (isBusy) return;
+    setCheckoutError(null);
+    setPendingNodeId(node.id);
+    try {
+      await onCheckout(node.id, position);
+    } catch (error) {
+      setCheckoutError(error instanceof Error ? error.message : "\u5207\u6362\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5");
+    } finally {
+      setPendingNodeId(null);
+    }
+  }
+  async function handleVirtualClick(node) {
+    if (isBusy || !node.isVirtual || node.isActive) return;
+    const sourceNode = nodeMap.get(node.content);
+    if (sourceNode) await checkoutNode(sourceNode, "turn_end");
+  }
+  async function handleNodeSelect(node) {
+    if (isBusy) return;
+    const sourceNode = nodeMap.get(node.id);
+    if (sourceNode) await checkoutNode(sourceNode, "before");
+  }
+  if (!hasHistory) return null;
+  return /* @__PURE__ */ jsxs2(Provider, { delayDuration: 200, children: [
+    checkoutError ? /* @__PURE__ */ jsx3("p", { role: "alert", className: "mb-2 text-xs text-destructive", children: checkoutError }) : null,
+    /* @__PURE__ */ jsx3("div", { className: "flex max-h-52 justify-center overflow-x-auto overflow-y-auto", children: /* @__PURE__ */ jsxs2("div", { className: "relative", style: { height: graphHeight, width: graphWidth }, children: [
+      /* @__PURE__ */ jsx3(
+        "svg",
+        {
+          "aria-hidden": "true",
+          className: "pointer-events-none absolute left-0 top-0 z-10 overflow-visible",
+          width: graphWidth,
+          height: graphHeight,
+          viewBox: `0 0 ${graphWidth} ${graphHeight}`,
+          fill: "none",
+          children: layout.nodes.map((node) => {
+            if (node.parentRow == null || node.parentColumn == null) {
+              return null;
+            }
+            const childStroke = node.isActive ? "hsl(var(--primary))" : "hsl(var(--muted-foreground))";
+            return /* @__PURE__ */ jsx3(
+              "path",
+              {
+                d: buildEdgePath(
+                  getColumnX(node.parentColumn),
+                  getRowY(node.parentRow),
+                  getColumnX(node.column),
+                  getRowY(node.row)
+                ),
+                stroke: childStroke,
+                strokeOpacity: node.isActive ? 0.95 : 0.45,
+                strokeWidth: node.isActive ? 1.8 : 1.4,
+                strokeLinecap: "round",
+                strokeLinejoin: "round",
+                strokeDasharray: node.isVirtual ? "3 3" : void 0
+              },
+              `path-${node.id}`
+            );
+          })
+        }
+      ),
+      /* @__PURE__ */ jsx3("div", { className: "relative z-0 h-full", children: layout.nodes.map((node) => {
+        const isPendingNode = pendingNodeId === node.id;
+        const color = node.isActive ? "hsl(var(--primary))" : "hsl(var(--muted-foreground))";
+        const previewText = node.isVirtual ? isPendingNode ? "\u5207\u6362\u4E2D..." : "" : isPendingNode ? "\u5207\u6362\u4E2D..." : node.preview;
+        const shouldShowTooltip = !node.isVirtual || Boolean(previewText);
+        const button = /* @__PURE__ */ jsx3(
+          "button",
+          {
+            type: "button",
+            onClick: () => void (node.isVirtual ? handleVirtualClick(node) : handleNodeSelect(node)),
+            disabled: isBusy,
+            "aria-current": !node.isVirtual && node.isCurrent ? "step" : void 0,
+            "aria-label": node.isVirtual ? "\u5207\u6362\u5230\u8BE5\u5206\u652F" : node.preview,
+            className: cn(
+              "absolute z-20 m-0 h-8 w-6 overflow-visible border-0 bg-transparent p-0",
+              isBusy ? "cursor-not-allowed opacity-60" : "cursor-pointer"
+            ),
+            style: {
+              top: node.row * ROW_HEIGHT,
+              left: getColumnX(node.column) - 12
+            },
+            children: /* @__PURE__ */ jsx3("span", { "aria-hidden": "true", className: "absolute left-0 top-0 h-8 w-6", children: /* @__PURE__ */ jsx3(
+              "svg",
+              {
+                "aria-hidden": "true",
+                role: "img",
+                className: "pointer-events-none absolute left-0 top-0 h-full w-full overflow-visible",
+                width: 24,
+                height: ROW_HEIGHT,
+                viewBox: `0 0 24 ${ROW_HEIGHT}`,
+                fill: "none",
+                children: node.isVirtual ? /* @__PURE__ */ jsx3(
+                  "circle",
+                  {
+                    cx: 12,
+                    cy: ROW_HEIGHT / 2,
+                    r: 3.5,
+                    fill: "none",
+                    stroke: color,
+                    strokeWidth: 1.2,
+                    strokeDasharray: "2 2",
+                    opacity: 0.7
+                  }
+                ) : /* @__PURE__ */ jsxs2("g", { children: [
+                  node.isCurrent ? /* @__PURE__ */ jsx3("circle", { cx: 12, cy: ROW_HEIGHT / 2, r: 9, fill: color, opacity: 0.18 }) : null,
+                  /* @__PURE__ */ jsx3(
+                    "circle",
+                    {
+                      cx: 12,
+                      cy: ROW_HEIGHT / 2,
+                      r: node.isCurrent ? 5.5 : 4,
+                      fill: color
+                    }
+                  )
+                ] })
+              }
+            ) })
+          }
+        );
+        if (!shouldShowTooltip) {
+          return /* @__PURE__ */ jsx3("div", { children: button }, node.id);
+        }
+        return /* @__PURE__ */ jsxs2(Root3, { children: [
+          /* @__PURE__ */ jsx3(Trigger, { asChild: true, children: button }),
+          /* @__PURE__ */ jsx3(Portal, { children: /* @__PURE__ */ jsx3(
+            Content2,
+            {
+              side: "right",
+              sideOffset: 8,
+              className: cn(
+                // z-[60]：这张图会被放进回溯弹层（z-50 且背景不透明），
+                // 消息预览不抬到弹层之上就会被它的背景吃掉。
+                "z-[60] rounded-md border border-border bg-popover px-2 py-1 text-xs text-foreground shadow-md",
+                !node.isVirtual && node.isCurrent && "font-semibold"
+              ),
+              children: previewText
+            }
+          ) })
+        ] }, node.id);
+      }) })
+    ] }) })
+  ] });
+}
+function buildLayoutNodes(tree) {
+  if (!tree || tree.nodes.length === 0) {
+    return { nodes: [], hasCycle: false, maxColumn: 0, maxRow: 0 };
+  }
+  const nodeMap = new Map(tree.nodes.map((node) => [node.id, node]));
+  const order = new Map(tree.nodes.map((node, index) => [node.id, index]));
+  const childrenMap = /* @__PURE__ */ new Map();
+  for (const node of tree.nodes) {
+    const parentId = node.parent_id && nodeMap.has(node.parent_id) ? node.parent_id : null;
+    const siblings = childrenMap.get(parentId) ?? [];
+    siblings.push(node);
+    childrenMap.set(parentId, siblings);
+  }
+  const activeIds = /* @__PURE__ */ new Set();
+  const activeVisited = /* @__PURE__ */ new Set();
+  const leafId = tree.leaf_id;
+  let current = tree.leaf_id;
+  while (current && nodeMap.has(current) && !activeVisited.has(current)) {
+    activeIds.add(current);
+    activeVisited.add(current);
+    current = nodeMap.get(current)?.parent_id ?? null;
+  }
+  const layoutNodes = [];
+  const placed = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  let nextColumn = 1;
+  let maxColumn = 0;
+  let maxRow = 0;
+  let hasCycle = false;
+  const rootSort = (a, b) => (order.get(a.id) ?? 0) - (order.get(b.id) ?? 0);
+  const childSort = (a, b) => (order.get(a.id) ?? 0) - (order.get(b.id) ?? 0);
+  const allocateColumn = () => {
+    const fresh = nextColumn;
+    nextColumn += 1;
+    return fresh;
+  };
+  function walk(node, parent, column, row) {
+    if (visiting.has(node.id)) {
+      hasCycle = true;
+      return;
+    }
+    if (placed.has(node.id)) {
+      return;
+    }
+    visiting.add(node.id);
+    maxColumn = Math.max(maxColumn, column);
+    maxRow = Math.max(maxRow, row);
+    const layoutNode = {
+      id: node.id,
+      column,
+      row,
+      parentRow: parent?.row ?? null,
+      parentColumn: parent?.column ?? null,
+      isActive: activeIds.has(node.id),
+      isCurrent: node.id === leafId,
+      isVirtual: false,
+      preview: formatPreview(node.content_preview),
+      content: node.content
+    };
+    layoutNodes.push(layoutNode);
+    placed.add(node.id);
+    const children = [...childrenMap.get(node.id) ?? []].sort(childSort);
+    if (children.length === 0) {
+      const virtualRow = row + 1;
+      maxRow = Math.max(maxRow, virtualRow);
+      layoutNodes.push({
+        id: `__virtual__${node.id}`,
+        column,
+        row: virtualRow,
+        parentRow: layoutNode.row,
+        parentColumn: layoutNode.column,
+        isActive: activeIds.has(node.id),
+        isCurrent: false,
+        isVirtual: true,
+        preview: "",
+        content: node.id
+      });
+    } else {
+      for (const [index, child] of children.entries()) {
+        if (visiting.has(child.id)) {
+          hasCycle = true;
+          continue;
+        }
+        const childColumn = index === 0 ? column : allocateColumn();
+        walk(child, layoutNode, childColumn, row + 1);
+      }
+    }
+    visiting.delete(node.id);
+  }
+  const roots = [...childrenMap.get(null) ?? []].sort(rootSort);
+  for (const [index, root] of roots.entries()) {
+    const rootColumn = index === 0 ? 0 : allocateColumn();
+    walk(root, null, rootColumn, 0);
+  }
+  for (const node of [...tree.nodes].sort(rootSort)) {
+    if (!placed.has(node.id)) {
+      hasCycle = true;
+      const rootColumn = layoutNodes.length === 0 ? 0 : allocateColumn();
+      walk(node, null, rootColumn, 0);
+    }
+  }
+  return {
+    nodes: layoutNodes,
+    hasCycle,
+    maxColumn,
+    maxRow
+  };
+}
+function formatPreview(preview) {
+  const normalized = preview.replace(/\s+/g, " ").trim();
+  return normalized.length > 0 ? normalized : "(\u7A7A\u6D88\u606F)";
+}
+function getColumnX(column) {
+  return 12 + column * 24;
+}
+function getRowY(row) {
+  return row * ROW_HEIGHT + ROW_HEIGHT / 2;
+}
+function buildEdgePath(fromX, fromY, toX, toY) {
+  if (fromX === toX || fromY === toY) {
+    return `M ${fromX} ${fromY} L ${toX} ${toY}`;
+  }
+  const r = Math.min(5, Math.abs(toX - fromX), Math.abs(toY - fromY));
+  const dx = toX > fromX ? 1 : -1;
+  return [
+    `M ${fromX} ${fromY}`,
+    `H ${toX - dx * r}`,
+    `A ${r} ${r} 0 0 ${dx > 0 ? 1 : 0} ${toX} ${fromY + r}`,
+    `V ${toY}`
+  ].join(" ");
+}
+export {
+  AgentChat,
+  BackgroundWakeNotice,
+  BladeProvider,
+  ChatView,
+  ConnectorPanel,
+  ContextCard,
+  ContextGroupCard,
+  DEFAULT_ALLOWED_TAGS,
+  LlmChat,
+  MarkdownContent,
+  MarkdownRenderer,
+  McpAppCard,
+  MessageImage,
+  MountHostContext,
+  MountSlot,
+  PLAN_AUTO_COLLAPSE_MS,
+  PlanUpdateBlock,
+  PluginConnectorList,
+  PluginTriggerStack,
+  ReplayBar,
+  ReplayMismatchPrompt,
+  SessionBranchPicker,
+  SessionMemoryToggle,
+  SessionPluginConfigDialog,
+  SessionPluginConfigForm,
+  SessionPluginIcon,
+  SessionPluginSelector,
+  SessionQueuePanel,
+  TRIGGER_ICON_LIMIT,
+  TURN_NAV_HIGHLIGHT_CLASS,
+  ToolUiCardView,
+  WhatIfUserBubble,
+  catalogToConnectorItems,
+  classifyAgentComputerLaunchOutcome,
+  filterConnectorItems,
+  getPlanUpdateDisplayState,
+  isAgentComputerCommand,
+  isAgentComputerToolCall,
+  isPlanUpdateTool,
+  isQueuePanelVisible,
+  latestUserSpeechEntryId,
+  mergeConnectorItems,
+  mountRenderersToReact,
+  parsePlanUpdate,
+  parseWhatIfPrompt,
+  pickCurrentPlanStep,
+  selectionFromItem,
+  sessionPluginLabel,
+  triggerSummary,
+  turnNavItemsFromMessages,
+  useAgentSession,
+  useBladeClient,
+  useBladeHost,
+  useLlmChat,
+  useMessagePin,
+  useOptionalBladeClient,
+  useReplay,
+  useSessionPluginActivation,
+  useTurnNavigation,
+  useTypewriterReveal
+};
+//# sourceMappingURL=internal.js.map