@dxos/plugin-assistant 0.8.4-main.937b3ca → 0.8.4-main.9be5663bfe

package/dist/lib/node-esm/index.mjs

@@ -1,354 +1,3272 @@
 import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
 import {
-  AssistantSettings,
-  BlueprintArticle,
-  Chat,
-  ChatCompanion,
-  ChatContainer,
-  ChatContextProvider,
-  ChatDialog,
-  PromptArticle,
-  Toolbox,
-  ToolboxContainer,
-  useActiveBlueprints,
-  useBlueprintHandlers,
-  useBlueprintRegistry,
-  useBlueprints,
-  useChatContext,
-  useChatProcessor,
-  useChatServices,
-  useChatToolbarActions,
-  useContextBinder,
-  useContextObjects,
-  useFilteredTypes,
-  useFlush,
-  useOnline,
-  usePresets,
-  useReferencesProvider
-} from "./chunk-4BERCIES.mjs";
-import "./chunk-ZRIPP7YF.mjs";
-import {
-  TemplateEditor
-} from "./chunk-75PHXBN3.mjs";
+  blueprint_default
+} from "./chunk-NZIKC7AN.mjs";
 import {
   ApiAuthorization,
   AssistantCapabilities,
   AssistantEvents,
-  AssistantOperation,
   Assistant_exports,
   LLM_PROVIDERS,
   ServiceType,
   categoryIcons
-} from "./chunk-355W5B27.mjs";
-import {
-  ASSISTANT_DIALOG,
-  meta
-} from "./chunk-POWB2BPC.mjs";
-import "./chunk-MSBPC4RJ.mjs";
+} from "./chunk-PY4X6FJT.mjs";
 import {
-  assistant_blueprint_exports
-} from "./chunk-DCA5QWQT.mjs";
+  UpdateChatName
+} from "./chunk-PXAJSTGZ.mjs";
 import "./chunk-HSLMI22Q.mjs";
 
