@dxos/plugin-assistant 0.8.4-main.4a85c3132b → 0.8.4-main.4f23b4e393

package/dist/lib/neutral/components/index.mjs

@@ -0,0 +1,2297 @@
+import "../chunk-J5LGTIGS.mjs";
+
+// src/components/index.ts
+import { lazy } from "react";
+
+// src/components/Chat/Chat.tsx
+import { useAtomValue as useAtomValue3 } from "@effect-atom/atom-react";
+import * as Array from "effect/Array";
+import * as Option4 from "effect/Option";
+import React15, { useCallback as useCallback6, useEffect as useEffect6, useMemo as useMemo5, useRef as useRef3, useState as useState7 } from "react";
+import { Agent } from "@dxos/assistant-toolkit";
+import { Event } from "@dxos/async";
+import { Filter as Filter2, Obj as Obj3, Query } from "@dxos/echo";
+import { useQuery as useQuery2 } from "@dxos/react-client/echo";
+import { useIdentity } from "@dxos/react-client/halo";
+import { Menu } from "@dxos/react-ui-menu";
+import { Message as Message2 } from "@dxos/types";
+import { composable as composable2, composableProps as composableProps2 } from "@dxos/ui-theme";
+import { useChatKeymapExtensions as useChatKeymapExtensions2, useChatToolbarActions, useDebug } from "#hooks";
+
+// src/components/ChatPrompt/ChatActions.tsx
+import React from "react";
+import { IconButton, useTranslation } from "@dxos/react-ui";
+import { mx } from "@dxos/ui-theme";
+import { meta } from "#meta";
+var ChatActions = ({ classNames, children, microphone, recording, processing, debug, onEvent }) => {
+  const { t } = useTranslation(meta.id);
+  return /* @__PURE__ */ React.createElement("div", {
+    className: mx("flex items-center", classNames)
+  }, children, microphone && /* @__PURE__ */ React.createElement(IconButton, {
+    disabled: !processing,
+    classNames: mx(recording && "bg-primary-500"),
+    variant: "ghost",
+    icon: "ph--microphone--regular",
+    iconOnly: true,
+    noTooltip: true,
+    label: t("microphone.button"),
+    onMouseDown: () => onEvent?.({
+      type: "record-start"
+    }),
+    onMouseUp: () => onEvent?.({
+      type: "record-stop"
+    }),
+    onTouchStart: () => onEvent?.({
+      type: "record-start"
+    }),
+    onTouchEnd: () => onEvent?.({
+      type: "record-stop"
+    })
+  }), debug && /* @__PURE__ */ React.createElement(IconButton, {
+    variant: "ghost",
+    icon: "ph--wrench--regular",
+    iconOnly: true,
+    label: t("debug.button"),
+    onClick: () => onEvent?.({
+      type: "toggle-debug"
+    })
+  }), /* @__PURE__ */ React.createElement(IconButton, {
+    disabled: !processing,
+    variant: "ghost",
+    icon: "ph--x--regular",
+    iconOnly: true,
+    label: t("cancel-processing.button"),
+    onClick: () => onEvent?.({
+      type: "cancel"
+    })
+  }));
+};
+
+// src/components/ChatPrompt/ChatMcpErrors.tsx
+import { useAtomValue } from "@effect-atom/atom-react";
+import React2, { useCallback } from "react";
+import { Message, useTranslation as useTranslation2 } from "@dxos/react-ui";
+import { meta as meta2 } from "#meta";
+var ChatMcpErrors = ({ classNames, processor }) => {
+  const { t } = useTranslation2(meta2.id);
+  const errors = useAtomValue(processor.mcpErrors);
+  const handleDismiss = useCallback(() => {
+    processor.dismissMcpErrors();
+  }, [
+    processor
+  ]);
+  if (errors.length === 0) {
+    return null;
+  }
+  return /* @__PURE__ */ React2.createElement(Message.Root, {
+    classNames: [
+      "m-1",
+      classNames
+    ],
+    valence: "warning"
+  }, /* @__PURE__ */ React2.createElement(Message.Title, {
+    onClose: handleDismiss
+  }, t("mcp-server-error.label")), /* @__PURE__ */ React2.createElement(Message.Content, {
+    asChild: true
+  }, /* @__PURE__ */ React2.createElement("ul", {
+    className: "flex flex-col gap-0.5 text-sm"
+  }, errors.map((error) => /* @__PURE__ */ React2.createElement("li", {
+    key: `${error.url}::${error.protocol}`,
+    className: "truncate"
+  }, /* @__PURE__ */ React2.createElement("span", {
+    className: "font-mono"
+  }, error.url), " \u2014 ", /* @__PURE__ */ React2.createElement("span", null, error.message))))));
+};
+
+// src/components/ChatPrompt/ChatOptions.tsx
+import * as Option from "effect/Option";
+import React3, { useCallback as useCallback2, useMemo, useState } from "react";
+import { McpServer } from "@dxos/assistant-toolkit";
+import { Annotation, Filter, Obj, Type } from "@dxos/echo";
+import { useObject, useQuery } from "@dxos/react-client/echo";
+import { IconButton as IconButton2, Input, Popover, Select, useTranslation as useTranslation3 } from "@dxos/react-ui";
+import { Listbox } from "@dxos/react-ui-list";
+import { SearchList, useSearchListResults } from "@dxos/react-ui-search";
+import { Tabs } from "@dxos/react-ui-tabs";
+import { getStyles, mx as mx2 } from "@dxos/ui-theme";
+import { useActiveBlueprints, useBlueprintHandlers, useBlueprints, useContextObjects, useFilteredTypes } from "#hooks";
+import { meta as meta3 } from "#meta";
+import { Assistant } from "#types";
+var styles = {
+  panel: "w-[calc(100dvw-.5rem)] sm:w-max max-w-document-width",
+  toolbar: "p-0! gap-0! border-t border-separator"
+};
+var ChatOptions = ({ chat, db, context, blueprintRegistry, presets, preset, onPresetChange }) => {
+  const { t } = useTranslation3(meta3.id);
+  return /* @__PURE__ */ React3.createElement("div", {
+    className: "flex"
+  }, /* @__PURE__ */ React3.createElement(Popover.Root, null, /* @__PURE__ */ React3.createElement(Popover.Trigger, {
+    asChild: true
+  }, /* @__PURE__ */ React3.createElement(IconButton2, {
+    variant: "ghost",
+    icon: "ph--plus--regular",
+    iconOnly: true,
+    label: t("context-objects.button")
+  })), /* @__PURE__ */ React3.createElement(Popover.Portal, null, /* @__PURE__ */ React3.createElement(Popover.Content, {
+    side: "top",
+    classNames: styles.panel
+  }, /* @__PURE__ */ React3.createElement(Popover.Viewport, null, /* @__PURE__ */ React3.createElement(ObjectsPanel, {
+    db,
+    context
+  })), /* @__PURE__ */ React3.createElement(Popover.Arrow, null)))), /* @__PURE__ */ React3.createElement(Popover.Root, null, /* @__PURE__ */ React3.createElement(Popover.Trigger, {
+    asChild: true
+  }, /* @__PURE__ */ React3.createElement(IconButton2, {
+    variant: "ghost",
+    icon: "ph--sliders-horizontal--regular",
+    iconOnly: true,
+    label: t("context-settings.button")
+  })), /* @__PURE__ */ React3.createElement(Popover.Portal, null, /* @__PURE__ */ React3.createElement(Popover.Content, {
+    side: "top",
+    classNames: styles.panel
+  }, /* @__PURE__ */ React3.createElement(Popover.Viewport, null, /* @__PURE__ */ React3.createElement(Tabs.Root, {
+    classNames: "flex",
+    orientation: "horizontal",
+    defaultValue: "view",
+    defaultActivePart: "list",
+    tabIndex: -1
+  }, /* @__PURE__ */ React3.createElement(Tabs.Viewport, {
+    classNames: mx2("grid grid-rows-[1fr_40px] w-full")
+  }, /* @__PURE__ */ React3.createElement(Tabs.Panel, {
+    tabIndex: -1,
+    classNames: "dx-focus-ring-inset overflow-hidden",
+    value: "view"
+  }, /* @__PURE__ */ React3.createElement(ViewPanel, {
+    chat
+  })), /* @__PURE__ */ React3.createElement(Tabs.Panel, {
+    tabIndex: -1,
+    classNames: "dx-focus-ring-inset overflow-hidden",
+    value: "blueprints"
+  }, /* @__PURE__ */ React3.createElement(BlueprintsPanel, {
+    blueprintRegistry,
+    db,
+    context
+  })), /* @__PURE__ */ React3.createElement(Tabs.Panel, {
+    tabIndex: -1,
+    classNames: "dx-focus-ring-inset overflow-hidden",
+    value: "mcp-servers"
+  }, /* @__PURE__ */ React3.createElement(McpServersPanel, {
+    db
+  })), /* @__PURE__ */ React3.createElement(Tabs.Panel, {
+    tabIndex: -1,
+    classNames: "dx-focus-ring-inset overflow-hidden",
+    value: "model"
+  }, /* @__PURE__ */ React3.createElement(ModelsPanel, {
+    presets,
+    preset,
+    onPresetChange
+  })), /* @__PURE__ */ React3.createElement(Tabs.Tablist, {
+    classNames: [
+      styles.toolbar
+    ]
+  }, /* @__PURE__ */ React3.createElement(Tabs.IconTab, {
+    value: "view",
+    icon: "ph--eye--regular",
+    label: t("chat-view.title")
+  }), /* @__PURE__ */ React3.createElement(Tabs.IconTab, {
+    value: "blueprints",
+    icon: "ph--blueprint--regular",
+    label: t("options.blueprints.title")
+  }), /* @__PURE__ */ React3.createElement(Tabs.IconTab, {
+    value: "mcp-servers",
+    icon: "ph--plugs-connected--regular",
+    label: t("options.mcp.title")
+  }), /* @__PURE__ */ React3.createElement(Tabs.IconTab, {
+    value: "model",
+    icon: "ph--cpu--regular",
+    label: t("options.chat-model.title")
+  }))))), /* @__PURE__ */ React3.createElement(Popover.Arrow, null)))));
+};
+var BlueprintsPanel = ({ blueprintRegistry, db, context }) => {
+  const { t } = useTranslation3(meta3.id);
+  const blueprints = useBlueprints({
+    blueprintRegistry,
+    db
+  });
+  const activeBlueprints = useActiveBlueprints({
+    context
+  });
+  const { onUpdateBlueprint } = useBlueprintHandlers({
+    db,
+    context,
+    blueprintRegistry
+  });
+  const { results, handleSearch } = useSearchListResults({
+    items: blueprints,
+    extract: (blueprint) => blueprint.name
+  });
+  return /* @__PURE__ */ React3.createElement(SearchList.Root, {
+    onSearch: handleSearch
+  }, /* @__PURE__ */ React3.createElement(SearchList.Content, {
+    classNames: "flex flex-col"
+  }, /* @__PURE__ */ React3.createElement(SearchList.Viewport, null, results.map((blueprint) => {
+    const isActive = activeBlueprints.has(blueprint.key);
+    return /* @__PURE__ */ React3.createElement(SearchList.Item, {
+      classNames: "flex items-center overflow-hidden",
+      key: blueprint.key,
+      value: blueprint.key,
+      label: blueprint.name,
+      checked: isActive,
+      onSelect: () => onUpdateBlueprint?.(blueprint.key, !isActive)
+    });
+  })), /* @__PURE__ */ React3.createElement(SearchList.Input, {
+    placeholder: t("search.placeholder"),
+    classNames: "border-t border-separator",
+    autoFocus: true
+  })));
+};
+var ViewPanel = ({ chat }) => {
+  const { t } = useTranslation3(meta3.id);
+  const [view, setView] = useObject(chat, "view");
+  const value2 = view ?? "normal";
+  return /* @__PURE__ */ React3.createElement(Listbox.Root, {
+    value: value2,
+    onValueChange: setView,
+    autoFocus: true
+  }, Assistant.ChatViews.map((view2) => /* @__PURE__ */ React3.createElement(Listbox.Option, {
+    key: view2,
+    value: view2
+  }, /* @__PURE__ */ React3.createElement(Listbox.OptionLabel, null, t(`chat-view.${view2}.label`, {
+    defaultValue: view2
+  })), /* @__PURE__ */ React3.createElement(Listbox.OptionIndicator, null))));
+};
+var ModelsPanel = ({ presets, preset, onPresetChange }) => {
+  return /* @__PURE__ */ React3.createElement(Listbox.Root, {
+    value: preset,
+    onValueChange: onPresetChange,
+    autoFocus: true
+  }, presets?.map(({ id, label }) => {
+    return /* @__PURE__ */ React3.createElement(Listbox.Option, {
+      key: id,
+      value: id
+    }, /* @__PURE__ */ React3.createElement(Listbox.OptionLabel, null, label), /* @__PURE__ */ React3.createElement(Listbox.OptionIndicator, null));
+  }));
+};
+var McpServersPanel = ({ db }) => {
+  const { t } = useTranslation3(meta3.id);
+  const servers = useQuery(db, Filter.type(McpServer.McpServer));
+  const [adding, setAdding] = useState(false);
+  const handleAdd = useCallback2((name, url, protocol, apiKey) => {
+    db.add(Obj.make(McpServer.McpServer, {
+      name,
+      url,
+      protocol,
+      apiKey,
+      enabled: true
+    }));
+    setAdding(false);
+  }, [
+    db
+  ]);
+  const handleRemove = useCallback2((server) => {
+    db.remove(server);
+  }, [
+    db
+  ]);
+  return /* @__PURE__ */ React3.createElement("div", {
+    className: "p-form-chrome"
+  }, servers.map((server) => /* @__PURE__ */ React3.createElement(McpServerRow, {
+    key: server.id,
+    server,
+    onRemove: handleRemove
+  })), adding ? /* @__PURE__ */ React3.createElement(McpServerForm, {
+    onSubmit: handleAdd,
+    onCancel: () => setAdding(false)
+  }) : /* @__PURE__ */ React3.createElement("div", null, /* @__PURE__ */ React3.createElement(IconButton2, {
+    variant: "ghost",
+    icon: "ph--plus--regular",
+    label: t("mcp-server-add.label"),
+    onClick: () => setAdding(true)
+  })));
+};
+var McpServerRow = ({ server, onRemove }) => {
+  const { t } = useTranslation3(meta3.id);
+  const [enabled, setEnabled] = useObject(server, "enabled");
+  return /* @__PURE__ */ React3.createElement("div", {
+    className: "flex items-center gap-2 px-form-chrome"
+  }, /* @__PURE__ */ React3.createElement(Input.Root, null, /* @__PURE__ */ React3.createElement(Input.Label, {
+    srOnly: true
+  }, server.name), /* @__PURE__ */ React3.createElement(Input.Switch, {
+    checked: enabled !== false,
+    onCheckedChange: (checked) => setEnabled(!!checked)
+  })), /* @__PURE__ */ React3.createElement("span", {
+    className: "flex-1 truncate text-sm"
+  }, server.name), /* @__PURE__ */ React3.createElement("span", {
+    className: "truncate text-xs text-description"
+  }, server.url), /* @__PURE__ */ React3.createElement(IconButton2, {
+    variant: "ghost",
+    icon: "ph--x--regular",
+    iconOnly: true,
+    label: t("mcp-server-remove.label"),
+    onClick: () => onRemove(server)
+  }));
+};
+var McpServerForm = ({ onSubmit, onCancel }) => {
+  const { t } = useTranslation3(meta3.id);
+  const [name, setName] = useState("");
+  const [url, setUrl] = useState("");
+  const [protocol, setProtocol] = useState("sse");
+  const [apiKey, setApiKey] = useState("");
+  const canSubmit = name.trim().length > 0 && url.trim().length > 0;
+  const handleSubmit = useCallback2(() => {
+    if (canSubmit) {
+      onSubmit(name.trim(), url.trim(), protocol, apiKey.trim() || void 0);
+    }
+  }, [
+    canSubmit,
+    name,
+    url,
+    protocol,
+    apiKey,
+    onSubmit
+  ]);
+  return /* @__PURE__ */ React3.createElement("div", {
+    className: "space-y-2 px-form-chrome"
+  }, /* @__PURE__ */ React3.createElement(Input.Root, null, /* @__PURE__ */ React3.createElement(Input.Label, {
+    srOnly: true
+  }, t("mcp-server-name.label")), /* @__PURE__ */ React3.createElement(Input.TextInput, {
+    placeholder: t("mcp-server-name.placeholder"),
+    value: name,
+    onChange: (event) => setName(event.target.value),
+    autoFocus: true
+  })), /* @__PURE__ */ React3.createElement(Input.Root, null, /* @__PURE__ */ React3.createElement(Input.Label, {
+    srOnly: true
+  }, t("mcp-server-url.label")), /* @__PURE__ */ React3.createElement(Input.TextInput, {
+    placeholder: t("mcp-server-url.placeholder"),
+    value: url,
+    onChange: (event) => setUrl(event.target.value)
+  })), /* @__PURE__ */ React3.createElement(Select.Root, {
+    value: protocol,
+    onValueChange: (value2) => setProtocol(value2)
+  }, /* @__PURE__ */ React3.createElement(Select.TriggerButton, {
+    placeholder: t("mcp-server-protocol.label")
+  }), /* @__PURE__ */ React3.createElement(Select.Portal, null, /* @__PURE__ */ React3.createElement(Select.Content, null, /* @__PURE__ */ React3.createElement(Select.Viewport, null, /* @__PURE__ */ React3.createElement(Select.Option, {
+    value: "sse"
+  }, "SSE"), /* @__PURE__ */ React3.createElement(Select.Option, {
+    value: "http"
+  }, "HTTP"))))), /* @__PURE__ */ React3.createElement(Input.Root, null, /* @__PURE__ */ React3.createElement(Input.Label, {
+    srOnly: true
+  }, t("mcp-server-api-key.label")), /* @__PURE__ */ React3.createElement(Input.TextInput, {
+    type: "password",
+    placeholder: t("mcp-server-api-key.placeholder"),
+    value: apiKey,
+    onChange: (event) => setApiKey(event.target.value)
+  })), /* @__PURE__ */ React3.createElement("div", {
+    className: "flex gap-2"
+  }, /* @__PURE__ */ React3.createElement(IconButton2, {
+    variant: "ghost",
+    icon: "ph--check--regular",
+    iconOnly: true,
+    label: t("save.button"),
+    onClick: handleSubmit,
+    disabled: !canSubmit
+  }), /* @__PURE__ */ React3.createElement(IconButton2, {
+    variant: "ghost",
+    icon: "ph--x--regular",
+    iconOnly: true,
+    label: t("cancel.button"),
+    onClick: onCancel
+  })));
+};
+var ANY = "__any__";
+var ObjectsPanel = ({ db, context }) => {
+  const { t } = useTranslation3(meta3.id);
+  const types = useFilteredTypes(db);
+  const typenames = useMemo(() => {
+    const typenames2 = types.map((type) => {
+      const typename2 = Type.getTypename(type);
+      return {
+        typename: typename2,
+        label: t("typename.label", {
+          ns: typename2,
+          defaultValue: typename2
+        })
+      };
+    });
+    typenames2.sort((a, b) => a.label.localeCompare(b.label));
+    return typenames2;
+  }, [
+    types
+  ]);
+  const [typename, setTypename] = useState(ANY);
+  const anyFilter = useMemo(() => Filter.or(...typenames.map(({ typename: typename2 }) => Filter.typename(typename2))), [
+    typenames
+  ]);
+  const objects = useQuery(db, typename === ANY ? anyFilter : Filter.typename(typename));
+  const { objects: contextObjects, onUpdateObject } = useContextObjects({
+    db,
+    context
+  });
+  const { results, handleSearch } = useSearchListResults({
+    items: objects,
+    extract: (object) => Obj.getLabel(object) ?? Obj.getTypename(object) ?? object.id
+  });
+  return /* @__PURE__ */ React3.createElement(SearchList.Root, {
+    onSearch: handleSearch
+  }, /* @__PURE__ */ React3.createElement(SearchList.Content, {
+    classNames: "p-form-chrome [&:has([cmdk-list-sizer]:empty)]:py-0"
+  }, /* @__PURE__ */ React3.createElement(SearchList.Viewport, null, results.length ? results.map((object) => {
+    const isActive = contextObjects.findIndex((obj) => obj.id === object.id) !== -1;
+    const { icon, hue } = Option.fromNullable(Obj.getSchema(object)).pipe(Option.flatMap(Annotation.IconAnnotation.get), Option.getOrElse(() => ({
+      icon: "ph--cube--regular",
+      hue: void 0
+    })));
+    const styles3 = hue ? getStyles(hue) : void 0;
+    return /* @__PURE__ */ React3.createElement(SearchList.Item, {
+      classNames: "flex items-center overflow-hidden",
+      key: object.id,
+      value: object.id,
+      icon,
+      iconClassNames: styles3?.foreground,
+      label: Obj.getLabel(object) ?? Obj.getTypename(object) ?? object.id,
+      checked: isActive,
+      onSelect: () => onUpdateObject?.(Obj.getDXN(object), !isActive)
+    });
+  }) : /* @__PURE__ */ React3.createElement(SearchList.Item, {
+    value: "__empty__",
+    label: t("no-results.message")
+  }))), /* @__PURE__ */ React3.createElement("div", {
+    className: mx2("flex flex-col", styles.toolbar)
+  }, /* @__PURE__ */ React3.createElement(Select.Root, {
+    value: typename === ANY ? void 0 : typename,
+    onValueChange: setTypename
+  }, /* @__PURE__ */ React3.createElement(Select.TriggerButton, {
+    placeholder: t("type-filter.placeholder")
+  }), /* @__PURE__ */ React3.createElement(Select.Portal, null, /* @__PURE__ */ React3.createElement(Select.Content, null, /* @__PURE__ */ React3.createElement(Select.ScrollUpButton, null), /* @__PURE__ */ React3.createElement(Select.Viewport, null, /* @__PURE__ */ React3.createElement(Select.Option, {
+    value: ANY
+  }, t("any-type-filter.label")), typenames.map(({ typename: typename2, label }) => /* @__PURE__ */ React3.createElement(Select.Option, {
+    key: typename2,
+    value: typename2
+  }, label))), /* @__PURE__ */ React3.createElement(Select.ScrollDownButton, null), /* @__PURE__ */ React3.createElement(Select.Arrow, null)))), /* @__PURE__ */ React3.createElement(SearchList.Input, {
+    placeholder: t("search.placeholder"),
+    autoFocus: true
+  })));
+};
+
+// src/components/ChatPrompt/ChatPresets.tsx
+import React4 from "react";
+import { Select as Select2 } from "@dxos/react-ui";
+
+// src/components/ChatPrompt/ChatPrompt.tsx
+import { useAtomValue as useAtomValue2 } from "@effect-atom/atom-react";
+import * as Option3 from "effect/Option";
+import React7, { useCallback as useCallback3, useEffect as useEffect2, useRef, useState as useState3 } from "react";
+import { useVoiceInput } from "@dxos/plugin-transcription";
+import { Input as Input2, useDynamicRef, useTranslation as useTranslation5 } from "@dxos/react-ui";
+import { ChatEditor } from "@dxos/react-ui-chat";
+import { mx as mx5 } from "@dxos/ui-theme";
+import { useChatKeymapExtensions } from "#hooks";
+import { meta as meta5 } from "#meta";
+
+// src/components/ChatPrompt/ChatReferences.tsx
+import * as Option2 from "effect/Option";
+import React5 from "react";
+import { Annotation as Annotation2, Obj as Obj2 } from "@dxos/echo";
+import { Icon, IconButton as IconButton3, toLocalizedString, useTranslation as useTranslation4 } from "@dxos/react-ui";
+import { getStyles as getStyles2, mx as mx3 } from "@dxos/ui-theme";
+import { useContextObjects as useContextObjects2 } from "#hooks";
+import { meta as meta4 } from "#meta";
+var ChatReferences = ({ classNames, context, db }) => {
+  const { t } = useTranslation4(meta4.id);
+  const { objects, onUpdateObject } = useContextObjects2({
+    db,
+    context
+  });
+  return /* @__PURE__ */ React5.createElement("ul", {
+    className: mx3("flex", classNames)
+  }, objects.map((obj) => {
+    const dxn = Obj2.getDXN(obj);
+    const typename = Obj2.getTypename(obj);
+    const label = Obj2.getLabel(obj) ?? (typename ? [
+      "object-name.placeholder",
+      {
+        ns: typename
+      }
+    ] : obj.id);
+    const { icon, hue } = Option2.fromNullable(Obj2.getSchema(obj)).pipe(Option2.flatMap(Annotation2.IconAnnotation.get), Option2.getOrElse(() => ({
+      icon: DEFAULT_OBJECT_ICON,
+      hue: void 0
+    })));
+    const styles3 = hue ? getStyles2(hue) : void 0;
+    return /* @__PURE__ */ React5.createElement("li", {
+      key: dxn.toString(),
+      className: "dx-tag py-0 ps-2 flex items-center gap-1",
+      "data-hue": "neutral"
+    }, /* @__PURE__ */ React5.createElement(Icon, {
+      icon,
+      size: 4,
+      classNames: styles3?.foreground
+    }), toLocalizedString(label, t), /* @__PURE__ */ React5.createElement(IconButton3, {
+      icon: "ph--x--bold",
+      iconOnly: true,
+      variant: "ghost",
+      label: t("remove-object.label"),
+      classNames: "p-0 hover:bg-transparent",
+      size: 3,
+      onClick: () => onUpdateObject?.(dxn, false)
+    }));
+  }));
+};
+var DEFAULT_OBJECT_ICON = "ph--cube--regular";
+
+// src/components/ChatPrompt/ChatStatusIndicator.tsx
+import React6, { useEffect, useState as useState2 } from "react";
+import { Tooltip, useTimeout } from "@dxos/react-ui";
+import { Spinner } from "@dxos/react-ui-sfx";
+import { mx as mx4 } from "@dxos/ui-theme";
+var period = 3e3;
+var ChatStatusIndicator = ({ classNames, preset, processing, error, ...props }) => {
+  const [init, setInit] = useState2(false);
+  useEffect(() => setInit(false), [
+    preset
+  ]);
+  useTimeout(async () => {
+    setInit(true);
+  }, period / 2, [
+    preset
+  ]);
+  return /* @__PURE__ */ React6.createElement("div", {
+    className: mx4("relative flex", classNames)
+  }, /* @__PURE__ */ React6.createElement(Spinner, {
+    duration: period,
+    state: !init ? "flash" : error ? "error" : processing ? "spin" : "pulse",
+    ...props
+  }), error && /* @__PURE__ */ React6.createElement(Tooltip.Trigger, {
+    asChild: true,
+    content: error.message
+  }, /* @__PURE__ */ React6.createElement("div", {
+    className: "absolute inset-0"
+  })));
+};
+
+// src/components/ChatPrompt/ChatPrompt.tsx
+var ChatPrompt = ({ classNames, outline, chat, db, processor, event, online, placeholder, onOnlineChange, onPresetChange, settings = true, presets, preset }) => {
+  const { t } = useTranslation5(meta5.id);
+  const error = useAtomValue2(processor.error).pipe(Option3.getOrUndefined);
+  const streaming = useAtomValue2(processor.streaming);
+  const active = useAtomValue2(processor.active);
+  const activeRef = useDynamicRef(active);
+  const editorRef = useRef(null);
+  const [recordingState, setRecordingState] = useState3(false);
+  useEffect2(() => {
+    return event.on((ev) => {
+      switch (ev.type) {
+        case "update-prompt":
+          if (!editorRef.current?.getText()?.length) {
+            editorRef.current?.setText(ev.text);
+            editorRef.current?.focus();
+          }
+          break;
+        case "record-start":
+          setRecordingState(true);
+          break;
+        case "record-stop":
+          setRecordingState(false);
+          break;
+      }
+    });
+  }, [
+    event
+  ]);
+  const { recording } = useVoiceInput({
+    active: recordingState,
+    onUpdate: (text) => {
+      editorRef.current?.setText(text);
+      editorRef.current?.focus();
+    }
+  });
+  const extensions = useChatKeymapExtensions({
+    event
+  });
+  const handleSubmit = useCallback3((text) => {
+    if (!activeRef.current) {
+      event.emit({
+        type: "submit",
+        text
+      });
+      return true;
+    }
+  }, [
+    event
+  ]);
+  const handleEvent = useCallback3((ev) => {
+    event.emit(ev);
+  }, [
+    event
+  ]);
+  return /* @__PURE__ */ React7.createElement("div", {
+    role: "group",
+    className: mx5("flex flex-col w-full dx-density-fine", outline && "bg-group-surface rounded-sm! border border-subdued-separator transition transition-border [&:has(.cm-content:focus)]:border-separator", classNames)
+  }, /* @__PURE__ */ React7.createElement(ChatMcpErrors, {
+    processor
+  }), /* @__PURE__ */ React7.createElement("div", {
+    className: "flex p-2 gap-2"
+  }, /* @__PURE__ */ React7.createElement(ChatStatusIndicator, {
+    classNames: "p-1",
+    preset,
+    error,
+    processing: streaming
+  }), /* @__PURE__ */ React7.createElement(ChatEditor, {
+    ref: editorRef,
+    autoFocus: true,
+    lineWrapping: true,
+    classNames: "col-span-2 pt-0.5",
+    placeholder: placeholder ?? t("prompt.placeholder"),
+    extensions,
+    onSubmit: handleSubmit
+  })), db && settings && /* @__PURE__ */ React7.createElement("div", {
+    className: "flex items-center overflow-hidden p-1.5"
+  }, /* @__PURE__ */ React7.createElement(ChatOptions, {
+    chat,
+    db,
+    blueprintRegistry: processor.blueprintRegistry,
+    context: processor.context,
+    preset,
+    presets,
+    onPresetChange
+  }), /* @__PURE__ */ React7.createElement("div", {
+    className: "flex h-8 grow overflow-x-auto scrollbar-none"
+  }, /* @__PURE__ */ React7.createElement(ChatReferences, {
+    db,
+    context: processor.context
+  })), /* @__PURE__ */ React7.createElement(ChatActions, {
+    classNames: "col-span-2",
+    microphone: true,
+    recording,
+    processing: streaming,
+    onEvent: handleEvent
+  }, online !== void 0 && /* @__PURE__ */ React7.createElement(Input2.Root, null, /* @__PURE__ */ React7.createElement(Input2.Label, {
+    srOnly: true
+  }, t("online-switch.label")), /* @__PURE__ */ React7.createElement(Input2.Switch, {
+    classNames: "mx-1",
+    checked: online,
+    onCheckedChange: onOnlineChange
+  })))));
+};
+ChatPrompt.displayName = "Chat.Prompt";
+
+// src/components/ChatPrompt/ChatStatus.tsx
+import React8, { useEffect as useEffect3, useMemo as useMemo2, useState as useState4 } from "react";
+import { ChatStatus as NaturalChatStatus, formatElapsed } from "@dxos/react-ui-chat";
+import { Matrix } from "@dxos/react-ui-sfx";
+import { Unit } from "@dxos/util";
+
+// src/components/Chat/context.ts
+import { createContext } from "@radix-ui/react-context";
+var [ChatContextProvider, useChatContext] = createContext("Chat");
+
+// src/components/ChatPrompt/ChatStatus.tsx
+var CHAT_STREAM_STATUS_NAME = "Chat.StreamStatus";
+var TICK_MS = 1e3;
+var ChatStatus = ({ classNames, icon }) => {
+  const { messages, requestTiming } = useChatContext(CHAT_STREAM_STATUS_NAME);
+  const { lastOutputTokens, sessionTotalTokens } = useMemo2(() => {
+    let last;
+    let total = 0;
+    for (const message of messages) {
+      for (const block of message.blocks) {
+        if (isStats(block) && block.usage) {
+          last = block.usage.outputTokens;
+          total += block.usage.totalTokens ?? 0;
+        }
+      }
+    }
+    return {
+      lastOutputTokens: last,
+      sessionTotalTokens: total
+    };
+  }, [
+    messages
+  ]);
+  const isRunning = requestTiming != null && requestTiming.endedAt == null;
+  const show = requestTiming || lastOutputTokens || sessionTotalTokens > 0;
+  if (!show) {
+    return null;
+  }
+  return /* @__PURE__ */ React8.createElement(NaturalChatStatus.Root, {
+    defaultRunning: false,
+    classNames: [
+      "py-2 gap-2 text-sm",
+      classNames
+    ]
+  }, icon && /* @__PURE__ */ React8.createElement(NaturalChatStatus.Icon, null, /* @__PURE__ */ React8.createElement(Matrix, {
+    classNames: "w-5 h-5",
+    dotClassNames: "bg-primary-500",
+    dim: 4,
+    dotSize: 3,
+    count: 10,
+    interval: 500,
+    active: isRunning
+  })), show && /* @__PURE__ */ React8.createElement("div", {
+    className: "flex items-center"
+  }, requestTiming && /* @__PURE__ */ React8.createElement(NaturalChatStatus.Text, null, /* @__PURE__ */ React8.createElement(Elapsed, {
+    timing: requestTiming
+  })), lastOutputTokens != null && /* @__PURE__ */ React8.createElement(React8.Fragment, null, requestTiming && /* @__PURE__ */ React8.createElement(NaturalChatStatus.Separator, null), /* @__PURE__ */ React8.createElement(NaturalChatStatus.Text, null, "\u2193 ", Unit.Thousand(lastOutputTokens).toString())), sessionTotalTokens > 0 && /* @__PURE__ */ React8.createElement(React8.Fragment, null, (requestTiming || lastOutputTokens != null) && /* @__PURE__ */ React8.createElement(NaturalChatStatus.Separator, null), /* @__PURE__ */ React8.createElement(NaturalChatStatus.Text, null, "\u03A3 ", Unit.Thousand(sessionTotalTokens).toString()))));
+};
+var Elapsed = ({ timing }) => {
+  const isRunning = timing.endedAt == null;
+  const [now, setNow] = useState4(Date.now());
+  useEffect3(() => {
+    if (!isRunning) {
+      return;
+    }
+    const id = setInterval(() => setNow(Date.now()), TICK_MS);
+    return () => clearInterval(id);
+  }, [
+    isRunning
+  ]);
+  return /* @__PURE__ */ React8.createElement(React8.Fragment, null, formatElapsed((timing.endedAt ?? now) - timing.startedAt));
+};
+var isStats = (block) => block._tag === "stats";
+
+// src/components/ChatThread/ChatThread.tsx
+import React13, { forwardRef, useCallback as useCallback5, useEffect as useEffect5, useMemo as useMemo4, useState as useState6 } from "react";
+import { PublicKey } from "@dxos/keys";
+import { setRef } from "@dxos/react-ui";
+import { MarkdownStream } from "@dxos/react-ui-markdown";
+import { keyToFallback } from "@dxos/util";
+
+// src/components/ChatThread/registry.tsx
+import React12 from "react";
+import { log } from "@dxos/log";
+import { getXmlTextChild } from "@dxos/ui-editor";
+
+// src/components/ChatThread/tool-widget-state.ts
+var applyToolBlockToWidgetState = (context, block) => {
+  switch (block._tag) {
+    case "toolCall": {
+      context.updateWidget(block.toolCallId, {
+        blocks: [
+          block
+        ]
+      });
+      break;
+    }
+    case "toolResult": {
+      context.updateWidget(block.toolCallId, ({ blocks = [] } = {
+        blocks: []
+      }) => ({
+        blocks: [
+          ...blocks,
+          block
+        ]
+      }));
+      break;
+    }
+    default: {
+      break;
+    }
+  }
+};
+var rehydrateToolWidgetsFromMessages = (context, messages) => {
+  for (const message of messages) {
+    for (const block of message.blocks) {
+      applyToolBlockToWidgetState(context, block);
+    }
+  }
+};
+
+// src/components/ChatThread/widgets/FallbackWidget.tsx
+import React9 from "react";
+import { TogglePanel } from "@dxos/react-ui-components";
+import { JsonHighlighter } from "@dxos/react-ui-syntax-highlighter";
+var FallbackWidget = ({ _tag, ...props }) => {
+  return /* @__PURE__ */ React9.createElement(TogglePanel.Root, null, /* @__PURE__ */ React9.createElement(TogglePanel.Header, {
+    classNames: "bg-group-surface"
+  }, _tag), /* @__PURE__ */ React9.createElement(TogglePanel.Content, {
+    classNames: "bg-modal-surface"
+  }, /* @__PURE__ */ React9.createElement(TogglePanel.Viewport, null, /* @__PURE__ */ React9.createElement(JsonHighlighter, {
+    classNames: "p-2! text-sm",
+    data: props
+  }))));
+};
+FallbackWidget.displayName = "Fallback";
+
+// src/components/ChatThread/widgets/ReasoningWidget.ts
+import { WidgetType } from "@codemirror/view";
+import { Domino } from "@dxos/ui";
+
+// src/components/ChatThread/widgets/defaults.ts
+var styles2 = {
+  padding: "my-4",
+  border: "border border-subdued-separator rounded-sm"
+};
+
+// src/components/ChatThread/widgets/ReasoningWidget.ts
+var ReasoningWidget = class extends WidgetType {
+  text;
+  #pos;
+  /** The timer id last registered for this instance (may differ from the map if superseded). */
+  #ownedTimerId = null;
+  constructor(text, pos) {
+    super(), this.text = text;
+    this.#pos = pos === void 0 || pos === "" ? "reasoning" : String(pos);
+  }
+  eq(other) {
+    return this.text === other.text && this.#pos === other.#pos;
+  }
+  toDOM() {
+    return Domino.of("div").classNames(styles2.padding).append(Domino.of("div").classNames("relative overflow-hidden p-px", styles2.border).attributes({
+      "data-trail-container": ""
+    }).append(Domino.of("div").classNames("relative z-10 bg-base-surface rounded-sm text-sm text-subdued py-1").append(Domino.of("div").classNames("px-2 max-h-[5lh] overflow-y-auto dx-scrollbar-thin").text(this.text).attributes({
+      "data-reasoning-text": ""
+    })), Domino.of("div").attributes({
+      "data-id": this.#pos
+    }))).root;
+  }
+  updateDOM(dom) {
+    dom.querySelector("[data-reasoning-text]")?.replaceChildren(this.text);
+    const container = dom.querySelector("[data-trail-container]");
+    let trailHost = container?.querySelector("[data-id]");
+    if (container && !trailHost) {
+      trailHost = Domino.of("div").attributes({
+        "data-id": this.#pos
+      }).root;
+      container.append(trailHost);
+    }
+    if (trailHost?.childElementCount === 0) {
+      trailHost.append(...createTrailLayers());
+    }
+    this.#scheduleTrailRemoval(dom);
+    return true;
+  }
+  destroy(_dom) {
+    this.#clearOwnedTrailTimer();
+  }
+  #scheduleTrailRemoval(dom) {
+    const previous = trailRemovalTimers.get(this.#pos);
+    if (previous !== void 0) {
+      clearTimeout(previous);
+    }
+    const timerId = setTimeout(() => {
+      if (trailRemovalTimers.get(this.#pos) !== timerId) {
+        return;
+      }
+      trailRemovalTimers.delete(this.#pos);
+      this.#ownedTimerId = null;
+      dom.querySelector("[data-id]")?.remove();
+    }, TRAIL_REMOVAL_DELAY_MS);
+    trailRemovalTimers.set(this.#pos, timerId);
+    this.#ownedTimerId = timerId;
+  }
+  #clearOwnedTrailTimer() {
+    const active = trailRemovalTimers.get(this.#pos);
+    if (active !== void 0 && active === this.#ownedTimerId) {
+      clearTimeout(active);
+      trailRemovalTimers.delete(this.#pos);
+    }
+    this.#ownedTimerId = null;
+  }
+};
+var trail = [
+  "absolute z-0 aspect-[2/1] w-16",
+  "bg-[radial-gradient(at_100%_50%,_theme(colors.green.700),_transparent_80%)]",
+  "[offset-anchor:100%_50%] [offset-path:border-box]"
+];
+var TRAIL_REMOVAL_DELAY_MS = 1e3;
+var trailRemovalTimers = /* @__PURE__ */ new Map();
+var createTrailLayers = () => [
+  Domino.of("div").classNames(...trail, "animate-trail").root,
+  Domino.of("div").classNames(...trail, "animate-trail-offset").root
+];
+
+// src/components/ChatThread/widgets/ReferenceWidget.ts
+import { WidgetType as WidgetType2 } from "@codemirror/view";
+import { Domino as Domino2 } from "@dxos/ui";
+var ReferenceWidget = class extends WidgetType2 {
+  text;
+  dxn;
+  constructor(text, dxn) {
+    super(), this.text = text, this.dxn = dxn;
+  }
+  eq(other) {
+    return this.dxn === other.dxn;
+  }
+  toDOM() {
+    return Domino2.of("div").classNames(styles2.padding).append(Domino2.of("dx-anchor").classNames("dx-tag--anchor").attributes({
+      dxn: this.dxn
+    }).text(this.text)).root;
+  }
+};
+
+// src/components/ChatThread/widgets/SelectWidget.ts
+import { WidgetType as WidgetType3 } from "@codemirror/view";
+import { Domino as Domino3 } from "@dxos/ui";
+var SelectWidget = class extends WidgetType3 {
+  options;
+  constructor(options) {
+    super(), this.options = options;
+  }
+  eq(other) {
+    return JSON.stringify(this.options) === JSON.stringify(other.options);
+  }
+  /**
+  * NOTE: Container must set var based on user's identity.
+  */
+  toDOM() {
+    return Domino3.of("div").attributes({
+      role: "group"
+    }).classNames(styles2.padding, "flex flex-wrap gap-1").append(...this.options.map((option) => Domino3.of("button").classNames("dx-button inline-block max-w-[100cqi]").attributes({
+      "data-action": "submit",
+      "data-value": option,
+      "data-density": "fine"
+    }).text(option))).root;
+  }
+};
+
+// src/components/ChatThread/widgets/StatsWidget.ts
+import { WidgetType as WidgetType4 } from "@codemirror/view";
+import { Domino as Domino4 } from "@dxos/ui";
+var StatsWidget = class extends WidgetType4 {
+  text;
+  constructor(text) {
+    super(), this.text = text;
+  }
+  eq(other) {
+    return this.text === other.text;
+  }
+  toDOM() {
+    return Domino4.of("div").classNames(styles2.padding, "text-sm text-placeholder").text(this.text).root;
+  }
+  updateDOM(dom) {
+    dom.textContent = this.text;
+    return true;
+  }
+};
+
+// src/components/ChatThread/widgets/StatusWidget.ts
+import { WidgetType as WidgetType5 } from "@codemirror/view";
+import { Domino as Domino5 } from "@dxos/ui";
+var StatusWidget = class extends WidgetType5 {
+  text;
+  constructor(text) {
+    super(), this.text = text;
+  }
+  eq(other) {
+    return this.text === other.text;
+  }
+  toDOM() {
+    return Domino5.of("div").classNames(styles2.padding).append(Domino5.of("div").classNames("relative overflow-hidden rounded-sm").append(Domino5.of("div").classNames("grid grid-cols-[24px_1fr] gap-x-0.5 gap-y-0 items-start px-0.5 py-0.5 text-placeholder").append(Domino5.of("div").classNames("flex h-5 w-full shrink-0 items-center justify-center self-start").append(Domino5.of("span").classNames("block size-1.5 shrink-0 rounded-full bg-current opacity-45")), Domino5.of("div").classNames("relative min-w-0").append(Domino5.of("div").classNames("relative z-10 rounded-sm text-sm leading-5").attributes({
+      "data-status-text": ""
+    }).text(this.text))))).root;
+  }
+  updateDOM(dom) {
+    dom.querySelector("[data-status-text]")?.replaceChildren(this.text);
+    return true;
+  }
+};
+
+// src/components/ChatThread/widgets/SummaryWidget.tsx
+import React10 from "react";
+import { useTranslation as useTranslation6 } from "@dxos/react-ui";
+import { TogglePanel as TogglePanel2 } from "@dxos/react-ui-components";
+import { meta as meta6 } from "#meta";
+var SummaryWidget = ({ children }) => {
+  const { t } = useTranslation6(meta6.id);
+  return /* @__PURE__ */ React10.createElement(TogglePanel2.Root, {
+    classNames: styles2.border
+  }, /* @__PURE__ */ React10.createElement(TogglePanel2.Header, {
+    classNames: "text-sm bg-group-surface"
+  }, t("summary.label")), /* @__PURE__ */ React10.createElement(TogglePanel2.Content, null, /* @__PURE__ */ React10.createElement("div", {
+    className: "p-1 text-sm text-subdued"
+  }, children)));
+};
+
+// src/components/ChatThread/widgets/SuggestionWidget.ts
+import { WidgetType as WidgetType6 } from "@codemirror/view";
+import { Domino as Domino6, mx as mx6 } from "@dxos/ui";
+var SuggestionWidget = class extends WidgetType6 {
+  text;
+  constructor(text) {
+    super(), this.text = text;
+  }
+  eq(other) {
+    return this.text === other.text;
+  }
+  toDOM() {
+    return Domino6.of("span").classNames(mx6("inline-flex max-w-[calc(100cqi-8px)] my-1 pe-2 overflow-hidden")).append(Domino6.of("button").attributes({
+      "data-action": "submit",
+      "data-density": "fine",
+      "data-value": this.text
+    }).classNames(mx6("dx-button gap-2 w-full overflow-hidden")).append(Domino6.of("dx-icon").attributes({
+      icon: "ph--lightning--regular"
+    }), Domino6.of("span").classNames("flex-1 truncate min-w-0").text(this.text))).root;
+  }
+};
+
+// src/components/ChatThread/widgets/ToolWidget.tsx
+import React11, { useCallback as useCallback4, useEffect as useEffect4, useMemo as useMemo3, useRef as useRef2, useState as useState5 } from "react";
+import { useTranslation as useTranslation7 } from "@dxos/react-ui";
+import { NumericTabs, TextCrawl, TogglePanel as TogglePanel3 } from "@dxos/react-ui-components";
+import { JsonHighlighter as JsonHighlighter2 } from "@dxos/react-ui-syntax-highlighter";
+import { isNonNullable, safeParseJson } from "@dxos/util";
+import { meta as meta7 } from "#meta";
+var ToolWidget = ({ view, blocks = [] }) => {
+  const { t } = useTranslation7(meta7.id);
+  const items = useMemo3(() => {
+    let lastToolCall;
+    const tools = [];
+    return blocks.filter((block) => block._tag === "toolCall" || block._tag === "toolResult" || block._tag === "stats").map((block) => {
+      switch (block._tag) {
+        case "toolCall": {
+          if (block.pending && lastToolCall?.block.toolCallId === block.toolCallId) {
+            return null;
+          }
+          const tool = tools.find((tool2) => tool2.name === block.name);
+          lastToolCall = {
+            tool,
+            block
+          };
+          return {
+            title: tool?.description ?? [
+              t("tool-call.label"),
+              block.name
+            ].filter(Boolean).join(" "),
+            content: {
+              ...block,
+              input: safeParseJson(block.input)
+            }
+          };
+        }
+        case "toolResult": {
+          if (block.error) {
+            return {
+              title: t("tool-error.label"),
+              content: block
+            };
+          }
+          const title = lastToolCall?.tool?.description ?? [
+            t("tool-result.label"),
+            lastToolCall?.block.name
+          ].filter(Boolean).join(" ");
+          lastToolCall = void 0;
+          return {
+            title,
+            content: {
+              ...block,
+              result: safeParseJson(block.result)
+            }
+          };
+        }
+        case "stats": {
+          if (!lastToolCall) {
+            return null;
+          }
+          return {
+            title: t("stats.label"),
+            content: block
+          };
+        }
+      }
+    }).filter(isNonNullable);
+  }, [
+    blocks,
+    t
+  ]);
+  const handleChangeOpen = useCallback4(() => {
+    setTimeout(() => {
+      view?.requestMeasure();
+    }, 1e3);
+  }, [
+    view
+  ]);
+  if (!items.length) {
+    return null;
+  }
+  return /* @__PURE__ */ React11.createElement(ToolPanel, {
+    items,
+    onChangeOpen: handleChangeOpen
+  });
+};
+var ToolPanel = ({ items, onChangeOpen }) => {
+  const tabsRef = useRef2(null);
+  const [selected, setSelected] = useState5(0);
+  const [open, setOpen] = useState5(false);
+  useEffect4(() => {
+    setSelected((prev) => Math.min(prev, Math.max(0, items.length - 1)));
+  }, [
+    items.length
+  ]);
+  useEffect4(() => {
+    onChangeOpen?.(open);
+    if (open) {
+      tabsRef.current?.focus();
+    }
+  }, [
+    open,
+    onChangeOpen
+  ]);
+  const handleSelect = useCallback4((index) => {
+    setSelected(index);
+  }, []);
+  return /* @__PURE__ */ React11.createElement(TogglePanel3.Root, {
+    open,
+    onChangeOpen: setOpen
+  }, /* @__PURE__ */ React11.createElement(TogglePanel3.Header, {
+    classNames: "text-sm text-placeholder"
+  }, /* @__PURE__ */ React11.createElement(TextCrawl, {
+    key: "status-roll",
+    lines: items.map((item) => item.title),
+    autoAdvance: true,
+    greedy: true
+  })), /* @__PURE__ */ React11.createElement(TogglePanel3.Content, null, /* @__PURE__ */ React11.createElement(TogglePanel3.Viewport, {
+    classNames: "grid grid-cols-[32px_1fr]"
+  }, /* @__PURE__ */ React11.createElement(NumericTabs, {
+    ref: tabsRef,
+    classNames: "p-1",
+    length: items.length,
+    selected,
+    onSelect: handleSelect
+  }), /* @__PURE__ */ React11.createElement(JsonHighlighter2, {
+    data: items[selected]?.content,
+    classNames: "p-1 text-xs bg-transparent",
+    replacer: {
+      maxDepth: 3,
+      maxArrayLen: 10,
+      maxStringLen: 128
+    }
+  }))));
+};
+
+// src/components/ChatThread/registry.tsx
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/components/ChatThread/registry.tsx";
+var componentRegistry = {
+  //
+  // Block-only (no widget — see note above).
+  //
+  prompt: {
+    block: true
+  },
+  //
+  // DOM Widgets
+  //
+  synthetic: {
+    block: true,
+    factory: ({ children, range }) => {
+      const text = getXmlTextChild(children);
+      return text ? new ReasoningWidget(text, range.from) : null;
+    }
+  },
+  reasoning: {
+    block: true,
+    streaming: true,
+    factory: ({ children, range }) => {
+      const text = getXmlTextChild(children);
+      return text ? new ReasoningWidget(text, range.from) : null;
+    }
+  },
+  reference: {
+    block: false,
+    factory: ({ children, ref }) => {
+      const text = getXmlTextChild(children);
+      return text && ref ? new ReferenceWidget(text, ref) : null;
+    }
+  },
+  select: {
+    block: true,
+    factory: ({ children }) => {
+      const options = children?.map((option) => option._tag === "option" && getXmlTextChild(option.children)).filter(Boolean);
+      return options?.length ? new SelectWidget(options) : null;
+    }
+  },
+  suggestion: {
+    block: true,
+    factory: ({ children }) => {
+      const text = getXmlTextChild(children);
+      return text ? new SuggestionWidget(text) : null;
+    }
+  },
+  stats: {
+    block: true,
+    factory: ({ children }) => {
+      const text = getXmlTextChild(children);
+      return text ? new StatsWidget(text) : null;
+    }
+  },
+  status: {
+    block: true,
+    streaming: true,
+    factory: ({ children }) => {
+      const text = getXmlTextChild(children);
+      return text ? new StatusWidget(text) : null;
+    }
+  },
+  //
+  // React Widgets (portaled outside of the editor)
+  //
+  summary: {
+    block: true,
+    Component: SummaryWidget
+  },
+  toolCall: {
+    block: true,
+    Component: (props) => /* @__PURE__ */ React12.createElement("div", {
+      className: "py-2"
+    }, /* @__PURE__ */ React12.createElement(ToolWidget, props))
+  },
+  toolResult: {
+    block: true,
+    Component: FallbackWidget
+  },
+  toolkit: {
+    block: true,
+    Component: FallbackWidget
+  },
+  //
+  // Fallback
+  //
+  json: {
+    block: true,
+    Component: FallbackWidget
+  }
+};
+var blockToMarkdown = createBlockRenderer("normal");
+function createBlockRenderer(viewType) {
+  return (context, message, block) => {
+    if (!isBlockVisible(viewType, message, block)) {
+      return;
+    }
+    let str = blockToMarkdownImpl(context, message, block);
+    if (str && !block.pending) {
+      return str += "\n";
+    }
+    return str;
+  };
+}
+var isBlockVisible = (viewType, message, block) => {
+  switch (viewType) {
+    case "debug":
+      return true;
+    case "normal":
+      return block._tag !== "reasoning";
+    case "summary":
+      return block._tag === "text" && block.disposition !== "synthetic";
+    case "thinking":
+    default:
+      return true;
+  }
+};
+var blockToMarkdownImpl = (context, message, block) => {
+  log("blockToMarkdown", {
+    block: JSON.stringify(block)
+  }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 154, S: void 0 });
+  switch (block._tag) {
+    case "text": {
+      if (message.sender.role === "user") {
+        if (block.disposition === "synthetic") {
+          return renderXMLBlock("synthetic", {
+            content: block.text,
+            pending: block.pending
+          });
+        } else {
+          return `
+<prompt>${block.text}</prompt>`;
+        }
+      } else {
+        const text = block.text.trim();
+        if (text.length > 0) {
+          return text;
+        }
+      }
+      break;
+    }
+    case "reference": {
+      if (block.pending) {
+        return;
+      }
+      const dxn = block.reference.dxn;
+      return `<reference ref="${dxn.toString()}">${context.getObjectLabel(dxn)}</reference>`;
+    }
+    case "suggestion": {
+      if (block.pending) {
+        return;
+      }
+      return `<suggestion>${block.text}</suggestion>`;
+    }
+    case "select": {
+      if (block.pending || block.options.length === 0) {
+        return;
+      }
+      return `<select>${block.options.map((option) => `<option>${option}</option>`).join("")}</select>`;
+    }
+    case "toolCall": {
+      applyToolBlockToWidgetState(context, block);
+      return `<toolCall id="${block.toolCallId}" />`;
+    }
+    case "toolResult": {
+      applyToolBlockToWidgetState(context, block);
+      break;
+    }
+    case "stats": {
+      return "";
+    }
+    case "reasoning": {
+      let text = block.reasoningText ?? block.redactedText;
+      if (!text) {
+        return;
+      }
+      return renderXMLBlock("reasoning", {
+        content: text,
+        pending: block.pending
+      });
+    }
+    case "summary": {
+      return renderXMLBlock("summary", {
+        content: block.content,
+        pending: block.pending
+      });
+    }
+    case "status": {
+      return renderXMLBlock("status", {
+        content: block.statusText,
+        pending: block.pending
+      });
+    }
+    default: {
+      return `<json id="${message.id}">
+${JSON.stringify(block)}
+</json>`;
+    }
+  }
+};
+var escapeXmlTextContent = (raw) => raw.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+var renderXMLBlock = (tag, opts) => {
+  const content = escapeXmlTextContent((opts.content ?? "").replace(/\n\n/g, " ").trim());
+  if (opts.pending) {
+    return `<${tag}${opts.attributes ? ` ${opts.attributes}` : ""}>${content}`;
+  } else {
+    return `<${tag}${opts.attributes ? ` ${opts.attributes}` : ""}>${content}</${tag}>`;
+  }
+};
+
+// src/components/ChatThread/sync.ts
+var MessageThreadContext = class {
+  _widgetState;
+  constructor(_widgetState) {
+    this._widgetState = _widgetState;
+  }
+  updateWidget(id, value2) {
+    this._widgetState?.updateWidget(id, value2);
+  }
+  // TODO(burdon): Resolve name from hypergraph.
+  getObjectLabel(_id) {
+    return "Object";
+  }
+};
+var MessageSyncer = class {
+  _document;
+  _renderer;
+  _threadId;
+  _completed = 0;
+  _trailing = 0;
+  _context;
+  constructor(_document, _renderer) {
+    this._document = _document;
+    this._renderer = _renderer;
+    this._context = new MessageThreadContext(this._document);
+  }
+  get context() {
+    return this._context;
+  }
+  /**
+  * Replace the document with the rendering of `messages`. Use on mount, on thread switch,
+  * and from {@link update} when it detects an identity change in `messages[0]`.
+  */
+  reset(messages = []) {
+    this._threadId = messages[0]?.id;
+    this._completed = 0;
+    this._trailing = 0;
+    const buffer = this._walk(messages);
+    void this._document.setContent(buffer).then(() => {
+      rehydrateToolWidgetsFromMessages(this._context, messages);
+    });
+  }
+  /**
+  * Stream the suffix of the rendered messages into the document.
+  * Returns `true` if the document was replaced (initial mount or thread switch), `false`
+  * if the call was a streaming append (or a no-op).
+  */
+  update(messages) {
+    if (messages[0]?.id !== this._threadId) {
+      this.reset(messages);
+      return true;
+    }
+    const buffer = this._walk(messages);
+    if (buffer.length > 0) {
+      void this._document.append(buffer);
+    }
+    return false;
+  }
+  /**
+  * Walk flat blocks starting at `_completed`, advancing the cursors and returning the chars
+  * to append. Blocks before `_completed` are skipped — their renderer is never re-invoked,
+  * which preserves single-shot side effects (e.g. tool widget state mutation).
+  */
+  _walk(messages) {
+    let buffer = "";
+    let index = 0;
+    outer: for (const message of messages) {
+      for (const block of message.blocks) {
+        if (index < this._completed) {
+          index++;
+          continue;
+        }
+        const rendered = this._renderer(this._context, message, block) ?? "";
+        if (rendered.length > this._trailing) {
+          buffer += rendered.slice(this._trailing);
+        }
+        if (block.pending) {
+          if (rendered.length > this._trailing) {
+            this._trailing = rendered.length;
+          }
+          break outer;
+        }
+        this._completed = index + 1;
+        this._trailing = 0;
+        index++;
+      }
+    }
+    return buffer;
+  }
+};
+
+// src/components/ChatThread/ChatThread.tsx
+var defaultOptions = {
+  autoScroll: true,
+  cursor: false,
+  fader: false,
+  typewriter: true
+};
+var ChatThread = /* @__PURE__ */ forwardRef(({ classNames, identity, messages = [], error, options = defaultOptions, footer, debug = false, extensions, viewType, onEvent }, forwardedRef) => {
+  const [controller, setController] = useState6(null);
+  const handleMarkdownStreamRef = useCallback5((instance) => {
+    setController(instance);
+    setRef(forwardedRef, instance);
+  }, [
+    forwardedRef
+  ]);
+  const userHue = useMemo4(() => identity?.profile?.data?.hue || keyToFallback(identity?.identityKey ?? PublicKey.random()).hue, [
+    identity
+  ]);
+  useEffect5(() => {
+    controller?.scrollToBottom();
+  }, [
+    controller,
+    error
+  ]);
+  const renderer = useMemo4(() => createBlockRenderer(viewType), [
+    viewType
+  ]);
+  const syncer = useMemo4(() => controller && new MessageSyncer(controller, renderer), [
+    controller,
+    renderer
+  ]);
+  useEffect5(() => {
+    if (!syncer) {
+      return;
+    }
+    if (syncer.update(messages)) {
+      controller?.scrollToBottom("instant");
+    }
+  }, [
+    controller,
+    syncer,
+    messages
+  ]);
+  const handleEvent = useCallback5(({ type, value: value2 }) => {
+    switch (type) {
+      case "submit": {
+        value2 && onEvent?.({
+          type,
+          text: value2
+        });
+        break;
+      }
+    }
+  }, [
+    onEvent
+  ]);
+  return /* @__PURE__ */ React13.createElement("div", {
+    "data-hue": userHue,
+    className: "contents"
+  }, /* @__PURE__ */ React13.createElement(MarkdownStream, {
+    key: viewType,
+    classNames,
+    registry: componentRegistry,
+    options,
+    debug,
+    extensions,
+    footer,
+    onEvent: handleEvent,
+    ref: handleMarkdownStreamRef
+  }));
+});
+
+// src/components/TaskList/TaskList.tsx
+import React14 from "react";
+import { useObject as useObject2 } from "@dxos/react-client/echo";
+import { Icon as Icon2, Tag } from "@dxos/react-ui";
+import { Row, RowList } from "@dxos/react-ui-list";
+import { composable, composableProps } from "@dxos/ui-theme";
+var TaskList = composable(({ plan, ...props }, forwardedRef) => {
+  const [snapshot] = useObject2(plan);
+  const tasks = snapshot?.tasks ?? [];
+  return /* @__PURE__ */ React14.createElement(RowList.Root, null, /* @__PURE__ */ React14.createElement(RowList.Viewport, {
+    ...composableProps(props, {
+      classNames: "dx-container"
+    }),
+    ref: forwardedRef
+  }, /* @__PURE__ */ React14.createElement(RowList.Content, {
+    "aria-label": "Tasks"
+  }, tasks.map((task) => /* @__PURE__ */ React14.createElement(Row, {
+    key: task.id,
+    id: task.id,
+    classNames: "py-0"
+  }, /* @__PURE__ */ React14.createElement("div", {
+    className: "flex items-center gap-2"
+  }, /* @__PURE__ */ React14.createElement(Icon2, {
+    icon: task.status === "done" ? "ph--check--regular" : "ph--circle--regular",
+    classNames: task.status === "done" ? "text-success-text" : void 0,
+    size: 4
+  }), /* @__PURE__ */ React14.createElement("span", {
+    className: "sr-only"
+  }, task.status === "done" ? "done" : task.status === "in-progress" ? "in progress" : "to do"), /* @__PURE__ */ React14.createElement("span", {
+    className: "truncate flex-1"
+  }, task.title), task.status === "in-progress" && /* @__PURE__ */ React14.createElement(Tag, {
+    palette: "info"
+  }, "pending")))))));
+});
+
+// src/components/Chat/Chat.tsx
+var ChatRoot = ({ children, chat, feed, processor, onEvent, ...props }) => {
+  const [debug, setDebug] = useState7(false);
+  const streaming = useAtomValue3(processor.streaming);
+  const active = useAtomValue3(processor.active);
+  const requestTiming = useRequestTiming({
+    active
+  });
+  const lastPrompt = useRef3(void 0);
+  const db = props.db ?? (chat && Obj3.getDatabase(chat));
+  const feedMessages = useQuery2(db, feed ? Query.select(Filter2.type(Message2.Message)).from(feed) : Query.select(Filter2.nothing()));
+  const pendingMessages = useAtomValue3(processor.messages);
+  const messages = useMemo5(() => Array.dedupeWith([
+    ...feedMessages,
+    ...pendingMessages
+  ], ({ id: a }, { id: b }) => a === b), [
+    feedMessages,
+    pendingMessages
+  ]);
+  const dump = useDebug({
+    processor
+  });
+  const event = useMemo5(() => new Event(), []);
+  useEffect6(() => {
+    return event.on((ev) => {
+      switch (ev.type) {
+        case "toggle-debug": {
+          setDebug((debug2) => {
+            if (debug2) {
+              return false;
+            } else {
+              void dump();
+              return true;
+            }
+          });
+          break;
+        }
+        case "submit": {
+          const text = ev.text.trim();
+          if (!streaming && text.length) {
+            lastPrompt.current = ev.text;
+            void processor.request({
+              message: text
+            });
+          }
+          break;
+        }
+        case "retry": {
+          if (!streaming) {
+            void processor.retry();
+          }
+          break;
+        }
+        case "cancel": {
+          if (streaming) {
+            void processor.cancel();
+            if (lastPrompt.current) {
+              event.emit({
+                type: "update-prompt",
+                text: lastPrompt.current
+              });
+            }
+          }
+          break;
+        }
+      }
+      onEvent?.(ev);
+    });
+  }, [
+    event,
+    dump,
+    processor,
+    streaming,
+    onEvent
+  ]);
+  return /* @__PURE__ */ React15.createElement(ChatContextProvider, {
+    debug,
+    event,
+    db,
+    chat,
+    messages,
+    processor,
+    requestTiming,
+    ...props
+  }, children);
+};
+ChatRoot.displayName = "Chat.Root";
+var useRequestTiming = ({ active }) => {
+  const [requestTiming, setRequestTiming] = useState7(null);
+  useEffect6(() => {
+    if (active) {
+      setRequestTiming({
+        startedAt: Date.now(),
+        endedAt: null
+      });
+    } else {
+      setRequestTiming((prev) => prev && prev.endedAt == null ? {
+        ...prev,
+        endedAt: Date.now()
+      } : prev);
+    }
+  }, [
+    active
+  ]);
+  return requestTiming;
+};
+var CHAT_TOOLBAR_NAME = "Chat.Toolbar";
+var ChatToolbar = composable2(({ attendableId, companionTo, ...props }, forwardedRef) => {
+  const { chat } = useChatContext(CHAT_TOOLBAR_NAME);
+  const menuActions = useChatToolbarActions({
+    chat,
+    companionTo
+  });
+  return /* @__PURE__ */ React15.createElement(Menu.Root, {
+    ...menuActions,
+    attendableId
+  }, /* @__PURE__ */ React15.createElement(Menu.Toolbar, {
+    ...composableProps2(props),
+    ref: forwardedRef
+  }));
+});
+ChatToolbar.displayName = CHAT_TOOLBAR_NAME;
+var CHAT_CONTENT_NAME = "Chat.Content";
+var ChatContent = composable2(({ children, ...props }, forwardedRef) => {
+  return /* @__PURE__ */ React15.createElement("div", {
+    ...composableProps2(props, {
+      classNames: "dx-expander flex flex-col"
+    }),
+    ref: forwardedRef
+  }, children);
+});
+ChatContent.displayName = CHAT_CONTENT_NAME;
+var CHAT_THREAD_NAME = "Chat.Thread";
+var ChatThread2 = ({ viewType, debug: debugProp, ...props }) => {
+  const { debug, event, messages, processor } = useChatContext(CHAT_THREAD_NAME);
+  const debugView = viewType === "debug";
+  const identity = useIdentity();
+  const error = useAtomValue3(processor.error).pipe(Option4.getOrUndefined);
+  const extensions = useChatKeymapExtensions2({
+    event
+  });
+  const controllerRef = useRef3(null);
+  useEffect6(() => {
+    return event.on((event2) => {
+      switch (event2.type) {
+        case "submit":
+        case "scroll-to-bottom":
+          controllerRef.current?.scrollToBottom();
+          break;
+        case "nav-previous":
+          controllerRef.current?.navigatePrevious();
+          break;
+        case "nav-next":
+          controllerRef.current?.navigateNext();
+          break;
+      }
+    });
+  }, [
+    event
+  ]);
+  const handleEvent = useCallback6((ev) => {
+    event.emit(ev);
+  }, [
+    event
+  ]);
+  if (!identity) {
+    return /* @__PURE__ */ React15.createElement("div", {
+      className: "dx-expander"
+    });
+  }
+  return /* @__PURE__ */ React15.createElement(ChatThread, {
+    ...props,
+    identity,
+    messages,
+    error,
+    debug: debugProp ?? (debug || debugView),
+    viewType,
+    extensions,
+    onEvent: handleEvent,
+    ref: controllerRef
+  });
+};
+ChatThread2.displayName = CHAT_THREAD_NAME;
+var CHAT_PROMPT_NAME = "Chat.Prompt";
+var ChatPrompt2 = (props) => {
+  const { chat, db, processor, event } = useChatContext(CHAT_PROMPT_NAME);
+  return /* @__PURE__ */ React15.createElement(ChatPrompt, {
+    ...props,
+    chat,
+    db,
+    processor,
+    event
+  });
+};
+ChatPrompt2.displayName = CHAT_PROMPT_NAME;
+var CHAT_TASK_LIST_NAME = "Chat.TaskList";
+var ChatTaskList = composable2(({ plan: planProp, ...props }, forwardedRef) => {
+  const { chat } = useChatContext(CHAT_TASK_LIST_NAME);
+  const parent = chat ? Obj3.getParent(chat) : void 0;
+  const agent = parent && Obj3.instanceOf(Agent.Agent, parent) ? parent : void 0;
+  const plan = planProp ?? agent?.plan.target;
+  if (!plan) {
+    return null;
+  }
+  return /* @__PURE__ */ React15.createElement(TaskList, {
+    ...props,
+    plan,
+    ref: forwardedRef
+  });
+});
+ChatTaskList.displayName = CHAT_TASK_LIST_NAME;
+var Chat = {
+  Root: ChatRoot,
+  Toolbar: ChatToolbar,
+  Content: ChatContent,
+  Prompt: ChatPrompt2,
+  Status: ChatStatus,
+  Thread: ChatThread2,
+  TaskList: ChatTaskList
+};
+
+// src/components/ProcessTree/ProcessTree.tsx
+import * as Match from "effect/Match";
+import * as Option5 from "effect/Option";
+import React16 from "react";
+import { Process } from "@dxos/functions-runtime";
+import { Icon as Icon3, IconButton as IconButton4, ScrollArea, Tooltip as Tooltip2, Treegrid } from "@dxos/react-ui";
+import { composable as composable3, composableProps as composableProps3, mx as mx7 } from "@dxos/ui-theme";
+import { Unit as Unit2 } from "@dxos/util";
+var ProcessTree = composable3(({ processes, onProcessSelect, onProcessTerminate, ...props }, forwardedRef) => {
+  const sortedProcesses = [
+    ...processes.filter((process) => [
+      Process.State.RUNNING,
+      Process.State.HYBERNATING
+    ].includes(process.state)),
+    ...processes.filter((process) => [
+      Process.State.IDLE
+    ].includes(process.state)).slice(0, 3),
+    ...processes.filter((process) => [
+      Process.State.SUCCEEDED,
+      Process.State.FAILED,
+      Process.State.TERMINATED
+    ].includes(process.state))
+  ].sort((a, b) => {
+    const aCompletedAt = Option5.getOrElse(a.completedAt, () => Infinity);
+    const bCompletedAt = Option5.getOrElse(b.completedAt, () => Infinity);
+    return bCompletedAt - aCompletedAt;
+  });
+  return /* @__PURE__ */ React16.createElement(ScrollArea.Root, {
+    ...composableProps3(props, {
+      classNames: "dx-expander"
+    }),
+    thin: true,
+    ref: forwardedRef
+  }, /* @__PURE__ */ React16.createElement(ScrollArea.Viewport, null, /* @__PURE__ */ React16.createElement(Treegrid.Root, {
+    gridTemplateColumns: "1fr"
+  }, sortedProcesses.filter((process) => process.parentPid === null).map((process) => {
+    return /* @__PURE__ */ React16.createElement(Treegrid.Row, {
+      key: process.pid.toString(),
+      id: process.pid.toString(),
+      parentOf: process.parentPid?.toString()
+    }, /* @__PURE__ */ React16.createElement(Treegrid.Cell, {
+      indent: true,
+      classNames: mx7("grid grid-cols-[min-content_1fr_min-content_min-content] items-center gap-1 min-w-0", onProcessSelect && "dx-hover"),
+      onClick: () => onProcessSelect?.(process)
+    }, /* @__PURE__ */ React16.createElement(Tooltip2.Trigger, {
+      className: "p-1",
+      content: process.state.toString()
+    }, /* @__PURE__ */ React16.createElement(Icon3, {
+      size: 4,
+      synchronized: true,
+      classNames: mx7(process.state === Process.State.RUNNING && "animate-spin", process.state === Process.State.FAILED && "text-error-text", process.state === Process.State.SUCCEEDED && "text-success-text"),
+      icon: Match.value(process.state).pipe(Match.when(Process.State.RUNNING, () => "ph--spinner-gap--regular"), Match.when(Process.State.SUCCEEDED, () => "ph--check-circle--regular"), Match.when(Process.State.FAILED, () => "ph--warning--regular"), Match.when(Process.State.HYBERNATING, () => "ph--spinner--regular"), Match.when(Process.State.IDLE, () => "ph--hourglass--regular"), Match.when(Process.State.TERMINATING, () => "ph--x-circle--regular"), Match.when(Process.State.TERMINATED, () => "ph--x-circle--regular"), Match.orElse(() => "ph--spinner-gap--regular"))
+    })), /* @__PURE__ */ React16.createElement("div", {
+      className: "flex items-center gap-2 text-xs overflow-hidden"
+    }, /* @__PURE__ */ React16.createElement("span", {
+      className: "truncate text-description select-none"
+    }, process.params.name ?? process.pid.toString())), [
+      Process.State.FAILED,
+      Process.State.SUCCEEDED
+    ].includes(process.state) && /* @__PURE__ */ React16.createElement("div", {
+      className: "text-xs text-description tabular-nums"
+    }, Unit2.Millisecond(process.metrics.wallTime).toString()) || /* @__PURE__ */ React16.createElement("div", null), onProcessTerminate && /* @__PURE__ */ React16.createElement(IconButton4, {
+      classNames: "min-h-0 p-1",
+      icon: "ph--x--regular",
+      iconOnly: true,
+      variant: "ghost",
+      size: 4,
+      label: "Actions",
+      onClick: (event) => {
+        event.stopPropagation();
+        onProcessTerminate?.(process);
+      }
+    })));
+  }))));
+});
+
+// src/components/TemplateEditor/TemplateEditor.tsx
+import { defaultHighlightStyle, syntaxHighlighting } from "@codemirror/language";
+import { composeRefs } from "@radix-ui/react-compose-refs";
+import React17 from "react";
+import { createDocAccessor } from "@dxos/echo-db";
+import { useThemeContext, useTranslation as useTranslation8 } from "@dxos/react-ui";
+import { useTextEditor } from "@dxos/react-ui-editor";
+import { createBasicExtensions, createDataExtensions, createMarkdownExtensions, createThemeExtensions, decorateMarkdown } from "@dxos/ui-editor";
+import { composable as composable4, composableProps as composableProps4 } from "@dxos/ui-theme";
+import { isNonNullable as isNonNullable2 } from "@dxos/util";
+import { meta as meta8 } from "#meta";
+
+// src/components/TemplateEditor/extensions/handlebars-extension.ts
+import { autocompletion, completionKeymap } from "@codemirror/autocomplete";
+import { RangeSetBuilder } from "@codemirror/state";
+import { Decoration, ViewPlugin, WidgetType as WidgetType7, keymap } from "@codemirror/view";
+import { Domino as Domino7, mx as mx8 } from "@dxos/ui";
+var handlebars = (_ = {}) => {
+  return [
+    handlebarsHighlightPlugin,
+    autocompletion({
+      activateOnTyping: true,
+      aboveCursor: true,
+      closeOnBlur: true,
+      override: [
+        handlebarsCompletions
+      ]
+    }),
+    keymap.of(completionKeymap)
+  ];
+};
+var regex = {
+  // {{! comment }}
+  comment: /\{\{!\s*[^}]*\}\}/g,
+  // {{var}}
+  brackets: /\{\{[^}]*\}\}/g,
+  // {{#command}} {{/command}}
+  command: /\{\{[#/]([^}]+)\}\}/g,
+  // {{var}}
+  var: /\{\{(?!\s*!)(\w[^}]*)\}\}/g,
+  // @dxn:queue:data:xxx
+  dxn: /@?dxn:[\w@:]+/g,
+  // example.com/path/xxx
+  url: /[\w.-]+\.[\w.-]+\/[\w/]+/g
+};
+var tagPadding = "mx-0.5 px-1 rounded-xs";
+var handlebarsHighlightPlugin = ViewPlugin.fromClass(class {
+  decorations;
+  constructor(view) {
+    this.decorations = this.buildDecorations(view);
+  }
+  update(update) {
+    if (update.docChanged || update.viewportChanged || update.selectionSet) {
+      this.decorations = this.buildDecorations(update.view);
+    }
+  }
+  // NOTE: Decorations may clash with other extensions (e.g., markdown).
+  buildDecorations(view) {
+    const selection = view.state.selection.main;
+    const decorations = [];
+    for (const { from, to } of view.visibleRanges) {
+      const text = view.state.doc.sliceString(from, to);
+      {
+        let match;
+        while ((match = regex.dxn.exec(text)) !== null) {
+          const start = from + match.index;
+          const end = start + match[0].length;
+          const overlaps = selection.to > start && selection.from <= end;
+          if (!overlaps) {
+            decorations.push({
+              from: start,
+              to: end,
+              decoration: Decoration.widget({
+                widget: new DXNWidget(match[0])
+              })
+            });
+          }
+        }
+      }
+      {
+        let match;
+        while ((match = regex.url.exec(text)) !== null) {
+          const start = from + match.index;
+          const end = start + match[0].length;
+          decorations.push({
+            from: start,
+            to: end,
+            decoration: Decoration.mark({
+              class: mx8("dx-tag--blue", tagPadding)
+            })
+          });
+        }
+      }
+      {
+        let match;
+        while ((match = regex.brackets.exec(text)) !== null) {
+          const start = from + match.index;
+          const end = start + match[0].length;
+          decorations.push({
+            from: start,
+            to: end,
+            decoration: Decoration.mark({
+              class: "text-subdued"
+            })
+          });
+        }
+      }
+      {
+        let match;
+        while ((match = regex.command.exec(text)) !== null) {
+          const start = from + match.index + 2;
+          let end = start + match[0].length - 4;
+          const text2 = view.state.doc.sliceString(start, end);
+          const parts = text2.split(/\s+/);
+          if (parts.length > 1) {
+            const idx = start + parts[0].length;
+            decorations.push({
+              from: idx,
+              to: end,
+              decoration: Decoration.mark({
+                class: "text-green-text"
+              })
+            });
+            end = idx;
+          }
+          decorations.push({
+            from: start,
+            to: end,
+            decoration: Decoration.mark({
+              class: "text-blue-text"
+            })
+          });
+        }
+      }
+      {
+        let match;
+        while ((match = regex.var.exec(text)) !== null) {
+          const start = from + match.index + 2;
+          const end = start + match[0].length - 4;
+          decorations.push({
+            from: start,
+            to: end,
+            decoration: Decoration.mark({
+              class: "text-green-text"
+            })
+          });
+        }
+      }
+    }
+    decorations.sort((a, b) => a.from - b.from || a.to - b.to);
+    const builder = new RangeSetBuilder();
+    for (const { from, to, decoration } of decorations) {
+      builder.add(from, to, decoration);
+    }
+    return builder.finish();
+  }
+}, {
+  decorations: (v) => v.decorations
+});
+var DXNWidget = class extends WidgetType7 {
+  _identifier;
+  constructor(_identifier) {
+    super(), this._identifier = _identifier;
+  }
+  ignoreEvent() {
+    return false;
+  }
+  eq(other) {
+    return this._identifier === other._identifier;
+  }
+  toDOM() {
+    const text = this._identifier.split(":").map((part) => {
+      const len = 16;
+      const plen = 4;
+      if (part.length > len) {
+        return `[${part.slice(0, plen)}\u2026${part.slice(-plen)}]`;
+      }
+      return part;
+    }).join(":");
+    return Domino7.of("span").classNames(mx8("font-mono dx-tag--blue", tagPadding)).text(text).root;
+  }
+};
+var variables = [
+  "this"
+];
+var commands = [
+  "this",
+  "each",
+  "if",
+  "unless",
+  "with"
+];
+function handlebarsCompletions(context) {
+  const match = context.matchBefore(/\{\{[^}]*/);
+  if (!match || match.from === match.to) {
+    return null;
+  }
+  let type = "variable";
+  let text = match.text.slice(2);
+  let from = match.from + 2;
+  let matches = [];
+  if (text.startsWith("#") || text.startsWith("/")) {
+    const idx = text.lastIndexOf(" ");
+    if (idx !== -1) {
+      type = "variable";
+      matches = variables;
+      text = text.slice(idx + 1);
+      from += idx + 1;
+    } else {
+      type = "command";
+      text = text.slice(1);
+      matches = commands;
+      from += 1;
+    }
+  } else {
+    type = "variable";
+    matches = variables;
+  }
+  const options = matches.filter((name) => name.startsWith(text)).map((name) => ({
+    type,
+    label: name
+  }));
+  return {
+    from,
+    options
+  };
+}
+
+// src/components/TemplateEditor/extensions/xml-extension.ts
+import { syntaxTree } from "@codemirror/language";
+import { RangeSetBuilder as RangeSetBuilder2 } from "@codemirror/state";
+import { Decoration as Decoration2, ViewPlugin as ViewPlugin2 } from "@codemirror/view";
+var xmlDecorator = (_ = {}) => {
+  return [
+    xmlDecoratorPlugin
+  ];
+};
+var xmlDecoratorPlugin = ViewPlugin2.fromClass(class {
+  decorations;
+  constructor(view) {
+    this.decorations = this.buildDecorations(view);
+  }
+  update(update) {
+    if (update.docChanged || update.viewportChanged) {
+      this.decorations = this.buildDecorations(update.view);
+    }
+  }
+  buildDecorations(view) {
+    const builder = new RangeSetBuilder2();
+    for (const { from, to } of view.visibleRanges) {
+      syntaxTree(view.state).iterate({
+        from,
+        to,
+        enter: (node) => {
+          if (node.name === "HTMLTag" || node.name === "OpenTag" || node.name === "CloseTag" || node.name === "SelfClosingTag" || node.name === "Element") {
+            builder.add(node.from, node.to, Decoration2.mark({
+              class: "font-mono text-subdued"
+            }));
+          }
+        }
+      });
+    }
+    return builder.finish();
+  }
+}, {
+  decorations: (v) => v.decorations
+});
+
+// src/components/TemplateEditor/TemplateEditor.tsx
+var TemplateEditor = composable4(({ classNames, id, template, lineNumbers = true, ...props }, forwardedRef) => {
+  const { t } = useTranslation8(meta8.id);
+  const { themeMode } = useThemeContext();
+  const { parentRef } = useTextEditor(() => {
+    const target = template.source?.target;
+    if (!target) {
+      return {};
+    }
+    return {
+      initialValue: target.content ?? "",
+      extensions: [
+        createDataExtensions({
+          id,
+          text: createDocAccessor(target, [
+            "content"
+          ])
+        }),
+        createBasicExtensions({
+          bracketMatching: false,
+          lineNumbers,
+          lineWrapping: true,
+          placeholder: t("template.placeholder")
+        }),
+        createThemeExtensions({
+          themeMode
+        }),
+        createMarkdownExtensions(),
+        decorateMarkdown(),
+        handlebars(),
+        // xml(),
+        // NOTE: Since we're using markdown only HTML nodes are parsed.
+        xmlDecorator(),
+        syntaxHighlighting(defaultHighlightStyle)
+      ].filter(isNonNullable2)
+    };
+  }, [
+    themeMode,
+    template.source?.target,
+    lineNumbers
+  ]);
+  return /* @__PURE__ */ React17.createElement("div", {
+    ...composableProps4(props, {
+      role: "none",
+      classNames: [
+        "h-full overflow-hidden",
+        classNames
+      ]
+    }),
+    ref: composeRefs(parentRef, forwardedRef)
+  });
+});
+
+// src/components/Toolbox/Toolbox.tsx
+import React18, { Fragment, useEffect as useEffect7, useState as useState8 } from "react";
+import { Operation } from "@dxos/compute";
+import { Filter as Filter3 } from "@dxos/echo";
+import { log as log2 } from "@dxos/log";
+import { useQuery as useQuery3 } from "@dxos/react-client/echo";
+import { ScrollArea as ScrollArea2 } from "@dxos/react-ui";
+import { composable as composable5, composableProps as composableProps5, mx as mx9 } from "@dxos/ui-theme";
+import { ServiceType } from "#types";
+var __dxlog_file2 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/components/Toolbox/Toolbox.tsx";
+var Toolbox = composable5(({ functions, services, blueprints, activeBlueprints, ...props }, forwardedRef) => {
+  return /* @__PURE__ */ React18.createElement(ScrollArea2.Root, {
+    ...composableProps5(props),
+    thin: true,
+    orientation: "vertical",
+    ref: forwardedRef
+  }, /* @__PURE__ */ React18.createElement(ScrollArea2.Viewport, null, blueprints && blueprints.length > 0 && /* @__PURE__ */ React18.createElement(Section, {
+    title: "Blueprints",
+    items: blueprints.map(({ name, description, tools }) => ({
+      name,
+      description,
+      subitems: tools.map((toolId) => ({
+        name: `\u2219 ${safeToolId(toolId)}`
+      }))
+    }))
+  }), activeBlueprints && activeBlueprints.length > 0 && /* @__PURE__ */ React18.createElement(Section, {
+    title: "Blueprints",
+    items: activeBlueprints.map(({ target }) => ({
+      name: target?.name ?? "",
+      description: target?.description ?? "",
+      subitems: target?.tools.map((toolId) => ({
+        name: `\u2219 ${safeToolId(toolId)}`
+      }))
+    }))
+  }), services && services.length > 0 && /* @__PURE__ */ React18.createElement(Section, {
+    title: "Services",
+    items: services.map(({ service: { serviceId, name, description } }) => ({
+      name: name ?? serviceId,
+      description
+    }))
+  }), functions && functions.length > 0 && /* @__PURE__ */ React18.createElement(Section, {
+    title: "Functions",
+    items: functions.map(({ name, description }) => ({
+      name,
+      description
+    }))
+  })));
+});
+Toolbox.displayName = "Toolbox";
+var Section = ({ title, items, striped }) => {
+  const stripeClassNames = "odd:bg-neutral-50 dark:odd:bg-neutral-800";
+  const gridClassNames = "grid grid-cols-[8rem_1fr]";
+  const subGridClassNames = mx9("col-span-full grid grid-cols-subgrid text-xs px-2", striped && stripeClassNames);
+  return /* @__PURE__ */ React18.createElement("div", null, /* @__PURE__ */ React18.createElement("h1", {
+    className: "px-2 text-sm"
+  }, title), /* @__PURE__ */ React18.createElement("div", {
+    className: gridClassNames
+  }, items.map(({ name, description, subitems }, i) => /* @__PURE__ */ React18.createElement(Fragment, {
+    key: i
+  }, name && /* @__PURE__ */ React18.createElement("div", {
+    className: subGridClassNames
+  }, /* @__PURE__ */ React18.createElement("div", {
+    className: "truncate text-primary-500"
+  }, name), /* @__PURE__ */ React18.createElement("div", {
+    className: "line-clamp-2"
+  }, description)), subitems?.map(({ name: name2, description: description2 }, i2) => /* @__PURE__ */ React18.createElement("div", {
+    key: i2,
+    className: mx9(subGridClassNames, striped && stripeClassNames)
+  }, /* @__PURE__ */ React18.createElement("div", {
+    className: "truncate"
+  }, name2), /* @__PURE__ */ React18.createElement("div", {
+    className: "line-clamp-3 text-subdued"
+  }, description2)))))));
+};
+var ToolboxPanel = ({ classNames, db, processor }) => {
+  const services = useQuery3(db, Filter3.type(ServiceType));
+  const [serviceTools, setServiceTools] = useState8([]);
+  useEffect7(() => {
+    log2("creating service tools...", {
+      services: services.length
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 81, S: void 0 });
+    queueMicrotask(async () => {
+    });
+  }, [
+    services
+  ]);
+  const functions = useQuery3(db, Filter3.type(Operation.PersistentOperation));
+  return /* @__PURE__ */ React18.createElement(Toolbox, {
+    classNames,
+    blueprints: processor?.context.getBlueprints(),
+    services: serviceTools,
+    functions
+  });
+};
+var safeToolId = (name) => {
+  return name.split("_").pop();
+};
+
+// src/components/index.ts
+var AssistantSettings = lazy(() => import("../AssistantSettings-GG52BLKS.mjs"));
+export {
+  AssistantSettings,
+  Chat,
+  ProcessTree,
+  TaskList,
+  TemplateEditor,
+  Toolbox,
+  ToolboxPanel,
+  useChatContext
+};
+//# sourceMappingURL=index.mjs.map