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

package/dist/lib/browser/{chunk-TQ3QW3HJ.mjs → chunk-VEBVAHNM.mjs}

@@ -1,31 +1,112 @@
-import {
-  ServiceType
-} from "./chunk-TU7UUGWQ.mjs";
 import {
   AssistantCapabilities
-} from "./chunk-NTBGTFTV.mjs";
+} from "./chunk-QB7OVS6Z.mjs";
+import {
+  ServiceType
+} from "./chunk-HRLMD35M.mjs";
 import {
   meta
 } from "./chunk-LKP65RPA.mjs";
 
-// src/hooks/useChatProcessor.tsx
-import { useEffect as useEffect2, useMemo as useMemo3, useState as useState4 } from "react";
-import { DEFAULT_EDGE_MODEL as DEFAULT_EDGE_MODEL2, DEFAULT_OLLAMA_MODEL } from "@dxos/ai";
-import { Capabilities as Capabilities3, useCapabilities as useCapabilities3, useIntentDispatcher } from "@dxos/app-framework";
-import { createSystemPrompt } from "@dxos/artifact";
-import { Conversation } from "@dxos/assistant";
-import { FunctionType } from "@dxos/functions";
-import { log as log5 } from "@dxos/log";
-import { useConfig } from "@dxos/react-client";
-import { Filter as Filter3, fullyQualifiedId, useQuery } from "@dxos/react-client/echo";
-import { isNonNullable as isNonNullable2 } from "@dxos/util";
+// src/hooks/useBlueprintRegistry.ts
+import { useSignals as _useSignals } from "@preact-signals/safe-react/tracking";
+import { useSignalEffect } from "@preact/signals-react";
+import { useCallback, useMemo, useState } from "react";
+import { Capabilities, useCapabilities } from "@dxos/app-framework";
+import { Blueprint } from "@dxos/blueprints";
+import { Filter, Obj, Ref } from "@dxos/echo";
+import { isNonNullable } from "@dxos/util";
+var useBlueprintRegistry = () => {
+  const blueprints = useCapabilities(Capabilities.BlueprintDefinition);
+  return useMemo(() => new Blueprint.Registry(blueprints), [
+    blueprints
+  ]);
+};
+var useBlueprints = ({ context }) => {
+  var _effect = _useSignals();
+  try {
+    const [active, setActive] = useState(/* @__PURE__ */ new Map());
+    useSignalEffect(() => {
+      const refs = [
+        ...context?.blueprints.value ?? []
+      ];
+      const t = setTimeout(async () => {
+        const blueprints = (await Ref.Array.loadAll(refs)).filter(isNonNullable);
+        setActive(new Map(blueprints.map((blueprint) => [
+          blueprint.key,
+          blueprint
+        ])));
+      });
+      return () => clearTimeout(t);
+    });
+    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-rx/rx-react";
+import { useContext, useMemo as useMemo6 } from "react";
+import { useIntentDispatcher } from "@dxos/app-framework";
+import { AiConversation } from "@dxos/assistant";
+import { log as log2 } from "@dxos/log";
+import { fullyQualifiedId } from "@dxos/react-client/echo";
 
 // src/hooks/chat-processor.ts
-import { batch, computed, signal } from "@preact/signals-core";
-import { DEFAULT_EDGE_MODEL } from "@dxos/ai";
+import { Registry, Result, Rx } from "@effect-rx/rx-react";
+import { Effect, Option, Stream, pipe } from "effect";
+import { AiService, DEFAULT_EDGE_MODEL } from "@dxos/ai";
+import { AiSession, ArtifactDiffResolver, createSystemPrompt } from "@dxos/assistant";
 import { Context } from "@dxos/context";
+import { Obj as Obj2 } from "@dxos/echo";
+import { runAndForwardErrors } from "@dxos/effect";
 import { log } from "@dxos/log";
-import { Filter, getVersion } from "@dxos/react-client/echo";
+import { Filter as Filter2, getVersion } from "@dxos/react-client/echo";
+import { DataType } from "@dxos/schema";
+
+// src/hooks/errors.ts
+var AiServiceOverloadedError = class extends Error {
+  code = "AI_SERVICE_OVERLOADED";
+};
+
+// src/hooks/chat-processor.ts
 function _ts_add_disposable_resource(env, value, async) {
   if (value !== null && value !== void 0) {
     if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
@@ -93,79 +174,123 @@ function _ts_dispose_resources(env) {
 }
 var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/hooks/chat-processor.ts";
 var defaultOptions = {
-  model: DEFAULT_EDGE_MODEL,
-  systemPrompt: "you are a helpful assistant"
+  model: DEFAULT_EDGE_MODEL
 };
-var ChatProcessor = class {
-  constructor(_conversation, _options = defaultOptions) {
+var AiChatProcessor = class {
+  _services;
+  _conversation;
+  _options;
+  /**
+  * Last error.
+  */
+  // TODO(wittjosiah): Error should come from the message stream.
+  error;
+  /** Rx registry. */
+  _observableRegistry;
+  /** Current session. */
+  _session;
+  /**
+  * Current streaming message (from the AI service).
+  */
+  _streaming;
+  /**
+  * Streaming state.
+  */
+  streaming;
+  /**
+  * Pending messages (incl. the current user request).
+  */
+  _pending;
+  /**
+  * Array of Messages (incl. the current message being streamed).
+  */
+  messages;
+  constructor(_services, _conversation, _options = defaultOptions) {
+    this._services = _services;
     this._conversation = _conversation;
     this._options = _options;
-    this._pending = signal([]);
-    this._block = signal(void 0);
-    this.streaming = computed(() => this._block.value !== void 0);
-    this.error = signal(void 0);
-    this.messages = computed(() => {
-      const messages = [
-        ...this._pending.value
-      ];
-      if (this._block.value && messages.length) {
-        const { content, ...rest } = messages.pop();
-        const message = {
-          ...rest,
-          content: [
-            ...content,
-            this._block.value
+    this.error = Rx.make(Option.none());
+    this._session = Rx.make(Option.none());
+    this._streaming = Rx.make((get) => {
+      return pipe(get(this._session), Option.map((session) => Stream.fromQueue(session.blockQueue)), Option.getOrElse(() => Stream.make()), Stream.scan(Option.none(), (acc, blockOption) => Option.flatMap(blockOption, (block) => acc.pipe(Option.match({
+        onNone: () => [
+          block
+        ],
+        onSome: (message) => [
+          ...message.blocks.filter((b) => !b.pending),
+          block
+        ]
+      }), Option.some, Option.map((blocks) => Obj2.make(DataType.Message, {
+        created: (/* @__PURE__ */ new Date()).toISOString(),
+        sender: {
+          role: "assistant"
+        },
+        blocks
+      }))))));
+    });
+    this.streaming = Rx.make((get) => {
+      return pipe(get(this._streaming), Result.map((streaming) => Option.isSome(streaming)), Result.getOrElse(() => false));
+    });
+    this._pending = Rx.make((get) => {
+      const session = get(this._session);
+      return Option.isSome(session) ? pipe(session.value.messageQueue, Stream.fromQueue, Stream.scan([], (acc, message) => [
+        ...acc,
+        message
+      ])) : Stream.make();
+    });
+    this.messages = Rx.make((get) => {
+      const streaming = get(this._streaming);
+      return Result.map(get(this._pending), (pending) => Result.match(streaming, {
+        onInitial: () => pending,
+        onSuccess: (streaming2) => Option.match(streaming2.value, {
+          onNone: () => pending,
+          onSome: (message) => [
+            ...pending,
+            message
           ]
-        };
-        messages.push(message);
-      }
-      return messages;
+        }),
+        onFailure: () => pending
+      }));
     });
-    this._session = void 0;
-    this._artifactDiffResolver = async (artifacts) => {
-      const space = this._options.extensions?.space;
-      if (!space) {
-        return /* @__PURE__ */ new Map();
-      }
-      const versions = /* @__PURE__ */ new Map();
-      await Promise.all(artifacts.map(async (artifact) => {
-        const { objects: [object] } = await space.db.query(Filter.ids(artifact.id)).run();
-        if (!object) {
-          return;
+    this._artifactDiffResolver = {
+      resolve: async (artifacts) => {
+        const space = this._options.extensions?.space;
+        if (!space) {
+          return /* @__PURE__ */ new Map();
         }
-        versions.set(artifact.id, {
-          version: getVersion(object),
-          diff: `Current state: ${JSON.stringify(object)}`
-        });
-      }));
-      return versions;
+        const versions = /* @__PURE__ */ new Map();
+        await Promise.all(artifacts.map(async (artifact) => {
+          const { objects: [object] } = await space.db.query(Filter2.ids(artifact.id)).run();
+          if (!object) {
+            return;
+          }
+          versions.set(artifact.id, {
+            version: getVersion(object),
+            diff: `Current state: ${JSON.stringify(object)}`
+          });
+        }));
+        return versions;
+      }
     };
-    this._tools = [
-      ..._options.tools ?? []
-    ];
-  }
-  get conversation() {
-    return this._conversation;
+    this._observableRegistry = 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 tools() {
-    return this._tools;
-  }
-  /**
-  * @deprecated Replace with blueprints
-  */
-  setTools(tools) {
-    this._tools = tools;
-  }
   /**
   * Make GPT request.
   */
-  async request(message, options = {}) {
+  async request(message, _options = {}) {
     const env = {
       stack: [],
       error: void 0,
@@ -174,133 +299,77 @@ var ChatProcessor = class {
     try {
       const ctx = _ts_add_disposable_resource(env, Context.default(void 0, {
         F: __dxlog_file,
-        L: 140
+        L: 174
       }), true);
-      this._conversation.onBegin.on(ctx, (session) => {
-        log.info("onBegin", {
+      const session = new AiSession();
+      this._observableRegistry.set(this._session, Option.some(session));
+      ctx.onDispose(() => {
+        log.info("onDispose", {
           session,
           isDisposed: ctx.disposed
         }, {
           F: __dxlog_file,
-          L: 143,
+          L: 180,
           S: this,
           C: (f, a) => f(...a)
         });
-        this._session = session;
-        ctx.onDispose(() => {
-          log.info("onDispose", {
-            session,
-            isDisposed: ctx.disposed
-          }, {
-            F: __dxlog_file,
-            L: 147,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          if (this._session === session) {
-            this._session = void 0;
+        Option.match(this._observableRegistry.get(this._session), {
+          onSome: (s) => {
+            if (s === session) {
+              this._observableRegistry.set(this._session, Option.none());
+            }
+          },
+          onNone: () => {
           }
         });
-        session.message.on((message2) => {
-          batch(() => {
-            this._pending.value = [
-              ...this._pending.value,
-              message2
-            ];
-            this._block.value = void 0;
-          });
-        });
-        session.update.on((block) => {
-          batch(() => {
-            this._block.value = block;
-          });
-        });
-        session.userMessage.on((message2) => {
-          log.info("userMessage", {
-            message: message2
-          }, {
-            F: __dxlog_file,
-            L: 169,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          this._pending.value = [
-            ...this._pending.value,
-            message2
-          ];
-        });
-        session.toolStatusReport.on(({ message: message2, status }) => {
-          const msg = this._pending.peek().find((m) => m.id === message2.id);
-          const toolUse = msg?.content.find((block2) => block2.type === "tool_use");
-          if (!toolUse) {
-            return;
-          }
-          const block = msg?.content.find((block2) => block2.type === "tool_use" && block2.id === toolUse.id);
-          if (block) {
-            this._pending.value = this._pending.value.map((m) => {
-              if (m.id === message2.id) {
-                return {
-                  ...m,
-                  content: m.content.map((block2) => block2.type === "tool_use" && block2.id === toolUse.id ? {
-                    ...block2,
-                    currentStatus: status
-                  } : block2)
-                };
-              }
-              return m;
-            });
-          } else {
-            log.warn("no block for status report", void 0, {
+      });
+      try {
+        const messages = await runAndForwardErrors(this._conversation.run({
+          session,
+          prompt: message,
+          system: this._options.system
+        }).pipe(
+          Effect.provide(AiService.model(this._options.model ?? DEFAULT_EDGE_MODEL)),
+          // TODO(dmaretskyi): Move ArtifactDiffResolver upstream.
+          Effect.provideService(ArtifactDiffResolver, this._artifactDiffResolver),
+          Effect.provide(this._services),
+          Effect.tapErrorCause((cause) => {
+            log.error("error", {
+              cause
+            }, {
               F: __dxlog_file,
-              L: 197,
+              L: 205,
               S: this,
               C: (f, a) => f(...a)
             });
-          }
-        });
-      });
-      try {
-        const messages = await this._conversation.run({
-          artifacts: [
-            ...this._options.artifacts ?? []
-          ],
-          requiredArtifactIds: this._options.artifacts?.map((artifact) => artifact.id) ?? [],
-          // TODO(dmaretskyi): Migrate to Effect's AiToolkit.
-          tools: this._tools ?? [],
-          systemPrompt: this._options.systemPrompt,
-          prompt: message,
-          extensions: this._options.extensions,
-          artifactDiffResolver: this._artifactDiffResolver,
-          generationOptions: {
-            model: this._options.model
-          }
-        });
+            return Effect.void;
+          })
+        ));
         log("completed", {
           messages
         }, {
           F: __dxlog_file,
-          L: 218,
+          L: 211,
           S: this,
           C: (f, a) => f(...a)
         });
       } catch (err) {
         log.catch(err, void 0, {
           F: __dxlog_file,
-          L: 220,
+          L: 213,
           S: this,
           C: (f, a) => f(...a)
         });
         if (err instanceof Error && err.message.includes("Overloaded")) {
-          this.error.value = new AiServiceOverloadedError("AI service overloaded", {
+          this._observableRegistry.set(this.error, Option.some(new AiServiceOverloadedError("AI service overloaded", {
             cause: err
-          });
+          })));
         } else {
-          this.error.value = new Error("AI service error", {
+          this._observableRegistry.set(this.error, Option.some(new Error("AI service error", {
             cause: err
-          });
+          })));
         }
       }
-      return this._reset();
     } catch (e) {
       env.error = e;
       env.hasError = true;
@@ -311,194 +380,277 @@ var ChatProcessor = class {
   }
   /**
   * Cancel pending requests.
-  * @returns Pending requests (incl. the request message).
   */
   async cancel() {
     log.info("cancelling...", void 0, {
       F: __dxlog_file,
-      L: 236,
+      L: 229,
       S: this,
       C: (f, a) => f(...a)
     });
-    this._session?.abort();
-    return this._reset();
-  }
-  async _reset() {
-    const messages = this._pending.value;
-    batch(() => {
-      this._pending.value = [];
-      this._block.value = void 0;
-    });
-    return messages;
   }
+  _artifactDiffResolver;
 };
-var AiServiceOverloadedError = class extends Error {
-  constructor() {
-    super(...arguments);
-    this.code = "AI_SERVICE_OVERLOADED";
+
+// src/hooks/presets.ts
+import { Schema } from "effect";
+var ModelProviders = [
+  "dxos-local",
+  "dxos-remote",
+  "lm-studio"
+];
+var ModelProvider = Schema.Literal(...ModelProviders);
+var createModelLabel = (model) => {
+  const parts = model.split("/");
+  return parts[parts.length - 1];
+};
+var AiServicePresets = [
+  {
+    provider: "dxos-remote",
+    model: "@anthropic/claude-opus-4-0"
+  },
+  {
+    provider: "dxos-remote",
+    model: "@anthropic/claude-3-5-haiku-20241022"
+  },
+  {
+    provider: "lm-studio",
+    model: "@google/gemma-3-12b"
+  },
+  {
+    provider: "lm-studio",
+    model: "@mlx-community/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/hooks/useChatServices.ts
+import { AiToolkit } from "@effect/ai";
+import { Layer } from "effect";
+import { useMemo as useMemo2 } from "react";
+import { Capabilities as Capabilities2, useCapabilities as useCapabilities2 } from "@dxos/app-framework";
+import { makeToolExecutionServiceFromFunctions, makeToolResolverFromFunctions } from "@dxos/assistant";
+import { ComputeEventLogger, CredentialsService, DatabaseService, LocalFunctionExecutionService, QueueService, RemoteFunctionExecutionService, TracingService } from "@dxos/functions";
+
+// src/capabilities/index.ts
+import { lazy } from "@dxos/app-framework";
+var AiService2 = lazy(() => import("./ai-service-7KJ5LXBT.mjs"));
+var AppGraphBuilder = lazy(() => import("./app-graph-builder-AVHHQ3KV.mjs"));
+var BlueprintDefinition = lazy(() => import("./blueprint-definition-CMGIZAOW.mjs"));
+var EdgeModelResolver = lazy(() => import("./edge-model-resolver-2HB4PCWH.mjs"));
+var IntentResolver = lazy(() => import("./intent-resolver-MVOIEJXZ.mjs"));
+var ReactSurface = lazy(() => import("./react-surface-4HXS3YLT.mjs"));
+var Settings = lazy(() => import("./settings-G2EZXMWT.mjs"));
+var Toolkit = lazy(() => import("./toolkit-IW4FBLLB.mjs"));
+
+// src/hooks/useChatServices.ts
+var useChatServices = ({ space }) => {
+  const serviceLayer = useCapabilities2(AssistantCapabilities.AiServiceLayer).at(0) ?? Layer.die("AiService not found");
+  const functions = useCapabilities2(Capabilities2.Functions);
+  const toolkits = useCapabilities2(Capabilities2.Toolkit);
+  const handlers = useCapabilities2(Capabilities2.ToolkitHandler);
+  return useMemo2(() => {
+    const allFunctions = functions.flat();
+    const toolkit = AiToolkit.merge(...toolkits);
+    const handlersLayer = Layer.mergeAll(Layer.empty, ...handlers);
+    return Layer.mergeAll(serviceLayer, makeToolResolverFromFunctions(allFunctions, toolkit), makeToolExecutionServiceFromFunctions(allFunctions, toolkit, handlersLayer), CredentialsService.layerFromDatabase(), ComputeEventLogger.layerFromTracing).pipe(Layer.provideMerge(Layer.mergeAll(space ? DatabaseService.layer(space.db) : DatabaseService.notAvailable, space ? QueueService.layer(space.queues) : QueueService.notAvailable, TracingService.layerNoop, LocalFunctionExecutionService.layer, RemoteFunctionExecutionService.mockLayer)));
+  }, [
+    space,
+    functions,
+    toolkits,
+    handlers
+  ]);
 };
 
-// src/hooks/useBlueprints.ts
-import { useSignals as _useSignals } from "@preact-signals/safe-react/tracking";
-import { useCallback, useState } from "react";
-import { Ref } from "@dxos/echo";
-import { log as log2 } from "@dxos/log";
-import { useTimeout } from "@dxos/react-ui";
-import { isNonNullable } from "@dxos/util";
-var __dxlog_file2 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/hooks/useBlueprints.ts";
-var useBlueprints = (context) => {
-  var _effect = _useSignals();
-  try {
-    const [blueprints, setBlueprints] = useState([]);
-    useTimeout(async () => {
-      const blueprints2 = (await Ref.Array.loadAll(context.blueprints.value ?? [])).filter(isNonNullable);
-      setBlueprints(blueprints2);
-    }, 0, [
-      context
-    ]);
-    const handleUpdate = useCallback((key, active) => {
-      log2.info("update", {
-        key,
-        active
-      }, {
-        F: __dxlog_file2,
-        L: 27,
-        S: void 0,
-        C: (f, a) => f(...a)
-      });
-    }, []);
-    return [
-      blueprints,
-      handleUpdate
-    ];
-  } finally {
-    _effect.f();
-  }
+// src/hooks/useOnline.ts
+import { useState as useState2 } from "react";
+var useOnline = () => {
+  const [online, setOnline] = useState2(true);
+  return [
+    online,
+    setOnline
+  ];
 };
 
-// src/hooks/useContextProvider.ts
-import { useMemo } from "react";
-import { Capabilities, useCapabilities } from "@dxos/app-framework";
-import { Filter as Filter2, Obj } from "@dxos/echo";
-var useContextProvider = (space) => {
-  const artifactDefinitions = useCapabilities(Capabilities.ArtifactDefinition);
-  return useMemo(() => {
+// src/hooks/usePresets.ts
+import { useCallback as useCallback2, useEffect, useMemo as useMemo3, useState as useState3 } from "react";
+var usePresets = (online) => {
+  const [preset, setPreset] = useState3();
+  const presets = useMemo3(() => AiServicePresets.filter((preset2) => online === (preset2.provider === "dxos-remote")), [
+    online
+  ]);
+  const presetOptions = useMemo3(() => presets.map(({ id, model, label }) => ({
+    id,
+    label: label ?? model
+  })), [
+    presets
+  ]);
+  useEffect(() => {
+    setPreset(presets[0]);
+  }, [
+    presets
+  ]);
+  const handleChangePreset = useCallback2((id) => {
+    const preset2 = presets.find((preset3) => preset3.id === id);
+    if (preset2) {
+      setPreset(preset2);
+    }
+  }, [
+    presets
+  ]);
+  return {
+    preset,
+    presets: presetOptions,
+    onChangePreset: handleChangePreset
+  };
+};
+
+// src/hooks/useReferencesProvider.ts
+import { useMemo as useMemo4 } from "react";
+import { Capabilities as Capabilities3, useCapabilities as useCapabilities3 } from "@dxos/app-framework";
+import { Filter as Filter3, Obj as Obj3 } from "@dxos/echo";
+var useReferencesProvider = (space) => {
+  const blueprints = useCapabilities3(Capabilities3.BlueprintDefinition);
+  return useMemo4(() => {
     if (!space) {
       return void 0;
     }
     return {
-      query: async ({ query }) => {
-        const artifactSchemas = artifactDefinitions.map((artifact) => artifact.schema);
-        const { objects } = await space.db.query(Filter2.or(...artifactSchemas.map((schema) => Filter2.type(schema)))).run();
-        return objects.filter((object) => stringMatch(query, Obj.getLabel(object) ?? "")).filter((object) => !!Obj.getDXN(object)).map((object) => ({
-          uri: Obj.getDXN(object).toString(),
-          label: Obj.getLabel(object) ?? ""
+      getReferences: async ({ query }) => {
+        const { objects } = await space.db.query(Filter3.everything()).run();
+        return objects.filter((object) => stringMatch(query, Obj3.getLabel(object) ?? "")).filter((object) => !!Obj3.getDXN(object)).map((object) => ({
+          uri: Obj3.getDXN(object).toString(),
+          label: Obj3.getLabel(object) ?? ""
         }));
       },
-      resolveMetadata: async ({ uri }) => {
-        const object = await space.db.query(Filter2.ids(uri)).first();
+      resolveReference: async ({ uri }) => {
+        const object = await space.db.query(Filter3.ids(uri)).first();
         return {
           uri,
-          label: Obj.getLabel(object) ?? ""
+          label: Obj3.getLabel(object) ?? ""
         };
       }
     };
   }, [
     space,
-    artifactDefinitions
+    blueprints
   ]);
 };
 var stringMatch = (query, label) => label.toLowerCase().startsWith(query.toLowerCase());
 
-// src/hooks/useServiceContainer.ts
-import { useSignals as _useSignals2 } from "@preact-signals/safe-react/tracking";
-import { useEffect, useMemo as useMemo2, useState as useState2 } from "react";
-import { ToolRegistry } from "@dxos/ai";
-import { Capabilities as Capabilities2, useCapabilities as useCapabilities2, useCapability } from "@dxos/app-framework";
-import { AiService, DatabaseService, QueueService, ServiceContainer, ToolResolverService } from "@dxos/functions";
-var useServiceContainer = ({ space }) => {
-  var _effect = _useSignals2();
-  try {
-    const aiClient = useCapability(AssistantCapabilities.AiClient);
-    const tools = useCapabilities2(Capabilities2.Tools).flat();
-    const [toolRegistry] = useState2(() => new ToolRegistry([]));
-    useEffect(() => {
-      for (const tool of tools) {
-        if (!toolRegistry.has(tool)) {
-          toolRegistry.register(tool);
-        }
-      }
-    }, [
-      toolRegistry,
-      JSON.stringify(tools.map((tool) => tool.id))
-    ]);
-    return useMemo2(() => new ServiceContainer().setServices({
-      ai: AiService.make(aiClient.value),
-      database: space ? DatabaseService.make(space.db) : void 0,
-      queues: space ? QueueService.make(space.queues, void 0) : void 0,
-      // eventLogger: consoleLogger,
-      toolResolver: ToolResolverService.make(toolRegistry)
-    }), [
-      space,
-      aiClient
-    ]);
-  } finally {
-    _effect.f();
-  }
+// src/hooks/useResolveRef.ts
+import { useMemo as useMemo5, useSyncExternalStore } from "react";
+var useResolvedRef = (space, ref) => {
+  const { subscribe, getSnapshot } = useMemo5(() => {
+    const resolver = space.db.graph.createRefResolver({});
+    let currentCallback = void 0;
+    return {
+      subscribe: (cb) => {
+        currentCallback = cb;
+        return () => {
+          if (currentCallback === cb) {
+            currentCallback = void 0;
+          }
+        };
+      },
+      getSnapshot: () => resolver?.resolveSync(ref.dxn, true, () => {
+        currentCallback?.();
+      })
+    };
+  }, [
+    space,
+    ref.dxn.toString()
+  ]);
+  return useSyncExternalStore(subscribe, getSnapshot);
 };
 
-// src/hooks/useTextInputEvents.ts
-import { useSignals as _useSignals3 } from "@preact-signals/safe-react/tracking";
-import { useState as useState3, useCallback as useCallback2 } from "react";
+// src/hooks/useChatProcessor.ts
+var __dxlog_file2 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/hooks/useChatProcessor.ts";
+var useChatProcessor = ({ space, chat, preset, services, blueprintRegistry, settings }) => {
+  const observableRegistry = useContext(RegistryContext);
+  const { dispatchPromise: dispatch } = useIntentDispatcher();
+  const chatId = useMemo6(() => chat ? fullyQualifiedId(chat) : void 0, [
+    chat
+  ]);
+  const extensions = useMemo6(() => ({
+    space,
+    dispatch,
+    pivotId: chatId
+  }), [
+    dispatch,
+    space,
+    chatId
+  ]);
+  const conversation = useMemo6(() => {
+    if (!chat?.queue.target) {
+      return;
+    }
+    return new AiConversation({
+      queue: chat.queue.target
+    });
+  }, [
+    chat?.queue.target
+  ]);
+  const processor = useMemo6(() => {
+    if (!services || !conversation) {
+      return void 0;
+    }
+    log2("creating processor", {
+      preset,
+      model: preset?.model,
+      settings
+    }, {
+      F: __dxlog_file2,
+      L: 60,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+    return new AiChatProcessor(services, conversation, {
+      extensions,
+      blueprintRegistry,
+      observableRegistry,
+      model: preset?.model
+    });
+  }, [
+    services,
+    conversation,
+    blueprintRegistry,
+    extensions,
+    preset
+  ]);
+  return processor;
+};
+var Stable = Object.freeze({
+  array: [],
+  object: {}
+});
+
+// src/components/Toolbox/Toolbox.tsx
+import { useSignals as _useSignals2 } from "@preact-signals/safe-react/tracking";
+import React, { Fragment, useEffect as useEffect2, useState as useState4 } from "react";
+import { FunctionType } from "@dxos/functions";
+import { log as log5 } from "@dxos/log";
+import { Filter as Filter4, useQuery } from "@dxos/react-client/echo";
+import { useTranslation } from "@dxos/react-ui";
+import { mx } from "@dxos/react-ui-theme";
 
 // src/tools/function.ts
-import { createTool, ToolResult } from "@dxos/ai";
+import { ToolResult, createTool } from "@dxos/ai";
 import { Type } from "@dxos/echo";
 import { getInvocationUrl, getUserFunctionUrlInMetadata } from "@dxos/functions";
 import { log as log3 } from "@dxos/log";
 import { getMeta } from "@dxos/react-client/echo";
-var __dxlog_file3 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/tools/function.ts";
-var convertFunctionToTool = (fn, edgeUrl, spaceId) => {
-  if (!fn.description || !fn.inputSchema) {
-    return void 0;
-  }
-  const existingFunctionUrl = getUserFunctionUrlInMetadata(getMeta(fn));
-  if (!existingFunctionUrl) {
-    return void 0;
-  }
-  const url = getInvocationUrl(existingFunctionUrl, edgeUrl, {
-    spaceId
-  });
-  return createTool("user-function", {
-    name: fn.name,
-    description: fn.description,
-    schema: Type.toEffectSchema(fn.inputSchema),
-    execute: async (input) => {
-      log3.info("execute function tool", {
-        name: fn.name,
-        url,
-        input
-      }, {
-        F: __dxlog_file3,
-        L: 34,
-        S: void 0,
-        C: (f, a) => f(...a)
-      });
-      const response = await fetch(url, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(input)
-      });
-      return ToolResult.Success(await response.text());
-    }
-  });
-};
 
 // src/tools/openapi.ts
-import { Schema } from "effect";
+import { Schema as Schema2 } from "effect";
 import jsonpointer from "jsonpointer";
 import { ToolResult as ToolResult2, createRawTool } from "@dxos/ai";
 import { Type as Type2 } from "@dxos/echo";
@@ -506,11 +658,11 @@ import { normalizeSchema } from "@dxos/echo-schema";
 import { invariant } from "@dxos/invariant";
 import { log as log4 } from "@dxos/log";
 import { deepMapValues } from "@dxos/util";
-var __dxlog_file4 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/tools/openapi.ts";
+var __dxlog_file3 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/tools/openapi.ts";
 var createToolsFromService = async (service) => {
   invariant(service.interfaces?.length === 1 && service.interfaces[0].kind === "api", void 0, {
-    F: __dxlog_file4,
-    L: 24,
+    F: __dxlog_file3,
+    L: 27,
     S: void 0,
     A: [
       "service.interfaces?.length === 1 && service.interfaces[0].kind === 'api'",
@@ -519,8 +671,8 @@ var createToolsFromService = async (service) => {
   });
   const iface = service.interfaces[0];
   invariant(iface.schemaUrl, void 0, {
-    F: __dxlog_file4,
-    L: 26,
+    F: __dxlog_file3,
+    L: 29,
     S: void 0,
     A: [
       "iface.schemaUrl",
@@ -528,8 +680,8 @@ var createToolsFromService = async (service) => {
     ]
   });
   invariant(iface.schemaUrl, void 0, {
-    F: __dxlog_file4,
-    L: 27,
+    F: __dxlog_file3,
+    L: 30,
     S: void 0,
     A: [
       "iface.schemaUrl",
@@ -546,8 +698,8 @@ var createToolsFromApi = async (url, options) => {
   log4("spec", {
     spec
   }, {
-    F: __dxlog_file4,
-    L: 37,
+    F: __dxlog_file3,
+    L: 40,
     S: void 0,
     C: (f, a) => f(...a)
   });
@@ -564,8 +716,8 @@ var createToolsFromApi = async (url, options) => {
         method,
         methodItem
       }, {
-        F: __dxlog_file4,
-        L: 48,
+        F: __dxlog_file3,
+        L: 51,
         S: void 0,
         C: (f, a) => f(...a)
       });
@@ -582,8 +734,8 @@ var createToolsFromApi = async (url, options) => {
         log4("parameter", {
           parameter
         }, {
-          F: __dxlog_file4,
-          L: 63,
+          F: __dxlog_file3,
+          L: 66,
           S: void 0,
           C: (f, a) => f(...a)
         });
@@ -605,20 +757,20 @@ var createToolsFromApi = async (url, options) => {
       log4("inputSchema", {
         inputSchema
       }, {
-        F: __dxlog_file4,
-        L: 88,
+        F: __dxlog_file3,
+        L: 91,
         S: void 0,
         C: (f, a) => f(...a)
       });
-      Schema.validateSync(Type2.JsonSchema)(inputSchema);
+      Schema2.validateSync(Type2.JsonSchema)(inputSchema);
       const description = methodItem.description ?? methodItem.summary;
       if (!description) {
         log4.warn("no description", {
           path,
           method
         }, {
-          F: __dxlog_file4,
-          L: 93,
+          F: __dxlog_file3,
+          L: 96,
           S: void 0,
           C: (f, a) => f(...a)
         });
@@ -696,8 +848,8 @@ var callApiEndpoint = async (endpoint, input) => {
     name: endpoint.path,
     input
   }, {
-    F: __dxlog_file4,
-    L: 180,
+    F: __dxlog_file3,
+    L: 183,
     S: void 0,
     C: (f, a) => f(...a)
   });
@@ -726,7 +878,7 @@ var callApiEndpoint = async (endpoint, input) => {
       case "body": {
         const value = input[parameter.name];
         const effectSchema = Type2.toEffectSchema(parameter.schema);
-        Schema.validateSync(effectSchema)(value);
+        Schema2.validateSync(effectSchema)(value);
         if (body) {
           throw new Error(`Duplicate body parameter: ${parameter.name}`);
         }
@@ -755,8 +907,8 @@ var callApiEndpoint = async (endpoint, input) => {
     url,
     request
   }, {
-    F: __dxlog_file4,
-    L: 243,
+    F: __dxlog_file3,
+    L: 246,
     S: void 0,
     C: (f, a) => f(...a)
   });
@@ -766,8 +918,8 @@ var callApiEndpoint = async (endpoint, input) => {
     status: response.status,
     statusText: response.statusText
   }, {
-    F: __dxlog_file4,
-    L: 246,
+    F: __dxlog_file3,
+    L: 249,
     S: void 0,
     C: (f, a) => f(...a)
   });
@@ -790,8 +942,8 @@ var callApiEndpoint = async (endpoint, input) => {
       log4.error("error", {
         error
       }, {
-        F: __dxlog_file4,
-        L: 264,
+        F: __dxlog_file3,
+        L: 267,
         S: void 0,
         C: (f, a) => f(...a)
       });
@@ -801,8 +953,8 @@ var callApiEndpoint = async (endpoint, input) => {
       log4.error("error", {
         error
       }, {
-        F: __dxlog_file4,
-        L: 268,
+        F: __dxlog_file3,
+        L: 271,
         S: void 0,
         C: (f, a) => f(...a)
       });
@@ -816,8 +968,8 @@ var getEndpointUrl = (endpoint) => {
     url = endpoint.document.servers[0].url;
   } else {
     invariant(!isV3_1(endpoint.document), void 0, {
-      F: __dxlog_file4,
-      L: 279,
+      F: __dxlog_file3,
+      L: 282,
       S: void 0,
       A: [
         "!isV3_1(endpoint.document)",
@@ -836,8 +988,8 @@ var resolveAuthorization = async (authorization) => {
   switch (authorization.type) {
     case "api-key": {
       invariant(authorization.placement.type === "authorization-header", void 0, {
-        F: __dxlog_file4,
-        L: 295,
+        F: __dxlog_file3,
+        L: 298,
         S: void 0,
         A: [
           "authorization.placement.type === 'authorization-header'",
@@ -861,166 +1013,38 @@ var resolveAuthorization = async (authorization) => {
       throw new Error(`Unknown authorization type: ${authorization.type}`);
     }
   }
-};
-var resolveJsonSchema = (schema, base) => {
-  return deepMapValues(schema, (value, recurse) => {
-    if (typeof value === "object" && value !== null && "$ref" in value && typeof value.$ref === "string") {
-      if (value.$ref.startsWith("#")) {
-        const resolved = jsonpointer.get(base, value.$ref.slice(1));
-        if (resolved) {
-          return recurse(resolved);
-        } else {
-          log4.warn("unresolved", {
-            ref: value.$ref,
-            base
-          }, {
-            F: __dxlog_file4,
-            L: 328,
-            S: void 0,
-            C: (f, a) => f(...a)
-          });
-        }
-      }
-    }
-    return recurse(value);
-  });
-};
-var isV3_1 = (document) => {
-  return document.openapi === "3.0.1";
-};
-
-// src/hooks/useChatProcessor.tsx
-var __dxlog_file5 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/hooks/useChatProcessor.tsx";
-var useChatProcessor = ({ part = "deck", space, chat, serviceContainer, blueprintRegistry, settings, instructions, artifact, noPluginArtifacts }) => {
-  const { dispatchPromise: dispatch } = useIntentDispatcher();
-  const globalTools = useCapabilities3(Capabilities3.Tools);
-  let artifacts = useCapabilities3(Capabilities3.ArtifactDefinition);
-  if (noPluginArtifacts) {
-    artifacts = Stable.array;
-  }
-  const services = useQuery(space, Filter3.type(ServiceType));
-  const [serviceTools, setServiceTools] = useState4([]);
-  useEffect2(() => {
-    log5("creating service tools...", void 0, {
-      F: __dxlog_file5,
-      L: 65,
-      S: void 0,
-      C: (f, a) => f(...a)
-    });
-    queueMicrotask(async () => {
-      const tools2 = await Promise.all(services.map((service) => createToolsFromService(service)));
-      setServiceTools(tools2.flat());
-    });
-  }, [
-    services
-  ]);
-  const config = useConfig();
-  const functions = useQuery(space, Filter3.type(FunctionType));
-  const chatId = useMemo3(() => chat ? fullyQualifiedId(chat) : void 0, [
-    chat
-  ]);
-  const [tools, extensions] = useMemo3(() => {
-    log5("creating tools...", void 0, {
-      F: __dxlog_file5,
-      L: 77,
-      S: void 0,
-      C: (f, a) => f(...a)
-    });
-    const tools2 = [
-      ...globalTools.flat(),
-      ...serviceTools,
-      ...functions.map((fn) => convertFunctionToTool(fn, config.values.runtime?.services?.edge?.url ?? "", space?.id)).filter(isNonNullable2)
-    ];
-    const extensions2 = {
-      part,
-      space,
-      dispatch,
-      pivotId: chatId
-    };
-    return [
-      tools2,
-      extensions2
-    ];
-  }, [
-    dispatch,
-    globalTools,
-    space,
-    chatId,
-    serviceTools,
-    functions
-  ]);
-  const systemPrompt = useMemo3(() => createSystemPrompt({
-    artifacts: artifacts.map((definition) => `${definition.name}
-${definition.instructions}`),
-    artifact,
-    instructions
-  }), [
-    artifacts,
-    artifact,
-    instructions
-  ]);
-  const model = settings?.llmProvider === "ollama" ? settings?.ollamaModel ?? DEFAULT_OLLAMA_MODEL : settings?.edgeModel ?? DEFAULT_EDGE_MODEL2;
-  const conversation = useMemo3(() => {
-    if (!chat?.queue.target) {
-      return;
-    }
-    return new Conversation({
-      serviceContainer,
-      queue: chat.queue.target
-    });
-  }, [
-    chat?.queue.target,
-    serviceContainer
-  ]);
-  const processor = useMemo3(() => {
-    if (!conversation) {
-      return void 0;
+};
+var resolveJsonSchema = (schema, base) => {
+  return deepMapValues(schema, (value, recurse) => {
+    if (typeof value === "object" && value !== null && "$ref" in value && typeof value.$ref === "string") {
+      if (value.$ref.startsWith("#")) {
+        const resolved = jsonpointer.get(base, value.$ref.slice(1));
+        if (resolved) {
+          return recurse(resolved);
+        } else {
+          log4.warn("unresolved", {
+            ref: value.$ref,
+            base
+          }, {
+            F: __dxlog_file3,
+            L: 331,
+            S: void 0,
+            C: (f, a) => f(...a)
+          });
+        }
+      }
     }
-    log5("creating processor...", {
-      settings
-    }, {
-      F: __dxlog_file5,
-      L: 124,
-      S: void 0,
-      C: (f, a) => f(...a)
-    });
-    return new ChatProcessor(conversation, {
-      tools,
-      extensions,
-      blueprintRegistry,
-      artifacts,
-      systemPrompt,
-      model
-    });
-  }, [
-    conversation,
-    tools,
-    blueprintRegistry,
-    artifacts,
-    extensions,
-    systemPrompt,
-    model
-  ]);
-  return processor;
+    return recurse(value);
+  });
+};
+var isV3_1 = (document) => {
+  return document.openapi === "3.0.1";
 };
-var Stable = Object.freeze({
-  array: [],
-  object: {}
-});
 
 // src/components/Toolbox/Toolbox.tsx
-import { useSignals as _useSignals4 } from "@preact-signals/safe-react/tracking";
-import React, { useState as useState5, useEffect as useEffect3, Fragment } from "react";
-import { parseToolName } from "@dxos/ai";
-import { Capabilities as Capabilities4, useCapabilities as useCapabilities4 } from "@dxos/app-framework";
-import { FunctionType as FunctionType2 } from "@dxos/functions";
-import { log as log6 } from "@dxos/log";
-import { Filter as Filter4, useQuery as useQuery2 } from "@dxos/react-client/echo";
-import { useTranslation } from "@dxos/react-ui";
-import { mx } from "@dxos/react-ui-theme";
-var __dxlog_file6 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/components/Toolbox/Toolbox.tsx";
-var Toolbox = ({ classNames, artifacts, functions, services, blueprints, activeBlueprints, striped }) => {
-  var _effect = _useSignals4();
+var __dxlog_file4 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/components/Toolbox/Toolbox.tsx";
+var Toolbox = ({ classNames, functions, services, blueprints, activeBlueprints }) => {
+  var _effect = _useSignals2();
   try {
     const { t } = useTranslation(meta.id);
     return /* @__PURE__ */ React.createElement("div", {
@@ -1031,7 +1055,7 @@ var Toolbox = ({ classNames, artifacts, functions, services, blueprints, activeB
         name: target?.name ?? "",
         description: target?.description ?? "",
         subitems: target?.tools.map((toolId) => ({
-          name: `\u2219 ${parseToolName(toolId)}`
+          name: `\u2219 ${safeToolId(toolId)}`
         }))
       }))
     }), activeBlueprints && activeBlueprints.length > 0 && /* @__PURE__ */ React.createElement(Section, {
@@ -1040,17 +1064,7 @@ var Toolbox = ({ classNames, artifacts, functions, services, blueprints, activeB
         name: target?.name ?? "",
         description: target?.description ?? "",
         subitems: target?.tools.map((toolId) => ({
-          name: `\u2219 ${parseToolName(toolId)}`
-        }))
-      }))
-    }), artifacts && artifacts.length > 0 && /* @__PURE__ */ React.createElement(Section, {
-      title: "Artifacts",
-      items: artifacts.map(({ name, description, tools }) => ({
-        name,
-        description,
-        subitems: tools.map(({ name: name2, description: description2 }) => ({
-          name: `\u2219 ${parseToolName(name2)}`,
-          description: description2
+          name: `\u2219 ${safeToolId(toolId)}`
         }))
       }))
     }), services && services.length > 0 && /* @__PURE__ */ React.createElement(Section, {
@@ -1069,13 +1083,13 @@ var Toolbox = ({ classNames, artifacts, functions, services, blueprints, activeB
         name,
         description
       }))
-    }), !blueprints?.length && !activeBlueprints?.length && !artifacts?.length && !services?.length && !functions?.length && /* @__PURE__ */ React.createElement("div", null, t("no tools")));
+    }), !blueprints?.length && !activeBlueprints?.length && !services?.length && !functions?.length && /* @__PURE__ */ React.createElement("div", null, t("no tools")));
   } finally {
     _effect.f();
   }
 };
 var Section = ({ title, items, striped }) => {
-  var _effect = _useSignals4();
+  var _effect = _useSignals2();
   try {
     const stripeClassNames = "odd:bg-neutral-50 dark:odd:bg-neutral-800";
     const gridClassNames = "grid grid-cols-[8rem_1fr]";
@@ -1105,17 +1119,16 @@ var Section = ({ title, items, striped }) => {
   }
 };
 var ToolboxContainer = ({ classNames, space, processor }) => {
-  var _effect = _useSignals4();
+  var _effect = _useSignals2();
   try {
-    const artifactDefinitions = useCapabilities4(Capabilities4.ArtifactDefinition);
-    const services = useQuery2(space, Filter4.type(ServiceType));
-    const [serviceTools, setServiceTools] = useState5([]);
-    useEffect3(() => {
-      log6("creating service tools...", {
+    const services = useQuery(space, Filter4.type(ServiceType));
+    const [serviceTools, setServiceTools] = useState4([]);
+    useEffect2(() => {
+      log5("creating service tools...", {
         services: services.length
       }, {
-        F: __dxlog_file6,
-        L: 147,
+        F: __dxlog_file4,
+        L: 123,
         S: void 0,
         C: (f, a) => f(...a)
       });
@@ -1129,11 +1142,10 @@ var ToolboxContainer = ({ classNames, space, processor }) => {
     }, [
       services
     ]);
-    const functions = useQuery2(space, Filter4.type(FunctionType2));
+    const functions = useQuery(space, Filter4.type(FunctionType));
     return /* @__PURE__ */ React.createElement(Toolbox, {
       classNames,
       blueprints: processor?.context.blueprints.value,
-      artifacts: artifactDefinitions,
       services: serviceTools,
       functions
     });
@@ -1141,47 +1153,42 @@ var ToolboxContainer = ({ classNames, space, processor }) => {
     _effect.f();
   }
 };
+var safeToolId = (name) => {
+  return name.split("_").pop();
+};
 
 // 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 { Result as Result2, useRxValue } from "@effect-rx/rx-react";
 import { createContext } from "@radix-ui/react-context";
-import { dedupeWith } from "effect/Array";
-import React9, { useCallback as useCallback4, useEffect as useEffect5, useMemo as useMemo7, useRef as useRef2, useState as useState7 } from "react";
-import { Message } from "@dxos/ai";
-import { CollaborationActions, createIntent, useIntentDispatcher as useIntentDispatcher2 } from "@dxos/app-framework";
+import { Array, Option as Option2 } from "effect";
+import React11, { useCallback as useCallback4, useEffect as useEffect5, useMemo as useMemo10, useRef as useRef2, useState as useState7 } from "react";
 import { Event } from "@dxos/async";
-import { DXN, Obj as Obj3, Ref as Ref3 } from "@dxos/echo";
-import { log as log8 } from "@dxos/log";
+import { DXN as DXN2, Obj as Obj7, Ref as Ref4 } from "@dxos/echo";
+import { log as log6 } from "@dxos/log";
 import { useVoiceInput } from "@dxos/plugin-transcription";
 import { getSpace, useQueue } from "@dxos/react-client/echo";
 import { useIdentity } from "@dxos/react-client/halo";
-import { useTranslation as useTranslation5 } from "@dxos/react-ui";
+import { Input, useTranslation as useTranslation7 } from "@dxos/react-ui";
 import { ChatEditor, references } from "@dxos/react-ui-chat";
-import { mx as mx5 } from "@dxos/react-ui-theme";
+import { mx as mx7 } from "@dxos/react-ui-theme";
+import { DataType as DataType2 } from "@dxos/schema";
 import { isNotFalsy as isNotFalsy2 } from "@dxos/util";
 
 // src/components/ChatPrompt/ChatActions.tsx
-import { useSignals as _useSignals5 } from "@preact-signals/safe-react/tracking";
+import { useSignals as _useSignals3 } from "@preact-signals/safe-react/tracking";
 import React2 from "react";
-import { IconButton, Select, useTranslation as useTranslation2 } from "@dxos/react-ui";
+import { IconButton, useTranslation as useTranslation2 } from "@dxos/react-ui";
 import { mx as mx2 } from "@dxos/react-ui-theme";
-var ChatActions = ({ microphone, recording, processing, onEvent }) => {
-  var _effect = _useSignals5();
+var ChatActions = ({ classNames, children, microphone, recording, processing, onEvent }) => {
+  var _effect = _useSignals3();
   try {
     const { t } = useTranslation2(meta.id);
     return /* @__PURE__ */ React2.createElement("div", {
-      className: "flex items-center mie-1"
-    }, /* @__PURE__ */ React2.createElement(Select.Root, {
-      value: "ollama",
-      disabled: true
-    }, /* @__PURE__ */ React2.createElement(Select.TriggerButton, {
-      classNames: "mie-2 text-sm"
-    }), /* @__PURE__ */ React2.createElement(Select.Content, null, /* @__PURE__ */ React2.createElement(Select.Option, {
-      value: "ollama",
-      classNames: "text-sm"
-    }, "Ollama"))), processing && /* @__PURE__ */ React2.createElement(IconButton, {
+      className: mx2("flex items-center mie-1", classNames)
+    }, children, processing && /* @__PURE__ */ React2.createElement(IconButton, {
       disabled: !processing,
       classNames: "px-1.5",
       variant: "ghost",
@@ -1193,6 +1200,7 @@ var ChatActions = ({ microphone, recording, processing, onEvent }) => {
         type: "cancel"
       })
     }) || /* @__PURE__ */ React2.createElement(IconButton, {
+      disabled: true,
       classNames: "px-1.5",
       variant: "ghost",
       size: 5,
@@ -1229,23 +1237,22 @@ var ChatActions = ({ microphone, recording, processing, onEvent }) => {
   }
 };
 
-// src/components/ChatPrompt/ChatOptionsMenu.tsx
-import { useSignals as _useSignals6 } from "@preact-signals/safe-react/tracking";
-import React3, { useMemo as useMemo4 } from "react";
-import { DropdownMenu, IconButton as IconButton2, Input, useTranslation as useTranslation3 } from "@dxos/react-ui";
-var ChatOptionsMenu = ({ blueprintRegistry, blueprints, onChange }) => {
-  var _effect = _useSignals6();
+// src/components/ChatPrompt/ChatOptions.tsx
+import { useSignals as _useSignals4 } from "@preact-signals/safe-react/tracking";
+import React3, { useMemo as useMemo7 } from "react";
+import { DropdownMenu, Icon, IconButton as IconButton2, useTranslation as useTranslation3 } from "@dxos/react-ui";
+var ChatOptions = ({ context, blueprintRegistry, onUpdateBlueprint }) => {
+  var _effect = _useSignals4();
   try {
     const { t } = useTranslation3(meta.id);
-    const blueprintOptions = useMemo4(() => blueprintRegistry?.query().map((blueprint) => ({
-      key: blueprint.key,
-      label: blueprint.name
-    })), [
+    const blueprints = useMemo7(() => blueprintRegistry?.query() ?? [], [
       blueprintRegistry
     ]);
+    const activeBlueprints = useBlueprints({
+      context
+    });
     return /* @__PURE__ */ React3.createElement(DropdownMenu.Root, null, /* @__PURE__ */ React3.createElement(DropdownMenu.Trigger, {
-      asChild: true,
-      disabled: !blueprintOptions?.length
+      asChild: true
     }, /* @__PURE__ */ React3.createElement(IconButton2, {
       icon: "ph--plus--regular",
       variant: "ghost",
@@ -1254,50 +1261,78 @@ var ChatOptionsMenu = ({ blueprintRegistry, blueprints, onChange }) => {
       label: t("button add blueprint")
     })), /* @__PURE__ */ React3.createElement(DropdownMenu.Portal, null, /* @__PURE__ */ React3.createElement(DropdownMenu.Content, {
       side: "left"
-    }, /* @__PURE__ */ React3.createElement(DropdownMenu.Viewport, null, blueprintOptions?.map((option) => /* @__PURE__ */ React3.createElement(DropdownMenu.Item, {
-      key: option.key
-    }, /* @__PURE__ */ React3.createElement(Input.Root, null, /* @__PURE__ */ React3.createElement(Input.Checkbox, {
-      checked: !!blueprints?.find((blueprint) => blueprint.key === option.key),
-      onCheckedChange: (checked) => onChange?.(option.key, !!checked)
-    }), /* @__PURE__ */ React3.createElement(Input.Label, {
-      classNames: "m-0"
-    }, option.label))))), /* @__PURE__ */ React3.createElement(DropdownMenu.Arrow, null))));
+    }, /* @__PURE__ */ React3.createElement(DropdownMenu.Viewport, null, blueprints.map((blueprint) => /* @__PURE__ */ React3.createElement(DropdownMenu.CheckboxItem, {
+      key: blueprint.key,
+      checked: activeBlueprints?.get(blueprint.key) !== void 0,
+      onCheckedChange: (checked) => onUpdateBlueprint?.(blueprint.key, !!checked),
+      classNames: "gap-2"
+    }, /* @__PURE__ */ React3.createElement("div", {
+      className: "flex-1 min-is-0"
+    }, blueprint.name), /* @__PURE__ */ React3.createElement(DropdownMenu.ItemIndicator, {
+      asChild: true
+    }, /* @__PURE__ */ React3.createElement(Icon, {
+      icon: "ph--check--regular",
+      size: 4
+    }))))), /* @__PURE__ */ React3.createElement(DropdownMenu.Arrow, null))));
+  } finally {
+    _effect.f();
+  }
+};
+
+// src/components/ChatPrompt/ChatPresets.tsx
+import { useSignals as _useSignals5 } from "@preact-signals/safe-react/tracking";
+import React4 from "react";
+import { Select } from "@dxos/react-ui";
+var ChatPresets = ({ presets, preset, onChange }) => {
+  var _effect = _useSignals5();
+  try {
+    return /* @__PURE__ */ React4.createElement(Select.Root, {
+      value: preset,
+      onValueChange: onChange
+    }, /* @__PURE__ */ React4.createElement(Select.TriggerButton, {
+      classNames: "text-sm"
+    }), /* @__PURE__ */ React4.createElement(Select.Content, null, presets?.map(({ id, label }) => /* @__PURE__ */ React4.createElement(Select.Option, {
+      key: id,
+      value: id,
+      classNames: "text-sm"
+    }, label))));
   } finally {
     _effect.f();
   }
 };
 
 // src/components/ChatPrompt/ChatReferences.tsx
-import { useSignals as _useSignals7 } from "@preact-signals/safe-react/tracking";
-import React4, { useCallback as useCallback3 } from "react";
-import { Filter as Filter5, Obj as Obj2, Ref as Ref2 } from "@dxos/echo";
+import { useSignals as _useSignals6 } from "@preact-signals/safe-react/tracking";
+import React5, { useCallback as useCallback3 } from "react";
+import { Filter as Filter5, Obj as Obj4, Ref as Ref2 } from "@dxos/echo";
 import { useAsyncState, useTranslation as useTranslation4 } from "@dxos/react-ui";
 import { TagPicker } from "@dxos/react-ui-tag-picker";
-import { isNonNullable as isNonNullable3 } from "@dxos/util";
+import { mx as mx3 } from "@dxos/react-ui-theme";
+import { isNonNullable as isNonNullable2 } from "@dxos/util";
 var ChatReferences = ({ classNames, space, context, onUpdate }) => {
-  var _effect = _useSignals7();
+  var _effect = _useSignals6();
   try {
     const { t } = useTranslation4(meta.id);
     const [items] = useAsyncState(async () => {
       const objects = await Ref2.Array.loadAll(context.objects.value ?? []);
-      return objects.filter(isNonNullable3).map((obj) => ({
-        id: obj.id,
-        label: Obj2.getLabel(obj) ?? obj.id
+      return objects.filter(isNonNullable2).map((obj) => ({
+        id: Obj4.getDXN(obj).toString(),
+        label: Obj4.getLabel(obj) ?? Obj4.getTypename(obj) ?? obj.id
       }));
     }, [
       context
     ]);
-    const handleSearch = useCallback3((text, ids) => {
+    const handleSearch = useCallback3((text, dxns) => {
       const objects = space.db.query(Filter5.everything()).runSync();
       return objects.map(({ object }) => ({
-        id: object.id,
-        label: Obj2.getLabel(object) ?? ""
-      })).filter(({ id, label }) => !ids.includes(id) && label.toLocaleLowerCase().includes(text.toLocaleLowerCase()));
+        id: Obj4.getDXN(object).toString(),
+        label: Obj4.getLabel(object) ?? ""
+      })).filter(({ id, label }) => !dxns.includes(id) && label.toLocaleLowerCase().includes(text.toLocaleLowerCase()));
     }, [
       space
     ]);
-    return /* @__PURE__ */ React4.createElement(TagPicker, {
-      classNames,
+    return /* @__PURE__ */ React5.createElement(TagPicker, {
+      classNames: mx3("h-[1.75rem] text-sm", classNames),
       mode: "multi-select",
       placeholder: t("context objects placeholder"),
       items,
@@ -1310,26 +1345,37 @@ var ChatReferences = ({ classNames, space, context, onUpdate }) => {
 };
 
 // src/components/ChatPrompt/ChatStatusIndicator.tsx
-import { useSignals as _useSignals8 } from "@preact-signals/safe-react/tracking";
-import React5 from "react";
-import { Icon, Tooltip } from "@dxos/react-ui";
+import { useSignals as _useSignals7 } from "@preact-signals/safe-react/tracking";
+import React6, { useEffect as useEffect3, useState as useState5 } from "react";
+import { Icon as Icon2, Tooltip, useTimeout } from "@dxos/react-ui";
 import { Spinner } from "@dxos/react-ui-sfx";
 import { errorText } from "@dxos/react-ui-theme";
-var ChatStatusIndicator = ({ error, processing }) => {
-  var _effect = _useSignals8();
+var ChatStatusIndicator = ({ preset, error, processing }) => {
+  var _effect = _useSignals7();
   try {
+    const [init, setInit] = useState5(false);
+    useEffect3(() => {
+      setInit(false);
+    }, [
+      preset
+    ]);
+    useTimeout(async () => {
+      setInit(true);
+    }, 1500, [
+      preset
+    ]);
     if (error) {
-      return /* @__PURE__ */ React5.createElement(Tooltip.Trigger, {
+      return /* @__PURE__ */ React6.createElement(Tooltip.Trigger, {
         content: error.message,
         delayDuration: 0
-      }, /* @__PURE__ */ React5.createElement(Icon, {
+      }, /* @__PURE__ */ React6.createElement(Icon2, {
         icon: "ph--warning-circle--regular",
         classNames: errorText,
         size: 5
       }));
     }
-    return /* @__PURE__ */ React5.createElement(Spinner, {
-      active: processing
+    return /* @__PURE__ */ React6.createElement(Spinner, {
+      state: !init ? "flash" : processing ? "spin" : "pulse"
     });
   } finally {
     _effect.f();
@@ -1338,52 +1384,84 @@ var ChatStatusIndicator = ({ error, processing }) => {
 
 // src/components/ChatThread/ChatThread.tsx
 import { useSignals as _useSignals11 } from "@preact-signals/safe-react/tracking";
-import React8, { forwardRef, useMemo as useMemo6 } from "react";
+import React10, { forwardRef, useMemo as useMemo9 } from "react";
 import { PublicKey } from "@dxos/keys";
 import { ScrollContainer } from "@dxos/react-ui-components";
-import { mx as mx4 } from "@dxos/react-ui-theme";
+import { mx as mx6 } from "@dxos/react-ui-theme";
 import { keyToFallback } from "@dxos/util";
 
 // src/components/ChatThread/ChatMessage.tsx
 import { useSignals as _useSignals10 } from "@preact-signals/safe-react/tracking";
-import React7 from "react";
-import { Surface } from "@dxos/app-framework";
+import React9, { Fragment as Fragment2 } from "react";
+import { ErrorBoundary, Surface } from "@dxos/app-framework";
+import { Obj as Obj6 } from "@dxos/echo";
 import { invariant as invariant2 } from "@dxos/invariant";
-import { Button, Icon as Icon2, IconButton as IconButton3 } from "@dxos/react-ui";
+import { DXN, DXN_ECHO_REGEXP } from "@dxos/keys";
+import { Button, IconButton as IconButton3, useTranslation as useTranslation6 } from "@dxos/react-ui";
 import { MarkdownViewer, ToggleContainer as NativeToggleContainer } from "@dxos/react-ui-components";
-import { mx as mx3 } from "@dxos/react-ui-theme";
+import { mx as mx5 } from "@dxos/react-ui-theme";
 import { safeParseJson } from "@dxos/util";
 
+// src/components/ChatThread/Link.tsx
+import { useSignals as _useSignals8 } from "@preact-signals/safe-react/tracking";
+import React7 from "react";
+import { Obj as Obj5, Ref as Ref3 } from "@dxos/echo";
+import { mx as mx4 } from "@dxos/react-ui-theme";
+var ObjectLink = ({ space, dxn }) => {
+  var _effect = _useSignals8();
+  try {
+    const object = useResolvedRef(space, Ref3.fromDXN(dxn));
+    const title = Obj5.getLabel(object) ?? object?.id ?? dxn.toString();
+    return /* @__PURE__ */ React7.createElement("a", {
+      // href={dxn.toString()}
+      title,
+      className: mx4(
+        // TODO(burdon): Use style for tags.
+        "inline-flex items-center max-w-[16rem] px-1.5 overflow-hidden",
+        "border border-separator rounded whitespace-nowrap text-ellipsis text-primary-500 hover:text-primary-500 hover:border-primary-500 cursor-pointer"
+      ),
+      target: "_blank",
+      rel: "noopener noreferrer"
+    }, /* @__PURE__ */ React7.createElement("span", {
+      className: "truncate"
+    }, title));
+  } finally {
+    _effect.f();
+  }
+};
+
 // src/components/ChatThread/ToolBlock.tsx
 import { useSignals as _useSignals9 } from "@preact-signals/safe-react/tracking";
-import React6, { useEffect as useEffect4, useMemo as useMemo5, useRef, useState as useState6 } from "react";
-import { log as log7 } from "@dxos/log";
+import React8, { useEffect as useEffect4, useMemo as useMemo8, useRef, useState as useState6 } from "react";
+import { useTranslation as useTranslation5 } from "@dxos/react-ui";
 import { NumericTabs, StatusRoll, ToggleContainer } from "@dxos/react-ui-components";
 import { Json as NativeJson } from "@dxos/react-ui-syntax-highlighter";
-import { isNonNullable as isNonNullable4, isNotFalsy } from "@dxos/util";
-var __dxlog_file7 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/components/ChatThread/ToolBlock.tsx";
+import { isNonNullable as isNonNullable3, isNotFalsy } from "@dxos/util";
 var isToolMessage = (message) => {
-  return message.content.some((block) => block.type === "tool_use" || block.type === "tool_result");
+  return message.blocks.some((block) => block._tag === "toolCall" || block._tag === "toolResult");
 };
 var getToolName2 = (tool) => {
   return tool.namespace && tool.function ? `${tool.namespace}:${tool.function}` : tool.name.split("_").pop();
 };
-var getToolCaption = (tool, status) => {
-  if (!tool) {
-    return "Calling tool...";
-  }
-  return status?.message ?? tool.caption ?? `Calling ${getToolName2(tool)}...`;
-};
 var ToolBlock = ({ classNames, message, tools }) => {
   var _effect = _useSignals9();
   try {
-    const { content = [] } = message;
+    const { t } = useTranslation5(meta.id);
+    const { blocks = [] } = message;
+    const getToolCaption = (tool, status) => {
+      if (!tool) {
+        return t("calling tool label");
+      }
+      return status?.message ?? tool.caption ?? [
+        t("calling label") + getToolName2(tool)
+      ].join(" ");
+    };
     let request;
-    const blocks = content.filter((block) => block.type === "tool_use" || block.type === "tool_result");
-    const items = blocks.map((block) => {
-      switch (block.type) {
-        case "tool_use": {
-          if (block.pending && request?.block.id === block.id) {
+    const toolBlocks = blocks.filter((block) => block._tag === "toolCall" || block._tag === "toolResult");
+    const items = toolBlocks.map((block) => {
+      switch (block._tag) {
+        case "toolCall": {
+          if (block.pending && request?.block.toolCallId === block.toolCallId) {
             return null;
           }
           request = {
@@ -1391,40 +1469,32 @@ var ToolBlock = ({ classNames, message, tools }) => {
             block
           };
           return {
-            title: getToolCaption(request.tool, block.currentStatus),
+            title: getToolCaption(request.tool, request.block.status),
             block
           };
         }
-        case "tool_result": {
-          if (!request) {
-            log7.warn("unexpected message", {
-              block
-            }, {
-              F: __dxlog_file7,
-              L: 55,
-              S: void 0,
-              C: (f, a) => f(...a)
-            });
+        case "toolResult": {
+          if (!request || block.error) {
             return {
-              title: "Error",
+              title: t("error label"),
               block
             };
           }
           return {
-            title: `${getToolCaption(request.tool, void 0)} (Success)`,
+            title: getToolCaption(request.tool, request.block.status),
             block
           };
         }
         default: {
           request = void 0;
           return {
-            title: "Error",
+            title: t("error label"),
             block
           };
         }
       }
-    }).filter(isNonNullable4);
-    return /* @__PURE__ */ React6.createElement(ToolContainer, {
+    }).filter(isNonNullable3);
+    return /* @__PURE__ */ React8.createElement(ToolContainer, {
       classNames,
       items
     });
@@ -1452,9 +1522,9 @@ var ToolContainer = ({ classNames, items }) => {
         setSelected(index);
       }
     };
-    const title = useMemo5(() => {
+    const title = useMemo8(() => {
       const lines = items.map((item) => item.title).filter(isNotFalsy);
-      return /* @__PURE__ */ React6.createElement(StatusRoll, {
+      return /* @__PURE__ */ React8.createElement(StatusRoll, {
         key: "status-roll",
         lines,
         duration: 1e3,
@@ -1463,7 +1533,7 @@ var ToolContainer = ({ classNames, items }) => {
     }, [
       items
     ]);
-    return /* @__PURE__ */ React6.createElement(ToggleContainer, {
+    return /* @__PURE__ */ React8.createElement(ToggleContainer, {
       classNames: [
         "flex flex-col",
         classNames
@@ -1471,14 +1541,14 @@ var ToolContainer = ({ classNames, items }) => {
       title,
       open,
       onChangeOpen: setOpen
-    }, /* @__PURE__ */ React6.createElement("div", {
+    }, /* @__PURE__ */ React8.createElement("div", {
       className: "w-full grid grid-cols-[32px_1fr]"
-    }, /* @__PURE__ */ React6.createElement(NumericTabs, {
+    }, /* @__PURE__ */ React8.createElement(NumericTabs, {
       ref: tabsRef,
       length: items.length,
       selected,
       onSelect: handleSelect
-    }), /* @__PURE__ */ React6.createElement(Json, {
+    }), /* @__PURE__ */ React8.createElement(Json, {
       data: items[selected].block
     })));
   } finally {
@@ -1488,7 +1558,7 @@ var ToolContainer = ({ classNames, items }) => {
 var Json = ({ data }) => {
   var _effect = _useSignals9();
   try {
-    return /* @__PURE__ */ React6.createElement(NativeJson, {
+    return /* @__PURE__ */ React8.createElement(NativeJson, {
       data,
       classNames: "!p-1 text-xs bg-transparent"
     });
@@ -1498,37 +1568,65 @@ var Json = ({ data }) => {
 };
 
 // src/components/ChatThread/ChatMessage.tsx
-var __dxlog_file8 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/components/ChatThread/ChatMessage.tsx";
-var ChatMessage = ({ classNames, space, processor, message, tools, onPrompt, onAddToGraph }) => {
+var __dxlog_file5 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/components/ChatThread/ChatMessage.tsx";
+var panelClasses = "flex flex-col is-full bg-activeSurface rounded-sm";
+var marginClasses = "pie-4 pis-4";
+var paddingClasses = "pis-2 pie-2 pbs-0.5 pbe-0.5";
+var ChatMessage = ({ classNames, debug, space, message, tools, onEvent, onDelete }) => {
   var _effect = _useSignals10();
   try {
-    const { role, content = [] } = message;
+    const { t } = useTranslation6(meta.id);
+    const { sender: { role }, blocks } = message;
     if (isToolMessage(message)) {
-      return /* @__PURE__ */ React7.createElement(MessageContainer, {
-        classNames: mx3(classNames, "animate-[fadeIn_0.5s]")
-      }, /* @__PURE__ */ React7.createElement(ToolBlock, {
-        classNames: panelClassNames,
+      return /* @__PURE__ */ React9.createElement(MessageItem, {
+        classNames: mx5(classNames, "animate-[fadeIn_0.5s]")
+      }, /* @__PURE__ */ React9.createElement(ToolBlock, {
+        classNames: panelClasses,
         message,
         tools
       }));
     }
-    return content.map((block, idx) => {
-      if (block.type === "text" && block.text.replaceAll(/\s+/g, "").length === 0) {
+    return /* @__PURE__ */ React9.createElement(React9.Fragment, null, debug && /* @__PURE__ */ React9.createElement("div", {
+      className: mx5("flex justify-end text-subdued", marginClasses)
+    }, /* @__PURE__ */ React9.createElement("pre", {
+      className: "text-xs"
+    }, JSON.stringify({
+      created: message.created
+    }))), blocks.map((block, idx) => {
+      if (block._tag === "text" && block.text.replaceAll(/\s+/g, "").length === 0) {
+        return null;
+      }
+      const Component = components[block._tag] ?? components.default;
+      if (!Component) {
         return null;
       }
-      const Component = components[block.type] ?? components.default;
-      return /* @__PURE__ */ React7.createElement(MessageContainer, {
-        key: idx,
-        classNames: mx3(classNames, "animate-[fadeIn_0.5s]"),
-        user: block.type === "text" && role === "user"
-      }, /* @__PURE__ */ React7.createElement(Component, {
+      return /* @__PURE__ */ React9.createElement(Fragment2, {
+        key: idx
+      }, /* @__PURE__ */ React9.createElement(MessageItem, {
+        classNames,
+        user: block._tag === "text" && role === "user"
+      }, /* @__PURE__ */ React9.createElement(ErrorBoundary, {
+        data: block
+      }, /* @__PURE__ */ React9.createElement(Component, {
         space,
-        processor,
         block,
-        onPrompt,
-        onAddToGraph
-      }));
-    });
+        onEvent
+      }))), debug && /* @__PURE__ */ React9.createElement("div", {
+        className: mx5("flex justify-end text-subdued", marginClasses)
+      }, /* @__PURE__ */ React9.createElement("pre", {
+        className: "text-xs"
+      }, JSON.stringify({
+        block: block._tag
+      }))));
+    }), onDelete && /* @__PURE__ */ React9.createElement("div", {
+      className: mx5("flex justify-end pbs-2 pbe-2 opacity-50 hover:opacity-100", marginClasses)
+    }, /* @__PURE__ */ React9.createElement(IconButton3, {
+      classNames: "animate-[fadeIn_0.5s]",
+      icon: "ph--trash--regular",
+      iconOnly: true,
+      label: t("button delete message"),
+      onClick: () => onDelete()
+    })));
   } finally {
     _effect.f();
   }
@@ -1537,187 +1635,217 @@ var components = {
   //
   // Text
   //
-  ["text"]: ({ block }) => {
-    invariant2(block.type === "text", void 0, {
-      F: __dxlog_file8,
-      L: 90,
+  ["text"]: ({ space, block }) => {
+    invariant2(block._tag === "text", void 0, {
+      F: __dxlog_file5,
+      L: 125,
       S: void 0,
       A: [
-        "block.type === 'text'",
+        "block._tag === 'text'",
         ""
       ]
     });
-    const title = block.disposition ? titles[block.disposition] : void 0;
-    if (!title) {
-      return /* @__PURE__ */ React7.createElement(MarkdownViewer, {
-        classNames: "[&>p]:animate-[fadeIn_0.5s]",
-        content: block.text
-      });
-    }
-    return /* @__PURE__ */ React7.createElement(ToggleContainer2, {
-      // open={open}
-      defaultOpen: systemDispositions.includes(block.disposition ?? "") && block.pending,
-      title,
-      icon: block.pending ? /* @__PURE__ */ React7.createElement(Icon2, {
-        icon: "ph--circle-notch--regular",
-        classNames: "text-subdued ml-2 animate-spin",
-        size: 4
-      }) : void 0
-    }, /* @__PURE__ */ React7.createElement(MarkdownViewer, {
-      content: block.text,
-      classNames: [
-        "pbe-2",
-        systemDispositions.includes(block.disposition ?? "") && "text-sm text-subdued"
+    return /* @__PURE__ */ React9.createElement(MarkdownViewer, {
+      content: preprocessTextContent(block.text),
+      components: {
+        a: ({ node: { properties }, children, href, ...props }) => {
+          if (space && typeof properties?.href === "string" && properties?.href?.startsWith("dxn")) {
+            try {
+              const dxn = DXN.parse(properties.href);
+              return /* @__PURE__ */ React9.createElement(ObjectLink, {
+                space,
+                dxn
+              });
+            } catch {
+            }
+          }
+          return /* @__PURE__ */ React9.createElement("a", {
+            href,
+            className: "text-primary-500 hover:text-primary-500",
+            target: "_blank",
+            rel: "noopener noreferrer",
+            ...props
+          }, children);
+        }
+      }
+    });
+  },
+  //
+  // Suggest
+  //
+  ["suggest"]: ({ block, onEvent }) => {
+    const { t } = useTranslation6(meta.id);
+    invariant2(block._tag === "suggest", void 0, {
+      F: __dxlog_file5,
+      L: 162,
+      S: void 0,
+      A: [
+        "block._tag === 'suggest'",
+        ""
+      ]
+    });
+    return /* @__PURE__ */ React9.createElement(IconButton3, {
+      icon: "ph--lightning--regular",
+      label: block.text,
+      title: t("button suggest"),
+      onClick: () => onEvent?.({
+        type: "submit",
+        text: block.text
+      })
+    });
+  },
+  //
+  // Select
+  //
+  ["select"]: ({ block, onEvent }) => {
+    const { t } = useTranslation6(meta.id);
+    invariant2(block._tag === "select", void 0, {
+      F: __dxlog_file5,
+      L: 178,
+      S: void 0,
+      A: [
+        "block._tag === 'select'",
+        ""
+      ]
+    });
+    return /* @__PURE__ */ React9.createElement("div", {
+      className: "flex flex-wrap gap-1"
+    }, block.options.map((option, idx) => /* @__PURE__ */ React9.createElement(Button, {
+      classNames: "animate-[fadeIn_0.5s] rounded-sm text-sm",
+      key: idx,
+      onClick: () => onEvent?.({
+        type: "submit",
+        text: option
+      }),
+      title: t("button select option")
+    }, option)));
+  },
+  //
+  // Toolkit
+  //
+  ["toolkit"]: ({ block }) => {
+    invariant2(block._tag === "toolkit", void 0, {
+      F: __dxlog_file5,
+      L: 199,
+      S: void 0,
+      A: [
+        "block._tag === 'toolkit'",
+        ""
       ]
+    });
+    return /* @__PURE__ */ React9.createElement(ToggleContainer2, {
+      title: "Toolbox",
+      classNames: panelClasses,
+      defaultOpen: true
+    }, /* @__PURE__ */ React9.createElement(Toolbox, {
+      classNames: marginClasses
     }));
   },
   //
   // JSON
   //
-  ["json"]: ({ space, processor, block, onPrompt, onAddToGraph }) => {
-    invariant2(block.type === "json", void 0, {
-      F: __dxlog_file8,
-      L: 128,
+  ["json"]: ({ block, onEvent }) => {
+    invariant2(block._tag === "json", void 0, {
+      F: __dxlog_file5,
+      L: 211,
       S: void 0,
       A: [
-        "block.type === 'json'",
+        "block._tag === 'json'",
         ""
       ]
     });
     switch (block.disposition) {
-      case "tool_list": {
-        return /* @__PURE__ */ React7.createElement(ToggleContainer2, {
-          title: titles[block.disposition],
-          defaultOpen: true
-        }, /* @__PURE__ */ React7.createElement(ToolboxContainer, {
-          space,
-          processor,
-          classNames: "pbe-2"
-        }));
-      }
-      case "suggest": {
-        const { text = "" } = safeParseJson(block.json ?? "{}") ?? {};
-        return /* @__PURE__ */ React7.createElement(IconButton3, {
-          icon: "ph--lightning--regular",
-          label: text,
-          onClick: () => onPrompt?.(text)
-        });
-      }
-      case "select": {
-        const { options = [] } = safeParseJson(block.json ?? "{}") ?? {};
-        return /* @__PURE__ */ React7.createElement("div", {
-          className: "flex flex-wrap gap-1"
-        }, options.map((option, idx) => /* @__PURE__ */ React7.createElement(Button, {
-          classNames: "animate-[fadeIn_0.5s] rounded-sm text-sm",
-          key: option,
-          onClick: () => onPrompt?.(option)
-        }, option)));
-      }
       case "graph": {
-        return /* @__PURE__ */ React7.createElement("div", {
+        return /* @__PURE__ */ React9.createElement("div", {
           className: "flex flex-wrap gap-1"
-        }, /* @__PURE__ */ React7.createElement(Surface, {
+        }, /* @__PURE__ */ React9.createElement(Surface, {
           role: "card",
           data: {
-            subject: JSON.parse(block.json ?? "{}")
+            subject: JSON.parse(block.data ?? "{}")
           },
           limit: 1,
-          fallback: /* @__PURE__ */ React7.createElement("div", {
+          fallback: /* @__PURE__ */ React9.createElement("div", {
             className: "font-mono text-xs text-pre"
-          }, block.json)
-        }), onAddToGraph && /* @__PURE__ */ React7.createElement(IconButton3, {
+          }, block.data)
+        }), onEvent && /* @__PURE__ */ React9.createElement(IconButton3, {
           icon: "ph--plus--regular",
           label: "Add to graph",
-          onClick: () => onAddToGraph?.(JSON.parse(block.json ?? "{}"))
+          onClick: () => onEvent?.({
+            type: "add",
+            object: JSON.parse(block.data ?? "{}")
+          })
         }));
       }
       default: {
-        const title = block.disposition ? titles[block.disposition] : void 0;
-        return /* @__PURE__ */ React7.createElement(ToggleContainer2, {
-          title: title ?? "JSON"
-        }, /* @__PURE__ */ React7.createElement(Json, {
-          data: safeParseJson(block.json ?? block)
+        return /* @__PURE__ */ React9.createElement(ToggleContainer2, {
+          title: block.disposition ?? block._tag
+        }, /* @__PURE__ */ React9.createElement(Json, {
+          data: safeParseJson(block.data ?? block)
         }));
       }
     }
   },
   //
-  // Default
+  // Fallback
   //
   default: ({ block }) => {
-    let title = titles[block.type];
-    if (block.type === "tool_use") {
-      title = `Tool [${block.name}]`;
-    }
-    return /* @__PURE__ */ React7.createElement(ToggleContainer2, {
-      title: title ?? "JSON"
-    }, /* @__PURE__ */ React7.createElement(Json, {
+    return /* @__PURE__ */ React9.createElement(ToggleContainer2, {
+      title: block._tag
+    }, /* @__PURE__ */ React9.createElement(Json, {
       data: block
     }));
   }
 };
-var titles = {
-  ["cot"]: "Chain of thought",
-  ["artifact"]: "Artifact",
-  ["tool_use"]: "Tool request",
-  ["tool_result"]: "Tool result",
-  ["tool_list"]: "Tools",
-  ["artifact-update"]: "Artifact(s) changed"
-};
-var systemDispositions = [
-  "cot",
-  "artifact-update"
-];
-var panelClassNames = "flex flex-col w-full px-2 bg-activeSurface rounded-sm";
-var userClassNames = "bg-[--user-fill] text-accentSurfaceText";
-var ToggleContainer2 = (props) => {
+var MessageItem = ({ classNames, children, user }) => {
   var _effect = _useSignals10();
   try {
-    return /* @__PURE__ */ React7.createElement(NativeToggleContainer, {
-      ...props,
-      classNames: mx3(panelClassNames, props.classNames)
-    });
+    if (!children) {
+      return null;
+    }
+    return /* @__PURE__ */ React9.createElement("div", {
+      role: "list-item",
+      className: mx5("flex is-full", user && "justify-end", marginClasses, classNames)
+    }, /* @__PURE__ */ React9.createElement("div", {
+      className: mx5(user ? [
+        "rounded-sm",
+        "bg-[--user-fill] text-accentSurfaceText",
+        paddingClasses
+      ] : "is-full")
+    }, children));
   } finally {
     _effect.f();
   }
 };
-var MessageContainer = ({ children, classNames, user }) => {
+var ToggleContainer2 = (props) => {
   var _effect = _useSignals10();
   try {
-    if (!children) {
-      return null;
-    }
-    return /* @__PURE__ */ React7.createElement("div", {
-      role: "list-item",
-      className: mx3("flex w-full", user && "justify-end", classNames)
-    }, /* @__PURE__ */ React7.createElement("div", {
-      className: mx3(user ? [
-        "px-2 py-1 rounded-sm",
-        userClassNames
-      ] : "w-full")
-    }, children));
+    return /* @__PURE__ */ React9.createElement(NativeToggleContainer, {
+      ...props,
+      classNames: mx5(panelClasses, props.classNames)
+    });
   } finally {
     _effect.f();
   }
 };
+var preprocessTextContent = (content) => content.replaceAll(new RegExp(DXN_ECHO_REGEXP, "g"), (_, dxn) => `<${dxn}>`);
 
 // src/components/ChatThread/reducer.ts
 var messageReducer = ({ current, messages }, message) => {
   let i = 0;
-  for (const block of message.content) {
-    switch (block.type) {
-      case "tool_use":
-      case "tool_result": {
+  for (const block of message.blocks) {
+    switch (block._tag) {
+      case "toolCall":
+      case "toolResult": {
         if (current) {
-          current.content.push(block);
+          current.blocks.push(block);
         } else {
           current = {
+            ...message,
             id: [
               message.id,
               i
             ].join("_"),
-            role: message.role,
-            content: [
+            blocks: [
               block
             ]
           };
@@ -1729,12 +1857,12 @@ var messageReducer = ({ current, messages }, message) => {
       default: {
         current = void 0;
         messages.push({
+          ...message,
           id: [
             message.id,
             i
           ].join("_"),
-          role: message.role,
-          content: [
+          blocks: [
             block
           ]
         });
@@ -1750,15 +1878,15 @@ var messageReducer = ({ current, messages }, message) => {
 };
 
 // src/components/ChatThread/ChatThread.tsx
-var ChatThread = /* @__PURE__ */ forwardRef(({ classNames, identity, space, processor, messages, collapse = true, ...props }, forwardedRef) => {
+var ChatThread = /* @__PURE__ */ forwardRef(({ classNames, identity, messages, collapse = true, ...props }, forwardedRef) => {
   var _effect = _useSignals11();
   try {
-    const userHue = useMemo6(() => {
+    const userHue = useMemo9(() => {
       return identity?.profile?.data?.hue || keyToFallback(identity?.identityKey ?? PublicKey.random()).hue;
     }, [
       identity
     ]);
-    const { messages: filteredMessages = [] } = useMemo6(() => {
+    const { messages: filteredMessages = [] } = useMemo9(() => {
       if (collapse) {
         return (messages ?? []).reduce(messageReducer, {
           messages: []
@@ -1772,21 +1900,18 @@ var ChatThread = /* @__PURE__ */ forwardRef(({ classNames, identity, space, proc
       messages,
       collapse
     ]);
-    return /* @__PURE__ */ React8.createElement(ScrollContainer, {
+    return /* @__PURE__ */ React10.createElement(ScrollContainer, {
       ref: forwardedRef,
       classNames,
       fade: true
-    }, /* @__PURE__ */ React8.createElement("div", {
+    }, /* @__PURE__ */ React10.createElement("div", {
       role: "none",
-      className: mx4(filteredMessages.length > 0 && "pbs-6 pbe-6"),
+      className: mx6("flex flex-col gap-2", filteredMessages.length > 0 && "pbs-4 pbe-4"),
       style: {
         "--user-fill": `var(--dx-${userHue}Fill)`
       }
-    }, filteredMessages.map((message) => /* @__PURE__ */ React8.createElement(ChatMessage, {
+    }, filteredMessages.map((message) => /* @__PURE__ */ React10.createElement(ChatMessage, {
       key: message.id,
-      classNames: "px-4 pbe-4",
-      space,
-      processor,
       message,
       ...props
     }))));
@@ -1796,11 +1921,11 @@ var ChatThread = /* @__PURE__ */ forwardRef(({ classNames, identity, space, proc
 });
 
 // src/components/Chat/Chat.tsx
-var __dxlog_file9 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/components/Chat/Chat.tsx";
+var __dxlog_file6 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/components/Chat/Chat.tsx";
 var Endcap = ({ children }) => {
   var _effect = _useSignals12();
   try {
-    return /* @__PURE__ */ React9.createElement("div", {
+    return /* @__PURE__ */ React11.createElement("div", {
       className: "grid w-[var(--rail-action)] h-[var(--rail-action)] items-center justify-center"
     }, children);
   } finally {
@@ -1808,43 +1933,49 @@ var Endcap = ({ children }) => {
   }
 };
 var [ChatContextProvider, useChatContext] = createContext("Chat");
-var ChatRoot = ({ classNames, children, chat, processor, artifact, onEvent, ...props }) => {
+var ChatRoot = ({ classNames, children, chat, processor, onEvent, ...props }) => {
   var _effect = _useSignals12();
   try {
+    const [debug, setDebug] = useState7(false);
     const space = getSpace(chat);
     const queue = useQueue(chat?.queue.dxn);
-    const messages = useMemo7(() => dedupeWith([
-      ...queue?.objects?.filter(Obj3.instanceOf(Message)) ?? [],
-      ...processor?.messages.value ?? []
-    ], (a, b) => a.id === b.id), [
-      queue?.objects,
-      processor?.messages.value
-    ]);
-    const { dispatchPromise: dispatch } = useIntentDispatcher2();
-    useEffect5(() => {
-      if (!processor?.streaming.value && queue?.objects && artifact) {
-        const message = queue.objects[queue.objects.length - 1];
-        if (dispatch && space && chat && message) {
-          void dispatch(createIntent(CollaborationActions.InsertContent, {
-            target: artifact,
-            object: Ref3.fromDXN(new DXN(DXN.kind.QUEUE, [
-              ...chat.queue.dxn.parts,
-              message.id
-            ])),
-            label: "View proposal"
-          }));
-        }
-      }
+    const pending = useRxValue(processor.messages);
+    const streaming = useRxValue(processor.streaming);
+    const messages = useMemo10(() => {
+      const queueMessages = queue?.objects?.filter(Obj7.instanceOf(DataType2.Message)) ?? [];
+      return Result2.match(pending, {
+        onInitial: () => queueMessages,
+        onSuccess: (pending2) => Array.dedupeWith([
+          ...queueMessages,
+          ...pending2.value
+        ], (a, b) => a.id === b.id),
+        onFailure: () => queueMessages
+      });
     }, [
-      queue,
-      processor?.streaming.value
+      queue?.objects,
+      pending
     ]);
-    const event = useMemo7(() => new Event(), []);
+    const event = useMemo10(() => new Event(), []);
     useEffect5(() => {
       return event.on((event2) => {
         switch (event2.type) {
+          case "toggle-debug": {
+            setDebug((current) => {
+              const debug2 = !current;
+              log6.info("toggle-debug", {
+                debug: debug2
+              }, {
+                F: __dxlog_file6,
+                L: 123,
+                S: void 0,
+                C: (f, a) => f(...a)
+              });
+              return debug2;
+            });
+            break;
+          }
           case "submit": {
-            if (!processor.streaming.value) {
+            if (!streaming) {
               void processor.request(event2.text);
             }
             break;
@@ -1853,26 +1984,31 @@ var ChatRoot = ({ classNames, children, chat, processor, artifact, onEvent, ...p
             void processor.cancel();
             break;
           }
+          default: {
+            onEvent?.(event2);
+          }
         }
-        onEvent?.(event2);
       });
     }, [
       event,
-      onEvent
+      onEvent,
+      processor,
+      streaming
     ]);
     if (!space) {
       return null;
     }
-    return /* @__PURE__ */ React9.createElement(ChatContextProvider, {
+    return /* @__PURE__ */ React11.createElement(ChatContextProvider, {
+      debug,
       event,
       chat,
       space,
       processor,
       messages,
       ...props
-    }, /* @__PURE__ */ React9.createElement("div", {
+    }, /* @__PURE__ */ React11.createElement("div", {
       role: "none",
-      className: mx5("flex flex-col grow", classNames)
+      className: mx7("flex flex-col h-full overflow-hidden", classNames)
     }, children));
   } finally {
     _effect.f();
@@ -1882,7 +2018,7 @@ ChatRoot.displayName = "Chat.Root";
 var ChatThread2 = (props) => {
   var _effect = _useSignals12();
   try {
-    const { event, space, processor, messages } = useChatContext(ChatThread2.displayName);
+    const { debug, event, space, messages } = useChatContext(ChatThread2.displayName);
     const identity = useIdentity();
     const scrollerRef = useRef2(null);
     useEffect5(() => {
@@ -1897,40 +2033,30 @@ var ChatThread2 = (props) => {
     }, [
       event
     ]);
-    const handlePrompt = useCallback4((text) => {
-      if (!processor.streaming.value) {
-        event.emit({
-          type: "submit",
-          text
-        });
-        return true;
-      }
-    }, [
-      processor,
-      event
-    ]);
     if (!identity) {
       return null;
     }
-    return /* @__PURE__ */ React9.createElement(ChatThread, {
+    return /* @__PURE__ */ React11.createElement(ChatThread, {
       ...props,
       ref: scrollerRef,
+      debug,
       identity,
       space,
       messages,
-      tools: processor?.tools,
-      onPrompt: handlePrompt
+      onEvent: (ev) => event.emit(ev)
     });
   } finally {
     _effect.f();
   }
 };
 ChatThread2.displayName = "Chat.Thread";
-var ChatPrompt = ({ classNames, placeholder, expandable }) => {
+var ChatPrompt = ({ classNames, placeholder, expandable, online, presets, preset, onChangePreset, onChangeOnline }) => {
   var _effect = _useSignals12();
   try {
-    const { t } = useTranslation5(meta.id);
+    const { t } = useTranslation7(meta.id);
     const { space, event, processor } = useChatContext(ChatPrompt.displayName);
+    const streaming = useRxValue(processor.streaming);
+    const error = useRxValue(processor.error).pipe(Option2.getOrUndefined);
     const [active, setActive] = useState7(false);
     useEffect5(() => {
       return event.on((event2) => {
@@ -1954,22 +2080,24 @@ var ChatPrompt = ({ classNames, placeholder, expandable }) => {
         editorRef.current?.focus();
       }
     });
-    const [blueprints, handleUpdateBlueprints] = useBlueprints(processor.context);
-    const contextProvider = useContextProvider(space);
-    const extensions = useMemo7(() => {
+    const referencesProvider = useReferencesProvider(space);
+    const extensions = useMemo10(() => {
       return [
-        contextProvider && references({
-          provider: {
-            getReferences: async ({ query }) => contextProvider.query({
-              query
-            }),
-            resolveReference: async ({ uri }) => contextProvider.resolveMetadata({
-              uri
-            })
-          }
+        referencesProvider && references({
+          provider: referencesProvider
         }),
-        expandable && Prec.highest(keymap.of([
+        Prec.highest(keymap.of([
           {
+            key: "cmd-d",
+            preventDefault: true,
+            run: () => {
+              event.emit({
+                type: "toggle-debug"
+              });
+              return true;
+            }
+          },
+          expandable && {
             key: "cmd-ArrowUp",
             preventDefault: true,
             run: () => {
@@ -1979,7 +2107,7 @@ var ChatPrompt = ({ classNames, placeholder, expandable }) => {
               return true;
             }
           },
-          {
+          expandable && {
             key: "cmd-ArrowDown",
             preventDefault: true,
             run: () => {
@@ -1989,15 +2117,15 @@ var ChatPrompt = ({ classNames, placeholder, expandable }) => {
               return true;
             }
           }
-        ]))
+        ].filter(isNotFalsy2)))
       ].filter(isNotFalsy2);
     }, [
       event,
       expandable,
-      contextProvider
+      referencesProvider
     ]);
     const handleSubmit = useCallback4((text) => {
-      if (!processor.streaming.value) {
+      if (!streaming) {
         event.emit({
           type: "submit",
           text
@@ -2005,7 +2133,7 @@ var ChatPrompt = ({ classNames, placeholder, expandable }) => {
         return true;
       }
     }, [
-      processor,
+      streaming,
       event
     ]);
     const handleEvent = useCallback4((ev) => {
@@ -2013,22 +2141,31 @@ var ChatPrompt = ({ classNames, placeholder, expandable }) => {
     }, [
       event
     ]);
-    const handleUpdateReferences = useCallback4((ids) => {
-      log8.info("update", {
-        ids
+    const handleUpdateReferences = useCallback4((dxns) => {
+      log6.info("update", {
+        dxns
       }, {
-        F: __dxlog_file9,
-        L: 289,
+        F: __dxlog_file6,
+        L: 323,
         S: void 0,
         C: (f, a) => f(...a)
       });
+      void processor.context.bind({
+        objects: dxns.map((dxn) => Ref4.fromDXN(DXN2.parse(dxn)))
+      });
     }, []);
-    return /* @__PURE__ */ React9.createElement("div", {
-      className: mx5("is-full grid grid-cols-[var(--rail-action)_1fr_min-content] grid-rows-[min-content_var(--rail-action)]", classNames)
-    }, /* @__PURE__ */ React9.createElement(Endcap, null, /* @__PURE__ */ React9.createElement(ChatStatusIndicator, {
-      error: processor.error.value,
-      processing: processor.streaming.value
-    })), /* @__PURE__ */ React9.createElement(ChatEditor, {
+    const { onUpdateBlueprint } = useBlueprintHandlers({
+      space,
+      context: processor.context,
+      blueprintRegistry: processor.blueprintRegistry
+    });
+    return /* @__PURE__ */ React11.createElement("div", {
+      className: mx7("is-full grid grid-cols-[var(--rail-action)_1fr_var(--rail-action)] grid-rows-[min-content_min-content_min-content]", classNames)
+    }, /* @__PURE__ */ React11.createElement(Endcap, null, /* @__PURE__ */ React11.createElement(ChatStatusIndicator, {
+      preset,
+      error,
+      processing: streaming
+    })), /* @__PURE__ */ React11.createElement(ChatEditor, {
       ref: editorRef,
       autoFocus: true,
       lineWrapping: true,
@@ -2036,21 +2173,32 @@ var ChatPrompt = ({ classNames, placeholder, expandable }) => {
       placeholder: placeholder ?? t("prompt placeholder"),
       extensions,
       onSubmit: handleSubmit
-    }), /* @__PURE__ */ React9.createElement(ChatOptionsMenu, {
-      blueprintRegistry: processor.blueprintRegistry,
-      blueprints,
-      onChange: handleUpdateBlueprints
-    }), /* @__PURE__ */ React9.createElement(ChatReferences, {
-      classNames: "flex pis-1 items-center",
+    }), /* @__PURE__ */ React11.createElement("div", null), /* @__PURE__ */ React11.createElement(ChatReferences, {
+      classNames: "col-span-2 flex pis-1 items-center",
       space,
       context: processor.context,
       onUpdate: handleUpdateReferences
-    }), /* @__PURE__ */ React9.createElement(ChatActions, {
+    }), /* @__PURE__ */ React11.createElement(ChatOptions, {
+      blueprintRegistry: processor.blueprintRegistry,
+      context: processor.context,
+      onUpdateBlueprint
+    }), /* @__PURE__ */ React11.createElement(ChatActions, {
+      classNames: "col-span-2",
       microphone: true,
       recording,
-      processing: processor.streaming.value,
+      processing: streaming,
       onEvent: handleEvent
-    }));
+    }, /* @__PURE__ */ React11.createElement(React11.Fragment, null, /* @__PURE__ */ React11.createElement("div", {
+      className: "grow"
+    }), presets && /* @__PURE__ */ React11.createElement(ChatPresets, {
+      preset,
+      presets,
+      onChange: onChangePreset
+    }), online !== void 0 && /* @__PURE__ */ React11.createElement(Input.Root, null, /* @__PURE__ */ React11.createElement(Input.Switch, {
+      classNames: "mis-2 mie-2",
+      checked: online,
+      onCheckedChange: onChangeOnline
+    })))));
   } finally {
     _effect.f();
   }
@@ -2063,10 +2211,21 @@ var Chat = {
 };
 
 export {
+  useBlueprintRegistry,
   useChatProcessor,
-  useServiceContainer,
+  useChatServices,
+  useOnline,
+  usePresets,
   Toolbox,
   ToolboxContainer,
-  Chat
+  Chat,
+  AiService2 as AiService,
+  AppGraphBuilder,
+  BlueprintDefinition,
+  EdgeModelResolver,
+  IntentResolver,
+  ReactSurface,
+  Settings,
+  Toolkit
 };
-//# sourceMappingURL=chunk-TQ3QW3HJ.mjs.map
+//# sourceMappingURL=chunk-VEBVAHNM.mjs.map