-// src/capabilities/ai-service/index.ts
-import { Capability } from "@dxos/app-framework";
-var AiService = Capability.lazy("AiService", () => import("./ai-service-PXKKCFIF.mjs"));
+// src/components/index.ts
+import { lazy } from "react";
+
+// src/components/Chat/Chat.tsx
+import { Prec } from "@codemirror/state";
+import { keymap } from "@codemirror/view";
+import { useAtomValue } from "@effect-atom/atom-react";
+import { createContext } from "@radix-ui/react-context";
+import * as Array2 from "effect/Array";
+import * as Option3 from "effect/Option";
+import React11, { useCallback as useCallback3, useEffect as useEffect4, useMemo as useMemo4, useRef as useRef2, useState as useState5 } from "react";
+import { Event } from "@dxos/async";
+import { Filter as Filter2, Obj as Obj3 } from "@dxos/echo";
+import { useVoiceInput } from "@dxos/plugin-transcription";
+import { useQuery as useQuery2 } from "@dxos/react-client/echo";
+import { useIdentity } from "@dxos/react-client/halo";
+import { Input, useDynamicRef, useTranslation as useTranslation6 } from "@dxos/react-ui";
+import { ChatEditor } from "@dxos/react-ui-chat";
+import { Menu } from "@dxos/react-ui-menu";
+import { Message } from "@dxos/types";
+import { composable, composableProps, mx as mx7 } from "@dxos/ui-theme";
+import { isTruthy, trim } from "@dxos/util";
+import { useChatToolbarActions } from "#hooks";
+import { meta as meta6 } from "#meta";
+
+// 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 me-1", classNames)
+  }, children, /* @__PURE__ */ React.createElement(IconButton, {
+    disabled: !processing,
+    variant: "ghost",
+    icon: "ph--x--regular",
+    iconOnly: true,
+    label: t("cancel-processing.button"),
+    onClick: () => onEvent?.({
+      type: "cancel"
+    })
+  }), 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"
+    })
+  }));
+};
+
+// src/components/ChatPrompt/ChatOptions.tsx
+import * as Option from "effect/Option";
+import React2, { useMemo, useState } from "react";
+import { Filter, Obj, Type } from "@dxos/echo";
+import { Annotation } from "@dxos/echo";
+import { useQuery } from "@dxos/react-client/echo";
+import { IconButton as IconButton2, Popover, Select, useTranslation as useTranslation2 } from "@dxos/react-ui";
+import { Listbox, 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 meta2 } from "#meta";
+var panelClassNames = "w-[calc(100dvw-.5rem)] sm:w-max md:w-72 max-w-document-width";
+var ChatOptions = ({ db, context, blueprintRegistry, presets, preset, onPresetChange }) => {
+  const { t } = useTranslation2(meta2.id);
+  return /* @__PURE__ */ React2.createElement("div", {
+    role: "none",
+    className: "flex p-2"
+  }, /* @__PURE__ */ React2.createElement(Popover.Root, null, /* @__PURE__ */ React2.createElement(Popover.Trigger, {
+    asChild: true
+  }, /* @__PURE__ */ React2.createElement(IconButton2, {
+    variant: "ghost",
+    icon: "ph--plus--regular",
+    iconOnly: true,
+    label: t("context-objects.button")
+  })), /* @__PURE__ */ React2.createElement(Popover.Portal, null, /* @__PURE__ */ React2.createElement(Popover.Content, {
+    side: "top",
+    classNames: panelClassNames
+  }, /* @__PURE__ */ React2.createElement(Popover.Viewport, null, /* @__PURE__ */ React2.createElement(ObjectsPanel, {
+    db,
+    context
+  })), /* @__PURE__ */ React2.createElement(Popover.Arrow, null)))), /* @__PURE__ */ React2.createElement(Popover.Root, null, /* @__PURE__ */ React2.createElement(Popover.Trigger, {
+    asChild: true
+  }, /* @__PURE__ */ React2.createElement(IconButton2, {
+    variant: "ghost",
+    icon: "ph--sliders-horizontal--regular",
+    iconOnly: true,
+    label: t("context-settings.button")
+  })), /* @__PURE__ */ React2.createElement(Popover.Portal, null, /* @__PURE__ */ React2.createElement(Popover.Content, {
+    side: "top",
+    classNames: panelClassNames
+  }, /* @__PURE__ */ React2.createElement(Popover.Viewport, null, /* @__PURE__ */ React2.createElement(Tabs.Root, {
+    orientation: "horizontal",
+    defaultValue: "blueprints",
+    defaultActivePart: "list",
+    tabIndex: -1
+  }, /* @__PURE__ */ React2.createElement(Tabs.Viewport, {
+    classNames: mx2("max-h-(--radix-popover-content-available-height) grid grid-rows-[1fr_min-content]", '[&_[cmdk-root]]:contents [&_[role="tabpanel"]]:grid [&_[role="tabpanel"]]:grid-rows-[1fr_min-content]', '[&_[role="listbox"]]:min-h-0 [&_[role="listbox"]]:overflow-y-auto', '[&_[role="tabpanel"]]:min-h-0 [&_[role="tabpanel"]]:px-form-chrome [&_[role="tabpanel"][data-state="active"]]:order-first [&_[role="tabpanel"][data-state="inactive"]]:hidden')
+  }, /* @__PURE__ */ React2.createElement(Tabs.Panel, {
+    value: "blueprints",
+    tabIndex: -1,
+    classNames: "dx-focus-ring-inset"
+  }, /* @__PURE__ */ React2.createElement(BlueprintsPanel, {
+    blueprintRegistry,
+    db,
+    context
+  })), /* @__PURE__ */ React2.createElement(Tabs.Panel, {
+    value: "model",
+    tabIndex: -1,
+    classNames: "dx-focus-ring-inset px-0!"
+  }, /* @__PURE__ */ React2.createElement(ModelsPanel, {
+    presets,
+    preset,
+    onPresetChange
+  })), /* @__PURE__ */ React2.createElement(Tabs.Tablist, {
+    classNames: "justify-center p-form-chrome border-y border-subdued-separator order-last"
+  }, /* @__PURE__ */ React2.createElement(Tabs.IconTab, {
+    value: "blueprints",
+    icon: "ph--blueprint--regular",
+    label: t("blueprints-in-context.title")
+  }), /* @__PURE__ */ React2.createElement(Tabs.IconTab, {
+    value: "model",
+    label: t("chat-model.title"),
+    icon: "ph--cpu--regular"
+  }))))), /* @__PURE__ */ React2.createElement(Popover.Arrow, null)))));
+};
+var BlueprintsPanel = ({ blueprintRegistry, db, context }) => {
+  const { t } = useTranslation2(meta2.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__ */ React2.createElement(SearchList.Root, {
+    onSearch: handleSearch
+  }, /* @__PURE__ */ React2.createElement(SearchList.Content, {
+    classNames: "py-form-chrome"
+  }, /* @__PURE__ */ React2.createElement(SearchList.Viewport, null, results.map((blueprint) => {
+    const isActive = activeBlueprints.has(blueprint.key);
+    return /* @__PURE__ */ React2.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__ */ React2.createElement(SearchList.Input, {
+    placeholder: t("search.placeholder"),
+    classNames: "mb-form-chrome",
+    autoFocus: true
+  }));
+};
+var ModelsPanel = ({ presets, preset, onPresetChange }) => {
+  return /* @__PURE__ */ React2.createElement(Listbox.Root, {
+    value: preset,
+    onValueChange: onPresetChange,
+    autoFocus: true
+  }, presets?.map(({ id, label }) => {
+    return /* @__PURE__ */ React2.createElement(Listbox.Option, {
+      key: id,
+      value: id
+    }, /* @__PURE__ */ React2.createElement(Listbox.OptionLabel, null, label), /* @__PURE__ */ React2.createElement(Listbox.OptionIndicator, null));
+  }));
+};
+var ANY = "__any__";
+var ObjectsPanel = ({ db, context }) => {
+  const { t } = useTranslation2(meta2.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__ */ React2.createElement(SearchList.Root, {
+    onSearch: handleSearch
+  }, /* @__PURE__ */ React2.createElement(SearchList.Content, {
+    classNames: "p-form-chrome [&:has([cmdk-list-sizer]:empty)]:py-0"
+  }, /* @__PURE__ */ React2.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: DEFAULT_OBJECT_ICON,
+      hue: void 0
+    })));
+    const styles = hue ? getStyles(hue) : void 0;
+    return /* @__PURE__ */ React2.createElement(SearchList.Item, {
+      classNames: "flex items-center overflow-hidden",
+      key: object.id,
+      value: object.id,
+      icon,
+      iconClassNames: styles?.surfaceText,
+      label: Obj.getLabel(object) ?? Obj.getTypename(object) ?? object.id,
+      checked: isActive,
+      onSelect: () => onUpdateObject?.(Obj.getDXN(object), !isActive)
+    });
+  }) : /* @__PURE__ */ React2.createElement(SearchList.Item, {
+    value: "__empty__",
+    label: t("no-results.message")
+  }))), /* @__PURE__ */ React2.createElement("div", {
+    role: "none",
+    className: "grid grid-cols-[min-content_1fr] gap-2 px-form-chrome mb-form-chrome"
+  }, /* @__PURE__ */ React2.createElement(Select.Root, {
+    value: typename === ANY ? void 0 : typename,
+    onValueChange: setTypename
+  }, /* @__PURE__ */ React2.createElement(Select.TriggerButton, {
+    placeholder: t("type-filter.placeholder")
+  }), /* @__PURE__ */ React2.createElement(Select.Portal, null, /* @__PURE__ */ React2.createElement(Select.Content, null, /* @__PURE__ */ React2.createElement(Select.ScrollUpButton, null), /* @__PURE__ */ React2.createElement(Select.Viewport, null, /* @__PURE__ */ React2.createElement(Select.Option, {
+    value: ANY
+  }, t("any-type-filter.label")), typenames.map(({ typename: typename2, label }) => /* @__PURE__ */ React2.createElement(Select.Option, {
+    key: typename2,
+    value: typename2
+  }, label))), /* @__PURE__ */ React2.createElement(Select.ScrollDownButton, null), /* @__PURE__ */ React2.createElement(Select.Arrow, null)))), /* @__PURE__ */ React2.createElement(SearchList.Input, {
+    placeholder: t("search.placeholder"),
+    classNames: "mb-0",
+    autoFocus: true
+  })));
+};
+var DEFAULT_OBJECT_ICON = "ph--cube--regular";
+
+// src/components/ChatPrompt/ChatPresets.tsx
+import React3 from "react";
+import { Select as Select2 } from "@dxos/react-ui";
+
+// src/components/ChatPrompt/ChatReferences.tsx
+import * as Option2 from "effect/Option";
+import React4 from "react";
+import { Annotation as Annotation2, Obj as Obj2 } from "@dxos/echo";
+import { Icon, IconButton as IconButton3, toLocalizedString, useTranslation as useTranslation3 } from "@dxos/react-ui";
+import { getStyles as getStyles2, mx as mx3 } from "@dxos/ui-theme";
+import { useContextObjects as useContextObjects2 } from "#hooks";
+import { meta as meta3 } from "#meta";
+var ChatReferences = ({ classNames, context, db }) => {
+  const { t } = useTranslation3(meta3.id);
+  const { objects, onUpdateObject } = useContextObjects2({
+    db,
+    context
+  });
+  return /* @__PURE__ */ React4.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_ICON2,
+      hue: void 0
+    })));
+    const styles = hue ? getStyles2(hue) : void 0;
+    return /* @__PURE__ */ React4.createElement("li", {
+      key: dxn.toString(),
+      className: "dx-tag py-0 ps-2 flex items-center gap-1",
+      "data-hue": "neutral"
+    }, /* @__PURE__ */ React4.createElement(Icon, {
+      icon,
+      size: 4,
+      classNames: styles?.surfaceText
+    }), toLocalizedString(label, t), /* @__PURE__ */ React4.createElement(IconButton3, {
+      icon: "ph--x--bold",
+      iconOnly: true,
+      variant: "ghost",
+      label: t("remove-object-in-context.label"),
+      classNames: "p-0 hover:bg-transparent",
+      size: 3,
+      onClick: () => onUpdateObject?.(dxn, false)
+    }));
+  }));
+};
+var DEFAULT_OBJECT_ICON2 = "ph--cube--regular";
+
+// src/components/ChatPrompt/ChatStatusIndicator.tsx
+import React5, { 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__ */ React5.createElement("div", {
+    role: "none",
+    className: mx4("relative flex", classNames)
+  }, /* @__PURE__ */ React5.createElement(Spinner, {
+    duration: period,
+    state: !init ? "flash" : error ? "error" : processing ? "spin" : "pulse",
+    ...props
+  }), error && /* @__PURE__ */ React5.createElement(Tooltip.Trigger, {
+    asChild: true,
+    content: error.message
+  }, /* @__PURE__ */ React5.createElement("div", {
+    className: "absolute inset-0"
+  })));
+};
+
+// src/components/ChatThread/ChatThread.tsx
+import React10, { forwardRef, useCallback as useCallback2, useEffect as useEffect3, useMemo as useMemo3, useState as useState4 } from "react";
+import { PublicKey } from "@dxos/keys";
+import { setRef } from "@dxos/react-ui";
+import { MarkdownStream } from "@dxos/react-ui-components";
+import { mx as mx6 } from "@dxos/ui-theme";
+import { keyToFallback } from "@dxos/util";
+
+// src/components/ChatThread/registry.tsx
+import React9 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 React6 from "react";
+import { TogglePanel } from "@dxos/react-ui-components";
+import { Json } from "@dxos/react-ui-syntax-highlighter";
+var FallbackWidget = ({ _tag, ...props }) => {
+  return /* @__PURE__ */ React6.createElement(TogglePanel.Root, null, /* @__PURE__ */ React6.createElement(TogglePanel.Header, {
+    classNames: "bg-group-surface"
+  }, _tag), /* @__PURE__ */ React6.createElement(TogglePanel.Content, {
+    classNames: "bg-modal-surface"
+  }, /* @__PURE__ */ React6.createElement(TogglePanel.Viewport, null, /* @__PURE__ */ React6.createElement(Json.Data, {
+    classNames: "p-2! text-sm",
+    data: props
+  }))));
+};
+FallbackWidget.displayName = "Fallback";
+
+// src/components/ChatThread/widgets/PromptWidget.ts
+import { WidgetType } from "@codemirror/view";
+import { Domino } from "@dxos/ui";
+var PromptWidget = class extends WidgetType {
+  text;
+  constructor(text) {
+    super(), this.text = text;
+  }
+  eq(other) {
+    return this.text === other.text;
+  }
+  /**
+  * NOTE: Container must set var based on user's identity.
+  */
+  toDOM() {
+    const inner = Domino.of("div").classNames("px-3 py-1.5 bg-(--user-fill) rounded-xs").text(this.text);
+    return Domino.of("div").classNames("flex justify-end my-2").append(inner).root;
+  }
+};
+
+// src/components/ChatThread/widgets/ReasoningWidget.ts
+import { WidgetType as WidgetType2 } from "@codemirror/view";
+import { Domino as Domino2 } from "@dxos/ui";
+var ReasoningWidget = class extends WidgetType2 {
+  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() {
+    const root = Domino2.of("div").classNames("pt-2 pb-2").append(Domino2.of("div").classNames("relative overflow-hidden p-px rounded-sm border border-subdued-separator").attributes({
+      "data-trail-container": ""
+    }).append(Domino2.of("div").classNames("relative z-10 bg-base-surface rounded-sm text-sm text-description px-2 py-1").append(Domino2.of("div").classNames("max-h-[5lh] overflow-y-auto").text(this.text).attributes({
+      "data-reasoning-text": ""
+    })), Domino2.of("div").attributes({
+      "data-id": this.#pos
+    }))).root;
+    return 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 = Domino2.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 = () => [
+  Domino2.of("div").classNames(...trail, "animate-trail").root,
+  Domino2.of("div").classNames(...trail, "animate-trail-offset").root
+];
+
+// src/components/ChatThread/widgets/ReferenceWidget.ts
+import { WidgetType as WidgetType3 } from "@codemirror/view";
+import { Domino as Domino3 } from "@dxos/ui";
+var ReferenceWidget = class extends WidgetType3 {
+  text;
+  dxn;
+  constructor(text, dxn) {
+    super(), this.text = text, this.dxn = dxn;
+  }
+  eq(other) {
+    return this.dxn === other.dxn;
+  }
+  toDOM() {
+    return Domino3.of("div").classNames("pt-2 pb-2").append(Domino3.of("dx-anchor").classNames("dx-tag--anchor").attributes({
+      dxn: this.dxn
+    }).text(this.text)).root;
+  }
+};
+
+// src/components/ChatThread/widgets/SelectWidget.ts
+import { WidgetType as WidgetType4 } from "@codemirror/view";
+import { Domino as Domino4 } from "@dxos/ui";
+var SelectWidget = class extends WidgetType4 {
+  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 Domino4.of("div").attributes({
+      role: "group"
+    }).classNames("flex flex-wrap pt-2 pb-2 gap-1").append(...this.options.map((option) => Domino4.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 WidgetType5 } from "@codemirror/view";
+import { Domino as Domino5 } from "@dxos/ui";
+var StatsWidget = class extends WidgetType5 {
+  text;
+  constructor(text) {
+    super(), this.text = text;
+  }
+  eq(other) {
+    return this.text === other.text;
+  }
+  toDOM() {
+    return Domino5.of("div").classNames("pt-2 pb-4 text-sm text-placeholder").text(this.text).root;
+  }
+  updateDOM(dom) {
+    dom.textContent = this.text;
+    return true;
+  }
+};
+
+// src/components/ChatThread/widgets/SummaryWidget.tsx
+import React7 from "react";
+import { useTranslation as useTranslation4 } from "@dxos/react-ui";
+import { TogglePanel as TogglePanel2 } from "@dxos/react-ui-components";
+import { meta as meta4 } from "#meta";
+var SummaryWidget = ({ children }) => {
+  const { t } = useTranslation4(meta4.id);
+  return /* @__PURE__ */ React7.createElement(TogglePanel2.Root, {
+    classNames: "border border-separator rounded-sm"
+  }, /* @__PURE__ */ React7.createElement(TogglePanel2.Header, {
+    classNames: "text-sm bg-group-surface"
+  }, t("summary.label")), /* @__PURE__ */ React7.createElement(TogglePanel2.Content, null, /* @__PURE__ */ React7.createElement("div", {
+    role: "none",
+    className: "p-1 text-sm text-description"
+  }, children)));
+};
+
+// src/components/ChatThread/widgets/SuggestionWidget.ts
+import { WidgetType as WidgetType6 } from "@codemirror/view";
+import { Domino as Domino6, mx as mx5 } 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(mx5("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(mx5("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 React8, { useCallback, useEffect as useEffect2, useMemo as useMemo2, useRef, useState as useState3 } from "react";
+import { useTranslation as useTranslation5 } from "@dxos/react-ui";
+import { NumericTabs, TextCrawl, TogglePanel as TogglePanel3 } from "@dxos/react-ui-components";
+import { Json as Json2 } from "@dxos/react-ui-syntax-highlighter";
+import { isNonNullable, safeParseJson } from "@dxos/util";
+import { meta as meta5 } from "#meta";
+var ToolWidget = ({ view, blocks = [] }) => {
+  const { t } = useTranslation5(meta5.id);
+  const items = useMemo2(() => {
+    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 = useCallback(() => {
+    setTimeout(() => {
+      view?.requestMeasure();
+    }, 1e3);
+  }, [
+    view
+  ]);
+  if (!items.length) {
+    return null;
+  }
+  return /* @__PURE__ */ React8.createElement(ToolPanel, {
+    items,
+    onChangeOpen: handleChangeOpen
+  });
+};
+var ToolPanel = ({ items, onChangeOpen }) => {
+  const tabsRef = useRef(null);
+  const [selected, setSelected] = useState3(0);
+  const [open, setOpen] = useState3(false);
+  useEffect2(() => {
+    setSelected((prev) => Math.min(prev, Math.max(0, items.length - 1)));
+  }, [
+    items.length
+  ]);
+  useEffect2(() => {
+    onChangeOpen?.(open);
+    if (open) {
+      tabsRef.current?.focus();
+    }
+  }, [
+    open,
+    onChangeOpen
+  ]);
+  const handleSelect = useCallback((index) => {
+    setSelected(index);
+  }, []);
+  return /* @__PURE__ */ React8.createElement(TogglePanel3.Root, {
+    open,
+    onChangeOpen: setOpen
+  }, /* @__PURE__ */ React8.createElement(TogglePanel3.Header, {
+    classNames: "text-sm text-placeholder"
+  }, /* @__PURE__ */ React8.createElement(TextCrawl, {
+    key: "status-roll",
+    lines: items.map((item) => item.title),
+    autoAdvance: true,
+    greedy: true
+  })), /* @__PURE__ */ React8.createElement(TogglePanel3.Content, null, /* @__PURE__ */ React8.createElement(TogglePanel3.Viewport, {
+    classNames: "grid grid-cols-[32px_1fr]"
+  }, /* @__PURE__ */ React8.createElement(NumericTabs, {
+    ref: tabsRef,
+    classNames: "p-1",
+    length: items.length,
+    selected,
+    onSelect: handleSelect
+  }), /* @__PURE__ */ React8.createElement(Json2.Data, {
+    data: items[selected]?.content,
+    classNames: "p-1 text-xs bg-transparent",
+    replacer: {
+      maxDepth: 3,
+      maxArrayLen: 10,
+      maxStringLen: 128
+    }
+  }))));
+};
+
+// src/components/ChatThread/widgets/StatusWidget.ts
+import { WidgetType as WidgetType7 } from "@codemirror/view";
+import { Domino as Domino7 } from "@dxos/ui";
+import { XML_WIDGET_DATA_ATTR } from "@dxos/ui-editor";
+var StatusWidget = class extends WidgetType7 {
+  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 === "" ? "status" : String(pos);
+  }
+  eq(other) {
+    return this.text === other.text && this.#pos === other.#pos;
+  }
+  toDOM() {
+    return Domino7.of("div").classNames("py-0.5").attributes({
+      [XML_WIDGET_DATA_ATTR]: ""
+    }).append(Domino7.of("div").classNames("relative overflow-hidden rounded-sm").append(Domino7.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(Domino7.of("div").classNames("flex h-5 w-full shrink-0 items-center justify-center self-start").append(Domino7.of("span").classNames("block size-1.5 shrink-0 rounded-full bg-current opacity-45")), Domino7.of("div").classNames("relative min-w-0").append(Domino7.of("div").classNames("relative z-10 rounded-sm text-sm leading-5").attributes({
+      "data-status-text": ""
+    }).text(this.text), Domino7.of("div").attributes({
+      "data-id": this.#pos
+    }))))).root;
+  }
+  updateDOM(dom) {
+    dom.querySelector("[data-status-text]")?.replaceChildren(this.text);
+    const trailHost = dom.querySelector("[data-id]");
+    if (trailHost?.childElementCount === 0) {
+      trailHost.append(...createTrailLayers2());
+    }
+    this.#scheduleTrailRemoval(dom);
+    return true;
+  }
+  destroy(_dom) {
+    this.#clearOwnedTrailTimer();
+  }
+  #scheduleTrailRemoval(dom) {
+    const previous = trailRemovalTimers2.get(this.#pos);
+    if (previous !== void 0) {
+      clearTimeout(previous);
+    }
+    const timerId = setTimeout(() => {
+      if (trailRemovalTimers2.get(this.#pos) !== timerId) {
+        return;
+      }
+      trailRemovalTimers2.delete(this.#pos);
+      this.#ownedTimerId = null;
+      dom.querySelector("[data-id]")?.remove();
+    }, TRAIL_REMOVAL_DELAY_MS2);
+    trailRemovalTimers2.set(this.#pos, timerId);
+    this.#ownedTimerId = timerId;
+  }
+  #clearOwnedTrailTimer() {
+    const active = trailRemovalTimers2.get(this.#pos);
+    if (active !== void 0 && active === this.#ownedTimerId) {
+      clearTimeout(active);
+      trailRemovalTimers2.delete(this.#pos);
+    }
+    this.#ownedTimerId = null;
+  }
+};
+var trail2 = [
+  "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_MS2 = 1e3;
+var trailRemovalTimers2 = /* @__PURE__ */ new Map();
+var createTrailLayers2 = () => [
+  Domino7.of("div").classNames(...trail2, "animate-trail").root,
+  Domino7.of("div").classNames(...trail2, "animate-trail-offset").root
+];
+
+// src/components/ChatThread/registry.tsx
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/components/ChatThread/registry.tsx";
+var componentRegistry = {
+  //
+  // DOM Widgets
+  //
+  prompt: {
+    block: true,
+    factory: ({ children }) => {
+      const text = getXmlTextChild(children);
+      return text ? new PromptWidget(text) : 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, range }) => {
+      const text = getXmlTextChild(children);
+      return text ? new StatusWidget(text, range.from) : null;
+    }
+  },
+  //
+  // React Widgets (portaled outside of the editor)
+  //
+  summary: {
+    block: true,
+    Component: SummaryWidget
+  },
+  toolCall: {
+    block: true,
+    Component: (props) => /* @__PURE__ */ React9.createElement("div", {
+      role: "none",
+      className: "py-2"
+    }, /* @__PURE__ */ React9.createElement(ToolWidget, props))
+  },
+  toolResult: {
+    block: true,
+    Component: FallbackWidget
+  },
+  toolkit: {
+    block: true,
+    Component: FallbackWidget
+  },
+  //
+  // Fallback
+  //
+  json: {
+    block: true,
+    Component: FallbackWidget
+  }
+};
+var blockToMarkdown = (context, message, block) => {
+  let str = blockToMarkdownImpl(context, message, block);
+  if (str && !block.pending) {
+    return str += "\n";
+  }
+  return str;
+};
+var blockToMarkdownImpl = (context, message, block) => {
+  log("blockToMarkdown", {
+    block: JSON.stringify(block)
+  }, {
+    F: __dxlog_file,
+    L: 140,
+    S: void 0,
+    C: (f, a) => f(...a)
+  });
+  switch (block._tag) {
+    case "text": {
+      if (message.sender.role === "user") {
+        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 stripBulletLikeLinePrefixes = (raw) => raw.split(/\r?\n/).map((line) => line.replace(/^\s*(?:[-*+•]|\d+[.)]\s)/, "")).join("\n");
+var renderXMLBlock = (tag, opts) => {
+  const content = escapeXmlTextContent(stripBulletLikeLinePrefixes((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
+import { log as log2 } from "@dxos/log";
+var __dxlog_file2 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/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 from hypergraph.
+  getObjectLabel(_id) {
+    return "Object";
+  }
+};
+var MessageSyncer = class {
+  _document;
+  _renderer;
+  #syncEpoch = 0;
+  _initialMessageId;
+  _currentMessageIndex = 0;
+  _currentBlockIndex = 0;
+  _currentBlockContent;
+  _context;
+  constructor(_document, _renderer) {
+    this._document = _document;
+    this._renderer = _renderer;
+    this._context = new MessageThreadContext(this._document);
+  }
+  get context() {
+    return this._context;
+  }
+  reset() {
+    log2("reset", void 0, {
+      F: __dxlog_file2,
+      L: 67,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    this.#syncEpoch++;
+    this._initialMessageId = void 0;
+    this._currentMessageIndex = 0;
+    this._currentBlockIndex = 0;
+    this._currentBlockContent = void 0;
+    void this._document.setContent("");
+  }
+  /**
+  * Syncs messages with the editor.
+  */
+  append(messages, flush = false) {
+    if (this._initialMessageId !== messages[0]?.id) {
+      this.reset();
+      this._initialMessageId = messages[0]?.id;
+    }
+    if (this._document.length === 0 && flush) {
+      const buffer = [];
+      this.processBlocks(messages, (content2) => buffer.push(content2));
+      const content = buffer.join("");
+      const epoch = this.#syncEpoch;
+      void this._document.setContent(content).then(() => {
+        if (epoch !== this.#syncEpoch) {
+          return;
+        }
+        rehydrateToolWidgetsFromMessages(this._context, messages);
+      }).catch((error) => {
+        log2.warn("failed to replace thread content before widget rehydration", {
+          error
+        }, {
+          F: __dxlog_file2,
+          L: 108,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+      });
+      return true;
+    } else {
+      this.processBlocks(messages, (content) => {
+        void this._document.append(content);
+      });
+      return false;
+    }
+  }
+  processBlocks(messages, append) {
+    let i = this._currentMessageIndex;
+    for (const message of messages.slice(this._currentMessageIndex)) {
+      if (i > this._currentMessageIndex) {
+        this._currentBlockIndex = 0;
+      }
+      this._currentMessageIndex = i;
+      let j = this._currentBlockIndex;
+      for (const block of message.blocks.slice(this._currentBlockIndex)) {
+        this._currentBlockIndex = j;
+        const currentBlockContent = this._renderer(this._context, message, block);
+        if (currentBlockContent) {
+          let content = "";
+          if (this._currentBlockContent && currentBlockContent.startsWith(this._currentBlockContent)) {
+            content = currentBlockContent.slice(this._currentBlockContent.length);
+          } else {
+            content = currentBlockContent;
+          }
+          this._currentBlockContent = currentBlockContent;
+          append(content);
+        }
+        if (block.pending) {
+          return;
+        } else {
+          this._currentBlockContent = void 0;
+          this._currentBlockIndex++;
+        }
+        j++;
+      }
+      i++;
+    }
+  }
+};
+
+// src/components/ChatThread/ChatThread.tsx
+var defaultOptions = {
+  autoScroll: true,
+  // wire: true,
+  cursor: true
+};
+var ChatThread = /* @__PURE__ */ forwardRef(({ classNames, identity, messages = [], error, options = defaultOptions, debug = false, onEvent }, forwardedRef) => {
+  const [controller, setController] = useState4(null);
+  const handleMarkdownStreamRef = useCallback2((instance) => {
+    setController(instance);
+    setRef(forwardedRef, instance);
+  }, [
+    forwardedRef
+  ]);
+  const userHue = useMemo3(() => identity?.profile?.data?.hue || keyToFallback(identity?.identityKey ?? PublicKey.random()).hue, [
+    identity
+  ]);
+  useEffect3(() => {
+    controller?.scrollToBottom();
+  }, [
+    controller,
+    error
+  ]);
+  const syncer = useMemo3(() => controller && new MessageSyncer(controller, blockToMarkdown), [
+    controller
+  ]);
+  useEffect3(() => {
+    const reset = syncer?.append(messages, true);
+    if (reset) {
+      controller?.scrollToBottom("instant");
+    }
+  }, [
+    controller,
+    syncer,
+    messages
+  ]);
+  const handleEvent = useCallback2(({ type, value: value2 }) => {
+    switch (type) {
+      case "submit": {
+        value2 && onEvent?.({
+          type,
+          text: value2
+        });
+        break;
+      }
+    }
+  }, [
+    onEvent
+  ]);
+  return /* @__PURE__ */ React10.createElement("div", {
+    role: "none",
+    className: mx6("flex h-full w-full justify-center overflow-hidden", classNames),
+    style: {
+      "--user-fill": `var(--color-${userHue}-fill)`
+    }
+  }, /* @__PURE__ */ React10.createElement(MarkdownStream, {
+    registry: componentRegistry,
+    options,
+    debug,
+    onEvent: handleEvent,
+    ref: handleMarkdownStreamRef
+  }));
+});
+
+// src/components/Chat/Chat.tsx
+var [ChatContextProvider, useChatContext] = createContext("Chat");
+var ChatRoot = ({ children, chat, queue, processor, onEvent, ...props }) => {
+  const [debug, setDebug] = useState5(false);
+  const pending = useAtomValue(processor.messages);
+  const streaming = useAtomValue(processor.streaming);
+  const lastPrompt = useRef2(void 0);
+  const storedMessages = useQuery2(queue, Filter2.type(Message.Message));
+  const messages = useMemo4(() => {
+    return Array2.dedupeWith([
+      ...storedMessages,
+      ...pending
+    ], ({ id: a }, { id: b }) => a === b);
+  }, [
+    storedMessages,
+    pending
+  ]);
+  const dump = useCallback3(async () => {
+    const objects = processor.context.getObjects();
+    const blueprints = processor.context.getBlueprints();
+    const system = await processor.getSystemPrompt();
+    const tools = await processor.getTools();
+    console.group("Chat", {
+      objects,
+      blueprints
+    });
+    console.log(trim`
+      System Prompt:
+      ${system}
+    `);
+    console.log(trim`
+      Tools:
+      ${Object.values(tools).map((tool) => JSON.stringify(tool, null, 2)).join("\n")}
+    `);
+    console.groupEnd();
+  }, [
+    processor
+  ]);
+  const event = useMemo4(() => new Event(), []);
+  useEffect4(() => {
+    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
+  ]);
+  const db = props.db ?? (chat && Obj3.getDatabase(chat));
+  return /* @__PURE__ */ React11.createElement(ChatContextProvider, {
+    debug,
+    event,
+    db,
+    chat,
+    messages,
+    processor,
+    ...props
+  }, children);
+};
+ChatRoot.displayName = "Chat.Root";
+var CHAT_VIEWPORT_NAME = "Chat.Viewport";
+var ChatViewport = composable(({ children, ...props }, forwardedRef) => {
+  return /* @__PURE__ */ React11.createElement("div", {
+    ...composableProps(props, {
+      classNames: "dx-expander flex flex-col"
+    }),
+    ref: forwardedRef
+  }, children);
+});
+ChatViewport.displayName = CHAT_VIEWPORT_NAME;
+var CHAT_THREAD_NAME = "Chat.Thread";
+var ChatThread2 = (props) => {
+  const { debug, event, messages, processor } = useChatContext(CHAT_THREAD_NAME);
+  const identity = useIdentity();
+  const error = useAtomValue(processor.error).pipe(Option3.getOrUndefined);
+  const controllerRef = useRef2(null);
+  useEffect4(() => {
+    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 = useCallback3((ev) => {
+    event.emit(ev);
+  }, [
+    event
+  ]);
+  if (!identity) {
+    return null;
+  }
+  return /* @__PURE__ */ React11.createElement(ChatThread, {
+    ...props,
+    identity,
+    messages,
+    error,
+    debug,
+    onEvent: handleEvent,
+    ref: controllerRef
+  });
+};
+ChatThread2.displayName = CHAT_THREAD_NAME;
+var CHAT_PROMPT_NAME = "Chat.Prompt";
+var ChatPrompt = ({ classNames, outline, settings = true, placeholder, expandable, online, presets, preset, onPresetChange, onOnlineChange }) => {
+  const { t } = useTranslation6(meta6.id);
+  const { db, processor, event } = useChatContext(CHAT_PROMPT_NAME);
+  const error = useAtomValue(processor.error).pipe(Option3.getOrUndefined);
+  const streaming = useAtomValue(processor.streaming);
+  const active = useAtomValue(processor.active);
+  const activeRef = useDynamicRef(active);
+  const editorRef = useRef2(null);
+  const [recordingState, setRecordingState] = useState5(false);
+  useEffect4(() => {
+    return event.on((event2) => {
+      switch (event2.type) {
+        case "update-prompt":
+          if (!editorRef.current?.getText()?.length) {
+            editorRef.current?.setText(event2.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 = useMemo4(() => {
+    return [
+      Prec.highest(keymap.of([
+        {
+          key: "Mod-d",
+          preventDefault: true,
+          run: () => {
+            event.emit({
+              type: "toggle-debug"
+            });
+            return true;
+          }
+        },
+        {
+          key: "Mod-ArrowUp",
+          preventDefault: true,
+          run: () => {
+            event.emit({
+              type: "nav-previous"
+            });
+            return true;
+          },
+          shift: () => {
+            event.emit({
+              type: "thread-open"
+            });
+            return true;
+          }
+        },
+        {
+          key: "Mod-ArrowDown",
+          preventDefault: true,
+          run: () => {
+            event.emit({
+              type: "nav-next"
+            });
+            return true;
+          },
+          shift: () => {
+            event.emit({
+              type: "thread-close"
+            });
+            return true;
+          }
+        }
+      ]))
+    ].filter(isTruthy);
+  }, [
+    event,
+    expandable
+  ]);
+  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__ */ React11.createElement("div", {
+    role: "group",
+    className: mx7("flex flex-col w-full dx-density-fine", outline && "bg-group-surface border border-subdued-separator transition transition-border [&:has(.cm-content:focus)]:border-separator rounded-sm", classNames)
+  }, /* @__PURE__ */ React11.createElement("div", {
+    role: "none",
+    className: "flex p-2 gap-2"
+  }, /* @__PURE__ */ React11.createElement(ChatStatusIndicator, {
+    classNames: "p-1",
+    preset,
+    error,
+    processing: streaming
+  }), /* @__PURE__ */ React11.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__ */ React11.createElement("div", {
+    role: "none",
+    className: "flex items-center overflow-hidden"
+  }, /* @__PURE__ */ React11.createElement(ChatOptions, {
+    db,
+    blueprintRegistry: processor.blueprintRegistry,
+    context: processor.context,
+    preset,
+    presets,
+    onPresetChange
+  }), /* @__PURE__ */ React11.createElement("div", {
+    role: "none",
+    className: "flex grow overflow-x-auto scrollbar-none"
+  }, /* @__PURE__ */ React11.createElement(ChatReferences, {
+    db,
+    context: processor.context
+  })), /* @__PURE__ */ React11.createElement(ChatActions, {
+    classNames: "col-span-2",
+    microphone: true,
+    recording,
+    processing: streaming,
+    onEvent: handleEvent
+  }, online !== void 0 && /* @__PURE__ */ React11.createElement(Input.Root, null, /* @__PURE__ */ React11.createElement(Input.Label, {
+    srOnly: true
+  }, t("online-switch.label")), /* @__PURE__ */ React11.createElement(Input.Switch, {
+    classNames: "mx-2",
+    checked: online,
+    onCheckedChange: onOnlineChange
+  })))));
+};
+ChatPrompt.displayName = CHAT_PROMPT_NAME;
+var CHAT_TOOLBAR_NAME = "Chat.Toolbar";
+var ChatToolbar = composable(({ attendableId, companionTo, ...props }, forwardedRef) => {
+  const { chat } = useChatContext(CHAT_TOOLBAR_NAME);
+  const menuActions = useChatToolbarActions({
+    chat,
+    companionTo
+  });
+  return /* @__PURE__ */ React11.createElement(Menu.Root, {
+    ...menuActions,
+    attendableId
+  }, /* @__PURE__ */ React11.createElement(Menu.Toolbar, {
+    ...composableProps(props),
+    ref: forwardedRef
+  }));
+});
+ChatToolbar.displayName = CHAT_TOOLBAR_NAME;
+var Chat = {
+  Root: ChatRoot,
+  Viewport: ChatViewport,
+  Thread: ChatThread2,
+  Prompt: ChatPrompt,
+  Toolbar: ChatToolbar
+};
+
+// src/components/ProcessTree/ProcessTree.tsx
+import * as Match from "effect/Match";
+import React12 from "react";
+import { Process } from "@dxos/functions-runtime";
+import { Icon as Icon2, ScrollArea, Treegrid } from "@dxos/react-ui";
+import { composable as composable2, composableProps as composableProps2, mx as mx8 } from "@dxos/ui-theme";
+var ProcessTree = composable2(({ processes, onProcessSelect, ...props }, forwardedRef) => {
+  const filteredProcesses = [
+    ...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)).slice(0, 3)
+  ];
+  return /* @__PURE__ */ React12.createElement(ScrollArea.Root, {
+    ...composableProps2(props, {
+      classNames: "dx-expander"
+    }),
+    thin: true,
+    ref: forwardedRef
+  }, /* @__PURE__ */ React12.createElement(ScrollArea.Viewport, null, /* @__PURE__ */ React12.createElement(Treegrid.Root, {
+    gridTemplateColumns: "1fr"
+  }, filteredProcesses.filter((process) => process.parentPid === null).map((process) => {
+    const activeChildren = filteredProcesses.filter((candidate) => candidate.parentPid?.toString() === process.pid.toString() && candidate.state === Process.State.RUNNING);
+    return /* @__PURE__ */ React12.createElement(Treegrid.Row, {
+      key: process.pid.toString(),
+      id: process.pid.toString(),
+      parentOf: process.parentPid?.toString()
+    }, /* @__PURE__ */ React12.createElement(Treegrid.Cell, {
+      indent: true,
+      classNames: "flex items-center p-1 gap-2 min-w-0",
+      onClick: () => onProcessSelect?.(process)
+    }, /* @__PURE__ */ React12.createElement(Icon2, {
+      size: 4,
+      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")),
+      classNames: mx8(process.state === Process.State.RUNNING && "animate-spin", process.state === Process.State.FAILED && "text-error-text", process.state === Process.State.SUCCEEDED && "text-success-text")
+    }), /* @__PURE__ */ React12.createElement("div", {
+      role: "none",
+      className: "flex items-center gap-2 text-xs overflow-hidden"
+    }, /* @__PURE__ */ React12.createElement("span", {
+      className: "text-description"
+    }, process.params.name), activeChildren.length > 0 && /* @__PURE__ */ React12.createElement("span", {
+      className: "text-xs text-description ml-1"
+    }, activeChildren[0].params.name))));
+  }))));
+});
+
+// src/components/TemplateEditor/TemplateEditor.tsx
+import { defaultHighlightStyle, syntaxHighlighting } from "@codemirror/language";
+import { composeRefs } from "@radix-ui/react-compose-refs";
+import React13 from "react";
+import { createDocAccessor } from "@dxos/echo-db";
+import { useThemeContext, useTranslation as useTranslation7 } from "@dxos/react-ui";
+import { useTextEditor } from "@dxos/react-ui-editor";
+import { createBasicExtensions, createDataExtensions, createMarkdownExtensions, createThemeExtensions, decorateMarkdown } from "@dxos/ui-editor";
+import { composable as composable3, composableProps as composableProps3 } from "@dxos/ui-theme";
+import { isNonNullable as isNonNullable2 } from "@dxos/util";
+import { meta as meta7 } 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 WidgetType8, keymap as keymap2 } from "@codemirror/view";
+import { Domino as Domino8, mx as mx9 } from "@dxos/ui";
+var handlebars = (_ = {}) => {
+  return [
+    handlebarsHighlightPlugin,
+    autocompletion({
+      activateOnTyping: true,
+      aboveCursor: true,
+      closeOnBlur: true,
+      override: [
+        handlebarsCompletions
+      ]
+    }),
+    keymap2.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,
+  // dxos.org/type/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: mx9("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 WidgetType8 {
+  _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 Domino8.of("span").classNames(mx9("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 = composable3(({ classNames, id, template, lineNumbers = true, ...props }, forwardedRef) => {
+  const { t } = useTranslation7(meta7.id);
+  const { themeMode } = useThemeContext();
+  const { parentRef } = useTextEditor(() => {
+    const text = template.source?.target;
+    if (!text) {
+      return {};
+    }
+    return {
+      initialValue: text.content ?? "",
+      extensions: [
+        createDataExtensions({
+          id,
+          text: createDocAccessor(text, [
+            "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__ */ React13.createElement("div", {
+    ...composableProps3(props, {
+      role: "none",
+      classNames: [
+        "h-full overflow-hidden",
+        classNames
+      ]
+    }),
+    ref: composeRefs(parentRef, forwardedRef)
+  });
+});
+
+// src/components/Toolbox/Toolbox.tsx
+import React14, { Fragment, useEffect as useEffect5, useState as useState6 } from "react";
+import { log as log3 } from "@dxos/log";
+import { Operation } from "@dxos/operation";
+import { Filter as Filter3, useQuery as useQuery3 } from "@dxos/react-client/echo";
+import { ScrollArea as ScrollArea2 } from "@dxos/react-ui";
+import { composable as composable4, composableProps as composableProps4, mx as mx10 } from "@dxos/ui-theme";
+import { ServiceType as ServiceType2 } from "#types";
+var __dxlog_file3 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/components/Toolbox/Toolbox.tsx";
+var Toolbox = composable4(({ functions, services, blueprints, activeBlueprints, ...props }, forwardedRef) => {
+  return /* @__PURE__ */ React14.createElement(ScrollArea2.Root, {
+    ...composableProps4(props),
+    thin: true,
+    orientation: "vertical",
+    ref: forwardedRef
+  }, /* @__PURE__ */ React14.createElement(ScrollArea2.Viewport, null, blueprints && blueprints.length > 0 && /* @__PURE__ */ React14.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__ */ React14.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__ */ React14.createElement(Section, {
+    title: "Services",
+    items: services.map(({ service: { serviceId, name, description } }) => ({
+      name: name ?? serviceId,
+      description
+    }))
+  }), functions && functions.length > 0 && /* @__PURE__ */ React14.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 = mx10("col-span-full grid grid-cols-subgrid text-xs px-2", striped && stripeClassNames);
+  return /* @__PURE__ */ React14.createElement("div", null, /* @__PURE__ */ React14.createElement("h1", {
+    className: "px-2 text-sm"
+  }, title), /* @__PURE__ */ React14.createElement("div", {
+    className: gridClassNames
+  }, items.map(({ name, description, subitems }, i) => /* @__PURE__ */ React14.createElement(Fragment, {
+    key: i
+  }, name && /* @__PURE__ */ React14.createElement("div", {
+    className: subGridClassNames
+  }, /* @__PURE__ */ React14.createElement("div", {
+    className: "truncate text-primary-500"
+  }, name), /* @__PURE__ */ React14.createElement("div", {
+    className: "line-clamp-2"
+  }, description)), subitems?.map(({ name: name2, description: description2 }, i2) => /* @__PURE__ */ React14.createElement("div", {
+    key: i2,
+    className: mx10(subGridClassNames, striped && stripeClassNames)
+  }, /* @__PURE__ */ React14.createElement("div", {
+    className: "truncate"
+  }, name2), /* @__PURE__ */ React14.createElement("div", {
+    className: "line-clamp-3 text-subdued"
+  }, description2)))))));
+};
+var ToolboxPanel = ({ classNames, db, processor }) => {
+  const services = useQuery3(db, Filter3.type(ServiceType2));
+  const [serviceTools, setServiceTools] = useState6([]);
+  useEffect5(() => {
+    log3("creating service tools...", {
+      services: services.length
+    }, {
+      F: __dxlog_file3,
+      L: 122,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+    queueMicrotask(async () => {
+    });
+  }, [
+    services
+  ]);
+  const functions = useQuery3(db, Filter3.type(Operation.PersistentOperation));
+  return /* @__PURE__ */ React14.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-UVUTKO7E.mjs"));
+
+// src/hooks/useBlueprintRegistry.ts
+import { useCallback as useCallback4, useEffect as useEffect6, useMemo as useMemo5, useState as useState7 } from "react";
+import { useCapabilities } from "@dxos/app-framework/ui";
+import { AppCapabilities } from "@dxos/app-toolkit";
+import { Blueprint } from "@dxos/blueprints";
+import { Filter as Filter4, Obj as Obj4, Ref } from "@dxos/echo";
+import { useQuery as useQuery4 } from "@dxos/react-client/echo";
+import { distinctBy } from "@dxos/util";
+var useBlueprintRegistry = () => {
+  const blueprintDefinitions = useCapabilities(AppCapabilities.BlueprintDefinition);
+  return useMemo5(() => new Blueprint.Registry(blueprintDefinitions.map((blueprint) => blueprint.make())), [
+    blueprintDefinitions
+  ]);
+};
+var useBlueprints2 = ({ blueprintRegistry, db }) => {
+  const staticBlueprints = useMemo5(() => blueprintRegistry?.query() ?? [], [
+    blueprintRegistry
+  ]);
+  const spaceBlueprints = useQuery4(db, Filter4.type(Blueprint.Blueprint));
+  return useMemo5(() => {
+    const blueprints = distinctBy([
+      ...staticBlueprints,
+      ...spaceBlueprints
+    ], (b) => b.key);
+    blueprints.sort(({ name: a }, { name: b }) => a.localeCompare(b));
+    return blueprints;
+  }, [
+    staticBlueprints,
+    spaceBlueprints
+  ]);
+};
+var useActiveBlueprints2 = ({ context }) => {
+  const [active, setActive] = useState7(/* @__PURE__ */ new Map());
+  useEffect6(() => {
+    if (!context) {
+      setActive(/* @__PURE__ */ new Map());
+      return;
+    }
+    const updateActive = () => {
+      const blueprints = context.getBlueprints();
+      setActive(new Map(blueprints.map((blueprint) => [
+        blueprint.key,
+        blueprint
+      ])));
+    };
+    updateActive();
+    return context.subscribeBlueprints(updateActive);
+  }, [
+    context
+  ]);
+  return active;
+};
+var useBlueprintHandlers2 = ({ db, context, blueprintRegistry }) => {
+  const onUpdateBlueprint = useCallback4(async (key, checked) => {
+    if (!context || !blueprintRegistry) {
+      return;
+    }
+    const objects = await db.query(Filter4.type(Blueprint.Blueprint)).run();
+    let storedBlueprint = objects.find((blueprint) => blueprint.key === key);
+    if (checked) {
+      if (!storedBlueprint) {
+        const blueprint = blueprintRegistry.getByKey(key);
+        if (!blueprint) {
+          return;
+        }
+        storedBlueprint = db.add(Obj4.clone(blueprint));
+      }
+      await context.bind({
+        blueprints: [
+          Ref.make(storedBlueprint)
+        ]
+      });
+    } else if (storedBlueprint) {
+      await context.unbind({
+        blueprints: [
+          Ref.make(storedBlueprint)
+        ]
+      });
+    }
+  }, [
+    db,
+    context,
+    blueprintRegistry
+  ]);
+  return {
+    onUpdateBlueprint
+  };
+};
+
+// src/hooks/useChatProcessor.ts
+import { RegistryContext } from "@effect-atom/atom-react";
+import * as Effect2 from "effect/Effect";
+import { useContext, useMemo as useMemo6, useState as useState8 } from "react";
+import { AiConversation } from "@dxos/assistant";
+import { Ref as Ref2 } from "@dxos/echo";
+import { createFeedServiceLayer } from "@dxos/echo-db";
+import { runAndForwardErrors as runAndForwardErrors2 } from "@dxos/effect";
+import { log as log5 } from "@dxos/log";
+import { useAsyncEffect } from "@dxos/react-ui";
+
+// src/processor/presets.ts
+import * as Schema from "effect/Schema";
+var ModelProviders = [
+  "dxos-local",
+  "dxos-remote",
+  "lm-studio"
+];
+var ModelProvider = Schema.Literal(...ModelProviders);
+var createModelLabel = (model) => {
+  const parts = model.split("/");
+  return parts[parts.length - 1];
+};
+var AiServicePresets = [
+  {
+    provider: "dxos-remote",
+    model: "@anthropic/claude-opus-4-6"
+  },
+  {
+    provider: "dxos-remote",
+    model: "@anthropic/claude-sonnet-4-5"
+  },
+  {
+    provider: "dxos-remote",
+    model: "@anthropic/claude-3-5-haiku-20241022"
+  },
+  {
+    provider: "lm-studio",
+    model: "@google/gemma-3-27b"
+  },
+  {
+    provider: "lm-studio",
+    model: "@meta/llama-3.2-3b-instruct"
+  },
+  {
+    model: "deepseek-r1:latest",
+    provider: "dxos-local"
+  }
+].map(({ model, provider }, i) => ({
+  id: `preset-${i}`,
+  provider,
+  model,
+  label: createModelLabel(model)
+}));
+
+// src/processor/processor.ts
+import { Atom, Registry } from "@effect-atom/atom-react";
+import * as Effect from "effect/Effect";
+import * as Fiber from "effect/Fiber";
+import * as Option4 from "effect/Option";
+import * as Stream from "effect/Stream";
+import { DEFAULT_EDGE_MODEL } from "@dxos/ai";
+import { AiContextService, createSystemPrompt, formatSystemPrompt, AgentService, PartialBlock } from "@dxos/assistant";
+import { Obj as Obj5 } from "@dxos/echo";
+import { runAndForwardErrors, unwrapExit } from "@dxos/effect";
+import { Trace } from "@dxos/functions";
+import { log as log4 } from "@dxos/log";
+import { Operation as Operation2 } from "@dxos/operation";
+import { Message as Message2 } from "@dxos/types";
+var __dxlog_file4 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/processor/processor.ts";
+var defaultOptions2 = {
+  model: DEFAULT_EDGE_MODEL,
+  autoUpdateNameChance: 0.1
+};
+var AiChatProcessor = class {
+  _conversation;
+  _runtime;
+  _feed;
+  _options;
+  #registry;
+  /** Pending messages (finalized, non-streaming). */
+  #pending = Atom.make([]);
+  /** Currently streaming messages (from ephemeral trace events). */
+  #streaming = Atom.make([]);
+  /** Set of message IDs that have been finalized (non-pending delivered via ephemeral). */
+  #finalizedIds = /* @__PURE__ */ new Set();
+  /** Currently active request fiber. */
+  #requestFiber;
+  /** Last request (for retries). */
+  #lastRequest;
+  /** Streaming state. */
+  streaming = Atom.make((get) => get(this.#streaming).length > 0);
+  /** Active state. */
+  active = Atom.make(false);
+  /** Array of Messages (incl. the current message being streamed). */
+  messages = Atom.make((get) => [
+    ...get(this.#pending),
+    ...get(this.#streaming)
+  ]);
+  /** Last error. */
+  error = Atom.make(Option4.none());
+  constructor(_conversation, _runtime, _feed, _options = defaultOptions2) {
+    this._conversation = _conversation;
+    this._runtime = _runtime;
+    this._feed = _feed;
+    this._options = _options;
+    this.#registry = this._options.observableRegistry ?? Registry.make();
+    if (this._options.model && !this._options.system) {
+      const capabilities = this._options.modelRegistry?.getCapabilities(this._options.model) ?? {};
+      this._options.system = createSystemPrompt(capabilities);
+    }
+  }
+  get context() {
+    return this._conversation.context;
+  }
+  get conversation() {
+    return this._conversation;
+  }
+  get blueprintRegistry() {
+    return this._options.blueprintRegistry;
+  }
+  get system() {
+    return this._options.system ?? "";
+  }
+  async getTools() {
+    return this._runtime.runPromise(this._conversation.getTools());
+  }
+  async getSystemPrompt() {
+    return this._runtime.runPromise(Effect.gen(this, function* () {
+      const blueprints = this.context.getBlueprints();
+      const objects = this.context.getObjects();
+      return yield* formatSystemPrompt({
+        system: this._options.system,
+        blueprints,
+        objects
+      });
+    }).pipe(Effect.provideService(AiContextService, {
+      binder: this.context
+    }), Effect.orDie));
+  }
+  /**
+  * Initiates a new request via AgentService.
+  */
+  async request(requestProp) {
+    if (this.#requestFiber) {
+      await this.cancel();
+    }
+    try {
+      this.#lastRequest = requestProp;
+      this.#registry.set(this.error, Option4.none());
+      this.#registry.set(this.active, true);
+      const effect = Effect.gen(this, function* () {
+        const session = yield* AgentService.getSession(this._feed);
+        const ephemeralStream = session.subscribeEphemeral();
+        yield* ephemeralStream.pipe(Stream.runForEach((message) => Effect.sync(() => {
+          for (const event of message.events) {
+            if (Trace.isOfType(PartialBlock, event)) {
+              this.#handleEphemeralMessage(event.data);
+            }
+          }
+        })), Effect.fork);
+        log4("chat processor submitting prompt", {
+          length: requestProp.message.length
+        }, {
+          F: __dxlog_file4,
+          L: 197,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        yield* session.submitPrompt(requestProp.message);
+        log4("chat processor submitPrompt returned, waiting for agent", {}, {
+          F: __dxlog_file4,
+          L: 199,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        yield* session.waitForCompletion();
+        log4.info("session complete", void 0, {
+          F: __dxlog_file4,
+          L: 201,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        this.#flushStreaming();
+        yield* this.#maybeUpdateChatName();
+      });
+      this.#requestFiber = this._runtime.runFork(effect);
+      try {
+        await this._runtime.runPromise(Fiber.join(this.#requestFiber));
+      } catch (err) {
+        if (err._tag === "InterruptedException" || err.message?.includes("interrupted")) {
+          return;
+        }
+        throw err;
+      }
+      this.#registry.set(this.error, Option4.none());
+      this.#lastRequest = void 0;
+      this.#requestFiber = void 0;
+    } catch (err) {
+      log4.error("request failed", {
+        error: err
+      }, {
+        F: __dxlog_file4,
+        L: 223,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      this.#registry.set(this.error, Option4.some(new Error("AI service error", {
+        cause: err
+      })));
+    } finally {
+      log4.info("setting active to false", void 0, {
+        F: __dxlog_file4,
+        L: 226,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      this.#registry.set(this.active, false);
+      this.#requestFiber = void 0;
+    }
+  }
+  /**
+  * Cancels the current request.
+  */
+  async cancel() {
+    await runAndForwardErrors(Effect.gen(this, function* () {
+      if (this.#requestFiber) {
+        yield* Fiber.interrupt(this.#requestFiber);
+      }
+    }));
+    this.#requestFiber = void 0;
+    this.#registry.set(this.active, false);
+  }
+  /**
+  * Retry last failed request.
+  */
+  async retry() {
+    if (this.#lastRequest) {
+      return this.request(this.#lastRequest);
+    }
+  }
+  /**
+  * Update the current chat's name.
+  */
+  async updateName(chat) {
+    unwrapExit(await this._runtime.runPromiseExit(Operation2.invoke(UpdateChatName, {
+      chat
+    })));
+  }
+  /**
+  * Handles an ephemeral message from the agent process.
+  * Both pending and completed blocks arrive here. Completed blocks are deduped
+  * against messages already written to the feed queue to handle the race between
+  * ephemeral delivery and feed replication.
+  */
+  #handleEphemeralMessage(event) {
+    const isPending = event.block.pending;
+    const message = Obj5.make(Message2.Message, {
+      id: event.messageId,
+      created: (/* @__PURE__ */ new Date()).toISOString(),
+      sender: {
+        role: event.role
+      },
+      blocks: [
+        event.block
+      ]
+    });
+    if (isPending) {
+      if (this.#finalizedIds.has(event.messageId)) {
+        return;
+      }
+      this.#registry.update(this.#streaming, (streaming) => {
+        const idx = streaming.findIndex((existing) => existing.id === event.messageId);
+        if (idx >= 0) {
+          const updated = [
+            ...streaming
+          ];
+          updated[idx] = message;
+          return updated;
+        }
+        return [
+          ...streaming,
+          message
+        ];
+      });
+    } else {
+      this.#finalizedIds.add(event.messageId);
+      this.#registry.update(this.#streaming, (streaming) => streaming.filter((existing) => existing.id !== message.id));
+      this.#registry.update(this.#pending, (pending) => {
+        if (pending.some((existing) => existing.id === message.id)) {
+          return pending;
+        }
+        return [
+          ...pending,
+          message
+        ];
+      });
+    }
+  }
+  /**
+  * Move remaining streaming messages to pending (called when agent completes).
+  */
+  #flushStreaming() {
+    const remaining = this.#registry.get(this.#streaming);
+    if (remaining.length > 0) {
+      this.#registry.update(this.#pending, (pending) => [
+        ...pending,
+        ...remaining
+      ]);
+      this.#registry.set(this.#streaming, []);
+    }
+    this.#finalizedIds.clear();
+  }
+  /**
+  * Conditionally schedule chat name update in detached fork mode.
+  * Updates if chat has no name OR based on random chance (default 10%).
+  */
+  #maybeUpdateChatName() {
+    const chat = this._options.chat?.target;
+    if (!chat) {
+      return Effect.void;
+    }
+    const chance = this._options.autoUpdateNameChance ?? defaultOptions2.autoUpdateNameChance ?? 0.1;
+    const shouldUpdate = !chat.name || Math.random() < chance;
+    if (!shouldUpdate) {
+      return Effect.void;
+    }
+    log4.info("scheduling chat name update", {
+      hasName: !!chat.name,
+      chance
+    }, {
+      F: __dxlog_file4,
+      L: 333,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    return Operation2.schedule(UpdateChatName, {
+      chat
+    });
+  }
+};
 
-// src/capabilities/app-graph-builder/index.ts
-import { Capability as Capability2 } from "@dxos/app-framework";
-var AppGraphBuilder = Capability2.lazy("AppGraphBuilder", () => import("./app-graph-builder-TJCUEXW5.mjs"));
+// src/hooks/useChatProcessor.ts
+var __dxlog_file5 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/hooks/useChatProcessor.ts";
+var useChatProcessor = ({ space, chat, preset, runtime: runtime3, blueprintRegistry, settings }) => {
+  const observableRegistry = useContext(RegistryContext);
+  const [conversation, setConversation] = useState8();
+  useAsyncEffect(async () => {
+    if (!space || !chat) {
+      return;
+    }
+    const feedTarget = chat.feed.target;
+    if (!feedTarget) {
+      return;
+    }
+    const feedServiceLayer = createFeedServiceLayer(space.queues);
+    const runtime4 = await runAndForwardErrors2(Effect2.runtime().pipe(Effect2.provide(feedServiceLayer)));
+    const conversation2 = new AiConversation({
+      feed: feedTarget,
+      runtime: runtime4,
+      registry: observableRegistry
+    });
+    await conversation2.open();
+    setConversation(conversation2);
+    return () => {
+      void conversation2.close();
+      setConversation(void 0);
+    };
+  }, [
+    space,
+    chat?.feed.target
+  ]);
+  const feed = chat?.feed.target;
+  const processor = useMemo6(() => {
+    if (!runtime3 || !conversation || !chat || !feed) {
+      return void 0;
+    }
+    log5("creating processor", {
+      preset,
+      model: preset?.model,
+      settings
+    }, {
+      F: __dxlog_file5,
+      L: 80,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+    return new AiChatProcessor(conversation, runtime3, feed, {
+      chat: chat ? Ref2.make(chat) : void 0,
+      observableRegistry,
+      blueprintRegistry,
+      model: preset?.model
+    });
+  }, [
+    runtime3,
+    conversation,
+    blueprintRegistry,
+    preset,
+    feed
+  ]);
+  return processor;
+};
+
+// src/hooks/useChatServices.ts
+import { useMemo as useMemo7 } from "react";
+import { useCapability } from "@dxos/app-framework/ui";
+import { getPersonalSpace } from "@dxos/app-toolkit";
+import { AutomationCapabilities } from "@dxos/plugin-automation/types";
+import { useClient } from "@dxos/react-client";
+var useChatServices = ({ id }) => {
+  const client = useClient();
+  id ??= getPersonalSpace(client)?.id;
+  const runtimeResolver = useCapability(AutomationCapabilities.ComputeRuntime);
+  return useMemo7(() => !id ? void 0 : runtimeResolver.getRuntime(id), [
+    id
+  ]);
+};
 
-// src/capabilities/blueprint-definition/index.ts
-import { Capability as Capability3 } from "@dxos/app-framework";
-var BlueprintDefinition = Capability3.lazy("BlueprintDefinition", () => import("./blueprint-definition-SEMDEIYG.mjs"));
+// src/hooks/useChatToolbarActions.ts
+import { Atom as Atom2 } from "@effect-atom/atom-react";
+import * as Effect3 from "effect/Effect";
+import { useMemo as useMemo8 } from "react";
+import { useOperationInvoker } from "@dxos/app-framework/ui";
+import { Chat as Chat2 } from "@dxos/assistant-toolkit";
+import { Filter as Filter5, Obj as Obj6, Query } from "@dxos/echo";
+import { runAndForwardErrors as runAndForwardErrors3 } from "@dxos/effect";
+import { invariant } from "@dxos/invariant";
+import { useQuery as useQuery5 } from "@dxos/react-client/echo";
+import { MenuBuilder, useMenuActions } from "@dxos/react-ui-menu";
+import { useChatContext as useChatContext2 } from "#components";
+import { meta as meta8 } from "#meta";
+import { AssistantOperation } from "#operations";
+var __dxlog_file6 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/hooks/useChatToolbarActions.ts";
+var useChatToolbarActions2 = ({ chat, companionTo }) => {
+  const { invoke } = useOperationInvoker();
+  const { db } = useChatContext2("useChatToolbarActions");
+  const query = companionTo ? Query.select(Filter5.id(companionTo.id)).targetOf(Chat2.CompanionTo).source() : Query.select(Filter5.nothing());
+  const chats = useQuery5(db, query);
+  return useMenuActions(useMemo8(() => {
+    return Atom2.make(() => {
+      const builder = MenuBuilder.make().root({
+        label: [
+          "chat-toolbar.title",
+          {
+            ns: meta8.id
+          }
+        ]
+      }).action("new", {
+        label: [
+          "new-thread.button",
+          {
+            ns: meta8.id
+          }
+        ],
+        icon: "ph--plus--regular",
+        type: "new",
+        disabled: !companionTo
+      }, () => {
+        invariant(companionTo, void 0, {
+          F: __dxlog_file6,
+          L: 53,
+          S: void 0,
+          A: [
+            "companionTo",
+            ""
+          ]
+        });
+        return invoke(AssistantOperation.SetCurrentChat, {
+          companionTo,
+          chat: void 0
+        }).pipe(runAndForwardErrors3);
+      }).action("rename", {
+        label: [
+          "rename-thread.button",
+          {
+            ns: meta8.id
+          }
+        ],
+        icon: "ph--magic-wand--regular",
+        type: "rename",
+        disabled: !chat
+      }, () => Effect3.gen(function* () {
+        invariant(chat, void 0, {
+          F: __dxlog_file6,
+          L: 70,
+          S: this,
+          A: [
+            "chat",
+            ""
+          ]
+        });
+        yield* invoke(AssistantOperation.UpdateChatName, {
+          chat
+        });
+      }).pipe(runAndForwardErrors3)).action("branch", {
+        label: [
+          "branch-thread.menu",
+          {
+            ns: meta8.id
+          }
+        ],
+        icon: "ph--git-branch--regular",
+        type: "branch",
+        disabled: true
+      }, () => {
+      });
+      if (chats.length > 0) {
+        builder.group("chats", {
+          label: [
+            "chat-history.label",
+            {
+              ns: meta8.id
+            }
+          ],
+          icon: "ph--clock-counter-clockwise--regular",
+          selectCardinality: "single",
+          variant: "dropdownMenu"
+        }, (builder2) => {
+          chats.toSorted((a, b) => a.id.localeCompare(b.id)).forEach((chat2) => {
+            builder2.action(chat2.id, {
+              label: Obj6.getLabel(chat2) ?? [
+                "object-name.placeholder",
+                {
+                  ns: Chat2.Chat.typename
+                }
+              ]
+            }, () => Effect3.gen(function* () {
+              invariant(companionTo, void 0, {
+                F: __dxlog_file6,
+                L: 106,
+                S: this,
+                A: [
+                  "companionTo",
+                  ""
+                ]
+              });
+              yield* invoke(AssistantOperation.SetCurrentChat, {
+                companionTo,
+                chat: chat2
+              });
+            }).pipe(runAndForwardErrors3));
+          });
+        });
+      }
+      return builder.build();
+    });
+  }, [
+    chats.length,
+    db?.spaceId,
+    companionTo?.id,
+    chat?.id,
+    invoke
+  ]));
+};
 
-// src/capabilities/edge-model-resolver/index.ts
-import { Capability as Capability4 } from "@dxos/app-framework";
-var EdgeModelResolver = Capability4.lazy("EdgeModelResolver", () => import("./edge-model-resolver-G5KMODPO.mjs"));
+// src/hooks/useContextBinder.ts
+import { RegistryContext as RegistryContext2 } from "@effect-atom/atom-react";
+import * as Effect4 from "effect/Effect";
+import { useContext as useContext2, useState as useState9 } from "react";
+import { AiContextBinder } from "@dxos/assistant";
+import { createFeedServiceLayer as createFeedServiceLayer2 } from "@dxos/echo-db";
+import { runAndForwardErrors as runAndForwardErrors4 } from "@dxos/effect";
+import { useAsyncEffect as useAsyncEffect2 } from "@dxos/react-ui";
+var useContextBinder = (space, feed) => {
+  const registry = useContext2(RegistryContext2);
+  const [binder, setBinder] = useState9();
+  useAsyncEffect2(async () => {
+    setBinder(void 0);
+    if (!space || !feed) {
+      return;
+    }
+    const feedServiceLayer = createFeedServiceLayer2(space.queues);
+    const runtime3 = await runAndForwardErrors4(Effect4.runtime().pipe(Effect4.provide(feedServiceLayer)));
+    const binder2 = new AiContextBinder({
+      feed,
+      runtime: runtime3,
+      registry
+    });
+    await binder2.open();
+    setBinder(binder2);
+    return () => {
+      void binder2.close();
+    };
+  }, [
+    space,
+    feed
+  ]);
+  return binder;
+};
 
-// src/capabilities/local-model-resolver/index.ts
-import { Capability as Capability5 } from "@dxos/app-framework";
-var LocalModelResolver = Capability5.lazy("LocalModelResolver", () => import("./local-model-resolver-KDZLYI7Y.mjs"));
+// src/hooks/useContextObjects.ts
+import { Atom as Atom3, useAtomValue as useAtomValue2 } from "@effect-atom/atom-react";
+import { useCallback as useCallback5 } from "react";
+var emptyObjectsAtom = Atom3.make([]);
+var useContextObjects3 = ({ db, context }) => {
+  const objects = useAtomValue2(context?.objects ?? emptyObjectsAtom);
+  const handleUpdateObject = useCallback5(async (dxn, checked) => {
+    if (!db || !context) {
+      return;
+    }
+    const ref = db.makeRef(dxn);
+    await ref.load();
+    if (checked) {
+      await context.bind({
+        objects: [
+          ref
+        ]
+      });
+    } else {
+      await context.unbind({
+        objects: [
+          ref
+        ]
+      });
+    }
+  }, [
+    db,
+    context
+  ]);
+  return {
+    objects,
+    onUpdateObject: handleUpdateObject
+  };
+};
 
-// src/capabilities/operation-resolver/index.ts
-import { Capability as Capability6 } from "@dxos/app-framework";
-var OperationResolver = Capability6.lazy("OperationResolver", () => import("./operation-resolver-SX4WMNA7.mjs"));
+// src/hooks/useFilteredTypes.ts
+import * as Option5 from "effect/Option";
+import { useEffect as useEffect7, useState as useState10 } from "react";
+import { EntityKind, SystemTypeAnnotation, getTypeAnnotation } from "@dxos/echo/internal";
+var useFilteredTypes2 = (db) => {
+  const [types, setTypes] = useState10([]);
+  useEffect7(() => {
+    if (!db) {
+      return;
+    }
+    return db.schemaRegistry.query({
+      location: [
+        "database",
+        "runtime"
+      ]
+    }).subscribe((query) => {
+      const types2 = Array.from(new Set(query.results.filter((schema) => getTypeAnnotation(schema)?.kind !== EntityKind.Relation).filter((schema) => !SystemTypeAnnotation.get(schema).pipe(Option5.getOrElse(() => false)))));
+      setTypes(types2);
+    }, {
+      fire: true
+    });
+  }, [
+    db
+  ]);
+  return types;
+};
 
-// src/capabilities/react-surface/index.ts
-import { Capability as Capability7 } from "@dxos/app-framework";
-var ReactSurface = Capability7.lazy("ReactSurface", () => import("./react-surface-ZR6FXGLF.mjs"));
+// src/hooks/useFlush.ts
+import { useCallback as useCallback6, useRef as useRef3, useState as useState11 } from "react";
+var useFlush = (space) => {
+  const [state, setState] = useState11("idle");
+  const resetTimer = useRef3(null);
+  const handleFlush = useCallback6(() => {
+    if (!space) {
+      return;
+    }
+    queueMicrotask(async () => {
+      if (resetTimer.current) {
+        clearTimeout(resetTimer.current);
+      }
+      setState("flushing");
+      await space.db.flush();
+      setState("flushed");
+      resetTimer.current = setTimeout(() => {
+        setState("idle");
+        resetTimer.current = null;
+      }, 1e3);
+    });
+  }, [
+    space
+  ]);
+  return {
+    state,
+    handleFlush
+  };
+};
 
-// src/capabilities/repair/index.ts
-import { Capability as Capability8 } from "@dxos/app-framework";
-var Repair = Capability8.lazy("Repair", () => import("./repair-QJ7CQDKU.mjs"));
+// src/hooks/useOnline.ts
+import { useState as useState12 } from "react";
+var useOnline = () => {
+  const [online, setOnline] = useState12(true);
+  return [
+    online,
+    setOnline
+  ];
+};
 
-// src/capabilities/settings/index.ts
-import { Capability as Capability9 } from "@dxos/app-framework";
-var Settings = Capability9.lazy("Settings", () => import("./settings-CQEOHR3R.mjs"));
+// src/hooks/usePresets.ts
+import { useCallback as useCallback7, useEffect as useEffect8, useMemo as useMemo9, useState as useState13 } from "react";
+var usePresets = (online) => {
+  const [preset, setPreset] = useState13();
+  const presets = useMemo9(() => AiServicePresets.filter((preset2) => online === (preset2.provider === "dxos-remote")), [
+    online
+  ]);
+  const presetOptions = useMemo9(() => presets.map(({ id, model, label }) => ({
+    id,
+    label: label ?? model
+  })), [
+    presets
+  ]);
+  useEffect8(() => {
+    setPreset(presets[0]);
+  }, [
+    presets
+  ]);
+  const handlePresetChange = useCallback7((id) => {
+    const preset2 = presets.find((preset3) => preset3.id === id);
+    if (preset2) {
+      setPreset(preset2);
+    }
+  }, [
+    presets
+  ]);
+  return {
+    preset,
+    presets: presetOptions,
+    onPresetChange: handlePresetChange
+  };
+};
 
-// src/capabilities/state/index.ts
-import { Capability as Capability10 } from "@dxos/app-framework";
-var AssistantState = Capability10.lazy("AssistantState", () => import("./state-HDON4REW.mjs"));
+// src/hooks/useReferencesProvider.ts
+import { useMemo as useMemo10 } from "react";
+import { Filter as Filter6, Obj as Obj7 } from "@dxos/echo";
+var useReferencesProvider = (space) => {
+  return useMemo10(() => {
+    if (!space) {
+      return void 0;
+    }
+    return {
+      getReferences: async ({ query }) => {
+        const objects = await space.db.query(Filter6.everything()).run();
+        return objects.filter((object) => stringMatch(query, Obj7.getLabel(object) ?? "")).filter((object) => !!Obj7.getDXN(object)).map((object) => ({
+          uri: Obj7.getDXN(object).toString(),
+          label: Obj7.getLabel(object) ?? ""
+        }));
+      },
+      resolveReference: async ({ uri }) => {
+        const object = await space.db.query(Filter6.id(uri)).first();
+        return {
+          uri,
+          label: Obj7.getLabel(object) ?? ""
+        };
+      }
+    };
+  }, [
+    space
+  ]);
+};
+var stringMatch = (query, label) => label.toLowerCase().startsWith(query.toLowerCase());
 
-// src/capabilities/toolkit/index.ts
-import { Capability as Capability11 } from "@dxos/app-framework";
-var Toolkit = Capability11.lazy("Toolkit", () => import("./toolkit-OWGCEKOO.mjs"));
+// src/meta.ts
+import { trim as trim2 } from "@dxos/util";
+var meta9 = {
+  id: "org.dxos.plugin.assistant",
+  name: "Assistant",
+  description: trim2`
+    Intelligent AI assistant that can analyze and interact with objects across your spaces.
+    Chat naturally to get insights, search content, and perform actions using AI-powered context awareness.
+  `,
+  icon: "ph--sparkle--regular",
+  iconHue: "sky",
+  source: "https://github.com/dxos/dxos/tree/main/packages/plugins/plugin-assistant",
+  tags: [
+    "labs"
+  ]
+};
+var ASSISTANT_DIALOG = `${meta9.id}.assistant.dialog`;
+var ASSISTANT_COMPANION_VARIANT = "assistant-chat";
 
 // src/translations.ts
-import { Blueprint, Prompt } from "@dxos/blueprints";
+import { Chat as Chat3, Agent } from "@dxos/assistant-toolkit";
+import { Blueprint as Blueprint2, Prompt } from "@dxos/blueprints";
 import { Sequence } from "@dxos/conductor";
-import { Type } from "@dxos/echo";
+import { Type as Type2 } from "@dxos/echo";
+import { meta as meta10 } from "#meta";
 var translations = [
   {
     "en-US": {
       // TODO(burdon): From assistant.
-      [Blueprint.Blueprint.typename]: {
-        "typename label": "Blueprint",
-        "typename label_zero": "Blueprints",
-        "typename label_one": "Blueprint",
-        "typename label_other": "Blueprints",
-        "object name placeholder": "New blueprint",
-        "rename object label": "Rename blueprint",
-        "delete object label": "Delete blueprint",
-        "object deleted label": "Blueprint deleted"
+      [Blueprint2.Blueprint.typename]: {
+        "typename.label": "Blueprint",
+        "typename.label_zero": "Blueprints",
+        "typename.label_one": "Blueprint",
+        "typename.label_other": "Blueprints",
+        "object-name.placeholder": "New blueprint",
+        "add-object.label": "Add blueprint",
+        "rename-object.label": "Rename blueprint",
+        "delete-object.label": "Delete blueprint",
+        "object-deleted.label": "Blueprint deleted"
       },
-      [Type.getTypename(Prompt.Prompt)]: {
-        "typename label": "Prompt",
-        "typename label_zero": "Prompts",
-        "typename label_one": "Prompt",
-        "typename label_other": "Prompts",
-        "object name placeholder": "New prompt",
-        "rename object label": "Rename prompt",
-        "delete object label": "Delete prompt",
-        "object deleted label": "Prompt deleted"
+      [Type2.getTypename(Prompt.Prompt)]: {
+        "typename.label": "Prompt",
+        "typename.label_zero": "Prompts",
+        "typename.label_one": "Prompt",
+        "typename.label_other": "Prompts",
+        "object-name.placeholder": "New prompt",
+        "add-object.label": "Add prompt",
+        "rename-object.label": "Rename prompt",
+        "delete-object.label": "Delete prompt",
+        "object-deleted.label": "Prompt deleted"
       },
       // TODO(burdon): From conductor.
       [Sequence.typename]: {
-        "typename label": "Sequence",
-        "typename label_zero": "Sequences",
-        "typename label_one": "Sequence",
-        "typename label_other": "Sequences",
-        "object name placeholder": "New sequence",
-        "rename object label": "Rename sequence",
-        "delete object label": "Delete sequence",
-        "object deleted label": "Sequence deleted"
+        "typename.label": "Sequence",
+        "typename.label_zero": "Sequences",
+        "typename.label_one": "Sequence",
+        "typename.label_other": "Sequences",
+        "object-name.placeholder": "New sequence",
+        "add-object.label": "Add sequence",
+        "rename-object.label": "Rename sequence",
+        "delete-object.label": "Delete sequence",
+        "object-deleted.label": "Sequence deleted"
       },
-      [Assistant_exports.Chat.typename]: {
-        "typename label": "AI Chat",
-        "object name placeholder": "New AI Chat",
-        "rename object label": "Rename AI Chat",
-        "delete object label": "Delete AI Chat",
-        "object deleted label": "AI Chat deleted"
+      [Chat3.Chat.typename]: {
+        "typename.label": "AI Chat",
+        "object-name.placeholder": "New AI Chat",
+        "add-object.label": "Add AI chat",
+        "rename-object.label": "Rename AI Chat",
+        "delete-object.label": "Delete AI Chat",
+        "object-deleted.label": "AI Chat deleted"
+      },
+      [Agent.Agent.typename]: {
+        "typename.label": "Agent",
+        "typename.label_zero": "Agents",
+        "typename.label_one": "Agent",
+        "typename.label_other": "Agents",
+        "object-name.placeholder": "New agent",
+        "add-object.label": "Add agent",
+        "rename-object.label": "Rename agent",
+        "delete-object.label": "Delete agent",
+        "object-deleted.label": "Agent deleted"
       },
       // TODO(burdon): Reconcile with react-ui-chat.
-      [meta.id]: {
-        "templates label": "Templates",
-        "open ambient chat label": "Open Assistant",
-        "assistant chat label": "Assistant",
-        "plugin name": "Assistant",
-        "settings title": "Assistant settings",
-        "object placeholder": "New prompt",
-        "create object label": "Create prompt",
-        "create trigger label": "Create trigger",
-        "create stack section label": "Create prompt",
-        "command placeholder": "Enter slash command...",
-        "template placeholder": "Enter template...",
-        "value placeholder": "Enter value...",
-        "prompt rules label": "Prompt Rules",
-        "typename placeholder": "Enter typename of objects which this template is for",
-        "description placeholder": "Enter description of when this template should be used",
-        "select preset template placeholder": "Select preset",
-        "service registry label": "Service Registry",
-        "type filter placeholder": "Type",
-        "any type filter label": "Any",
-        "no blueprint message": "No active blueprints",
-        "tool call label": "Calling tool...",
-        "tool result label": "Success",
-        "tool error label": "Tool call failed",
-        "invocations label": "Invocations",
-        "assistant dialog title": "Assistant",
-        "open assistant label": "Open assistant",
-        "no tools": "No tools are configured",
-        "no results": "No results",
-        "cancel button": "Cancel",
-        "save button": "Save",
-        "new thread button": "New Chat",
-        "rename thread button": "Rename Chat",
-        "chat history label": "Chat History",
-        "chat update name label": "Update AI Chat name",
-        "toolkit label": "Toolkit",
-        "summary label": "Summary",
-        "search placeholder": "Search...",
-        "prompt placeholder": "Enter question or command...",
-        "context objects button": "Add to context",
-        "context settings button": "Chat settings",
-        "microphone button": "Click to speak",
-        "cancel processing button": "Stop processing",
-        "blueprints in context title": "Blueprints",
-        "objects in context title": "Content",
-        "remove object in context label": "Remove document",
-        "chat model title": "Model",
-        "settings default label": "Default",
-        "settings custom prompts label": "Use custom prompts",
-        "settings llm provider label": "LLM provider",
-        "settings edge llm model label": "Remote language model",
-        "settings ollama llm model label": "Ollama language model"
+      [meta10.id]: {
+        "templates.label": "Templates",
+        "open-ambient-chat.label": "Open Assistant",
+        "assistant-chat.label": "Assistant",
+        "plugin.name": "Assistant",
+        "settings.title": "Assistant settings",
+        "object.placeholder": "New prompt",
+        "create-object.label": "Create prompt",
+        "create-trigger.label": "Create trigger",
+        "create-stack-section.label": "Create prompt",
+        "command.placeholder": "Enter slash command...",
+        "template.placeholder": "Enter template...",
+        "value.placeholder": "Enter value...",
+        "prompt-rules.label": "Prompt Rules",
+        "typename.placeholder": "Enter typename of objects which this template is for",
+        "description.placeholder": "Enter description of when this template should be used",
+        "select-preset-template.placeholder": "Select preset",
+        "service-registry.label": "Service Registry",
+        "type-filter.placeholder": "Type",
+        "any-type-filter.label": "Any",
+        "no-blueprint.message": "No active blueprints",
+        "tool-call.label": "Calling",
+        "tool-result.label": "Success",
+        "tool-error.label": "Tool call failed",
+        "invocations.label": "Invocations",
+        "trace.label": "Trace",
+        "assistant-dialog.title": "Assistant",
+        "open-assistant.label": "Open assistant",
+        "reset-blueprints.label": "Reset blueprints",
+        "no-results.message": "No results",
+        "cancel.button": "Cancel",
+        "save.button": "Save",
+        "new-thread.button": "New Chat",
+        "rename-thread.button": "Rename Chat",
+        "chat-history.label": "Chat History",
+        "chat-update-name.label": "Update AI Chat name",
+        "toolkit.label": "Toolkit",
+        "stats.label": "Stats",
+        "summary.label": "Summary",
+        "thinking.label": "Thinking",
+        "search.placeholder": "Search...",
+        "prompt.placeholder": "Enter question or command...",
+        "context-objects.button": "Add to context",
+        "context-settings.button": "Chat settings",
+        "microphone.button": "Click to speak",
+        "cancel-processing.button": "Stop processing",
+        "blueprints-in-context.title": "Blueprints",
+        "objects-in-context.title": "Content",
+        "remove-object-in-context.label": "Remove document",
+        "chat-model.title": "Model",
+        "debug.button": "Debug",
+        "online-switch.label": "Online",
+        "run-prompt.label": "Run prompt",
+        "typename.label": "Typename",
+        "branch-thread.menu": "Branch chat",
+        "chat-toolbar.title": "Chat toolbar",
+        "settings.default.label": "Default",
+        "settings.custom-prompts.label": "Use custom prompts",
+        "settings.custom-prompts.description": "Allow the assistant to use custom prompts defined in your spaces.",
+        "settings.llm-provider.label": "LLM provider",
+        "settings.llm-provider.description": "Select which language model service to use for AI responses.",
+        "settings.edge-llm-model.label": "Remote language model",
+        "settings.edge-llm-model.description": "Choose the remote language model used for AI requests.",
+        "settings.ollama-llm-model.label": "Ollama language model",
+        "settings.ollama-llm-model.description": "Choose the locally hosted Ollama model for AI requests.",
+        "settings.default-llm-model.label": "Default language model",
+        // Trigger status
+        "trigger-status-disabled.label": "Triggers disabled",
+        "trigger-status-idle.label": "Triggers idle",
+        "trigger-status-running.label": "Trigger running",
+        "trigger-status-error.label": "Trigger error",
+        "trigger-runtime.label": "Auto trigger execution",
+        "trigger-last-invocation.label": "Last run",
+        "trigger-duration.label": "Duration",
+        // AgentArticle.
+        "project-empty-spec.message": "Open Properties to configure the agent.",
+        "project-empty-spec.description": "Open Assistant to interact with the agent.",
+        "artifacts.label": "Artifacts",
+        "input-queue.label": "Inputs",
+        // AgentProperties.
+        "instructions.label": "Instructions",
+        "agent.spec.placeholder": "Enter instructions, goals, and constraints for the assistant.",
+        "reset-history.button": "Reset",
+        "subscriptions.label": "Subscriptions"
       }
     }
   }
 ];
 
 // src/AssistantPlugin.tsx
-import * as Effect from "effect/Effect";
-import { Capability as Capability12, Common, Plugin } from "@dxos/app-framework";
-import { ResearchGraph } from "@dxos/assistant-toolkit";
-import { Blueprint as Blueprint2, Prompt as Prompt2 } from "@dxos/blueprints";
+import * as Effect5 from "effect/Effect";
+import * as Option6 from "effect/Option";
+import { ActivationEvent, ActivationEvents, Capability, Plugin } from "@dxos/app-framework";
+import { AppActivationEvents, AppPlugin } from "@dxos/app-toolkit";
+import { Agent as Agent2, AgentBlueprint, Chat as Chat4, Memory, Plan, ResearchGraph } from "@dxos/assistant-toolkit";
+import { Blueprint as Blueprint3, Prompt as Prompt2 } from "@dxos/blueprints";
 import { Sequence as Sequence2 } from "@dxos/conductor";
-import { Obj, Type as Type2 } from "@dxos/echo";
-import { Operation } from "@dxos/operation";
+import { Annotation as Annotation3, Feed, Obj as Obj8, Type as Type3 } from "@dxos/echo";
+import { Operation as Operation3 } from "@dxos/operation";
+import { AutomationCapabilities as AutomationCapabilities2 } from "@dxos/plugin-automation/types";
 import { ClientEvents } from "@dxos/plugin-client/types";
+import { DeckEvents } from "@dxos/plugin-deck/types";
+import { MarkdownEvents } from "@dxos/plugin-markdown";
+import { SpaceOperation } from "@dxos/plugin-space/operations";
 import { SpaceCapabilities, SpaceEvents } from "@dxos/plugin-space/types";
 import { HasSubject } from "@dxos/types";
-var AssistantPlugin = Plugin.define(meta).pipe(Common.Plugin.addTranslationsModule({
-  translations
-}), Common.Plugin.addSettingsModule({
-  activate: Settings
-}), Plugin.addModule({
-  // TODO(wittjosiah): Does not integrate with settings store.
-  //   Should this be a different event?
-  //   Should settings store be renamed to be more generic?
-  activatesOn: Common.ActivationEvent.SetupSettings,
-  activate: AssistantState
-}), Common.Plugin.addMetadataModule({
+import { AiService, AppGraphBuilder, AssistantState, BlueprintDefinition, CompanionChatProvisioner, EdgeModelResolver, LocalModelResolver, MarkdownExtension, Migrations, OperationHandler, ReactSurface, Settings, Toolkit } from "#capabilities";
+import { meta as meta11 } from "#meta";
+import { AssistantOperation as AssistantOperation2 } from "#operations";
+import { AssistantEvents as AssistantEvents2 } from "#types";
+var AssistantPlugin = Plugin.define(meta11).pipe(AppPlugin.addAppGraphModule({
+  activate: AppGraphBuilder
+}), AppPlugin.addBlueprintDefinitionModule({
+  activate: BlueprintDefinition
+}), AppPlugin.addMetadataModule({
   metadata: [
     {
-      id: Type2.getTypename(Assistant_exports.Chat),
+      id: Type3.getTypename(Chat4.Chat),
       metadata: {
-        icon: "ph--atom--regular",
-        iconHue: "sky",
-        createObject: (props) => Effect.sync(() => Assistant_exports.make(props))
+        icon: Annotation3.IconAnnotation.get(Chat4.Chat).pipe(Option6.getOrThrow).icon,
+        iconHue: Annotation3.IconAnnotation.get(Chat4.Chat).pipe(Option6.getOrThrow).hue ?? "white",
+        createObject: (props, options) => Effect5.gen(function* () {
+          const { object } = yield* Operation3.invoke(AssistantOperation2.CreateChat, {
+            db: options.db,
+            name: props?.name
+          });
+          return yield* Operation3.invoke(SpaceOperation.AddObject, {
+            object,
+            target: options.target,
+            hidden: true,
+            targetNodeId: options.targetNodeId
+          });
+        })
       }
     },
     {
-      id: Type2.getTypename(Blueprint2.Blueprint),
+      id: Type3.getTypename(Blueprint3.Blueprint),
       metadata: {
-        icon: "ph--blueprint--regular",
-        iconHue: "sky",
-        inputSchema: AssistantOperation.BlueprintForm,
-        createObject: (props) => Effect.sync(() => Blueprint2.make(props))
+        icon: Annotation3.IconAnnotation.get(Blueprint3.Blueprint).pipe(Option6.getOrThrow).icon,
+        iconHue: Annotation3.IconAnnotation.get(Blueprint3.Blueprint).pipe(Option6.getOrThrow).hue ?? "white",
+        inputSchema: AssistantOperation2.BlueprintForm,
+        createObject: (props, options) => Effect5.gen(function* () {
+          const object = Blueprint3.make(props);
+          return yield* Operation3.invoke(SpaceOperation.AddObject, {
+            object,
+            target: options.target,
+            hidden: true,
+            targetNodeId: options.targetNodeId
+          });
+        })
       }
     },
     {
-      id: Type2.getTypename(Prompt2.Prompt),
+      id: Type3.getTypename(Prompt2.Prompt),
       metadata: {
-        icon: "ph--scroll--regular",
-        iconHue: "sky",
-        createObject: (props) => Effect.sync(() => Prompt2.make(props))
+        icon: Annotation3.IconAnnotation.get(Prompt2.Prompt).pipe(Option6.getOrThrow).icon,
+        iconHue: Annotation3.IconAnnotation.get(Prompt2.Prompt).pipe(Option6.getOrThrow).hue ?? "white",
+        createObject: (props, options) => Effect5.gen(function* () {
+          const object = Prompt2.make(props);
+          return yield* Operation3.invoke(SpaceOperation.AddObject, {
+            object,
+            target: options.target,
+            hidden: true,
+            targetNodeId: options.targetNodeId
+          });
+        })
       }
     },
     {
-      id: Type2.getTypename(Sequence2),
+      id: Type3.getTypename(Sequence2),
       metadata: {
-        icon: "ph--circuitry--regular",
-        iconHue: "sky",
-        createObject: (props) => Effect.sync(() => Obj.make(Sequence2, props)),
-        addToCollectionOnCreate: true
+        icon: Annotation3.IconAnnotation.get(Sequence2).pipe(Option6.getOrThrow).icon,
+        iconHue: Annotation3.IconAnnotation.get(Sequence2).pipe(Option6.getOrThrow).hue ?? "white",
+        createObject: (props, options) => Effect5.gen(function* () {
+          const object = Obj8.make(Sequence2, props);
+          return yield* Operation3.invoke(SpaceOperation.AddObject, {
+            object,
+            target: options.target,
+            hidden: true,
+            targetNodeId: options.targetNodeId
+          });
+        })
+      }
+    },
+    {
+      id: Type3.getTypename(Agent2.Agent),
+      metadata: {
+        icon: Annotation3.IconAnnotation.get(Agent2.Agent).pipe(Option6.getOrThrow).icon,
+        iconHue: Annotation3.IconAnnotation.get(Agent2.Agent).pipe(Option6.getOrThrow).hue ?? "white",
+        createObject: (props, options) => Effect5.gen(function* () {
+          const object = yield* Agent2.makeInitialized({
+            name: "",
+            spec: ""
+          }, AgentBlueprint.make()).pipe(withComputeRuntime(options.db.spaceId));
+          return yield* Operation3.invoke(SpaceOperation.AddObject, {
+            object,
+            target: options.target,
+            hidden: true,
+            targetNodeId: options.targetNodeId
+          });
+        })
       }
     }
   ]
-}), Common.Plugin.addSchemaModule({
+}), AppPlugin.addOperationHandlerModule({
+  activate: OperationHandler
+}), AppPlugin.addSchemaModule({
   schema: [
-    Assistant_exports.Chat,
-    Assistant_exports.CompanionTo,
-    Blueprint2.Blueprint,
+    Chat4.Chat,
+    Chat4.CompanionTo,
+    Blueprint3.Blueprint,
+    Feed.Feed,
     HasSubject.HasSubject,
     Prompt2.Prompt,
-    ResearchGraph,
-    Sequence2
+    ResearchGraph.ResearchGraph,
+    Agent2.Agent,
+    Plan.Plan,
+    Sequence2,
+    Memory.Memory
   ]
-}), Plugin.addModule({
-  id: "on-space-created",
-  activatesOn: SpaceEvents.SpaceCreated,
-  activate: () => Effect.succeed(Capability12.contributes(SpaceCapabilities.OnCreateSpace, (params) => Operation.invoke(AssistantOperation.OnCreateSpace, params)))
-}), Plugin.addModule({
-  activatesOn: ClientEvents.SpacesReady,
-  activate: Repair
-}), Common.Plugin.addAppGraphModule({
-  activate: AppGraphBuilder
-}), Common.Plugin.addOperationResolverModule({
-  activate: OperationResolver
-}), Common.Plugin.addSurfaceModule({
+}), AppPlugin.addSettingsModule({
+  activate: Settings
+}), AppPlugin.addSurfaceModule({
   activate: ReactSurface,
   activatesBefore: [
-    Common.ActivationEvent.SetupArtifactDefinition
+    AppActivationEvents.SetupArtifactDefinition
   ]
+}), AppPlugin.addTranslationsModule({
+  translations
+}), Plugin.addModule({
+  id: "markdown",
+  activatesOn: MarkdownEvents.SetupExtensions,
+  activate: MarkdownExtension
+}), Plugin.addModule({
+  // TODO(wittjosiah): Does not integrate with settings store.
+  //   Should this be a different event?
+  //   Should settings store be renamed to be more generic?
+  activatesOn: AppActivationEvents.SetupSettings,
+  activate: AssistantState
+}), Plugin.addModule({
+  id: "on-space-created",
+  activatesOn: SpaceEvents.SpaceCreated,
+  activate: () => Effect5.succeed(Capability.contributes(SpaceCapabilities.OnCreateSpace, (params) => Operation3.invoke(AssistantOperation2.OnCreateSpace, params)))
 }), Plugin.addModule({
-  activatesOn: AssistantEvents.SetupAiServiceProviders,
+  activatesOn: AssistantEvents2.SetupAiServiceProviders,
   activate: EdgeModelResolver
 }), Plugin.addModule({
-  activatesOn: AssistantEvents.SetupAiServiceProviders,
+  activatesOn: AssistantEvents2.SetupAiServiceProviders,
   activate: LocalModelResolver
 }), Plugin.addModule({
   activatesBefore: [
-    AssistantEvents.SetupAiServiceProviders
+    AssistantEvents2.SetupAiServiceProviders
   ],
   // TODO(dmaretskyi): This should activate lazily when the AI chat is used.
-  activatesOn: Common.ActivationEvent.Startup,
+  activatesOn: ActivationEvents.Startup,
   activate: AiService
-}), Common.Plugin.addBlueprintDefinitionModule({
-  activate: BlueprintDefinition
 }), Plugin.addModule({
   // TODO(wittjosiah): Use a different event.
-  activatesOn: Common.ActivationEvent.Startup,
+  activatesOn: ActivationEvents.Startup,
   activate: Toolkit
+}), Plugin.addModule({
+  activatesOn: ActivationEvent.allOf(ActivationEvents.OperationInvokerReady, AppActivationEvents.AppGraphReady, DeckEvents.StateReady),
+  activate: CompanionChatProvisioner
+}), Plugin.addModule({
+  activatesOn: ClientEvents.SetupMigration,
+  activate: Migrations
 }), Plugin.make);
+var withComputeRuntime = (spaceId) => (effect) => Effect5.gen(function* () {
+  const provider = yield* Capability.get(AutomationCapabilities2.ComputeRuntime).pipe(Effect5.orDie);
+  const runtime3 = yield* provider.getRuntime(spaceId).runtimeEffect;
+  return yield* effect.pipe(Effect5.provide(runtime3));
+});
 export {
+  ASSISTANT_COMPANION_VARIANT,
   ASSISTANT_DIALOG,
-  AiService,
   ApiAuthorization,
-  AppGraphBuilder,
   Assistant_exports as Assistant,
-  assistant_blueprint_exports as AssistantBlueprint,
+  blueprint_default as AssistantBlueprint,
   AssistantCapabilities,
   AssistantEvents,
-  AssistantOperation,
   AssistantPlugin,
   AssistantSettings,
-  AssistantState,
-  BlueprintArticle,
-  BlueprintDefinition,
   Chat,
-  ChatCompanion,
-  ChatContainer,
   ChatContextProvider,
-  ChatDialog,
-  EdgeModelResolver,
   LLM_PROVIDERS,
-  LocalModelResolver,
-  OperationResolver,
-  PromptArticle,
-  ReactSurface,
-  Repair,
+  ProcessTree,
   ServiceType,
-  Settings,
   TemplateEditor,
   Toolbox,
-  ToolboxContainer,
-  Toolkit,
+  ToolboxPanel,
   categoryIcons,
-  meta,
+  meta9 as meta,
   translations,
-  useActiveBlueprints,
-  useBlueprintHandlers,
+  useActiveBlueprints2 as useActiveBlueprints,
+  useBlueprintHandlers2 as useBlueprintHandlers,
   useBlueprintRegistry,
-  useBlueprints,
+  useBlueprints2 as useBlueprints,
   useChatContext,
   useChatProcessor,
   useChatServices,
-  useChatToolbarActions,
+  useChatToolbarActions2 as useChatToolbarActions,
   useContextBinder,
-  useContextObjects,
-  useFilteredTypes,
+  useContextObjects3 as useContextObjects,
+  useFilteredTypes2 as useFilteredTypes,
   useFlush,
   useOnline,
   usePresets,