@dxos/plugin-assistant 0.8.4-main.f9ba587 → 0.8.4-main.fcc0d83b33

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

@@ -1,266 +1,3371 @@
 import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
 import {
-  AssistantSettings,
-  ChatContainer,
-  ChatDialog,
-  PromptSettings,
-  SequenceContainer,
-  TemplateContainer
-} from "./chunk-HVMVHP4R.mjs";
-import {
-  TemplateEditor,
-  handlebarsHighlightStyle
-} from "./chunk-VESVUAOS.mjs";
-import {
-  Chat,
-  Toolbox,
-  ToolboxContainer
-} from "./chunk-D3HTVK5D.mjs";
-import {
-  ApiAuthorization,
-  Assistant,
-  LLM_PROVIDERS,
-  ServiceType,
-  TemplateInputSchema,
-  TemplateInputType,
-  TemplateKindSchema,
-  TemplateKinds,
-  TemplateType,
-  categoryIcons
-} from "./chunk-YYUVTTVK.mjs";
-import {
-  AiClient,
-  AppGraphBuilder,
-  IntentResolver,
-  ReactSurface,
-  Settings
-} from "./chunk-HXKRKIN2.mjs";
-import {
-  AssistantCapabilities
-} from "./chunk-E6V2RUQ2.mjs";
-import {
-  ASSISTANT_DIALOG,
-  ASSISTANT_PLUGIN,
-  meta
-} from "./chunk-KOC6ESG7.mjs";
+  UpdateChatName
+} from "./chunk-NCIZY5ZV.mjs";
+import "./chunk-HSLMI22Q.mjs";
 
-// src/events.ts
-import { Events } from "@dxos/app-framework";
-(function(AssistantEvents2) {
-  AssistantEvents2.AiClientReady = Events.createStateEvent(`${meta.id}/ai-client-ready`);
-})(AssistantEvents || (AssistantEvents = {}));
-var AssistantEvents;
+// src/components/index.ts
+import { lazy } from "react";
 
