@dxos/plugin-assistant 0.8.4-main.2e9d522 → 0.8.4-main.3c1ae3b

package/dist/lib/node-esm/chunk-ZNSHGWE4.mjs

@@ -0,0 +1,1931 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  AiChatProcessor,
+  AiServicePresets
+} from "./chunk-GWKWQSEQ.mjs";
+import {
+  AssistantAction_exports,
+  Assistant_exports,
+  LLM_PROVIDERS,
+  ServiceType
+} from "./chunk-E4JSYCWZ.mjs";
+import {
+  meta
+} from "./chunk-WE6KTH72.mjs";
+
+// src/components/AssistantSettings/AssistantSettings.tsx
+import { useSignals as _useSignals } from "@preact-signals/safe-react/tracking";
+import React from "react";
+import { DEFAULT_EDGE_MODELS, DEFAULT_OLLAMA_MODELS } from "@dxos/ai";
+import { Input, Select, useTranslation } from "@dxos/react-ui";
+import { ControlGroup, ControlItemInput, ControlPage, ControlSection } from "@dxos/react-ui-form";
+var DEFAULT_VALUE = "__default";
+var LLM_PROVIDER_LABELS = {
+  edge: "DXOS",
+  ollama: "Ollama",
+  lmstudio: "LM Studio"
+};
+var AssistantSettings = ({ settings }) => {
+  var _effect = _useSignals();
+  try {
+    const { t } = useTranslation(meta.id);
+    return /* @__PURE__ */ React.createElement(ControlPage, null, /* @__PURE__ */ React.createElement(ControlSection, {
+      title: t("settings title", {
+        ns: meta.id
+      })
+    }, /* @__PURE__ */ React.createElement(ControlGroup, null, /* @__PURE__ */ React.createElement(ControlItemInput, {
+      title: t("settings custom prompts label")
+    }, /* @__PURE__ */ React.createElement(Input.Switch, {
+      checked: !!settings.customPrompts,
+      onCheckedChange: (checked) => settings.customPrompts = checked
+    })), /* @__PURE__ */ React.createElement(ControlItemInput, {
+      title: t("settings llm provider label")
+    }, /* @__PURE__ */ React.createElement(Select.Root, {
+      value: settings.llmProvider ?? "edge",
+      onValueChange: (value) => {
+        settings.llmProvider = value === DEFAULT_VALUE ? void 0 : value;
+      }
+    }, /* @__PURE__ */ React.createElement(Select.TriggerButton, {
+      placeholder: t("settings llm provider label")
+    }), /* @__PURE__ */ React.createElement(Select.Portal, null, /* @__PURE__ */ React.createElement(Select.Content, null, /* @__PURE__ */ React.createElement(Select.Viewport, null, /* @__PURE__ */ React.createElement(Select.Option, {
+      value: DEFAULT_VALUE
+    }, t("settings default label")), LLM_PROVIDERS.map((model) => /* @__PURE__ */ React.createElement(Select.Option, {
+      key: model,
+      value: model
+    }, LLM_PROVIDER_LABELS[model]))), /* @__PURE__ */ React.createElement(Select.Arrow, null))))), /* @__PURE__ */ React.createElement(ControlItemInput, {
+      title: t("settings edge llm model label")
+    }, /* @__PURE__ */ React.createElement(Select.Root, {
+      value: settings.edgeModel ?? DEFAULT_VALUE,
+      onValueChange: (value) => {
+        settings.edgeModel = value === DEFAULT_VALUE ? void 0 : value;
+      }
+    }, /* @__PURE__ */ React.createElement(Select.TriggerButton, {
+      placeholder: t("settings default llm model label")
+    }), /* @__PURE__ */ React.createElement(Select.Portal, null, /* @__PURE__ */ React.createElement(Select.Content, null, /* @__PURE__ */ React.createElement(Select.Viewport, null, /* @__PURE__ */ React.createElement(Select.Option, {
+      value: DEFAULT_VALUE
+    }, t("settings default label")), DEFAULT_EDGE_MODELS.map((model) => /* @__PURE__ */ React.createElement(Select.Option, {
+      key: model,
+      value: model
+    }, model))), /* @__PURE__ */ React.createElement(Select.Arrow, null))))), /* @__PURE__ */ React.createElement(ControlItemInput, {
+      title: t("settings ollama llm model label")
+    }, /* @__PURE__ */ React.createElement(Select.Root, {
+      value: settings.ollamaModel ?? DEFAULT_VALUE,
+      onValueChange: (value) => {
+        settings.ollamaModel = value === DEFAULT_VALUE ? void 0 : value;
+      }
+    }, /* @__PURE__ */ React.createElement(Select.TriggerButton, {
+      placeholder: t("settings default llm model label")
+    }), /* @__PURE__ */ React.createElement(Select.Portal, null, /* @__PURE__ */ React.createElement(Select.Content, null, /* @__PURE__ */ React.createElement(Select.Viewport, null, /* @__PURE__ */ React.createElement(Select.Option, {
+      value: DEFAULT_VALUE
+    }, t("settings default label")), DEFAULT_OLLAMA_MODELS.map((model) => /* @__PURE__ */ React.createElement(Select.Option, {
+      key: model,
+      value: model
+    }, model))), /* @__PURE__ */ React.createElement(Select.Arrow, null))))))));
+  } finally {
+    _effect.f();
+  }
+};
+
+// src/hooks/useBlueprintRegistry.ts
+import { useSignals as _useSignals2 } from "@preact-signals/safe-react/tracking";
+import { useSignalEffect } from "@preact/signals-react";
+import { useCallback, useMemo, useState } from "react";
+import { Capabilities } from "@dxos/app-framework";
+import { useCapabilities } from "@dxos/app-framework/react";
+import { Blueprint } from "@dxos/blueprints";
+import { Filter, Obj, Ref } from "@dxos/echo";
+import { useQuery } from "@dxos/react-client/echo";
+import { distinctBy, isNonNullable } from "@dxos/util";
+var useBlueprintRegistry = () => {
+  const blueprints = useCapabilities(Capabilities.BlueprintDefinition);
+  return useMemo(() => new Blueprint.Registry(blueprints), [
+    blueprints
+  ]);
+};
+var useBlueprints = ({ blueprintRegistry, space }) => {
+  const staticBlueprints = useMemo(() => blueprintRegistry?.query() ?? [], [
+    blueprintRegistry
+  ]);
+  const spaceBlueprints = useQuery(space, Filter.type(Blueprint.Blueprint));
+  return useMemo(() => {
+    const blueprints = distinctBy([
+      ...staticBlueprints,
+      ...spaceBlueprints
+    ], (b) => b.key);
+    blueprints.sort(({ name: a }, { name: b }) => a.localeCompare(b));
+    return blueprints;
+  }, [
+    staticBlueprints,
+    spaceBlueprints
+  ]);
+};
+var useActiveBlueprints = ({ context }) => {
+  var _effect = _useSignals2();
+  try {
+    const [active, setActive] = useState(/* @__PURE__ */ new Map());
+    useSignalEffect(() => {
+      const refs = [
+        ...context?.blueprints.value ?? []
+      ];
+      const blueprints = refs.map((ref) => ref.target).filter(isNonNullable);
+      setActive(new Map(blueprints.map((blueprint) => [
+        blueprint.key,
+        blueprint
+      ])));
+    });
+    return active;
+  } finally {
+    _effect.f();
+  }
+};
+var useBlueprintHandlers = ({ space, context, blueprintRegistry }) => {
+  const onUpdateBlueprint = useCallback(async (key, checked) => {
+    if (!context || !blueprintRegistry) {
+      return;
+    }
+    const objects = await space.db.query(Filter.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 = space.db.add(Obj.clone(blueprint));
+      }
+      await context.bind({
+        blueprints: [
+          Ref.make(storedBlueprint)
+        ]
+      });
+    } else if (storedBlueprint) {
+      await context.unbind({
+        blueprints: [
+          Ref.make(storedBlueprint)
+        ]
+      });
+    }
+  }, [
+    space,
+    context,
+    blueprintRegistry
+  ]);
+  return {
+    onUpdateBlueprint
+  };
+};
+
+// src/hooks/useChatProcessor.ts
+import { RegistryContext } from "@effect-atom/atom-react";
+import { useContext, useMemo as useMemo2, useState as useState2 } from "react";
+import { AiConversation } from "@dxos/assistant";
+import { log } from "@dxos/log";
+import { useAsyncEffect } from "@dxos/react-ui";
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/hooks/useChatProcessor.ts";
+var useChatProcessor = ({ space, chat, preset, services, blueprintRegistry, settings }) => {
+  const observableRegistry = useContext(RegistryContext);
+  const [conversation, setConversation] = useState2();
+  useAsyncEffect(async () => {
+    if (!space || !chat) {
+      return;
+    }
+    const queue = space.queues.get(chat.queue.dxn);
+    const conversation2 = new AiConversation(queue);
+    await conversation2.open();
+    setConversation(conversation2);
+    return () => {
+      void conversation2.close();
+      setConversation(void 0);
+    };
+  }, [
+    space,
+    chat?.queue.dxn.toString()
+  ]);
+  const processor = useMemo2(() => {
+    if (!services || !conversation) {
+      return void 0;
+    }
+    log("creating processor", {
+      preset,
+      model: preset?.model,
+      settings
+    }, {
+      F: __dxlog_file,
+      L: 65,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+    return new AiChatProcessor(conversation, services, {
+      observableRegistry,
+      blueprintRegistry,
+      model: preset?.model
+    });
+  }, [
+    services,
+    conversation,
+    blueprintRegistry,
+    preset
+  ]);
+  return processor;
+};
+
+// src/hooks/useChatServices.ts
+import * as Effect from "effect/Effect";
+import { useMemo as useMemo3 } from "react";
+import { useCapability } from "@dxos/app-framework/react";
+import { TracingService } from "@dxos/functions";
+import { TracingServiceExt } from "@dxos/functions-runtime";
+import { AutomationCapabilities } from "@dxos/plugin-automation";
+import { useClient } from "@dxos/react-client";
+var useChatServices = ({ space, chat }) => {
+  const client = useClient();
+  space ??= client.spaces.default;
+  const runtimeResolver = useCapability(AutomationCapabilities.ComputeRuntime);
+  return useMemo3(() => {
+    const runtime2 = runtimeResolver.getRuntime(space.id);
+    return () => runtime2.runPromise(Effect.gen(function* () {
+      return yield* Effect.runtime().pipe(Effect.provide(chat?.traceQueue?.target ? TracingServiceExt.layerQueue(chat.traceQueue?.target) : TracingService.layerNoop));
+    }));
+  }, [
+    space,
+    chat?.traceQueue?.target
+  ]);
+};
+
+// src/hooks/useChatToolbarActions.ts
+import { Atom } from "@effect-atom/atom-react";
+import * as Effect2 from "effect/Effect";
+import { useMemo as useMemo10 } from "react";
+import { createIntent } from "@dxos/app-framework";
+import { useIntentDispatcher } from "@dxos/app-framework/react";
+import { Filter as Filter5, Obj as Obj6, Query } from "@dxos/echo";
+import { invariant } from "@dxos/invariant";
+import { useQuery as useQuery4 } from "@dxos/react-client/echo";
+import { MenuBuilder, useMenuActions } from "@dxos/react-ui-menu";
+
+// src/components/index.ts
+import { lazy } from "react";
+
+// src/components/Chat/Chat.tsx
+import { useSignals as _useSignals12 } from "@preact-signals/safe-react/tracking";
+import { Prec } from "@codemirror/state";
+import { keymap } from "@codemirror/view";
+import { useAtomValue } from "@effect-atom/atom-react";
+import { createContext } from "@radix-ui/react-context";
+import * as Array2 from "effect/Array";
+import * as Option2 from "effect/Option";
+import React10, { useCallback as useCallback7, useEffect as useEffect6, useMemo as useMemo9, useRef as useRef3, useState as useState11 } from "react";
+import { Event } from "@dxos/async";
+import { Obj as Obj5 } from "@dxos/echo";
+import { useVoiceInput } from "@dxos/plugin-transcription";
+import { getSpace, useQueue } from "@dxos/react-client/echo";
+import { useIdentity } from "@dxos/react-client/halo";
+import { Input as Input2, useDynamicRef, useTranslation as useTranslation6 } from "@dxos/react-ui";
+import { ChatEditor } from "@dxos/react-ui-chat";
+import { MenuProvider, ToolbarMenu } from "@dxos/react-ui-menu";
+import { mx as mx5 } from "@dxos/react-ui-theme";
+import { Message } from "@dxos/types";
+import { isTruthy } from "@dxos/util";
+
+// src/hooks/useContextBinder.ts
+import { useState as useState3 } from "react";
+import { AiContextBinder } from "@dxos/assistant";
+import { useAsyncEffect as useAsyncEffect2 } from "@dxos/react-ui";
+var useContextBinder = (queue) => {
+  const [binder, setBinder] = useState3();
+  useAsyncEffect2(async () => {
+    if (!queue) {
+      return;
+    }
+    const binder2 = new AiContextBinder(queue);
+    await binder2.open();
+    setBinder(binder2);
+    return () => {
+      void binder2.close();
+    };
+  }, [
+    queue
+  ]);
+  return binder;
+};
+
+// src/hooks/useContextObjects.ts
+import { useSignals as _useSignals3 } from "@preact-signals/safe-react/tracking";
+import { useCallback as useCallback2 } from "react";
+import { Ref as Ref2 } from "@dxos/echo";
+import { log as log2 } from "@dxos/log";
+import { isNonNullable as isNonNullable2 } from "@dxos/util";
+var __dxlog_file2 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/hooks/useContextObjects.ts";
+var useContextObjects = ({ space, context }) => {
+  var _effect = _useSignals3();
+  try {
+    const objects = context?.objects.value.map((ref) => ref.target).filter(isNonNullable2) ?? [];
+    const handleUpdateObject = useCallback2(async (dxn, checked) => {
+      if (!space || !context) {
+        return;
+      }
+      const id = dxn.asEchoDXN();
+      const object = id && space.db.getObjectById(id.echoId);
+      if (!object) {
+        log2.warn("Object not found", {
+          dxn,
+          id
+        }, {
+          F: __dxlog_file2,
+          L: 40,
+          S: void 0,
+          C: (f, a) => f(...a)
+        });
+        return;
+      }
+      const ref = Ref2.fromDXN(dxn);
+      if (checked) {
+        await context.bind({
+          objects: [
+            ref
+          ]
+        });
+      } else {
+        await context.unbind({
+          objects: [
+            ref
+          ]
+        });
+      }
+    }, [
+      space,
+      context
+    ]);
+    return {
+      objects,
+      onUpdateObject: handleUpdateObject
+    };
+  } finally {
+    _effect.f();
+  }
+};
+
+// src/hooks/useFilteredTypes.ts
+import * as Option from "effect/Option";
+import { useEffect, useState as useState4 } from "react";
+import { EntityKind, SystemTypeAnnotation, getTypeAnnotation } from "@dxos/echo/internal";
+var useFilteredTypes = (space) => {
+  const [types, setTypes] = useState4([]);
+  useEffect(() => {
+    if (!space) {
+      return;
+    }
+    return space.db.schemaRegistry.query().subscribe((query) => {
+      const types2 = Array.from(new Set([
+        ...space.db.graph.schemaRegistry.schemas,
+        ...query.results
+      ].filter((schema) => getTypeAnnotation(schema)?.kind !== EntityKind.Relation).filter((schema) => SystemTypeAnnotation.get(schema).pipe(Option.getOrElse(() => false)))));
+      setTypes(types2);
+    }, {
+      fire: true
+    });
+  }, [
+    space
+  ]);
+  return types;
+};
+
+// src/hooks/useFlush.ts
+import { useCallback as useCallback3, useRef, useState as useState5 } from "react";
+var useFlush = (space) => {
+  const [state, setState] = useState5("idle");
+  const resetTimer = useRef(null);
+  const handleFlush = useCallback3(() => {
+    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 useState6 } from "react";
+var useOnline = () => {
+  const [online, setOnline] = useState6(true);
+  return [
+    online,
+    setOnline
+  ];
+};
+
+// src/hooks/usePresets.ts
+import { useCallback as useCallback4, useEffect as useEffect2, useMemo as useMemo4, useState as useState7 } from "react";
+var usePresets = (online) => {
+  const [preset, setPreset] = useState7();
+  const presets = useMemo4(() => AiServicePresets.filter((preset2) => online === (preset2.provider === "dxos-remote")), [
+    online
+  ]);
+  const presetOptions = useMemo4(() => presets.map(({ id, model, label }) => ({
+    id,
+    label: label ?? model
+  })), [
+    presets
+  ]);
+  useEffect2(() => {
+    setPreset(presets[0]);
+  }, [
+    presets
+  ]);
+  const handlePresetChange = useCallback4((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 useMemo5 } from "react";
+import { Capabilities as Capabilities2 } from "@dxos/app-framework";
+import { useCapabilities as useCapabilities2 } from "@dxos/app-framework/react";
+import { Filter as Filter2, Obj as Obj2 } from "@dxos/echo";
+var useReferencesProvider = (space) => {
+  const blueprints = useCapabilities2(Capabilities2.BlueprintDefinition);
+  return useMemo5(() => {
+    if (!space) {
+      return void 0;
+    }
+    return {
+      getReferences: async ({ query }) => {
+        const objects = await space.db.query(Filter2.everything()).run();
+        return objects.filter((object) => stringMatch(query, Obj2.getLabel(object) ?? "")).filter((object) => !!Obj2.getDXN(object)).map((object) => ({
+          uri: Obj2.getDXN(object).toString(),
+          label: Obj2.getLabel(object) ?? ""
+        }));
+      },
+      resolveReference: async ({ uri }) => {
+        const object = await space.db.query(Filter2.id(uri)).first();
+        return {
+          uri,
+          label: Obj2.getLabel(object) ?? ""
+        };
+      }
+    };
+  }, [
+    space,
+    blueprints
+  ]);
+};
+var stringMatch = (query, label) => label.toLowerCase().startsWith(query.toLowerCase());
+
+// src/components/ChatPrompt/ChatActions.tsx
+import { useSignals as _useSignals4 } from "@preact-signals/safe-react/tracking";
+import React2 from "react";
+import { IconButton, useTranslation as useTranslation2 } from "@dxos/react-ui";
+import { mx } from "@dxos/react-ui-theme";
+var ChatActions = ({ classNames, children, microphone, recording, processing, onEvent }) => {
+  var _effect = _useSignals4();
+  try {
+    const { t } = useTranslation2(meta.id);
+    return /* @__PURE__ */ React2.createElement("div", {
+      className: mx("flex items-center mie-1", classNames)
+    }, children, /* @__PURE__ */ React2.createElement(IconButton, {
+      disabled: !processing,
+      variant: "ghost",
+      icon: "ph--x--regular",
+      iconOnly: true,
+      label: t("cancel processing button"),
+      onClick: () => onEvent?.({
+        type: "cancel"
+      })
+    }), microphone && /* @__PURE__ */ React2.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"
+      })
+    }));
+  } finally {
+    _effect.f();
+  }
+};
+
+// src/components/ChatPrompt/ChatOptions.tsx
+import { useSignals as _useSignals5 } from "@preact-signals/safe-react/tracking";
+import React3, { useMemo as useMemo6, useState as useState8 } from "react";
+import { Filter as Filter3, Obj as Obj3, Type } from "@dxos/echo";
+import { useQuery as useQuery2 } from "@dxos/react-client/echo";
+import { Icon, IconButton as IconButton2, Popover, Select as Select2, useTranslation as useTranslation3 } from "@dxos/react-ui";
+import { Listbox, SearchList } from "@dxos/react-ui-searchlist";
+import { Tabs } from "@dxos/react-ui-tabs";
+var panelClassNames = "is-[calc(100dvw-.5rem)] sm:is-max md:is-72 max-is-[--text-content]";
+var ChatOptions = ({ space, context, blueprintRegistry, presets, preset, onPresetChange }) => {
+  var _effect = _useSignals5();
+  try {
+    const { t } = useTranslation3(meta.id);
+    return /* @__PURE__ */ React3.createElement("div", {
+      role: "none",
+      className: "flex p-2"
+    }, /* @__PURE__ */ React3.createElement(Popover.Root, null, /* @__PURE__ */ React3.createElement(Popover.Trigger, {
+      asChild: true
+    }, /* @__PURE__ */ React3.createElement(IconButton2, {
+      variant: "ghost",
+      icon: "ph--plus--regular",
+      iconOnly: true,
+      label: t("context objects button")
+    })), /* @__PURE__ */ React3.createElement(Popover.Portal, null, /* @__PURE__ */ React3.createElement(Popover.Content, {
+      side: "top",
+      classNames: panelClassNames
+    }, /* @__PURE__ */ React3.createElement(Popover.Viewport, null, /* @__PURE__ */ React3.createElement(ObjectsPanel, {
+      space,
+      context
+    })), /* @__PURE__ */ React3.createElement(Popover.Arrow, null)))), /* @__PURE__ */ React3.createElement(Popover.Root, null, /* @__PURE__ */ React3.createElement(Popover.Trigger, {
+      asChild: true
+    }, /* @__PURE__ */ React3.createElement(IconButton2, {
+      variant: "ghost",
+      icon: "ph--sliders-horizontal--regular",
+      iconOnly: true,
+      label: t("context settings button")
+    })), /* @__PURE__ */ React3.createElement(Popover.Portal, null, /* @__PURE__ */ React3.createElement(Popover.Content, {
+      side: "top",
+      classNames: panelClassNames
+    }, /* @__PURE__ */ React3.createElement(Popover.Viewport, null, /* @__PURE__ */ React3.createElement(Tabs.Root, {
+      orientation: "horizontal",
+      defaultValue: "blueprints",
+      defaultActivePart: "list",
+      tabIndex: -1
+    }, /* @__PURE__ */ React3.createElement(Tabs.Viewport, {
+      classNames: 'max-bs-[--radix-popover-content-available-height] grid grid-rows-[1fr_min-content] [&_[cmdk-root]]:contents [&_[role="tabpanel"]]:grid [&_[role="tabpanel"]]:grid-rows-[1fr_min-content] [&_[role="listbox"]]:min-bs-0 [&_[role="listbox"]]:overflow-y-auto [&_[role="tabpanel"]]:min-bs-0 [&_[role="tabpanel"]]:pli-cardSpacingChrome [&_[role="tabpanel"][data-state="active"]]:order-first [&_[role="tabpanel"][data-state="inactive"]]:hidden'
+    }, /* @__PURE__ */ React3.createElement(Tabs.Tabpanel, {
+      value: "blueprints",
+      tabIndex: -1,
+      classNames: "dx-focus-ring-inset"
+    }, /* @__PURE__ */ React3.createElement(BlueprintsPanel, {
+      blueprintRegistry,
+      space,
+      context
+    })), /* @__PURE__ */ React3.createElement(Tabs.Tabpanel, {
+      value: "model",
+      tabIndex: -1,
+      classNames: "dx-focus-ring-inset !pli-0"
+    }, /* @__PURE__ */ React3.createElement(ModelsPanel, {
+      presets,
+      preset,
+      onPresetChange
+    })), /* @__PURE__ */ React3.createElement(Tabs.Tablist, {
+      classNames: "sm:overflow-x-hidden justify-center p-[--dx-cardSpacingChrome] border-bs border-subduedSeparator order-last"
+    }, /* @__PURE__ */ React3.createElement(Tabs.IconTab, {
+      value: "blueprints",
+      icon: "ph--blueprint--regular",
+      label: t("blueprints in context title")
+    }), /* @__PURE__ */ React3.createElement(Tabs.IconTab, {
+      value: "model",
+      label: t("chat model title"),
+      icon: "ph--cpu--regular"
+    }))))), /* @__PURE__ */ React3.createElement(Popover.Arrow, null)))));
+  } finally {
+    _effect.f();
+  }
+};
+var BlueprintsPanel = ({ blueprintRegistry, space, context }) => {
+  var _effect = _useSignals5();
+  try {
+    const { t } = useTranslation3(meta.id);
+    const blueprints = useBlueprints({
+      blueprintRegistry,
+      space
+    });
+    const activeBlueprints = useActiveBlueprints({
+      context
+    });
+    const { onUpdateBlueprint } = useBlueprintHandlers({
+      space,
+      context,
+      blueprintRegistry
+    });
+    return /* @__PURE__ */ React3.createElement(SearchList.Root, null, /* @__PURE__ */ React3.createElement(SearchList.Content, {
+      classNames: "plb-cardSpacingChrome"
+    }, blueprints.map((blueprint) => {
+      const isActive = activeBlueprints.has(blueprint.key);
+      return /* @__PURE__ */ React3.createElement(SearchList.Item, {
+        classNames: "flex items-center overflow-hidden",
+        key: blueprint.key,
+        value: blueprint.name,
+        onSelect: () => onUpdateBlueprint?.(blueprint.key, !isActive)
+      }, /* @__PURE__ */ React3.createElement("div", {
+        className: "grow truncate"
+      }, blueprint.name), /* @__PURE__ */ React3.createElement(Icon, {
+        icon: "ph--check--regular",
+        classNames: [
+          !isActive && "invisible"
+        ]
+      }));
+    })), /* @__PURE__ */ React3.createElement(SearchList.Input, {
+      placeholder: t("search placeholder"),
+      classNames: "mbe-cardSpacingChrome",
+      autoFocus: true
+    }));
+  } finally {
+    _effect.f();
+  }
+};
+var ModelsPanel = ({ presets, preset, onPresetChange }) => {
+  var _effect = _useSignals5();
+  try {
+    return /* @__PURE__ */ React3.createElement(Listbox.Root, {
+      value: preset,
+      onValueChange: onPresetChange,
+      autoFocus: true
+    }, presets?.map(({ id, label }) => {
+      return /* @__PURE__ */ React3.createElement(Listbox.Option, {
+        key: id,
+        value: id
+      }, /* @__PURE__ */ React3.createElement(Listbox.OptionLabel, null, label), /* @__PURE__ */ React3.createElement(Listbox.OptionIndicator, null));
+    }));
+  } finally {
+    _effect.f();
+  }
+};
+var ANY = "__any__";
+var ObjectsPanel = ({ space, context }) => {
+  var _effect = _useSignals5();
+  try {
+    const { t } = useTranslation3(meta.id);
+    const types = useFilteredTypes(space);
+    const typenames = useMemo6(() => {
+      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] = useState8(ANY);
+    const anyFilter = useMemo6(() => Filter3.or(...typenames.map(({ typename: typename2 }) => Filter3.typename(typename2))), [
+      typenames
+    ]);
+    const objects = useQuery2(space, typename === ANY ? anyFilter : Filter3.typename(typename));
+    const { objects: contextObjects, onUpdateObject } = useContextObjects({
+      space,
+      context
+    });
+    return /* @__PURE__ */ React3.createElement(SearchList.Root, null, /* @__PURE__ */ React3.createElement(SearchList.Content, {
+      classNames: "p-cardSpacingChrome [&:has([cmdk-list-sizer]:empty)]:plb-0"
+    }, objects.length ? objects.map((object) => {
+      const label = Obj3.getLabel(object) ?? Obj3.getTypename(object) ?? object.id;
+      const isActive = contextObjects.findIndex((obj) => obj.id === object.id) !== -1;
+      return /* @__PURE__ */ React3.createElement(SearchList.Item, {
+        classNames: "flex items-center overflow-hidden",
+        key: object.id,
+        value: object.id,
+        onSelect: () => onUpdateObject?.(Obj3.getDXN(object), !isActive)
+      }, /* @__PURE__ */ React3.createElement("div", {
+        className: "grow truncate"
+      }, label), /* @__PURE__ */ React3.createElement(Icon, {
+        icon: "ph--check--regular",
+        classNames: [
+          !isActive && "invisible"
+        ]
+      }));
+    }) : /* @__PURE__ */ React3.createElement(SearchList.Item, null, t("no results"))), /* @__PURE__ */ React3.createElement("div", {
+      role: "none",
+      className: "grid grid-cols-[min-content_1fr] gap-2 pli-cardSpacingChrome mbe-cardSpacingChrome"
+    }, /* @__PURE__ */ React3.createElement(Select2.Root, {
+      value: typename === ANY ? void 0 : typename,
+      onValueChange: setTypename
+    }, /* @__PURE__ */ React3.createElement(Select2.TriggerButton, {
+      density: "fine",
+      placeholder: t("type filter placeholder")
+    }), /* @__PURE__ */ React3.createElement(Select2.Portal, null, /* @__PURE__ */ React3.createElement(Select2.Content, null, /* @__PURE__ */ React3.createElement(Select2.ScrollUpButton, null), /* @__PURE__ */ React3.createElement(Select2.Viewport, null, /* @__PURE__ */ React3.createElement(Select2.Option, {
+      value: ANY
+    }, t("any type filter label")), typenames.map(({ typename: typename2, label }) => /* @__PURE__ */ React3.createElement(Select2.Option, {
+      key: typename2,
+      value: typename2
+    }, label))), /* @__PURE__ */ React3.createElement(Select2.ScrollDownButton, null), /* @__PURE__ */ React3.createElement(Select2.Arrow, null)))), /* @__PURE__ */ React3.createElement(SearchList.Input, {
+      placeholder: t("search placeholder"),
+      classNames: "mbe-0",
+      autoFocus: true
+    })));
+  } finally {
+    _effect.f();
+  }
+};
+
+// src/components/ChatPrompt/ChatPresets.tsx
+import { useSignals as _useSignals6 } from "@preact-signals/safe-react/tracking";
+import React4 from "react";
+import { Select as Select3 } from "@dxos/react-ui";
+
+// src/components/ChatPrompt/ChatReferences.tsx
+import { useSignals as _useSignals7 } from "@preact-signals/safe-react/tracking";
+import React5 from "react";
+import { Obj as Obj4 } from "@dxos/echo";
+import { IconButton as IconButton3, toLocalizedString, useTranslation as useTranslation4 } from "@dxos/react-ui";
+import { mx as mx2 } from "@dxos/react-ui-theme";
+var ChatReferences = ({ classNames, context, space }) => {
+  var _effect = _useSignals7();
+  try {
+    const { t } = useTranslation4(meta.id);
+    const { objects, onUpdateObject } = useContextObjects({
+      space,
+      context
+    });
+    return /* @__PURE__ */ React5.createElement("ul", {
+      className: mx2("flex", classNames)
+    }, objects.map((obj) => {
+      const dxn = Obj4.getDXN(obj);
+      const typename = Obj4.getTypename(obj);
+      const label = Obj4.getLabel(obj) ?? (typename ? [
+        "object name placeholder",
+        {
+          ns: typename
+        }
+      ] : obj.id);
+      return /* @__PURE__ */ React5.createElement("li", {
+        key: dxn.toString(),
+        className: "dx-tag plb-0 pis-2 flex items-center",
+        "data-hue": "neutral"
+      }, toLocalizedString(label, t), /* @__PURE__ */ React5.createElement(IconButton3, {
+        icon: "ph--x--bold",
+        iconOnly: true,
+        variant: "ghost",
+        label: t("remove object in context label"),
+        classNames: "p-0 hover:bg-transparent",
+        size: 3,
+        onClick: () => onUpdateObject?.(dxn, false)
+      }));
+    }));
+  } finally {
+    _effect.f();
+  }
+};
+
+// src/components/ChatPrompt/ChatStatusIndicator.tsx
+import { useSignals as _useSignals8 } from "@preact-signals/safe-react/tracking";
+import React6, { useEffect as useEffect3, useState as useState9 } from "react";
+import { Tooltip, useTimeout } from "@dxos/react-ui";
+import { Spinner } from "@dxos/react-ui-sfx";
+import { mx as mx3 } from "@dxos/react-ui-theme";
+var period = 3e3;
+var ChatStatusIndicator = ({ classNames, preset, processing, error, ...props }) => {
+  var _effect = _useSignals8();
+  try {
+    const [init, setInit] = useState9(false);
+    useEffect3(() => setInit(false), [
+      preset
+    ]);
+    useTimeout(async () => {
+      setInit(true);
+    }, period / 2, [
+      preset
+    ]);
+    return /* @__PURE__ */ React6.createElement("div", {
+      role: "none",
+      className: mx3("relative flex", classNames)
+    }, /* @__PURE__ */ React6.createElement(Spinner, {
+      duration: period,
+      state: !init ? "flash" : error ? "error" : processing ? "spin" : "pulse",
+      ...props
+    }), error && /* @__PURE__ */ React6.createElement(Tooltip.Trigger, {
+      asChild: true,
+      content: error.message
+    }, /* @__PURE__ */ React6.createElement("div", {
+      className: "absolute inset-0"
+    })));
+  } finally {
+    _effect.f();
+  }
+};
+
+// src/components/ChatThread/ChatThread.tsx
+import { useSignals as _useSignals11 } from "@preact-signals/safe-react/tracking";
+import React9, { forwardRef, useCallback as useCallback6, useEffect as useEffect5, useMemo as useMemo8 } from "react";
+import { PublicKey } from "@dxos/keys";
+import { useForwardedRef } from "@dxos/react-ui";
+import { MarkdownStream } from "@dxos/react-ui-components";
+import { mx as mx4 } from "@dxos/react-ui-theme";
+import { keyToFallback } from "@dxos/util";
+
+// src/components/ChatThread/registry.tsx
+import { useSignals as _useSignals10 } from "@preact-signals/safe-react/tracking";
+import React8 from "react";
+import { log as log3 } from "@dxos/log";
+import { ToggleContainer as ToggleContainer2 } from "@dxos/react-ui-components";
+import { PromptWidget, ReferenceWidget, SelectWidget, SuggestionWidget, SummaryWidget } from "@dxos/react-ui-components";
+import { getXmlTextChild } from "@dxos/react-ui-editor";
+import { Json as Json2 } from "@dxos/react-ui-syntax-highlighter";
+import { ContentBlock } from "@dxos/types";
+
+// src/components/ToolBlock/ToolBlock.tsx
+import { useSignals as _useSignals9 } from "@preact-signals/safe-react/tracking";
+import React7, { useCallback as useCallback5, useEffect as useEffect4, useMemo as useMemo7, useRef as useRef2, useState as useState10 } from "react";
+import { useTranslation as useTranslation5 } from "@dxos/react-ui";
+import { NumericTabs, TextCrawl, ToggleContainer } from "@dxos/react-ui-components";
+import { Json } from "@dxos/react-ui-syntax-highlighter";
+import { isNonNullable as isNonNullable3, safeParseJson } from "@dxos/util";
+var ToolBlock = ({ view, blocks = [] }) => {
+  var _effect = _useSignals9();
+  try {
+    const { t } = useTranslation5(meta.id);
+    const items = useMemo7(() => {
+      let lastToolCall;
+      const tools = [];
+      return blocks.filter((block) => block._tag === "toolCall" || block._tag === "toolResult" || block._tag === "summary").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"),
+                tool?.name
+              ].join(" "),
+              content: {
+                ...block,
+                input: safeParseJson(block.input)
+              }
+            };
+          }
+          case "toolResult": {
+            if (block.error) {
+              return {
+                title: t("tool error label"),
+                content: block
+              };
+            }
+            const title = lastToolCall?.tool?.description ?? [
+              t("tool result label"),
+              lastToolCall?.tool?.name
+            ].join(" ");
+            lastToolCall = void 0;
+            return {
+              title,
+              content: {
+                ...block,
+                result: safeParseJson(block.result)
+              }
+            };
+          }
+          case "summary": {
+            if (!lastToolCall) {
+              return null;
+            }
+            return {
+              title: t("summary label"),
+              content: block
+            };
+          }
+        }
+      }).filter(isNonNullable3);
+    }, [
+      blocks
+    ]);
+    const handleChangeOpen = useCallback5(() => {
+      setTimeout(() => {
+        view?.requestMeasure();
+      }, 1e3);
+    }, [
+      view
+    ]);
+    if (!items.length) {
+      return null;
+    }
+    return /* @__PURE__ */ React7.createElement(ToolContainer, {
+      items,
+      onChangeOpen: handleChangeOpen
+    });
+  } finally {
+    _effect.f();
+  }
+};
+ToolBlock.displayName = "ToolBlock";
+var ToolContainer = ({ items, onChangeOpen }) => {
+  var _effect = _useSignals9();
+  try {
+    const tabsRef = useRef2(null);
+    const [selected, setSelected] = useState10(0);
+    const [open, setOpen] = useState10(false);
+    useEffect4(() => {
+      onChangeOpen?.(open);
+      if (open) {
+        tabsRef.current?.focus();
+      }
+    }, [
+      open,
+      onChangeOpen
+    ]);
+    const handleSelect = (index) => {
+      setSelected(index);
+    };
+    return /* @__PURE__ */ React7.createElement(ToggleContainer.Root, {
+      classNames: "mbs-2 is-full rounded-sm",
+      open,
+      onChangeOpen: setOpen
+    }, /* @__PURE__ */ React7.createElement(ToggleContainer.Header, {
+      classNames: "text-sm text-placeholder"
+    }, /* @__PURE__ */ React7.createElement(TextCrawl, {
+      key: "status-roll",
+      lines: items.map((item) => item.title),
+      autoAdvance: true,
+      greedy: true
+    })), /* @__PURE__ */ React7.createElement(ToggleContainer.Content, {
+      classNames: "grid grid-cols-[32px_1fr]"
+    }, /* @__PURE__ */ React7.createElement(NumericTabs, {
+      ref: tabsRef,
+      classNames: "p-1",
+      length: items.length,
+      selected,
+      onSelect: handleSelect
+    }), /* @__PURE__ */ React7.createElement(Json, {
+      data: items[selected]?.content,
+      classNames: "p-1 text-xs bg-transparent",
+      replacer: {
+        maxDepth: 3,
+        maxArrayLen: 10,
+        maxStringLen: 128
+      }
+    })));
+  } finally {
+    _effect.f();
+  }
+};
+
+// src/components/ChatThread/registry.tsx
+var __dxlog_file3 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/components/ChatThread/registry.tsx";
+var Fallback = ({ _tag, ...props }) => {
+  var _effect = _useSignals10();
+  try {
+    return /* @__PURE__ */ React8.createElement(ToggleContainer2.Root, {
+      classNames: "rounded-sm"
+    }, /* @__PURE__ */ React8.createElement(ToggleContainer2.Header, {
+      classNames: "bg-groupSurface"
+    }, _tag), /* @__PURE__ */ React8.createElement(ToggleContainer2.Content, {
+      classNames: "bg-modalSurface"
+    }, /* @__PURE__ */ React8.createElement(Json2, {
+      classNames: "!p-2 text-sm",
+      data: props
+    })));
+  } finally {
+    _effect.f();
+  }
+};
+var componentRegistry = {
+  //
+  // Widgets
+  //
+  ["prompt"]: {
+    block: true,
+    factory: ({ children }) => {
+      const text = getXmlTextChild(children);
+      return text ? new PromptWidget(text) : 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;
+    }
+  },
+  ["summary"]: {
+    block: true,
+    factory: ({ children }) => {
+      const text = getXmlTextChild(children);
+      return text ? new SummaryWidget(text) : null;
+    }
+  },
+  //
+  // React
+  //
+  ["toolCall"]: {
+    block: true,
+    Component: ToolBlock
+  },
+  ["toolResult"]: {
+    block: true,
+    Component: Fallback
+  },
+  ["toolkit"]: {
+    block: true,
+    Component: Fallback
+  },
+  //
+  // Fallback
+  //
+  ["json"]: {
+    block: true,
+    Component: Fallback
+  }
+};
+var blockToMarkdown = (context, message, block) => {
+  let str = blockToMarkdownImpl(context, message, block);
+  if (str && !block.pending) {
+    return str += "\n";
+  }
+  return str;
+};
+var blockToMarkdownImpl = (context, message, block) => {
+  log3("blockToMarkdown", {
+    block: JSON.stringify(block)
+  }, {
+    F: __dxlog_file3,
+    L: 125,
+    S: void 0,
+    C: (f, a) => f(...a)
+  });
+  switch (block._tag) {
+    case "text": {
+      if (message.sender.role === "user") {
+        return `<prompt>${block.text}</prompt>`;
+      } else {
+        const text = block.text.trim();
+        if (text.length > 0) {
+          return text;
+        }
+      }
+      break;
+    }
+    case "reference": {
+      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": {
+      context.updateWidget(block.toolCallId, {
+        blocks: [
+          block
+        ]
+      });
+      return `<toolCall id="${block.toolCallId}" />`;
+    }
+    case "toolResult": {
+      context.updateWidget(block.toolCallId, ({ blocks = [] }) => ({
+        blocks: [
+          ...blocks,
+          block
+        ]
+      }));
+      break;
+    }
+    case "summary": {
+      return `<summary>${ContentBlock.createSummaryMessage(block)}</summary>`;
+    }
+    default: {
+      return `<json id="${message.id}">
+${JSON.stringify(block)}
+</json>`;
+    }
+  }
+};
+
+// src/components/ChatThread/sync.ts
+import { log as log4 } from "@dxos/log";
+var __dxlog_file4 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/components/ChatThread/sync.ts";
+var MessageThreadContext = class {
+  _widgetState;
+  constructor(_widgetState) {
+    this._widgetState = _widgetState;
+  }
+  updateWidget(id, value) {
+    this._widgetState?.updateWidget(id, value);
+  }
+  // TODO(burdon): Resolve from hypergraph.
+  getObjectLabel(_id) {
+    return "Object";
+  }
+};
+var MessageSyncer = class {
+  _model;
+  _blockRenderer;
+  _initialMessageId;
+  _currentMessageIndex = 0;
+  _currentBlockIndex = 0;
+  _currentBlockContent;
+  _context;
+  constructor(_model, _blockRenderer) {
+    this._model = _model;
+    this._blockRenderer = _blockRenderer;
+    this._context = new MessageThreadContext(this._model);
+  }
+  get context() {
+    return this._context;
+  }
+  reset() {
+    log4("reset", void 0, {
+      F: __dxlog_file4,
+      L: 64,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    this._initialMessageId = void 0;
+    this._currentMessageIndex = 0;
+    this._currentBlockIndex = 0;
+    this._currentBlockContent = void 0;
+    void this._model.reset("");
+  }
+  /**
+  * Syncs messages with the editor.
+  */
+  append(messages, flush = false) {
+    if (this._initialMessageId !== messages[0]?.id) {
+      this.reset();
+      this._initialMessageId = messages[0]?.id;
+    }
+    if (flush && this._model.view?.state.doc.length === 0) {
+      const buffer = [];
+      this.process(messages, (content2) => {
+        buffer.push(content2);
+      });
+      const content = buffer.join("");
+      this._model.view?.dispatch({
+        changes: [
+          {
+            from: 0,
+            to: this._model.view?.state.doc.length ?? 0,
+            insert: content
+          }
+        ],
+        selection: {
+          anchor: content.length
+        }
+      });
+      return true;
+    } else {
+      this.process(messages, (content) => {
+        void this._model.append(content);
+      });
+      return false;
+    }
+  }
+  process(messages, append) {
+    log4("sync", {
+      doc: this._model.view?.state.doc.length,
+      messages: messages.map((message) => message.blocks.length),
+      currentMessageIndex: this._currentMessageIndex,
+      currentBlockIndex: this._currentBlockIndex,
+      currentBlockContent: this._currentBlockContent
+    }, {
+      F: __dxlog_file4,
+      L: 105,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    let i = this._currentMessageIndex;
+    for (const message of messages.slice(this._currentMessageIndex)) {
+      if (i > this._currentMessageIndex) {
+        this._currentBlockIndex = 0;
+      }
+      this._currentMessageIndex = i;
+      let j = this._currentBlockIndex;
+      for (const block of message.blocks.slice(this._currentBlockIndex)) {
+        this._currentBlockIndex = j;
+        const currentBlockContent = this._blockRenderer(this._context, message, block);
+        if (currentBlockContent) {
+          let content = "";
+          if (this._currentBlockContent && currentBlockContent.startsWith(this._currentBlockContent)) {
+            content = currentBlockContent.slice(this._currentBlockContent.length);
+          } else {
+            content = currentBlockContent;
+          }
+          log4("append", {
+            message: i,
+            block: j,
+            content
+          }, {
+            F: __dxlog_file4,
+            L: 132,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          this._currentBlockContent = currentBlockContent;
+          append(content);
+        }
+        if (block.pending) {
+          return;
+        } else {
+          this._currentBlockContent = void 0;
+          this._currentBlockIndex++;
+        }
+        j++;
+      }
+      i++;
+    }
+  }
+};
+
+// src/components/ChatThread/ChatThread.tsx
+var ChatThread = /* @__PURE__ */ forwardRef(({ classNames, identity, messages = [], error, cursor = false, fadeIn = true, debug = false, onEvent }, forwardedRef) => {
+  var _effect = _useSignals11();
+  try {
+    const controllerRef = useForwardedRef(forwardedRef);
+    const controller = controllerRef.current;
+    const userHue = useMemo8(() => identity?.profile?.data?.hue || keyToFallback(identity?.identityKey ?? PublicKey.random()).hue, [
+      identity
+    ]);
+    useEffect5(() => {
+      controller?.scrollToBottom();
+    }, [
+      controller,
+      error
+    ]);
+    const syncer = useMemo8(() => controller && new MessageSyncer(controller, blockToMarkdown), [
+      controller
+    ]);
+    useEffect5(() => {
+      const reset = syncer?.append(messages, true);
+      if (reset) {
+        controller?.scrollToBottom("instant");
+      }
+    }, [
+      syncer,
+      messages
+    ]);
+    const handleEvent = useCallback6(({ type, value }) => {
+      switch (type) {
+        case "submit": {
+          value && onEvent?.({
+            type,
+            text: value
+          });
+          break;
+        }
+      }
+    }, [
+      onEvent
+    ]);
+    return /* @__PURE__ */ React9.createElement("div", {
+      role: "none",
+      className: mx4("flex bs-full is-full justify-center overflow-hidden", classNames),
+      style: {
+        "--user-fill": `var(--dx-${userHue}Fill)`
+      }
+    }, /* @__PURE__ */ React9.createElement(MarkdownStream, {
+      ref: controllerRef,
+      registry: componentRegistry,
+      cursor,
+      fadeIn,
+      debug,
+      onEvent: handleEvent
+    }));
+  } finally {
+    _effect.f();
+  }
+});
+
+// src/components/Chat/Chat.tsx
+var [ChatContextProvider, useChatContext] = createContext("Chat");
+var ChatRoot = ({ children, chat, processor, onEvent, ...props }) => {
+  var _effect = _useSignals12();
+  try {
+    const [debug, setDebug] = useState11(false);
+    const pending = useAtomValue(processor.messages);
+    const streaming = useAtomValue(processor.streaming);
+    const lastPrompt = useRef3(void 0);
+    const queue = useQueue(chat?.queue.dxn);
+    const messages = useMemo9(() => {
+      const queueMessages = queue?.objects?.filter(Obj5.instanceOf(Message.Message)) ?? [];
+      return Array2.dedupeWith([
+        ...queueMessages,
+        ...pending
+      ], ({ id: a }, { id: b }) => a === b);
+    }, [
+      queue?.objects,
+      pending
+    ]);
+    const event = useMemo9(() => new Event(), []);
+    useEffect6(() => {
+      return event.on((ev) => {
+        switch (ev.type) {
+          case "toggle-debug": {
+            setDebug((current) => !current);
+            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,
+      processor,
+      streaming,
+      onEvent
+    ]);
+    const space = props.space ?? getSpace(chat);
+    return /* @__PURE__ */ React10.createElement(ChatContextProvider, {
+      debug,
+      event,
+      space,
+      chat,
+      messages,
+      processor,
+      ...props
+    }, children);
+  } finally {
+    _effect.f();
+  }
+};
+ChatRoot.displayName = "Chat.Root";
+var ChatViewport = ({ classNames, children }) => {
+  var _effect = _useSignals12();
+  try {
+    return /* @__PURE__ */ React10.createElement("div", {
+      role: "none",
+      className: mx5("flex flex-col bs-full is-full", classNames)
+    }, children);
+  } finally {
+    _effect.f();
+  }
+};
+var ChatPrompt = ({ classNames, outline, settings = true, placeholder, expandable, online, presets, preset, onPresetChange, onOnlineChange }) => {
+  var _effect = _useSignals12();
+  try {
+    const { t } = useTranslation6(meta.id);
+    const { space, processor, event } = useChatContext(ChatPrompt.displayName);
+    const error = useAtomValue(processor.error).pipe(Option2.getOrUndefined);
+    const streaming = useAtomValue(processor.streaming);
+    const active = useAtomValue(processor.active);
+    const activeRef = useDynamicRef(active);
+    const editorRef = useRef3(null);
+    const [recordingState, setRecordingState] = useState11(false);
+    useEffect6(() => {
+      return event.on((event2) => {
+        switch (event2.type) {
+          case "update-prompt":
+            if (!editorRef.current?.getText()?.length) {
+              editorRef.current?.setText(event2.text);
+              editorRef.current?.focus();
+            }
+            break;
+          case "record-start":
+            setRecordingState(true);
+            break;
+          case "record-stop":
+            setRecordingState(false);
+            break;
+        }
+      });
+    }, [
+      event
+    ]);
+    const { recording } = useVoiceInput({
+      active: recordingState,
+      onUpdate: (text) => {
+        editorRef.current?.setText(text);
+        editorRef.current?.focus();
+      }
+    });
+    const extensions = useMemo9(() => {
+      return [
+        Prec.highest(keymap.of([
+          {
+            key: "Mod-d",
+            preventDefault: true,
+            run: () => {
+              event.emit({
+                type: "toggle-debug"
+              });
+              return true;
+            }
+          },
+          {
+            key: "Mod-ArrowUp",
+            preventDefault: true,
+            run: () => {
+              event.emit({
+                type: "nav-previous"
+              });
+              return true;
+            },
+            shift: () => {
+              event.emit({
+                type: "thread-open"
+              });
+              return true;
+            }
+          },
+          {
+            key: "Mod-ArrowDown",
+            preventDefault: true,
+            run: () => {
+              event.emit({
+                type: "nav-next"
+              });
+              return true;
+            },
+            shift: () => {
+              event.emit({
+                type: "thread-close"
+              });
+              return true;
+            }
+          }
+        ]))
+      ].filter(isTruthy);
+    }, [
+      event,
+      expandable
+    ]);
+    const handleSubmit = useCallback7((text) => {
+      if (!activeRef.current) {
+        event.emit({
+          type: "submit",
+          text
+        });
+        return true;
+      }
+    }, [
+      event
+    ]);
+    const handleEvent = useCallback7((ev) => {
+      event.emit(ev);
+    }, [
+      event
+    ]);
+    return /* @__PURE__ */ React10.createElement("div", {
+      role: "group",
+      className: mx5("flex flex-col is-full density-fine", outline && "bg-groupSurface border border-subduedSeparator transition transition-border [&:has(.cm-content:focus)]:border-separator rounded", classNames)
+    }, /* @__PURE__ */ React10.createElement("div", {
+      role: "none",
+      className: "flex p-2 gap-2"
+    }, /* @__PURE__ */ React10.createElement(ChatStatusIndicator, {
+      classNames: "p-1",
+      preset,
+      error,
+      processing: streaming
+    }), /* @__PURE__ */ React10.createElement(ChatEditor, {
+      ref: editorRef,
+      autoFocus: true,
+      lineWrapping: true,
+      classNames: "col-span-2 pbs-0.5",
+      placeholder: placeholder ?? t("prompt placeholder"),
+      extensions,
+      onSubmit: handleSubmit
+    })), space && settings && /* @__PURE__ */ React10.createElement("div", {
+      role: "none",
+      className: "flex items-center overflow-hidden"
+    }, /* @__PURE__ */ React10.createElement(ChatOptions, {
+      space,
+      blueprintRegistry: processor.blueprintRegistry,
+      context: processor.context,
+      preset,
+      presets,
+      onPresetChange
+    }), /* @__PURE__ */ React10.createElement("div", {
+      role: "none",
+      className: "flex grow overflow-x-auto scrollbar-none"
+    }, /* @__PURE__ */ React10.createElement(ChatReferences, {
+      space,
+      context: processor.context
+    })), /* @__PURE__ */ React10.createElement(ChatActions, {
+      classNames: "col-span-2",
+      microphone: true,
+      recording,
+      processing: streaming,
+      onEvent: handleEvent
+    }, online !== void 0 && /* @__PURE__ */ React10.createElement(Input2.Root, null, /* @__PURE__ */ React10.createElement(Input2.Label, {
+      srOnly: true
+    }, t("online switch label")), /* @__PURE__ */ React10.createElement(Input2.Switch, {
+      classNames: "mli-2",
+      checked: online,
+      onCheckedChange: onOnlineChange
+    })))));
+  } finally {
+    _effect.f();
+  }
+};
+ChatPrompt.displayName = "Chat.Prompt";
+var ChatThread2 = (props) => {
+  var _effect = _useSignals12();
+  try {
+    const { debug, event, messages, processor } = useChatContext(ChatThread2.displayName);
+    const identity = useIdentity();
+    const error = useAtomValue(processor.error).pipe(Option2.getOrUndefined);
+    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 = useCallback7((ev) => {
+      event.emit(ev);
+    }, [
+      event
+    ]);
+    if (!identity) {
+      return null;
+    }
+    return /* @__PURE__ */ React10.createElement(ChatThread, {
+      ...props,
+      identity,
+      messages,
+      error,
+      debug,
+      onEvent: handleEvent,
+      ref: controllerRef
+    });
+  } finally {
+    _effect.f();
+  }
+};
+ChatThread2.displayName = "Chat.Thread";
+var ChatToolbar = ({ classNames, companionTo }) => {
+  var _effect = _useSignals12();
+  try {
+    const { chat } = useChatContext(ChatToolbar.displayName);
+    const menu = useChatToolbarActions({
+      chat,
+      companionTo
+    });
+    return /* @__PURE__ */ React10.createElement(MenuProvider, {
+      ...menu,
+      attendableId: companionTo ? Obj5.getDXN(companionTo).toString() : chat ? Obj5.getDXN(chat).toString() : ""
+    }, /* @__PURE__ */ React10.createElement(ToolbarMenu, {
+      classNames,
+      textBlockWidth: true
+    }));
+  } finally {
+    _effect.f();
+  }
+};
+ChatToolbar.displayName = "Chat.Toolbar";
+var Chat = {
+  Root: ChatRoot,
+  Viewport: ChatViewport,
+  Prompt: ChatPrompt,
+  Thread: ChatThread2,
+  Toolbar: ChatToolbar
+};
+
+// src/components/Toolbox/Toolbox.tsx
+import { useSignals as _useSignals13 } from "@preact-signals/safe-react/tracking";
+import React11, { Fragment, useEffect as useEffect7, useState as useState12 } from "react";
+import { Function } from "@dxos/functions";
+import { log as log5 } from "@dxos/log";
+import { Filter as Filter4, useQuery as useQuery3 } from "@dxos/react-client/echo";
+import { useTranslation as useTranslation7 } from "@dxos/react-ui";
+import { mx as mx6 } from "@dxos/react-ui-theme";
+var __dxlog_file5 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/components/Toolbox/Toolbox.tsx";
+var Toolbox = ({ classNames, functions, services, blueprints, activeBlueprints }) => {
+  var _effect = _useSignals13();
+  try {
+    const { t } = useTranslation7(meta.id);
+    return /* @__PURE__ */ React11.createElement("div", {
+      className: mx6("flex flex-col overflow-y-auto box-content", classNames)
+    }, blueprints && blueprints.length > 0 && /* @__PURE__ */ React11.createElement(Section, {
+      title: "Blueprints",
+      items: blueprints.map(({ target }) => ({
+        name: target?.name ?? "",
+        description: target?.description ?? "",
+        subitems: target?.tools.map((toolId) => ({
+          name: `\u2219 ${safeToolId(toolId)}`
+        }))
+      }))
+    }), activeBlueprints && activeBlueprints.length > 0 && /* @__PURE__ */ React11.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__ */ React11.createElement(Section, {
+      title: "Services",
+      items: services.map(({ service: { serviceId, name, description } }) => ({
+        name: name ?? serviceId,
+        description
+      }))
+    }), functions && functions.length > 0 && /* @__PURE__ */ React11.createElement(Section, {
+      title: "Functions",
+      items: functions.map(({ name, description }) => ({
+        name,
+        description
+      }))
+    }));
+  } finally {
+    _effect.f();
+  }
+};
+var Section = ({ title, items, striped }) => {
+  var _effect = _useSignals13();
+  try {
+    const stripeClassNames = "odd:bg-neutral-50 dark:odd:bg-neutral-800";
+    const gridClassNames = "grid grid-cols-[8rem_1fr]";
+    const subGridClassNames = mx6("col-span-full grid grid-cols-subgrid text-xs pli-2", striped && stripeClassNames);
+    return /* @__PURE__ */ React11.createElement("div", null, /* @__PURE__ */ React11.createElement("h1", {
+      className: "pli-2 text-sm"
+    }, title), /* @__PURE__ */ React11.createElement("div", {
+      className: gridClassNames
+    }, items.map(({ name, description, subitems }, i) => /* @__PURE__ */ React11.createElement(Fragment, {
+      key: i
+    }, name && /* @__PURE__ */ React11.createElement("div", {
+      className: subGridClassNames
+    }, /* @__PURE__ */ React11.createElement("div", {
+      className: "truncate text-primary-500"
+    }, name), /* @__PURE__ */ React11.createElement("div", {
+      className: "line-clamp-2"
+    }, description)), subitems?.map(({ name: name2, description: description2 }, i2) => /* @__PURE__ */ React11.createElement("div", {
+      key: i2,
+      className: mx6(subGridClassNames, striped && stripeClassNames)
+    }, /* @__PURE__ */ React11.createElement("div", {
+      className: "truncate"
+    }, name2), /* @__PURE__ */ React11.createElement("div", {
+      className: "line-clamp-3 text-subdued"
+    }, description2)))))));
+  } finally {
+    _effect.f();
+  }
+};
+var ToolboxContainer = ({ classNames, space, processor }) => {
+  var _effect = _useSignals13();
+  try {
+    const services = useQuery3(space, Filter4.type(ServiceType));
+    const [serviceTools, setServiceTools] = useState12([]);
+    useEffect7(() => {
+      log5("creating service tools...", {
+        services: services.length
+      }, {
+        F: __dxlog_file5,
+        L: 117,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+      queueMicrotask(async () => {
+      });
+    }, [
+      services
+    ]);
+    const functions = useQuery3(space, Filter4.type(Function.Function));
+    return /* @__PURE__ */ React11.createElement(Toolbox, {
+      classNames,
+      blueprints: processor?.context.blueprints.value,
+      services: serviceTools,
+      functions
+    });
+  } finally {
+    _effect.f();
+  }
+};
+var safeToolId = (name) => {
+  return name.split("_").pop();
+};
+
+// src/components/index.ts
+var BlueprintArticle = lazy(() => import("./BlueprintArticle-R2XYBRCK.mjs"));
+var ChatCompanion = lazy(() => import("./ChatCompanion-O4T7PMMC.mjs"));
+var ChatContainer = lazy(() => import("./ChatContainer-OWAZI6ZF.mjs"));
+var ChatDialog = lazy(() => import("./ChatDialog-IBXH5FRI.mjs"));
+var PromptArticle = lazy(() => import("./PromptArticle-IV7O5UZ3.mjs"));
+
+// src/hooks/useChatToolbarActions.ts
+var __dxlog_file6 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/hooks/useChatToolbarActions.ts";
+var useChatToolbarActions = ({ chat, companionTo }) => {
+  const { dispatch } = useIntentDispatcher();
+  const { space } = useChatContext("useChatToolbarActions");
+  const query = companionTo ? Query.select(Filter5.id(companionTo.id)).targetOf(Assistant_exports.CompanionTo).source() : Query.select(Filter5.nothing());
+  const chats = useQuery4(space, query);
+  return useMenuActions(useMemo10(() => {
+    return Atom.make(() => {
+      const builder = MenuBuilder.make().root({
+        label: [
+          "chat toolbar title",
+          {
+            ns: meta.id
+          }
+        ]
+      }).action("new", {
+        label: [
+          "new thread button",
+          {
+            ns: meta.id
+          }
+        ],
+        icon: "ph--plus--regular",
+        type: "new"
+      }, () => dispatch(createIntent(AssistantAction_exports.SetCurrentChat, {
+        companionTo,
+        chat: void 0
+      })).pipe(Effect2.runPromise)).action("rename", {
+        label: [
+          "rename thread button",
+          {
+            ns: meta.id
+          }
+        ],
+        icon: "ph--magic-wand--regular",
+        type: "rename",
+        disabled: !chat
+      }, () => Effect2.gen(function* () {
+        invariant(chat, void 0, {
+          F: __dxlog_file6,
+          L: 68,
+          S: this,
+          A: [
+            "chat",
+            ""
+          ]
+        });
+        yield* dispatch(createIntent(AssistantAction_exports.UpdateChatName, {
+          chat
+        }));
+      }).pipe(Effect2.runPromise)).action("branch", {
+        label: [
+          "button branch thread",
+          {
+            ns: meta.id
+          }
+        ],
+        icon: "ph--git-branch--regular",
+        type: "branch",
+        disabled: true
+      }, () => {
+      });
+      if (chats.length > 0) {
+        builder.group("chats", {
+          label: [
+            "chat history label",
+            {
+              ns: meta.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: Assistant_exports.Chat.typename
+                }
+              ]
+            }, () => Effect2.gen(function* () {
+              invariant(companionTo, void 0, {
+                F: __dxlog_file6,
+                L: 104,
+                S: this,
+                A: [
+                  "companionTo",
+                  ""
+                ]
+              });
+              yield* dispatch(createIntent(AssistantAction_exports.SetCurrentChat, {
+                companionTo,
+                chat: chat2
+              }));
+            }).pipe(Effect2.runPromise));
+          });
+        });
+      }
+      return builder.build();
+    });
+  }, [
+    chats.length,
+    space?.id,
+    companionTo?.id,
+    chat?.id,
+    dispatch
+  ]));
+};
+
+export {
+  AssistantSettings,
+  useBlueprintRegistry,
+  useBlueprints,
+  useActiveBlueprints,
+  useBlueprintHandlers,
+  useChatProcessor,
+  useChatServices,
+  useChatToolbarActions,
+  useContextBinder,
+  useContextObjects,
+  useFilteredTypes,
+  useFlush,
+  useOnline,
+  usePresets,
+  useReferencesProvider,
+  ChatContextProvider,
+  useChatContext,
+  Chat,
+  Toolbox,
+  ToolboxContainer,
+  BlueprintArticle,
+  ChatCompanion,
+  ChatContainer,
+  ChatDialog,
+  PromptArticle
+};
+//# sourceMappingURL=chunk-ZNSHGWE4.mjs.map