-// src/AssistantPlugin.tsx
-import { Effect } from "effect";
-import { Capabilities, Events as Events2, allOf, contributes, createIntent, defineModule, definePlugin } from "@dxos/app-framework";
-import { Sequence as Sequence2 } from "@dxos/conductor";
-import { Ref, Type } from "@dxos/echo";
-import { ClientCapabilities, ClientEvents } from "@dxos/plugin-client";
-import { SpaceCapabilities, SpaceEvents } from "@dxos/plugin-space";
-import { CollectionAction, defineObjectForm } from "@dxos/plugin-space/types";
-
-// src/translations.ts
-import { Sequence } from "@dxos/conductor";
-var translations = [
-  {
-    "en-US": {
-      [Assistant.Chat.typename]: {
-        "typename label": "Assistant",
-        "typename label_zero": "Assistants",
-        "typename label_one": "Assistant",
-        "typename label_other": "Assistants",
-        "object name placeholder": "New assistant"
-      },
-      [Sequence.typename]: {
-        "typename label": "Sequence",
-        "typename label_zero": "Sequences",
-        "typename label_one": "Sequence",
-        "typename label_other": "Sequences",
-        "object name placeholder": "New sequence"
-      },
-      [TemplateType.typename]: {
-        "typename label": "Template",
-        "typename label_zero": "Templates",
-        "typename label_one": "Template",
-        "typename label_other": "Templates",
-        "object name placeholder": "New template"
-      },
-      [meta.id]: {
-        "templates label": "Templates",
-        "open ambient chat label": "Open Assistant",
-        "assistant chat label": "Assistant",
-        "plugin name": "Assistant",
-        "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",
-        "sequence logs label": "Logs",
-        "assistant dialog title": "Assistant",
-        "open assistant label": "Open assistant",
-        "no tools": "No tools are configured.",
-        "button save": "Save",
-        "button run": "Run",
-        "search placeholder": "Search...",
-        "prompt placeholder": "Ask or search for anything...",
-        "context objects placeholder": "Add to context...",
-        "button add blueprint": "Configure blueprints",
-        "button microphone": "Click to speak",
-        "button cancel processing": "Stop processing",
-        "button scroll down": "Scroll down",
-        "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"
+// src/components/Chat/Chat.tsx
+import { useAtomValue as useAtomValue2 } from "@effect-atom/atom-react";
+import * as Array2 from "effect/Array";
+import * as Option4 from "effect/Option";
+import React13, { useCallback as useCallback5, useEffect as useEffect6, useMemo as useMemo5, useRef as useRef3, useState as useState7 } from "react";
+import { Event } from "@dxos/async";
+import { Filter as Filter2, Obj as Obj3 } from "@dxos/echo";
+import { useQuery as useQuery2 } from "@dxos/react-client/echo";
+import { useIdentity } from "@dxos/react-client/halo";
+import { Menu } from "@dxos/react-ui-menu";
+import { Message } from "@dxos/types";
+import { composable, composableProps } from "@dxos/ui-theme";
+import { useChatKeymapExtensions as useChatKeymapExtensions2, useChatToolbarActions, useDebug } from "#hooks";
+
+// src/components/ChatPrompt/ChatActions.tsx
+import React from "react";
+import { IconButton, useTranslation } from "@dxos/react-ui";
+import { mx } from "@dxos/ui-theme";
+import { meta } from "#meta";
+var ChatActions = ({ classNames, children, microphone, recording, processing, debug, onEvent }) => {
+  const { t } = useTranslation(meta.id);
+  return /* @__PURE__ */ React.createElement("div", {
+    className: mx("flex items-center", classNames)
+  }, children, microphone && /* @__PURE__ */ React.createElement(IconButton, {
+    disabled: !processing,
+    classNames: mx(recording && "bg-primary-500"),
+    variant: "ghost",
+    icon: "ph--microphone--regular",
+    iconOnly: true,
+    noTooltip: true,
+    label: t("microphone.button"),
+    onMouseDown: () => onEvent?.({
+      type: "record-start"
+    }),
+    onMouseUp: () => onEvent?.({
+      type: "record-stop"
+    }),
+    onTouchStart: () => onEvent?.({
+      type: "record-start"
+    }),
+    onTouchEnd: () => onEvent?.({
+      type: "record-stop"
+    })
+  }), debug && /* @__PURE__ */ React.createElement(IconButton, {
+    variant: "ghost",
+    icon: "ph--wrench--regular",
+    iconOnly: true,
+    label: t("debug.button"),
+    onClick: () => onEvent?.({
+      type: "toggle-debug"
+    })
+  }), /* @__PURE__ */ React.createElement(IconButton, {
+    disabled: !processing,
+    variant: "ghost",
+    icon: "ph--x--regular",
+    iconOnly: true,
+    label: t("cancel-processing.button"),
+    onClick: () => onEvent?.({
+      type: "cancel"
+    })
+  }));
+};
+
+// src/components/ChatPrompt/ChatOptions.tsx
+import * as Option from "effect/Option";
+import React2, { useCallback, useMemo, useState } from "react";
+import { McpServer } from "@dxos/assistant-toolkit";
+import { Annotation, Filter, Obj, Type } from "@dxos/echo";
+import { useObject, useQuery } from "@dxos/react-client/echo";
+import { IconButton as IconButton2, Input, Popover, Select, useTranslation as 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";
+import { Assistant } from "#types";
+var styles = {
+  panel: "w-[calc(100dvw-.5rem)] sm:w-max max-w-document-width",
+  toolbar: "p-0! gap-0! border-t border-separator"
+};
+var ChatOptions = ({ chat, db, context, blueprintRegistry, presets, preset, onPresetChange }) => {
+  const { t } = useTranslation2(meta2.id);
+  return /* @__PURE__ */ React2.createElement("div", {
+    role: "none",
+    className: "flex"
+  }, /* @__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: styles.panel
+  }, /* @__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: styles.panel
+  }, /* @__PURE__ */ React2.createElement(Popover.Viewport, null, /* @__PURE__ */ React2.createElement(Tabs.Root, {
+    classNames: "flex",
+    orientation: "horizontal",
+    defaultValue: "view",
+    defaultActivePart: "list",
+    tabIndex: -1
+  }, /* @__PURE__ */ React2.createElement(Tabs.Viewport, {
+    classNames: mx2("grid grid-rows-[1fr_40px] w-full")
+  }, /* @__PURE__ */ React2.createElement(Tabs.Panel, {
+    tabIndex: -1,
+    classNames: "dx-focus-ring-inset overflow-hidden",
+    value: "view"
+  }, /* @__PURE__ */ React2.createElement(ViewPanel, {
+    chat
+  })), /* @__PURE__ */ React2.createElement(Tabs.Panel, {
+    tabIndex: -1,
+    classNames: "dx-focus-ring-inset overflow-hidden",
+    value: "blueprints"
+  }, /* @__PURE__ */ React2.createElement(BlueprintsPanel, {
+    blueprintRegistry,
+    db,
+    context
+  })), /* @__PURE__ */ React2.createElement(Tabs.Panel, {
+    tabIndex: -1,
+    classNames: "dx-focus-ring-inset overflow-hidden",
+    value: "mcp-servers"
+  }, /* @__PURE__ */ React2.createElement(McpServersPanel, {
+    db
+  })), /* @__PURE__ */ React2.createElement(Tabs.Panel, {
+    tabIndex: -1,
+    classNames: "dx-focus-ring-inset overflow-hidden",
+    value: "model"
+  }, /* @__PURE__ */ React2.createElement(ModelsPanel, {
+    presets,
+    preset,
+    onPresetChange
+  })), /* @__PURE__ */ React2.createElement(Tabs.Tablist, {
+    classNames: [
+      styles.toolbar
+    ]
+  }, /* @__PURE__ */ React2.createElement(Tabs.IconTab, {
+    value: "view",
+    icon: "ph--eye--regular",
+    label: t("chat-view.title")
+  }), /* @__PURE__ */ React2.createElement(Tabs.IconTab, {
+    value: "blueprints",
+    icon: "ph--blueprint--regular",
+    label: t("options.blueprints.title")
+  }), /* @__PURE__ */ React2.createElement(Tabs.IconTab, {
+    value: "mcp-servers",
+    icon: "ph--plugs-connected--regular",
+    label: t("options.mcp.title")
+  }), /* @__PURE__ */ React2.createElement(Tabs.IconTab, {
+    value: "model",
+    icon: "ph--cpu--regular",
+    label: t("options.chat-model.title")
+  }))))), /* @__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: "flex flex-col"
+  }, /* @__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: "border-t border-separator",
+    autoFocus: true
+  })));
+};
+var ViewPanel = ({ chat }) => {
+  const { t } = useTranslation2(meta2.id);
+  const [view, setView] = useObject(chat, "view");
+  const value2 = view ?? "normal";
+  return /* @__PURE__ */ React2.createElement(Listbox.Root, {
+    value: value2,
+    onValueChange: setView,
+    autoFocus: true
+  }, Assistant.ChatViews.map((view2) => /* @__PURE__ */ React2.createElement(Listbox.Option, {
+    key: view2,
+    value: view2
+  }, /* @__PURE__ */ React2.createElement(Listbox.OptionLabel, null, t(`chat-view.${view2}.label`, {
+    defaultValue: view2
+  })), /* @__PURE__ */ React2.createElement(Listbox.OptionIndicator, null))));
+};
+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 McpServersPanel = ({ db }) => {
+  const { t } = useTranslation2(meta2.id);
+  const servers = useQuery(db, Filter.type(McpServer.McpServer));
+  const [adding, setAdding] = useState(false);
+  const handleAdd = useCallback((name, url, protocol, apiKey) => {
+    db.add(Obj.make(McpServer.McpServer, {
+      name,
+      url,
+      protocol,
+      apiKey,
+      enabled: true
+    }));
+    setAdding(false);
+  }, [
+    db
+  ]);
+  const handleToggle = useCallback((server, enabled) => {
+    Obj.update(server, (server2) => {
+      server2.enabled = enabled;
+    });
+  }, []);
+  const handleRemove = useCallback((server) => {
+    db.remove(server);
+  }, [
+    db
+  ]);
+  return /* @__PURE__ */ React2.createElement("div", {
+    className: "p-form-chrome"
+  }, servers.map((server) => /* @__PURE__ */ React2.createElement("div", {
+    key: server.id,
+    className: "flex items-center gap-2 px-form-chrome"
+  }, /* @__PURE__ */ React2.createElement(Input.Root, null, /* @__PURE__ */ React2.createElement(Input.Label, {
+    srOnly: true
+  }, server.name), /* @__PURE__ */ React2.createElement(Input.Switch, {
+    checked: server.enabled !== false,
+    onCheckedChange: (checked) => handleToggle(server, !!checked)
+  })), /* @__PURE__ */ React2.createElement("span", {
+    className: "flex-1 truncate text-sm"
+  }, server.name), /* @__PURE__ */ React2.createElement("span", {
+    className: "truncate text-xs text-description"
+  }, server.url), /* @__PURE__ */ React2.createElement(IconButton2, {
+    variant: "ghost",
+    icon: "ph--x--regular",
+    iconOnly: true,
+    label: t("mcp-server-remove.label"),
+    onClick: () => handleRemove(server)
+  }))), adding ? /* @__PURE__ */ React2.createElement(McpServerForm, {
+    onSubmit: handleAdd,
+    onCancel: () => setAdding(false)
+  }) : /* @__PURE__ */ React2.createElement("div", {
+    role: "none"
+  }, /* @__PURE__ */ React2.createElement(IconButton2, {
+    variant: "ghost",
+    icon: "ph--plus--regular",
+    label: t("mcp-server-add.label"),
+    onClick: () => setAdding(true)
+  })));
+};
+var McpServerForm = ({ onSubmit, onCancel }) => {
+  const { t } = useTranslation2(meta2.id);
+  const [name, setName] = useState("");
+  const [url, setUrl] = useState("");
+  const [protocol, setProtocol] = useState("sse");
+  const [apiKey, setApiKey] = useState("");
+  const canSubmit = name.trim().length > 0 && url.trim().length > 0;
+  const handleSubmit = useCallback(() => {
+    if (canSubmit) {
+      onSubmit(name.trim(), url.trim(), protocol, apiKey.trim() || void 0);
+    }
+  }, [
+    canSubmit,
+    name,
+    url,
+    protocol,
+    apiKey,
+    onSubmit
+  ]);
+  return /* @__PURE__ */ React2.createElement("div", {
+    className: "space-y-2 px-form-chrome"
+  }, /* @__PURE__ */ React2.createElement(Input.Root, null, /* @__PURE__ */ React2.createElement(Input.Label, {
+    srOnly: true
+  }, t("mcp-server-name.label")), /* @__PURE__ */ React2.createElement(Input.TextInput, {
+    placeholder: t("mcp-server-name.placeholder"),
+    value: name,
+    onChange: (event) => setName(event.target.value),
+    autoFocus: true
+  })), /* @__PURE__ */ React2.createElement(Input.Root, null, /* @__PURE__ */ React2.createElement(Input.Label, {
+    srOnly: true
+  }, t("mcp-server-url.label")), /* @__PURE__ */ React2.createElement(Input.TextInput, {
+    placeholder: t("mcp-server-url.placeholder"),
+    value: url,
+    onChange: (event) => setUrl(event.target.value)
+  })), /* @__PURE__ */ React2.createElement(Select.Root, {
+    value: protocol,
+    onValueChange: (value2) => setProtocol(value2)
+  }, /* @__PURE__ */ React2.createElement(Select.TriggerButton, {
+    placeholder: t("mcp-server-protocol.label")
+  }), /* @__PURE__ */ React2.createElement(Select.Portal, null, /* @__PURE__ */ React2.createElement(Select.Content, null, /* @__PURE__ */ React2.createElement(Select.Viewport, null, /* @__PURE__ */ React2.createElement(Select.Option, {
+    value: "sse"
+  }, "SSE"), /* @__PURE__ */ React2.createElement(Select.Option, {
+    value: "http"
+  }, "HTTP"))))), /* @__PURE__ */ React2.createElement(Input.Root, null, /* @__PURE__ */ React2.createElement(Input.Label, {
+    srOnly: true
+  }, t("mcp-server-api-key.label")), /* @__PURE__ */ React2.createElement(Input.TextInput, {
+    type: "password",
+    placeholder: t("mcp-server-api-key.placeholder"),
+    value: apiKey,
+    onChange: (event) => setApiKey(event.target.value)
+  })), /* @__PURE__ */ React2.createElement("div", {
+    role: "none",
+    className: "flex gap-2"
+  }, /* @__PURE__ */ React2.createElement(IconButton2, {
+    variant: "ghost",
+    icon: "ph--check--regular",
+    iconOnly: true,
+    label: t("save.button"),
+    onClick: handleSubmit,
+    disabled: !canSubmit
+  }), /* @__PURE__ */ React2.createElement(IconButton2, {
+    variant: "ghost",
+    icon: "ph--x--regular",
+    iconOnly: true,
+    label: t("cancel.button"),
+    onClick: onCancel
+  })));
+};
+var ANY = "__any__";
+var ObjectsPanel = ({ db, context }) => {
+  const { t } = 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: "ph--cube--regular",
+      hue: void 0
+    })));
+    const styles3 = 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: styles3?.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: mx2("flex flex-col", styles.toolbar)
+  }, /* @__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"),
+    autoFocus: true
+  })));
+};
+
+// src/components/ChatPrompt/ChatPresets.tsx
+import React3 from "react";
+import { Select as Select2 } from "@dxos/react-ui";
+
+// src/components/ChatPrompt/ChatPrompt.tsx
+import { useAtomValue } from "@effect-atom/atom-react";
+import * as Option3 from "effect/Option";
+import React6, { useCallback as useCallback2, useEffect as useEffect2, useRef, useState as useState3 } from "react";
+import { useVoiceInput } from "@dxos/plugin-transcription";
+import { Input as Input2, useDynamicRef, useTranslation as useTranslation4 } from "@dxos/react-ui";
+import { ChatEditor } from "@dxos/react-ui-chat";
+import { mx as mx5 } from "@dxos/ui-theme";
+import { useChatKeymapExtensions } from "#hooks";
+import { meta as meta4 } from "#meta";
+
+// 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_ICON,
+      hue: void 0
+    })));
+    const styles3 = 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: styles3?.surfaceText
+    }), toLocalizedString(label, t), /* @__PURE__ */ React4.createElement(IconButton3, {
+      icon: "ph--x--bold",
+      iconOnly: true,
+      variant: "ghost",
+      label: t("remove-object.label"),
+      classNames: "p-0 hover:bg-transparent",
+      size: 3,
+      onClick: () => onUpdateObject?.(dxn, false)
+    }));
+  }));
+};
+var DEFAULT_OBJECT_ICON = "ph--cube--regular";
+
+// src/components/ChatPrompt/ChatStatusIndicator.tsx
+import 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/ChatPrompt/ChatPrompt.tsx
+var ChatPrompt = ({ classNames, outline, chat, db, processor, event, online, placeholder, onOnlineChange, onPresetChange, settings = true, presets, preset }) => {
+  const { t } = useTranslation4(meta4.id);
+  const error = useAtomValue(processor.error).pipe(Option3.getOrUndefined);
+  const streaming = useAtomValue(processor.streaming);
+  const active = useAtomValue(processor.active);
+  const activeRef = useDynamicRef(active);
+  const editorRef = useRef(null);
+  const [recordingState, setRecordingState] = useState3(false);
+  useEffect2(() => {
+    return event.on((ev) => {
+      switch (ev.type) {
+        case "update-prompt":
+          if (!editorRef.current?.getText()?.length) {
+            editorRef.current?.setText(ev.text);
+            editorRef.current?.focus();
+          }
+          break;
+        case "record-start":
+          setRecordingState(true);
+          break;
+        case "record-stop":
+          setRecordingState(false);
+          break;
+      }
+    });
+  }, [
+    event
+  ]);
+  const { recording } = useVoiceInput({
+    active: recordingState,
+    onUpdate: (text) => {
+      editorRef.current?.setText(text);
+      editorRef.current?.focus();
+    }
+  });
+  const extensions = useChatKeymapExtensions({
+    event
+  });
+  const handleSubmit = useCallback2((text) => {
+    if (!activeRef.current) {
+      event.emit({
+        type: "submit",
+        text
+      });
+      return true;
+    }
+  }, [
+    event
+  ]);
+  const handleEvent = useCallback2((ev) => {
+    event.emit(ev);
+  }, [
+    event
+  ]);
+  return /* @__PURE__ */ React6.createElement("div", {
+    role: "group",
+    className: mx5("flex flex-col w-full dx-density-fine", outline && "bg-group-surface rounded-sm! border border-subdued-separator transition transition-border [&:has(.cm-content:focus)]:border-separator", classNames)
+  }, /* @__PURE__ */ React6.createElement("div", {
+    role: "none",
+    className: "flex p-2 gap-2"
+  }, /* @__PURE__ */ React6.createElement(ChatStatusIndicator, {
+    classNames: "p-1",
+    preset,
+    error,
+    processing: streaming
+  }), /* @__PURE__ */ React6.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__ */ React6.createElement("div", {
+    role: "none",
+    className: "flex items-center overflow-hidden p-1.5"
+  }, /* @__PURE__ */ React6.createElement(ChatOptions, {
+    chat,
+    db,
+    blueprintRegistry: processor.blueprintRegistry,
+    context: processor.context,
+    preset,
+    presets,
+    onPresetChange
+  }), /* @__PURE__ */ React6.createElement("div", {
+    role: "none",
+    className: "flex grow overflow-x-auto scrollbar-none"
+  }, /* @__PURE__ */ React6.createElement(ChatReferences, {
+    db,
+    context: processor.context
+  })), /* @__PURE__ */ React6.createElement(ChatActions, {
+    classNames: "col-span-2",
+    microphone: true,
+    recording,
+    processing: streaming,
+    onEvent: handleEvent
+  }, online !== void 0 && /* @__PURE__ */ React6.createElement(Input2.Root, null, /* @__PURE__ */ React6.createElement(Input2.Label, {
+    srOnly: true
+  }, t("online-switch.label")), /* @__PURE__ */ React6.createElement(Input2.Switch, {
+    classNames: "mx-2",
+    checked: online,
+    onCheckedChange: onOnlineChange
+  })))));
+};
+ChatPrompt.displayName = "Chat.Prompt";
+
+// src/components/ChatPrompt/ChatStatus.tsx
+import React7, { useEffect as useEffect3, useMemo as useMemo2, useState as useState4 } from "react";
+import { ChatStatus as NaturalChatStatus, formatElapsed } from "@dxos/react-ui-chat";
+import { Matrix } from "@dxos/react-ui-sfx";
+import { Unit } from "@dxos/util";
+
+// src/components/Chat/context.ts
+import { createContext } from "@radix-ui/react-context";
+var [ChatContextProvider, useChatContext] = createContext("Chat");
+
+// src/components/ChatPrompt/ChatStatus.tsx
+var CHAT_STREAM_STATUS_NAME = "Chat.StreamStatus";
+var TICK_MS = 1e3;
+var ChatStatus = ({ classNames, icon }) => {
+  const { messages, requestTiming } = useChatContext(CHAT_STREAM_STATUS_NAME);
+  const { lastOutputTokens, sessionTotalTokens } = useMemo2(() => {
+    let last;
+    let total = 0;
+    for (const message of messages) {
+      for (const block of message.blocks) {
+        if (isStats(block) && block.usage) {
+          last = block.usage.outputTokens;
+          total += block.usage.totalTokens ?? 0;
+        }
       }
     }
+    return {
+      lastOutputTokens: last,
+      sessionTotalTokens: total
+    };
+  }, [
+    messages
+  ]);
+  const isRunning = requestTiming != null && requestTiming.endedAt == null;
+  const show = requestTiming || lastOutputTokens || sessionTotalTokens > 0;
+  if (!show) {
+    return null;
   }
+  return /* @__PURE__ */ React7.createElement(NaturalChatStatus.Root, {
+    defaultRunning: false,
+    classNames: [
+      "py-2 gap-2 text-sm",
+      classNames
+    ]
+  }, icon && /* @__PURE__ */ React7.createElement(NaturalChatStatus.Icon, null, /* @__PURE__ */ React7.createElement(Matrix, {
+    classNames: "w-5 h-5",
+    dotClassNames: "bg-primary-500",
+    dim: 4,
+    dotSize: 3,
+    count: 10,
+    interval: 500,
+    active: isRunning
+  })), show && /* @__PURE__ */ React7.createElement("div", {
+    role: "none",
+    className: "flex items-center"
+  }, requestTiming && /* @__PURE__ */ React7.createElement(NaturalChatStatus.Text, null, /* @__PURE__ */ React7.createElement(Elapsed, {
+    timing: requestTiming
+  })), lastOutputTokens != null && /* @__PURE__ */ React7.createElement(React7.Fragment, null, requestTiming && /* @__PURE__ */ React7.createElement(NaturalChatStatus.Separator, null), /* @__PURE__ */ React7.createElement(NaturalChatStatus.Text, null, "\u2193 ", Unit.Thousand(lastOutputTokens).toString())), sessionTotalTokens > 0 && /* @__PURE__ */ React7.createElement(React7.Fragment, null, (requestTiming || lastOutputTokens != null) && /* @__PURE__ */ React7.createElement(NaturalChatStatus.Separator, null), /* @__PURE__ */ React7.createElement(NaturalChatStatus.Text, null, "\u03A3 ", Unit.Thousand(sessionTotalTokens).toString()))));
+};
+var Elapsed = ({ timing }) => {
+  const isRunning = timing.endedAt == null;
+  const [now, setNow] = useState4(Date.now());
+  useEffect3(() => {
+    if (!isRunning) {
+      return;
+    }
+    const id = setInterval(() => setNow(Date.now()), TICK_MS);
+    return () => clearInterval(id);
+  }, [
+    isRunning
+  ]);
+  return /* @__PURE__ */ React7.createElement(React7.Fragment, null, formatElapsed((timing.endedAt ?? now) - timing.startedAt));
+};
+var isStats = (block) => block._tag === "stats";
+
+// src/components/ChatThread/ChatThread.tsx
+import React12, { forwardRef, useCallback as useCallback4, useEffect as useEffect5, useMemo as useMemo4, useState as useState6 } from "react";
+import { PublicKey } from "@dxos/keys";
+import { setRef } from "@dxos/react-ui";
+import { MarkdownStream } from "@dxos/react-ui-markdown";
+import { keyToFallback } from "@dxos/util";
+
+// src/components/ChatThread/registry.tsx
+import React11 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 React8 from "react";
+import { TogglePanel } from "@dxos/react-ui-components";
+import { JsonHighlighter } from "@dxos/react-ui-syntax-highlighter";
+var FallbackWidget = ({ _tag, ...props }) => {
+  return /* @__PURE__ */ React8.createElement(TogglePanel.Root, null, /* @__PURE__ */ React8.createElement(TogglePanel.Header, {
+    classNames: "bg-group-surface"
+  }, _tag), /* @__PURE__ */ React8.createElement(TogglePanel.Content, {
+    classNames: "bg-modal-surface"
+  }, /* @__PURE__ */ React8.createElement(TogglePanel.Viewport, null, /* @__PURE__ */ React8.createElement(JsonHighlighter, {
+    classNames: "p-2! text-sm",
+    data: props
+  }))));
+};
+FallbackWidget.displayName = "Fallback";
+
+// src/components/ChatThread/widgets/ReasoningWidget.ts
+import { WidgetType } from "@codemirror/view";
+import { Domino } from "@dxos/ui";
+
+// src/components/ChatThread/widgets/defaults.ts
+var styles2 = {
+  padding: "my-4",
+  border: "border border-subdued-separator rounded-sm"
+};
+
+// src/components/ChatThread/widgets/ReasoningWidget.ts
+var ReasoningWidget = class extends WidgetType {
+  text;
+  #pos;
+  /** The timer id last registered for this instance (may differ from the map if superseded). */
+  #ownedTimerId = null;
+  constructor(text, pos) {
+    super(), this.text = text;
+    this.#pos = pos === void 0 || pos === "" ? "reasoning" : String(pos);
+  }
+  eq(other) {
+    return this.text === other.text && this.#pos === other.#pos;
+  }
+  toDOM() {
+    return Domino.of("div").classNames(styles2.padding).append(Domino.of("div").classNames("relative overflow-hidden p-px", styles2.border).attributes({
+      "data-trail-container": ""
+    }).append(Domino.of("div").classNames("relative z-10 bg-base-surface rounded-sm text-sm text-subdued px-2 py-1").append(Domino.of("div").classNames("max-h-[5lh] overflow-y-auto").text(this.text).attributes({
+      "data-reasoning-text": ""
+    })), Domino.of("div").attributes({
+      "data-id": this.#pos
+    }))).root;
+  }
+  updateDOM(dom) {
+    dom.querySelector("[data-reasoning-text]")?.replaceChildren(this.text);
+    const container = dom.querySelector("[data-trail-container]");
+    let trailHost = container?.querySelector("[data-id]");
+    if (container && !trailHost) {
+      trailHost = Domino.of("div").attributes({
+        "data-id": this.#pos
+      }).root;
+      container.append(trailHost);
+    }
+    if (trailHost?.childElementCount === 0) {
+      trailHost.append(...createTrailLayers());
+    }
+    this.#scheduleTrailRemoval(dom);
+    return true;
+  }
+  destroy(_dom) {
+    this.#clearOwnedTrailTimer();
+  }
+  #scheduleTrailRemoval(dom) {
+    const previous = trailRemovalTimers.get(this.#pos);
+    if (previous !== void 0) {
+      clearTimeout(previous);
+    }
+    const timerId = setTimeout(() => {
+      if (trailRemovalTimers.get(this.#pos) !== timerId) {
+        return;
+      }
+      trailRemovalTimers.delete(this.#pos);
+      this.#ownedTimerId = null;
+      dom.querySelector("[data-id]")?.remove();
+    }, TRAIL_REMOVAL_DELAY_MS);
+    trailRemovalTimers.set(this.#pos, timerId);
+    this.#ownedTimerId = timerId;
+  }
+  #clearOwnedTrailTimer() {
+    const active = trailRemovalTimers.get(this.#pos);
+    if (active !== void 0 && active === this.#ownedTimerId) {
+      clearTimeout(active);
+      trailRemovalTimers.delete(this.#pos);
+    }
+    this.#ownedTimerId = null;
+  }
+};
+var trail = [
+  "absolute z-0 aspect-[2/1] w-16",
+  "bg-[radial-gradient(at_100%_50%,_theme(colors.green.700),_transparent_80%)]",
+  "[offset-anchor:100%_50%] [offset-path:border-box]"
+];
+var TRAIL_REMOVAL_DELAY_MS = 1e3;
+var trailRemovalTimers = /* @__PURE__ */ new Map();
+var createTrailLayers = () => [
+  Domino.of("div").classNames(...trail, "animate-trail").root,
+  Domino.of("div").classNames(...trail, "animate-trail-offset").root
 ];
 
-// src/AssistantPlugin.tsx
-var AssistantPlugin = () => definePlugin(meta, [
-  defineModule({
-    id: `${meta.id}/module/translations`,
-    activatesOn: Events2.SetupTranslations,
-    activate: () => contributes(Capabilities.Translations, translations)
-  }),
-  defineModule({
-    id: `${meta.id}/module/settings`,
-    activatesOn: Events2.SetupSettings,
-    activate: Settings
-  }),
-  defineModule({
-    id: `${meta.id}/module/metadata`,
-    activatesOn: Events2.SetupMetadata,
-    activate: () => [
-      contributes(Capabilities.Metadata, {
-        id: Type.getTypename(Sequence2),
-        metadata: {
-          icon: "ph--circuitry--regular"
+// src/components/ChatThread/widgets/ReferenceWidget.ts
+import { WidgetType as WidgetType2 } from "@codemirror/view";
+import { Domino as Domino2 } from "@dxos/ui";
+var ReferenceWidget = class extends WidgetType2 {
+  text;
+  dxn;
+  constructor(text, dxn) {
+    super(), this.text = text, this.dxn = dxn;
+  }
+  eq(other) {
+    return this.dxn === other.dxn;
+  }
+  toDOM() {
+    return Domino2.of("div").classNames(styles2.padding).append(Domino2.of("dx-anchor").classNames("dx-tag--anchor").attributes({
+      dxn: this.dxn
+    }).text(this.text)).root;
+  }
+};
+
+// src/components/ChatThread/widgets/SelectWidget.ts
+import { WidgetType as WidgetType3 } from "@codemirror/view";
+import { Domino as Domino3 } from "@dxos/ui";
+var SelectWidget = class extends WidgetType3 {
+  options;
+  constructor(options) {
+    super(), this.options = options;
+  }
+  eq(other) {
+    return JSON.stringify(this.options) === JSON.stringify(other.options);
+  }
+  /**
+  * NOTE: Container must set var based on user's identity.
+  */
+  toDOM() {
+    return Domino3.of("div").attributes({
+      role: "group"
+    }).classNames(styles2.padding, "flex flex-wrap gap-1").append(...this.options.map((option) => Domino3.of("button").classNames("dx-button inline-block max-w-[100cqi]").attributes({
+      "data-action": "submit",
+      "data-value": option,
+      "data-density": "fine"
+    }).text(option))).root;
+  }
+};
+
+// src/components/ChatThread/widgets/StatsWidget.ts
+import { WidgetType as WidgetType4 } from "@codemirror/view";
+import { Domino as Domino4 } from "@dxos/ui";
+var StatsWidget = class extends WidgetType4 {
+  text;
+  constructor(text) {
+    super(), this.text = text;
+  }
+  eq(other) {
+    return this.text === other.text;
+  }
+  toDOM() {
+    return Domino4.of("div").classNames(styles2.padding, "text-sm text-placeholder").text(this.text).root;
+  }
+  updateDOM(dom) {
+    dom.textContent = this.text;
+    return true;
+  }
+};
+
+// src/components/ChatThread/widgets/StatusWidget.ts
+import { WidgetType as WidgetType5 } from "@codemirror/view";
+import { Domino as Domino5 } from "@dxos/ui";
+var StatusWidget = class extends WidgetType5 {
+  text;
+  #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 Domino5.of("div").classNames(styles2.padding).append(Domino5.of("div").classNames("relative overflow-hidden rounded-sm").append(Domino5.of("div").classNames("grid grid-cols-[24px_1fr] gap-x-0.5 gap-y-0 items-start px-0.5 py-0.5 text-placeholder").append(Domino5.of("div").classNames("flex h-5 w-full shrink-0 items-center justify-center self-start").append(Domino5.of("span").classNames("block size-1.5 shrink-0 rounded-full bg-current opacity-45")), Domino5.of("div").classNames("relative min-w-0").append(Domino5.of("div").classNames("relative z-10 rounded-sm text-sm leading-5").attributes({
+      "data-status-text": ""
+    }).text(this.text), Domino5.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 = () => [
+  Domino5.of("div").classNames(...trail2, "animate-trail").root,
+  Domino5.of("div").classNames(...trail2, "animate-trail-offset").root
+];
+
+// src/components/ChatThread/widgets/SummaryWidget.tsx
+import React9 from "react";
+import { useTranslation as useTranslation5 } from "@dxos/react-ui";
+import { TogglePanel as TogglePanel2 } from "@dxos/react-ui-components";
+import { meta as meta5 } from "#meta";
+var SummaryWidget = ({ children }) => {
+  const { t } = useTranslation5(meta5.id);
+  return /* @__PURE__ */ React9.createElement(TogglePanel2.Root, {
+    classNames: styles2.border
+  }, /* @__PURE__ */ React9.createElement(TogglePanel2.Header, {
+    classNames: "text-sm bg-group-surface"
+  }, t("summary.label")), /* @__PURE__ */ React9.createElement(TogglePanel2.Content, null, /* @__PURE__ */ React9.createElement("div", {
+    role: "none",
+    className: "p-1 text-sm text-subdued"
+  }, children)));
+};
+
+// src/components/ChatThread/widgets/SuggestionWidget.ts
+import { WidgetType as WidgetType6 } from "@codemirror/view";
+import { Domino as Domino6, mx as mx6 } from "@dxos/ui";
+var SuggestionWidget = class extends WidgetType6 {
+  text;
+  constructor(text) {
+    super(), this.text = text;
+  }
+  eq(other) {
+    return this.text === other.text;
+  }
+  toDOM() {
+    return Domino6.of("span").classNames(mx6("inline-flex max-w-[calc(100cqi-8px)] my-1 pe-2 overflow-hidden")).append(Domino6.of("button").attributes({
+      "data-action": "submit",
+      "data-density": "fine",
+      "data-value": this.text
+    }).classNames(mx6("dx-button gap-2 w-full overflow-hidden")).append(Domino6.of("dx-icon").attributes({
+      icon: "ph--lightning--regular"
+    }), Domino6.of("span").classNames("flex-1 truncate min-w-0").text(this.text))).root;
+  }
+};
+
+// src/components/ChatThread/widgets/ToolWidget.tsx
+import React10, { useCallback as useCallback3, useEffect as useEffect4, useMemo as useMemo3, useRef as useRef2, useState as useState5 } from "react";
+import { useTranslation as useTranslation6 } from "@dxos/react-ui";
+import { NumericTabs, TextCrawl, TogglePanel as TogglePanel3 } from "@dxos/react-ui-components";
+import { JsonHighlighter as JsonHighlighter2 } from "@dxos/react-ui-syntax-highlighter";
+import { isNonNullable, safeParseJson } from "@dxos/util";
+import { meta as meta6 } from "#meta";
+var ToolWidget = ({ view, blocks = [] }) => {
+  const { t } = useTranslation6(meta6.id);
+  const items = useMemo3(() => {
+    let lastToolCall;
+    const tools = [];
+    return blocks.filter((block) => block._tag === "toolCall" || block._tag === "toolResult" || block._tag === "stats").map((block) => {
+      switch (block._tag) {
+        case "toolCall": {
+          if (block.pending && lastToolCall?.block.toolCallId === block.toolCallId) {
+            return null;
+          }
+          const tool = tools.find((tool2) => tool2.name === block.name);
+          lastToolCall = {
+            tool,
+            block
+          };
+          return {
+            title: tool?.description ?? [
+              t("tool-call.label"),
+              block.name
+            ].filter(Boolean).join(" "),
+            content: {
+              ...block,
+              input: safeParseJson(block.input)
+            }
+          };
         }
-      }),
-      contributes(Capabilities.Metadata, {
-        id: Type.getTypename(Assistant.Chat),
-        metadata: {
-          icon: "ph--atom--regular"
+        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)
+            }
+          };
         }
-      })
-    ]
-  }),
-  defineModule({
-    id: `${meta.id}/module/object-form`,
-    activatesOn: ClientEvents.SetupSchema,
-    activate: () => [
-      contributes(SpaceCapabilities.ObjectForm, defineObjectForm({
-        objectSchema: Assistant.Chat,
-        getIntent: (_, options) => createIntent(Assistant.CreateChat, {
-          space: options.space
-        })
-      })),
-      contributes(SpaceCapabilities.ObjectForm, defineObjectForm({
-        objectSchema: Sequence2,
-        getIntent: () => createIntent(Assistant.CreateSequence)
+        case "stats": {
+          if (!lastToolCall) {
+            return null;
+          }
+          return {
+            title: t("stats.label"),
+            content: block
+          };
+        }
+      }
+    }).filter(isNonNullable);
+  }, [
+    blocks,
+    t
+  ]);
+  const handleChangeOpen = useCallback3(() => {
+    setTimeout(() => {
+      view?.requestMeasure();
+    }, 1e3);
+  }, [
+    view
+  ]);
+  if (!items.length) {
+    return null;
+  }
+  return /* @__PURE__ */ React10.createElement(ToolPanel, {
+    items,
+    onChangeOpen: handleChangeOpen
+  });
+};
+var ToolPanel = ({ items, onChangeOpen }) => {
+  const tabsRef = useRef2(null);
+  const [selected, setSelected] = useState5(0);
+  const [open, setOpen] = useState5(false);
+  useEffect4(() => {
+    setSelected((prev) => Math.min(prev, Math.max(0, items.length - 1)));
+  }, [
+    items.length
+  ]);
+  useEffect4(() => {
+    onChangeOpen?.(open);
+    if (open) {
+      tabsRef.current?.focus();
+    }
+  }, [
+    open,
+    onChangeOpen
+  ]);
+  const handleSelect = useCallback3((index) => {
+    setSelected(index);
+  }, []);
+  return /* @__PURE__ */ React10.createElement(TogglePanel3.Root, {
+    open,
+    onChangeOpen: setOpen
+  }, /* @__PURE__ */ React10.createElement(TogglePanel3.Header, {
+    classNames: "text-sm text-placeholder"
+  }, /* @__PURE__ */ React10.createElement(TextCrawl, {
+    key: "status-roll",
+    lines: items.map((item) => item.title),
+    autoAdvance: true,
+    greedy: true
+  })), /* @__PURE__ */ React10.createElement(TogglePanel3.Content, null, /* @__PURE__ */ React10.createElement(TogglePanel3.Viewport, {
+    classNames: "grid grid-cols-[32px_1fr]"
+  }, /* @__PURE__ */ React10.createElement(NumericTabs, {
+    ref: tabsRef,
+    classNames: "p-1",
+    length: items.length,
+    selected,
+    onSelect: handleSelect
+  }), /* @__PURE__ */ React10.createElement(JsonHighlighter2, {
+    data: items[selected]?.content,
+    classNames: "p-1 text-xs bg-transparent",
+    replacer: {
+      maxDepth: 3,
+      maxArrayLen: 10,
+      maxStringLen: 128
+    }
+  }))));
+};
+
+// src/components/ChatThread/registry.tsx
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/components/ChatThread/registry.tsx";
+var componentRegistry = {
+  //
+  // Block-only (no widget — see note above).
+  //
+  prompt: {
+    block: true
+  },
+  //
+  // DOM Widgets
+  //
+  synthetic: {
+    block: true,
+    factory: ({ children, range }) => {
+      const text = getXmlTextChild(children);
+      return text ? new ReasoningWidget(text, range.from) : null;
+    }
+  },
+  reasoning: {
+    block: true,
+    streaming: true,
+    factory: ({ children, range }) => {
+      const text = getXmlTextChild(children);
+      return text ? new ReasoningWidget(text, range.from) : null;
+    }
+  },
+  reference: {
+    block: false,
+    factory: ({ children, ref }) => {
+      const text = getXmlTextChild(children);
+      return text && ref ? new ReferenceWidget(text, ref) : null;
+    }
+  },
+  select: {
+    block: true,
+    factory: ({ children }) => {
+      const options = children?.map((option) => option._tag === "option" && getXmlTextChild(option.children)).filter(Boolean);
+      return options?.length ? new SelectWidget(options) : null;
+    }
+  },
+  suggestion: {
+    block: true,
+    factory: ({ children }) => {
+      const text = getXmlTextChild(children);
+      return text ? new SuggestionWidget(text) : null;
+    }
+  },
+  stats: {
+    block: true,
+    factory: ({ children }) => {
+      const text = getXmlTextChild(children);
+      return text ? new StatsWidget(text) : null;
+    }
+  },
+  status: {
+    block: true,
+    streaming: true,
+    factory: ({ children, 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__ */ React11.createElement("div", {
+      role: "none",
+      className: "py-2"
+    }, /* @__PURE__ */ React11.createElement(ToolWidget, props))
+  },
+  toolResult: {
+    block: true,
+    Component: FallbackWidget
+  },
+  toolkit: {
+    block: true,
+    Component: FallbackWidget
+  },
+  //
+  // Fallback
+  //
+  json: {
+    block: true,
+    Component: FallbackWidget
+  }
+};
+var blockToMarkdown = createBlockRenderer("normal");
+function createBlockRenderer(viewType) {
+  return (context, message, block) => {
+    if (!isBlockVisible(viewType, message, block)) {
+      return;
+    }
+    let str = blockToMarkdownImpl(context, message, block);
+    if (str && !block.pending) {
+      return str += "\n";
+    }
+    return str;
+  };
+}
+var isBlockVisible = (viewType, message, block) => {
+  switch (viewType) {
+    case "debug":
+      return true;
+    case "normal":
+      return block._tag !== "reasoning";
+    case "summary":
+      return block._tag === "text" && block.disposition !== "synthetic";
+    case "thinking":
+    default:
+      return true;
+  }
+};
+var blockToMarkdownImpl = (context, message, block) => {
+  log("blockToMarkdown", {
+    block: JSON.stringify(block)
+  }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 151, S: void 0 });
+  switch (block._tag) {
+    case "text": {
+      if (message.sender.role === "user") {
+        if (block.disposition === "synthetic") {
+          return renderXMLBlock("synthetic", {
+            content: block.text,
+            pending: block.pending
+          });
+        } else {
+          return `<prompt>${block.text}</prompt>`;
+        }
+      } else {
+        const text = block.text.trim();
+        if (text.length > 0) {
+          return text;
+        }
+      }
+      break;
+    }
+    case "reference": {
+      if (block.pending) {
+        return;
+      }
+      const dxn = block.reference.dxn;
+      return `<reference ref="${dxn.toString()}">${context.getObjectLabel(dxn)}</reference>`;
+    }
+    case "suggestion": {
+      if (block.pending) {
+        return;
+      }
+      return `<suggestion>${block.text}</suggestion>`;
+    }
+    case "select": {
+      if (block.pending || block.options.length === 0) {
+        return;
+      }
+      return `<select>${block.options.map((option) => `<option>${option}</option>`).join("")}</select>`;
+    }
+    case "toolCall": {
+      applyToolBlockToWidgetState(context, block);
+      return `<toolCall id="${block.toolCallId}" />`;
+    }
+    case "toolResult": {
+      applyToolBlockToWidgetState(context, block);
+      break;
+    }
+    case "stats": {
+      return "";
+    }
+    case "reasoning": {
+      let text = block.reasoningText ?? block.redactedText;
+      if (!text) {
+        return;
+      }
+      return renderXMLBlock("reasoning", {
+        content: text,
+        pending: block.pending
+      });
+    }
+    case "summary": {
+      return renderXMLBlock("summary", {
+        content: block.content,
+        pending: block.pending
+      });
+    }
+    case "status": {
+      return renderXMLBlock("status", {
+        content: block.statusText,
+        pending: block.pending
+      });
+    }
+    default: {
+      return `<json id="${message.id}">
+${JSON.stringify(block)}
+</json>`;
+    }
+  }
+};
+var escapeXmlTextContent = (raw) => raw.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+var renderXMLBlock = (tag, opts) => {
+  const content = escapeXmlTextContent((opts.content ?? "").replace(/\n\n/g, " ").trim());
+  if (opts.pending) {
+    return `<${tag}${opts.attributes ? ` ${opts.attributes}` : ""}>${content}`;
+  } else {
+    return `<${tag}${opts.attributes ? ` ${opts.attributes}` : ""}>${content}</${tag}>`;
+  }
+};
+
+// src/components/ChatThread/sync.ts
+var MessageThreadContext = class {
+  _widgetState;
+  constructor(_widgetState) {
+    this._widgetState = _widgetState;
+  }
+  updateWidget(id, value2) {
+    this._widgetState?.updateWidget(id, value2);
+  }
+  // TODO(burdon): Resolve name from hypergraph.
+  getObjectLabel(_id) {
+    return "Object";
+  }
+};
+var MessageSyncer = class {
+  _document;
+  _renderer;
+  _threadId;
+  _completed = 0;
+  _trailing = 0;
+  _context;
+  constructor(_document, _renderer) {
+    this._document = _document;
+    this._renderer = _renderer;
+    this._context = new MessageThreadContext(this._document);
+  }
+  get context() {
+    return this._context;
+  }
+  /**
+  * Replace the document with the rendering of `messages`. Use on mount, on thread switch,
+  * and from {@link update} when it detects an identity change in `messages[0]`.
+  */
+  reset(messages = []) {
+    this._threadId = messages[0]?.id;
+    this._completed = 0;
+    this._trailing = 0;
+    const buffer = this._walk(messages);
+    void this._document.setContent(buffer).then(() => {
+      rehydrateToolWidgetsFromMessages(this._context, messages);
+    });
+  }
+  /**
+  * Stream the suffix of the rendered messages into the document.
+  * Returns `true` if the document was replaced (initial mount or thread switch), `false`
+  * if the call was a streaming append (or a no-op).
+  */
+  update(messages) {
+    if (messages[0]?.id !== this._threadId) {
+      this.reset(messages);
+      return true;
+    }
+    const buffer = this._walk(messages);
+    if (buffer.length > 0) {
+      void this._document.append(buffer);
+    }
+    return false;
+  }
+  /**
+  * Walk flat blocks starting at `_completed`, advancing the cursors and returning the chars
+  * to append. Blocks before `_completed` are skipped — their renderer is never re-invoked,
+  * which preserves single-shot side effects (e.g. tool widget state mutation).
+  */
+  _walk(messages) {
+    let buffer = "";
+    let index = 0;
+    outer: for (const message of messages) {
+      for (const block of message.blocks) {
+        if (index < this._completed) {
+          index++;
+          continue;
+        }
+        const rendered = this._renderer(this._context, message, block) ?? "";
+        if (rendered.length > this._trailing) {
+          buffer += rendered.slice(this._trailing);
+        }
+        if (block.pending) {
+          if (rendered.length > this._trailing) {
+            this._trailing = rendered.length;
+          }
+          break outer;
+        }
+        this._completed = index + 1;
+        this._trailing = 0;
+        index++;
+      }
+    }
+    return buffer;
+  }
+};
+
+// src/components/ChatThread/ChatThread.tsx
+var defaultOptions = {
+  autoScroll: true,
+  cursor: false,
+  fader: false,
+  typewriter: true
+};
+var ChatThread = /* @__PURE__ */ forwardRef(({ classNames, identity, messages = [], error, options = defaultOptions, footer, debug = false, extensions, viewType, onEvent }, forwardedRef) => {
+  const [controller, setController] = useState6(null);
+  const handleMarkdownStreamRef = useCallback4((instance) => {
+    setController(instance);
+    setRef(forwardedRef, instance);
+  }, [
+    forwardedRef
+  ]);
+  const userHue = useMemo4(() => identity?.profile?.data?.hue || keyToFallback(identity?.identityKey ?? PublicKey.random()).hue, [
+    identity
+  ]);
+  useEffect5(() => {
+    controller?.scrollToBottom();
+  }, [
+    controller,
+    error
+  ]);
+  const renderer = useMemo4(() => createBlockRenderer(viewType), [
+    viewType
+  ]);
+  const syncer = useMemo4(() => controller && new MessageSyncer(controller, renderer), [
+    controller,
+    renderer
+  ]);
+  useEffect5(() => {
+    if (!syncer) {
+      return;
+    }
+    if (syncer.update(messages)) {
+      controller?.scrollToBottom("instant");
+    }
+  }, [
+    controller,
+    syncer,
+    messages
+  ]);
+  const handleEvent = useCallback4(({ type, value: value2 }) => {
+    switch (type) {
+      case "submit": {
+        value2 && onEvent?.({
+          type,
+          text: value2
+        });
+        break;
+      }
+    }
+  }, [
+    onEvent
+  ]);
+  return /* @__PURE__ */ React12.createElement("div", {
+    role: "none",
+    "data-hue": userHue,
+    className: "contents"
+  }, /* @__PURE__ */ React12.createElement(MarkdownStream, {
+    key: viewType,
+    classNames,
+    registry: componentRegistry,
+    options,
+    debug,
+    extensions,
+    footer,
+    onEvent: handleEvent,
+    ref: handleMarkdownStreamRef
+  }));
+});
+
+// src/components/Chat/Chat.tsx
+var ChatRoot = ({ children, chat, feed, processor, onEvent, ...props }) => {
+  const [debug, setDebug] = useState7(false);
+  const streaming = useAtomValue2(processor.streaming);
+  const active = useAtomValue2(processor.active);
+  const requestTiming = useRequestTiming({
+    active
+  });
+  const lastPrompt = useRef3(void 0);
+  const db = props.db ?? (chat && Obj3.getDatabase(chat));
+  const feedMessages = useQuery2(feed, Filter2.type(Message.Message));
+  const pendingMessages = useAtomValue2(processor.messages);
+  const messages = useMemo5(() => Array2.dedupeWith([
+    ...feedMessages,
+    ...pendingMessages
+  ], ({ id: a }, { id: b }) => a === b), [
+    feedMessages,
+    pendingMessages
+  ]);
+  const dump = useDebug({
+    processor
+  });
+  const event = useMemo5(() => new Event(), []);
+  useEffect6(() => {
+    return event.on((ev) => {
+      switch (ev.type) {
+        case "toggle-debug": {
+          setDebug((debug2) => {
+            if (debug2) {
+              return false;
+            } else {
+              void dump();
+              return true;
+            }
+          });
+          break;
+        }
+        case "submit": {
+          const text = ev.text.trim();
+          if (!streaming && text.length) {
+            lastPrompt.current = ev.text;
+            void processor.request({
+              message: text
+            });
+          }
+          break;
+        }
+        case "retry": {
+          if (!streaming) {
+            void processor.retry();
+          }
+          break;
+        }
+        case "cancel": {
+          if (streaming) {
+            void processor.cancel();
+            if (lastPrompt.current) {
+              event.emit({
+                type: "update-prompt",
+                text: lastPrompt.current
+              });
+            }
+          }
+          break;
+        }
+      }
+      onEvent?.(ev);
+    });
+  }, [
+    event,
+    dump,
+    processor,
+    streaming,
+    onEvent
+  ]);
+  return /* @__PURE__ */ React13.createElement(ChatContextProvider, {
+    debug,
+    event,
+    db,
+    chat,
+    messages,
+    processor,
+    requestTiming,
+    ...props
+  }, children);
+};
+ChatRoot.displayName = "Chat.Root";
+var useRequestTiming = ({ active }) => {
+  const [requestTiming, setRequestTiming] = useState7(null);
+  useEffect6(() => {
+    if (active) {
+      setRequestTiming({
+        startedAt: Date.now(),
+        endedAt: null
+      });
+    } else {
+      setRequestTiming((prev) => prev && prev.endedAt == null ? {
+        ...prev,
+        endedAt: Date.now()
+      } : prev);
+    }
+  }, [
+    active
+  ]);
+  return requestTiming;
+};
+var CHAT_TOOLBAR_NAME = "Chat.Toolbar";
+var ChatToolbar = composable(({ attendableId, companionTo, ...props }, forwardedRef) => {
+  const { chat } = useChatContext(CHAT_TOOLBAR_NAME);
+  const menuActions = useChatToolbarActions({
+    chat,
+    companionTo
+  });
+  return /* @__PURE__ */ React13.createElement(Menu.Root, {
+    ...menuActions,
+    attendableId
+  }, /* @__PURE__ */ React13.createElement(Menu.Toolbar, {
+    ...composableProps(props),
+    ref: forwardedRef
+  }));
+});
+ChatToolbar.displayName = CHAT_TOOLBAR_NAME;
+var CHAT_CONTENT_NAME = "Chat.Content";
+var ChatContent = composable(({ children, ...props }, forwardedRef) => {
+  return /* @__PURE__ */ React13.createElement("div", {
+    ...composableProps(props, {
+      classNames: "dx-expander flex flex-col"
+    }),
+    ref: forwardedRef
+  }, children);
+});
+ChatContent.displayName = CHAT_CONTENT_NAME;
+var CHAT_THREAD_NAME = "Chat.Thread";
+var ChatThread2 = ({ viewType, debug: debugProp, ...props }) => {
+  const { debug, event, messages, processor } = useChatContext(CHAT_THREAD_NAME);
+  const debugView = viewType === "debug";
+  const identity = useIdentity();
+  const error = useAtomValue2(processor.error).pipe(Option4.getOrUndefined);
+  const extensions = useChatKeymapExtensions2({
+    event
+  });
+  const controllerRef = useRef3(null);
+  useEffect6(() => {
+    return event.on((event2) => {
+      switch (event2.type) {
+        case "submit":
+        case "scroll-to-bottom":
+          controllerRef.current?.scrollToBottom();
+          break;
+        case "nav-previous":
+          controllerRef.current?.navigatePrevious();
+          break;
+        case "nav-next":
+          controllerRef.current?.navigateNext();
+          break;
+      }
+    });
+  }, [
+    event
+  ]);
+  const handleEvent = useCallback5((ev) => {
+    event.emit(ev);
+  }, [
+    event
+  ]);
+  if (!identity) {
+    return null;
+  }
+  return /* @__PURE__ */ React13.createElement(ChatThread, {
+    ...props,
+    identity,
+    messages,
+    error,
+    debug: debugProp ?? (debug || debugView),
+    viewType,
+    extensions,
+    onEvent: handleEvent,
+    ref: controllerRef
+  });
+};
+ChatThread2.displayName = CHAT_THREAD_NAME;
+var CHAT_PROMPT_NAME = "Chat.Prompt";
+var ChatPrompt2 = (props) => {
+  const { chat, db, processor, event } = useChatContext(CHAT_PROMPT_NAME);
+  return /* @__PURE__ */ React13.createElement(ChatPrompt, {
+    ...props,
+    chat,
+    db,
+    processor,
+    event
+  });
+};
+ChatPrompt2.displayName = CHAT_PROMPT_NAME;
+var Chat = {
+  Root: ChatRoot,
+  Toolbar: ChatToolbar,
+  Content: ChatContent,
+  Prompt: ChatPrompt2,
+  Status: ChatStatus,
+  Thread: ChatThread2
+};
+
+// src/components/ProcessTree/ProcessTree.tsx
+import * as Match from "effect/Match";
+import * as Option5 from "effect/Option";
+import React14 from "react";
+import { Process } from "@dxos/functions-runtime";
+import { Icon as Icon2, IconButton as IconButton4, ScrollArea, Tooltip as Tooltip2, Treegrid } from "@dxos/react-ui";
+import { composable as composable2, composableProps as composableProps2, mx as mx7 } from "@dxos/ui-theme";
+import { Unit as Unit2 } from "@dxos/util";
+var ProcessTree = composable2(({ processes, onProcessSelect, onProcessTerminate, ...props }, forwardedRef) => {
+  const sortedProcesses = [
+    ...processes.filter((process) => [
+      Process.State.RUNNING,
+      Process.State.HYBERNATING
+    ].includes(process.state)),
+    ...processes.filter((process) => [
+      Process.State.IDLE
+    ].includes(process.state)).slice(0, 3),
+    ...processes.filter((process) => [
+      Process.State.SUCCEEDED,
+      Process.State.FAILED,
+      Process.State.TERMINATED
+    ].includes(process.state))
+  ].sort((a, b) => {
+    const aCompletedAt = Option5.getOrElse(a.completedAt, () => Infinity);
+    const bCompletedAt = Option5.getOrElse(b.completedAt, () => Infinity);
+    return bCompletedAt - aCompletedAt;
+  });
+  return /* @__PURE__ */ React14.createElement(ScrollArea.Root, {
+    ...composableProps2(props, {
+      classNames: "dx-expander"
+    }),
+    thin: true,
+    ref: forwardedRef
+  }, /* @__PURE__ */ React14.createElement(ScrollArea.Viewport, null, /* @__PURE__ */ React14.createElement(Treegrid.Root, {
+    gridTemplateColumns: "1fr"
+  }, sortedProcesses.filter((process) => process.parentPid === null).map((process) => {
+    return /* @__PURE__ */ React14.createElement(Treegrid.Row, {
+      key: process.pid.toString(),
+      id: process.pid.toString(),
+      parentOf: process.parentPid?.toString()
+    }, /* @__PURE__ */ React14.createElement(Treegrid.Cell, {
+      indent: true,
+      classNames: mx7("grid grid-cols-[min-content_1fr_min-content_min-content] items-center gap-1 min-w-0", onProcessSelect && "dx-hover"),
+      onClick: () => onProcessSelect?.(process)
+    }, /* @__PURE__ */ React14.createElement(Tooltip2.Trigger, {
+      className: "p-1",
+      content: process.state.toString()
+    }, /* @__PURE__ */ React14.createElement(Icon2, {
+      size: 4,
+      classNames: mx7(process.state === Process.State.RUNNING && "animate-spin", process.state === Process.State.FAILED && "text-error-text", process.state === Process.State.SUCCEEDED && "text-success-text"),
+      icon: Match.value(process.state).pipe(Match.when(Process.State.RUNNING, () => "ph--spinner-gap--regular"), Match.when(Process.State.SUCCEEDED, () => "ph--check-circle--regular"), Match.when(Process.State.FAILED, () => "ph--warning--regular"), Match.when(Process.State.HYBERNATING, () => "ph--spinner--regular"), Match.when(Process.State.IDLE, () => "ph--hourglass--regular"), Match.when(Process.State.TERMINATING, () => "ph--x-circle--regular"), Match.when(Process.State.TERMINATED, () => "ph--x-circle--regular"), Match.orElse(() => "ph--spinner-gap--regular"))
+    })), /* @__PURE__ */ React14.createElement("div", {
+      role: "none",
+      className: "flex items-center gap-2 text-xs overflow-hidden"
+    }, /* @__PURE__ */ React14.createElement("span", {
+      className: "truncate text-description select-none"
+    }, process.params.name ?? process.pid.toString())), [
+      Process.State.FAILED,
+      Process.State.SUCCEEDED
+    ].includes(process.state) && /* @__PURE__ */ React14.createElement("div", {
+      className: "text-xs text-description tabular-nums"
+    }, Unit2.Millisecond(process.metrics.wallTime).toString()) || /* @__PURE__ */ React14.createElement("div", null), onProcessTerminate && /* @__PURE__ */ React14.createElement(IconButton4, {
+      classNames: "min-h-0 p-1",
+      icon: "ph--x--regular",
+      iconOnly: true,
+      variant: "ghost",
+      size: 4,
+      label: "Actions",
+      onClick: (event) => {
+        event.stopPropagation();
+        onProcessTerminate?.(process);
+      }
+    })));
+  }))));
+});
+
+// src/components/TemplateEditor/TemplateEditor.tsx
+import { defaultHighlightStyle, syntaxHighlighting } from "@codemirror/language";
+import { composeRefs } from "@radix-ui/react-compose-refs";
+import React15 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 WidgetType7, keymap } from "@codemirror/view";
+import { Domino as Domino7, mx as mx8 } from "@dxos/ui";
+var handlebars = (_ = {}) => {
+  return [
+    handlebarsHighlightPlugin,
+    autocompletion({
+      activateOnTyping: true,
+      aboveCursor: true,
+      closeOnBlur: true,
+      override: [
+        handlebarsCompletions
+      ]
+    }),
+    keymap.of(completionKeymap)
+  ];
+};
+var regex = {
+  // {{! comment }}
+  comment: /\{\{!\s*[^}]*\}\}/g,
+  // {{var}}
+  brackets: /\{\{[^}]*\}\}/g,
+  // {{#command}} {{/command}}
+  command: /\{\{[#/]([^}]+)\}\}/g,
+  // {{var}}
+  var: /\{\{(?!\s*!)(\w[^}]*)\}\}/g,
+  // @dxn:queue:data:xxx
+  dxn: /@?dxn:[\w@:]+/g,
+  // example.com/path/xxx
+  url: /[\w.-]+\.[\w.-]+\/[\w/]+/g
+};
+var tagPadding = "mx-0.5 px-1 rounded-xs";
+var handlebarsHighlightPlugin = ViewPlugin.fromClass(class {
+  decorations;
+  constructor(view) {
+    this.decorations = this.buildDecorations(view);
+  }
+  update(update) {
+    if (update.docChanged || update.viewportChanged || update.selectionSet) {
+      this.decorations = this.buildDecorations(update.view);
+    }
+  }
+  // NOTE: Decorations may clash with other extensions (e.g., markdown).
+  buildDecorations(view) {
+    const selection = view.state.selection.main;
+    const decorations = [];
+    for (const { from, to } of view.visibleRanges) {
+      const text = view.state.doc.sliceString(from, to);
+      {
+        let match;
+        while ((match = regex.dxn.exec(text)) !== null) {
+          const start = from + match.index;
+          const end = start + match[0].length;
+          const overlaps = selection.to > start && selection.from <= end;
+          if (!overlaps) {
+            decorations.push({
+              from: start,
+              to: end,
+              decoration: Decoration.widget({
+                widget: new DXNWidget(match[0])
+              })
+            });
+          }
+        }
+      }
+      {
+        let match;
+        while ((match = regex.url.exec(text)) !== null) {
+          const start = from + match.index;
+          const end = start + match[0].length;
+          decorations.push({
+            from: start,
+            to: end,
+            decoration: Decoration.mark({
+              class: mx8("dx-tag--blue", tagPadding)
+            })
+          });
+        }
+      }
+      {
+        let match;
+        while ((match = regex.brackets.exec(text)) !== null) {
+          const start = from + match.index;
+          const end = start + match[0].length;
+          decorations.push({
+            from: start,
+            to: end,
+            decoration: Decoration.mark({
+              class: "text-subdued"
+            })
+          });
+        }
+      }
+      {
+        let match;
+        while ((match = regex.command.exec(text)) !== null) {
+          const start = from + match.index + 2;
+          let end = start + match[0].length - 4;
+          const text2 = view.state.doc.sliceString(start, end);
+          const parts = text2.split(/\s+/);
+          if (parts.length > 1) {
+            const idx = start + parts[0].length;
+            decorations.push({
+              from: idx,
+              to: end,
+              decoration: Decoration.mark({
+                class: "text-green-text"
+              })
+            });
+            end = idx;
+          }
+          decorations.push({
+            from: start,
+            to: end,
+            decoration: Decoration.mark({
+              class: "text-blue-text"
+            })
+          });
+        }
+      }
+      {
+        let match;
+        while ((match = regex.var.exec(text)) !== null) {
+          const start = from + match.index + 2;
+          const end = start + match[0].length - 4;
+          decorations.push({
+            from: start,
+            to: end,
+            decoration: Decoration.mark({
+              class: "text-green-text"
+            })
+          });
+        }
+      }
+    }
+    decorations.sort((a, b) => a.from - b.from || a.to - b.to);
+    const builder = new RangeSetBuilder();
+    for (const { from, to, decoration } of decorations) {
+      builder.add(from, to, decoration);
+    }
+    return builder.finish();
+  }
+}, {
+  decorations: (v) => v.decorations
+});
+var DXNWidget = class extends WidgetType7 {
+  _identifier;
+  constructor(_identifier) {
+    super(), this._identifier = _identifier;
+  }
+  ignoreEvent() {
+    return false;
+  }
+  eq(other) {
+    return this._identifier === other._identifier;
+  }
+  toDOM() {
+    const text = this._identifier.split(":").map((part) => {
+      const len = 16;
+      const plen = 4;
+      if (part.length > len) {
+        return `[${part.slice(0, plen)}\u2026${part.slice(-plen)}]`;
+      }
+      return part;
+    }).join(":");
+    return Domino7.of("span").classNames(mx8("font-mono dx-tag--blue", tagPadding)).text(text).root;
+  }
+};
+var variables = [
+  "this"
+];
+var commands = [
+  "this",
+  "each",
+  "if",
+  "unless",
+  "with"
+];
+function handlebarsCompletions(context) {
+  const match = context.matchBefore(/\{\{[^}]*/);
+  if (!match || match.from === match.to) {
+    return null;
+  }
+  let type = "variable";
+  let text = match.text.slice(2);
+  let from = match.from + 2;
+  let matches = [];
+  if (text.startsWith("#") || text.startsWith("/")) {
+    const idx = text.lastIndexOf(" ");
+    if (idx !== -1) {
+      type = "variable";
+      matches = variables;
+      text = text.slice(idx + 1);
+      from += idx + 1;
+    } else {
+      type = "command";
+      text = text.slice(1);
+      matches = commands;
+      from += 1;
+    }
+  } else {
+    type = "variable";
+    matches = variables;
+  }
+  const options = matches.filter((name) => name.startsWith(text)).map((name) => ({
+    type,
+    label: name
+  }));
+  return {
+    from,
+    options
+  };
+}
+
+// src/components/TemplateEditor/extensions/xml-extension.ts
+import { syntaxTree } from "@codemirror/language";
+import { RangeSetBuilder as RangeSetBuilder2 } from "@codemirror/state";
+import { Decoration as Decoration2, ViewPlugin as ViewPlugin2 } from "@codemirror/view";
+var xmlDecorator = (_ = {}) => {
+  return [
+    xmlDecoratorPlugin
+  ];
+};
+var xmlDecoratorPlugin = ViewPlugin2.fromClass(class {
+  decorations;
+  constructor(view) {
+    this.decorations = this.buildDecorations(view);
+  }
+  update(update) {
+    if (update.docChanged || update.viewportChanged) {
+      this.decorations = this.buildDecorations(update.view);
+    }
+  }
+  buildDecorations(view) {
+    const builder = new RangeSetBuilder2();
+    for (const { from, to } of view.visibleRanges) {
+      syntaxTree(view.state).iterate({
+        from,
+        to,
+        enter: (node) => {
+          if (node.name === "HTMLTag" || node.name === "OpenTag" || node.name === "CloseTag" || node.name === "SelfClosingTag" || node.name === "Element") {
+            builder.add(node.from, node.to, Decoration2.mark({
+              class: "font-mono text-subdued"
+            }));
+          }
+        }
+      });
+    }
+    return builder.finish();
+  }
+}, {
+  decorations: (v) => v.decorations
+});
+
+// src/components/TemplateEditor/TemplateEditor.tsx
+var TemplateEditor = composable3(({ classNames, id, template, lineNumbers = true, ...props }, forwardedRef) => {
+  const { t } = useTranslation7(meta7.id);
+  const { themeMode } = useThemeContext();
+  const { parentRef } = useTextEditor(() => {
+    const target = template.source?.target;
+    if (!target) {
+      return {};
+    }
+    return {
+      initialValue: target.content ?? "",
+      extensions: [
+        createDataExtensions({
+          id,
+          text: createDocAccessor(target, [
+            "content"
+          ])
+        }),
+        createBasicExtensions({
+          bracketMatching: false,
+          lineNumbers,
+          lineWrapping: true,
+          placeholder: t("template.placeholder")
+        }),
+        createThemeExtensions({
+          themeMode
+        }),
+        createMarkdownExtensions(),
+        decorateMarkdown(),
+        handlebars(),
+        // xml(),
+        // NOTE: Since we're using markdown only HTML nodes are parsed.
+        xmlDecorator(),
+        syntaxHighlighting(defaultHighlightStyle)
+      ].filter(isNonNullable2)
+    };
+  }, [
+    themeMode,
+    template.source?.target,
+    lineNumbers
+  ]);
+  return /* @__PURE__ */ React15.createElement("div", {
+    ...composableProps3(props, {
+      role: "none",
+      classNames: [
+        "h-full overflow-hidden",
+        classNames
+      ]
+    }),
+    ref: composeRefs(parentRef, forwardedRef)
+  });
+});
+
+// src/components/Toolbox/Toolbox.tsx
+import React16, { Fragment, useEffect as useEffect7, useState as useState8 } from "react";
+import { Operation } from "@dxos/compute";
+import { log as log2 } from "@dxos/log";
+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 mx9 } from "@dxos/ui-theme";
+import { ServiceType } from "#types";
+var __dxlog_file2 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/components/Toolbox/Toolbox.tsx";
+var Toolbox = composable4(({ functions, services, blueprints, activeBlueprints, ...props }, forwardedRef) => {
+  return /* @__PURE__ */ React16.createElement(ScrollArea2.Root, {
+    ...composableProps4(props),
+    thin: true,
+    orientation: "vertical",
+    ref: forwardedRef
+  }, /* @__PURE__ */ React16.createElement(ScrollArea2.Viewport, null, blueprints && blueprints.length > 0 && /* @__PURE__ */ React16.createElement(Section, {
+    title: "Blueprints",
+    items: blueprints.map(({ name, description, tools }) => ({
+      name,
+      description,
+      subitems: tools.map((toolId) => ({
+        name: `\u2219 ${safeToolId(toolId)}`
       }))
-    ]
-  }),
-  defineModule({
-    id: `${meta.id}/module/schema`,
-    activatesOn: ClientEvents.SetupSchema,
-    activate: () => contributes(ClientCapabilities.Schema, [
-      ServiceType,
-      TemplateType,
-      Assistant.CompanionTo
-    ])
-  }),
-  defineModule({
-    id: `${meta.id}/module/on-space-created`,
-    activatesOn: SpaceEvents.SpaceCreated,
-    activate: (context) => {
-      const { dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-      return contributes(SpaceCapabilities.OnSpaceCreated, async ({ space, rootCollection }) => {
-        const program = Effect.gen(function* () {
-          const { object: collection } = yield* dispatch(createIntent(CollectionAction.CreateQueryCollection, {
-            typename: Type.getTypename(Assistant.Chat)
-          }));
-          rootCollection.objects.push(Ref.make(collection));
-          const { object: chat } = yield* dispatch(createIntent(Assistant.CreateChat, {
-            space
-          }));
-          space.db.add(chat);
+    }))
+  }), activeBlueprints && activeBlueprints.length > 0 && /* @__PURE__ */ React16.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__ */ React16.createElement(Section, {
+    title: "Services",
+    items: services.map(({ service: { serviceId, name, description } }) => ({
+      name: name ?? serviceId,
+      description
+    }))
+  }), functions && functions.length > 0 && /* @__PURE__ */ React16.createElement(Section, {
+    title: "Functions",
+    items: functions.map(({ name, description }) => ({
+      name,
+      description
+    }))
+  })));
+});
+Toolbox.displayName = "Toolbox";
+var Section = ({ title, items, striped }) => {
+  const stripeClassNames = "odd:bg-neutral-50 dark:odd:bg-neutral-800";
+  const gridClassNames = "grid grid-cols-[8rem_1fr]";
+  const subGridClassNames = mx9("col-span-full grid grid-cols-subgrid text-xs px-2", striped && stripeClassNames);
+  return /* @__PURE__ */ React16.createElement("div", null, /* @__PURE__ */ React16.createElement("h1", {
+    className: "px-2 text-sm"
+  }, title), /* @__PURE__ */ React16.createElement("div", {
+    className: gridClassNames
+  }, items.map(({ name, description, subitems }, i) => /* @__PURE__ */ React16.createElement(Fragment, {
+    key: i
+  }, name && /* @__PURE__ */ React16.createElement("div", {
+    className: subGridClassNames
+  }, /* @__PURE__ */ React16.createElement("div", {
+    className: "truncate text-primary-500"
+  }, name), /* @__PURE__ */ React16.createElement("div", {
+    className: "line-clamp-2"
+  }, description)), subitems?.map(({ name: name2, description: description2 }, i2) => /* @__PURE__ */ React16.createElement("div", {
+    key: i2,
+    className: mx9(subGridClassNames, striped && stripeClassNames)
+  }, /* @__PURE__ */ React16.createElement("div", {
+    className: "truncate"
+  }, name2), /* @__PURE__ */ React16.createElement("div", {
+    className: "line-clamp-3 text-subdued"
+  }, description2)))))));
+};
+var ToolboxPanel = ({ classNames, db, processor }) => {
+  const services = useQuery3(db, Filter3.type(ServiceType));
+  const [serviceTools, setServiceTools] = useState8([]);
+  useEffect7(() => {
+    log2("creating service tools...", {
+      services: services.length
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 80, S: void 0 });
+    queueMicrotask(async () => {
+    });
+  }, [
+    services
+  ]);
+  const functions = useQuery3(db, Filter3.type(Operation.PersistentOperation));
+  return /* @__PURE__ */ React16.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-23A5IMHS.mjs"));
+
+// src/hooks/useBlueprintRegistry.ts
+import { useCallback as useCallback6, useEffect as useEffect8, useMemo as useMemo6, useState as useState9 } from "react";
+import { useCapabilities } from "@dxos/app-framework/ui";
+import { AppCapabilities } from "@dxos/app-toolkit";
+import { Blueprint } from "@dxos/compute";
+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 useMemo6(() => new Blueprint.Registry(blueprintDefinitions.map((blueprint) => blueprint.make())), [
+    blueprintDefinitions
+  ]);
+};
+var useBlueprints2 = ({ blueprintRegistry, db }) => {
+  const staticBlueprints = useMemo6(() => blueprintRegistry?.query() ?? [], [
+    blueprintRegistry
+  ]);
+  const spaceBlueprints = useQuery4(db, Filter4.type(Blueprint.Blueprint));
+  return useMemo6(() => {
+    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] = useState9(/* @__PURE__ */ new Map());
+  useEffect8(() => {
+    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 = useCallback6(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/useChatKeymap.ts
+import { Prec } from "@codemirror/state";
+import { keymap as keymap2 } from "@codemirror/view";
+import { useMemo as useMemo7 } from "react";
+import { isTruthy } from "@dxos/util";
+var useChatKeymapExtensions3 = ({ event }) => {
+  return useMemo7(() => {
+    return [
+      Prec.highest(keymap2.of([
+        {
+          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
+  ]);
+};
+
+// src/hooks/useChatProcessor.ts
+import { RegistryContext } from "@effect-atom/atom-react";
+import * as Effect2 from "effect/Effect";
+import { useContext, useMemo as useMemo8, useState as useState10 } from "react";
+import { AiSession } 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 log4 } 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",
+  "ollama"
+];
+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: "ollama",
+    model: "gpt-oss:20b"
+  },
+  {
+    provider: "ollama",
+    model: "gemma4:latest"
+  },
+  {
+    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 Option6 from "effect/Option";
+import * as Stream from "effect/Stream";
+import { DEFAULT_EDGE_MODEL } from "@dxos/ai";
+import { AiContextService, createSystemPrompt, formatSystemPrompt, PartialBlock, ToolExecutionServices } from "@dxos/assistant";
+import { Trace } from "@dxos/compute";
+import { Operation as Operation2 } from "@dxos/compute";
+import { Obj as Obj5 } from "@dxos/echo";
+import { runAndForwardErrors, unwrapExit } from "@dxos/effect";
+import { AgentService } from "@dxos/functions-runtime";
+import { log as log3 } from "@dxos/log";
+import { Message as Message2 } from "@dxos/types";
+var __dxlog_file3 = "/__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(Option6.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(Effect.provide(this._conversation.getTools(), ToolExecutionServices));
+  }
+  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, Option6.none());
+      this.#registry.set(this.active, true);
+      const effect = Effect.gen(this, function* () {
+        log3.info("init agent session", {
+          feed: Obj5.getDXN(this._feed).toString(),
+          model: this._options.model
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 95, S: this });
+        const session = yield* AgentService.getSession(this._feed, {
+          model: this._options.model
+        });
+        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);
+        log3("chat processor submitting prompt", {
+          length: requestProp.message.length
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 110, S: this });
+        yield* session.submitPrompt(requestProp.message);
+        log3("chat processor submitPrompt returned, waiting for agent", {}, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 114, S: this });
+        yield* session.waitForCompletion();
+        log3.info("session complete", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 116, S: this });
+        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, Option6.none());
+      this.#lastRequest = void 0;
+      this.#requestFiber = void 0;
+    } catch (err) {
+      log3.error("request failed", {
+        error: err
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 133, S: this });
+      this.#registry.set(this.error, Option6.some(new Error("AI service error", {
+        cause: err
+      })));
+    } finally {
+      log3.info("setting active to false", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 140, S: this });
+      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;
+    }
+    log3.info("scheduling chat name update", {
+      hasName: !!chat.name,
+      chance
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 246, S: this });
+    return Operation2.schedule(UpdateChatName, {
+      chat
+    });
+  }
+};
+
+// src/hooks/useChatProcessor.ts
+var __dxlog_file4 = "/__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 [session, setSession] = useState10();
+  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 session2 = new AiSession({
+      feed: feedTarget,
+      runtime: runtime4,
+      registry: observableRegistry
+    });
+    await session2.open();
+    setSession(session2);
+    return () => {
+      void session2.close();
+      setSession(void 0);
+    };
+  }, [
+    space,
+    chat?.feed.target
+  ]);
+  const feed = chat?.feed.target;
+  const processor = useMemo8(() => {
+    if (!runtime3 || !session || !chat || !feed) {
+      return void 0;
+    }
+    log4("creating processor", {
+      preset,
+      model: preset?.model,
+      settings
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 49, S: void 0 });
+    return new AiChatProcessor(session, runtime3, feed, {
+      chat: chat ? Ref2.make(chat) : void 0,
+      observableRegistry,
+      blueprintRegistry,
+      model: preset?.model
+    });
+  }, [
+    runtime3,
+    session,
+    blueprintRegistry,
+    preset,
+    feed
+  ]);
+  return processor;
+};
+
+// src/hooks/useChatServices.ts
+import { useMemo as useMemo9 } 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 useMemo9(() => !id ? void 0 : runtimeResolver.getRuntime(id), [
+    id
+  ]);
+};
+
+// src/hooks/useChatToolbarActions.ts
+import { Atom as Atom2 } from "@effect-atom/atom-react";
+import * as Effect3 from "effect/Effect";
+import { useMemo as useMemo10 } 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_file5 = "/__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(useMemo10(() => {
+    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, { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 44, 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, { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 60, S: this, A: ["chat", ""] });
+        yield* invoke(AssistantOperation.UpdateChatName, {
+          chat
         });
-        await Effect.runPromise(program);
+      }).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, { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 97, 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/hooks/useContextBinder.ts
+import { RegistryContext as RegistryContext2 } from "@effect-atom/atom-react";
+import * as Effect4 from "effect/Effect";
+import { useContext as useContext2, useState as useState11 } 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] = useState11();
+  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/hooks/useContextObjects.ts
+import { Atom as Atom3, useAtomValue as useAtomValue3 } from "@effect-atom/atom-react";
+import { useCallback as useCallback7 } from "react";
+var emptyObjectsAtom = Atom3.make([]);
+var useContextObjects3 = ({ db, context }) => {
+  const objects = useAtomValue3(context?.objects ?? emptyObjectsAtom);
+  const handleUpdateObject = useCallback7(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/hooks/useDebug.ts
+import { useCallback as useCallback8 } from "react";
+import { trim } from "@dxos/util";
+var useDebug2 = ({ processor }) => {
+  return useCallback8(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
+    });
+    try {
+      console.log(trim`
+        System Prompt:
+        ${system}
+      `);
+      console.log(trim`
+        Tools:
+        ${Object.values(tools).map((tool) => JSON.stringify(tool, null, 2)).join("\n")}
+      `);
+    } finally {
+      console.groupEnd();
+    }
+  }, [
+    processor
+  ]);
+};
+
+// src/hooks/useFilteredTypes.ts
+import * as Option7 from "effect/Option";
+import { useEffect as useEffect9, useState as useState12 } from "react";
+import { EntityKind, SystemTypeAnnotation, getTypeAnnotation } from "@dxos/echo/internal";
+var useFilteredTypes2 = (db) => {
+  const [types, setTypes] = useState12([]);
+  useEffect9(() => {
+    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(Option7.getOrElse(() => false)))));
+      setTypes(types2);
+    }, {
+      fire: true
+    });
+  }, [
+    db
+  ]);
+  return types;
+};
+
+// src/hooks/useFlush.ts
+import { useCallback as useCallback9, useRef as useRef4, useState as useState13 } from "react";
+var useFlush = (space) => {
+  const [state, setState] = useState13("idle");
+  const resetTimer = useRef4(null);
+  const handleFlush = useCallback9(() => {
+    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/hooks/useOnline.ts
+import { useState as useState14 } from "react";
+var useOnline = () => {
+  const [online, setOnline] = useState14(true);
+  return [
+    online,
+    setOnline
+  ];
+};
+
+// src/hooks/usePresets.ts
+import { useCallback as useCallback10, useEffect as useEffect10, useMemo as useMemo11, useState as useState15 } from "react";
+var usePresets = (online) => {
+  const [preset, setPreset] = useState15();
+  const presets = useMemo11(() => AiServicePresets.filter((preset2) => online === (preset2.provider === "dxos-remote")), [
+    online
+  ]);
+  const presetOptions = useMemo11(() => presets.map(({ id, model, label }) => ({
+    id,
+    label: label ?? model
+  })), [
+    presets
+  ]);
+  useEffect10(() => {
+    setPreset(presets[0]);
+  }, [
+    presets
+  ]);
+  const handlePresetChange = useCallback10((id) => {
+    const preset2 = presets.find((preset3) => preset3.id === id);
+    if (preset2) {
+      setPreset(preset2);
+    }
+  }, [
+    presets
+  ]);
+  return {
+    preset,
+    presets: presetOptions,
+    onPresetChange: handlePresetChange
+  };
+};
+
+// src/hooks/useReferencesProvider.ts
+import { useMemo as useMemo12 } from "react";
+import { Filter as Filter6, Obj as Obj7 } from "@dxos/echo";
+var useReferencesProvider = (space) => {
+  return useMemo12(() => {
+    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/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/AssistantPlugin.tsx
+import * as Effect5 from "effect/Effect";
+import * as Option8 from "effect/Option";
+import { ActivationEvent, ActivationEvents, Capability, Plugin } from "@dxos/app-framework";
+import { AppActivationEvents, AppPlugin } from "@dxos/app-toolkit";
+import { ContextBinding } from "@dxos/assistant";
+import { Agent, AgentBlueprint, Chat as Chat3, McpServer as McpServer2, Memory, Plan } from "@dxos/assistant-toolkit";
+import { Blueprint as Blueprint2, Routine } from "@dxos/compute";
+import { Operation as Operation3 } from "@dxos/compute";
+import { Sequence } from "@dxos/conductor";
+import { Annotation as Annotation3, Feed, Obj as Obj8, Type as Type2 } from "@dxos/echo";
+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/types";
+import { SpaceOperation } from "@dxos/plugin-space/operations";
+import { SpaceCapabilities, SpaceEvents } from "@dxos/plugin-space/types";
+import { Text } from "@dxos/schema";
+import { HasSubject, Message as Message3 } from "@dxos/types";
+import { AiService, AppGraphBuilder, AssistantState, BlueprintDefinition, CompanionChatProvisioner, EdgeModelResolver, LocalModelResolver, MarkdownExtension, Migrations, OperationHandler, ReactSurface, Settings, Toolkit } from "#capabilities";
+import { meta as meta10 } from "#meta";
+import { AssistantOperation as AssistantOperation2 } from "#operations";
+import { translations } from "#translations";
+import { AssistantEvents } from "#types";
+var AssistantPlugin = Plugin.define(meta10).pipe(AppPlugin.addAppGraphModule({
+  activate: AppGraphBuilder
+}), AppPlugin.addBlueprintDefinitionModule({
+  activate: BlueprintDefinition
+}), AppPlugin.addMetadataModule({
+  metadata: [
+    {
+      id: Type2.getTypename(Chat3.Chat),
+      metadata: {
+        icon: Annotation3.IconAnnotation.get(Chat3.Chat).pipe(Option8.getOrThrow).icon,
+        iconHue: Annotation3.IconAnnotation.get(Chat3.Chat).pipe(Option8.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),
+      metadata: {
+        icon: Annotation3.IconAnnotation.get(Blueprint2.Blueprint).pipe(Option8.getOrThrow).icon,
+        iconHue: Annotation3.IconAnnotation.get(Blueprint2.Blueprint).pipe(Option8.getOrThrow).hue ?? "white",
+        inputSchema: AssistantOperation2.BlueprintForm,
+        createObject: (props, options) => Effect5.gen(function* () {
+          const object = Blueprint2.make(props);
+          return yield* Operation3.invoke(SpaceOperation.AddObject, {
+            object,
+            target: options.target,
+            hidden: true,
+            targetNodeId: options.targetNodeId
+          });
+        })
+      }
+    },
+    {
+      id: Type2.getTypename(Routine.Routine),
+      metadata: {
+        icon: Annotation3.IconAnnotation.get(Routine.Routine).pipe(Option8.getOrThrow).icon,
+        iconHue: Annotation3.IconAnnotation.get(Routine.Routine).pipe(Option8.getOrThrow).hue ?? "white",
+        createObject: (props, options) => Effect5.gen(function* () {
+          const object = Routine.make(props);
+          return yield* Operation3.invoke(SpaceOperation.AddObject, {
+            object,
+            target: options.target,
+            hidden: true,
+            targetNodeId: options.targetNodeId
+          });
+        })
+      }
+    },
+    {
+      id: Type2.getTypename(Sequence),
+      metadata: {
+        icon: Annotation3.IconAnnotation.get(Sequence).pipe(Option8.getOrThrow).icon,
+        iconHue: Annotation3.IconAnnotation.get(Sequence).pipe(Option8.getOrThrow).hue ?? "white",
+        createObject: (props, options) => Effect5.gen(function* () {
+          const object = Obj8.make(Sequence, props);
+          return yield* Operation3.invoke(SpaceOperation.AddObject, {
+            object,
+            target: options.target,
+            hidden: true,
+            targetNodeId: options.targetNodeId
+          });
+        })
+      }
+    },
+    {
+      id: Type2.getTypename(Agent.Agent),
+      metadata: {
+        icon: Annotation3.IconAnnotation.get(Agent.Agent).pipe(Option8.getOrThrow).icon,
+        iconHue: Annotation3.IconAnnotation.get(Agent.Agent).pipe(Option8.getOrThrow).hue ?? "white",
+        createObject: (props, options) => Effect5.gen(function* () {
+          const object = yield* Agent.makeInitialized({
+            name: "",
+            instructions: ""
+          }, AgentBlueprint.make()).pipe(withComputeRuntime(options.db.spaceId));
+          return yield* Operation3.invoke(SpaceOperation.AddObject, {
+            object,
+            target: options.target,
+            hidden: true,
+            targetNodeId: options.targetNodeId
+          });
+        })
+      }
     }
-  }),
-  defineModule({
-    id: `${meta.id}/module/app-graph-builder`,
-    activatesOn: Events2.SetupAppGraph,
-    activate: AppGraphBuilder
-  }),
-  defineModule({
-    id: `${meta.id}/module/intent-resolver`,
-    activatesOn: Events2.SetupIntentResolver,
-    activate: IntentResolver
-  }),
-  defineModule({
-    id: `${meta.id}/module/react-surface`,
-    activatesOn: Events2.SetupReactSurface,
-    // TODO(wittjosiah): Should occur before the chat is loaded when surfaces activation is more granular.
-    activatesBefore: [
-      Events2.SetupArtifactDefinition
-    ],
-    activate: ReactSurface
-  }),
-  defineModule({
-    id: `${meta.id}/module/ai-client`,
-    activatesOn: allOf(ClientEvents.ClientReady, Events2.SettingsReady),
-    activatesAfter: [
-      AssistantEvents.AiClientReady
-    ],
-    activate: AiClient
-  })
-]);
+  ]
+}), AppPlugin.addOperationHandlerModule({
+  activate: OperationHandler
+}), AppPlugin.addSchemaModule({
+  schema: [
+    Chat3.Chat,
+    Chat3.CompanionTo,
+    Blueprint2.Blueprint,
+    ContextBinding,
+    Feed.Feed,
+    HasSubject.HasSubject,
+    Message3.Message,
+    Routine.Routine,
+    Agent.Agent,
+    McpServer2.McpServer,
+    Plan.Plan,
+    Sequence,
+    Memory.Memory,
+    Text.Text
+  ]
+}), AppPlugin.addSettingsModule({
+  activate: Settings
+}), AppPlugin.addSurfaceModule({
+  activate: ReactSurface,
+  firesBeforeActivation: [
+    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,
+  activate: EdgeModelResolver
+}), Plugin.addModule({
+  activatesOn: AssistantEvents.SetupAiServiceProviders,
+  activate: LocalModelResolver
+}), Plugin.addModule({
+  firesBeforeActivation: [
+    AssistantEvents.SetupAiServiceProviders
+  ],
+  // TODO(dmaretskyi): This should activate lazily when the AI chat is used.
+  activatesOn: ActivationEvents.Startup,
+  activate: AiService
+}), Plugin.addModule({
+  // TODO(wittjosiah): Use a different event.
+  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,
-  ASSISTANT_PLUGIN,
-  AiClient,
-  ApiAuthorization,
-  AppGraphBuilder,
-  Assistant,
-  AssistantCapabilities,
-  AssistantEvents,
   AssistantPlugin,
   AssistantSettings,
   Chat,
-  ChatContainer,
-  ChatDialog,
-  IntentResolver,
-  LLM_PROVIDERS,
-  PromptSettings,
-  ReactSurface,
-  SequenceContainer,
-  ServiceType,
-  Settings,
-  TemplateContainer,
+  ProcessTree,
   TemplateEditor,
-  TemplateInputSchema,
-  TemplateInputType,
-  TemplateKindSchema,
-  TemplateKinds,
-  TemplateType,
   Toolbox,
-  ToolboxContainer,
-  categoryIcons,
-  handlebarsHighlightStyle,
-  meta
+  ToolboxPanel,
+  meta9 as meta,
+  useActiveBlueprints2 as useActiveBlueprints,
+  useBlueprintHandlers2 as useBlueprintHandlers,
+  useBlueprintRegistry,
+  useBlueprints2 as useBlueprints,
+  useChatContext,
+  useChatKeymapExtensions3 as useChatKeymapExtensions,
+  useChatProcessor,
+  useChatServices,
+  useChatToolbarActions2 as useChatToolbarActions,
+  useContextBinder,
+  useContextObjects3 as useContextObjects,
+  useDebug2 as useDebug,
+  useFilteredTypes2 as useFilteredTypes,
+  useFlush,
+  useOnline,
+  usePresets,
+  useReferencesProvider
 };
 //# sourceMappingURL=index.mjs.map