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

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

@@ -0,0 +1,992 @@
+import {
+  useChatContext
+} from "../chunk-VTK5R4H3.mjs";
+import "../chunk-J5LGTIGS.mjs";
+
+// src/hooks/useBlueprintRegistry.ts
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { Blueprint } from "@dxos/compute";
+import { Filter, Obj, Ref } from "@dxos/echo";
+import { useQuery } from "@dxos/react-client/echo";
+import { distinctBy } from "@dxos/util";
+var useBlueprints = ({ registry, db }) => {
+  const [registryBlueprints, setRegistryBlueprints] = useState(() => registry?.query(Filter.type(Blueprint.Blueprint)).runSync() ?? []);
+  useEffect(() => {
+    if (!registry) {
+      setRegistryBlueprints([]);
+      return;
+    }
+    setRegistryBlueprints(registry.query(Filter.type(Blueprint.Blueprint)).runSync());
+    return registry.changed.on(() => {
+      setRegistryBlueprints(registry.query(Filter.type(Blueprint.Blueprint)).runSync());
+    });
+  }, [
+    registry
+  ]);
+  const spaceBlueprints = useQuery(db, Filter.type(Blueprint.Blueprint));
+  return useMemo(() => {
+    const blueprints = distinctBy([
+      ...registryBlueprints,
+      ...spaceBlueprints
+    ], (b) => Obj.getMeta(b).key);
+    blueprints.sort(({ name: a }, { name: b }) => a.localeCompare(b));
+    return blueprints;
+  }, [
+    registryBlueprints,
+    spaceBlueprints
+  ]);
+};
+var useActiveBlueprints = ({ context }) => {
+  const [active, setActive] = useState(/* @__PURE__ */ new Map());
+  useEffect(() => {
+    if (!context) {
+      setActive(/* @__PURE__ */ new Map());
+      return;
+    }
+    const updateActive = () => {
+      const blueprints = context.getBlueprints();
+      setActive(new Map(blueprints.map((blueprint) => [
+        Obj.getMeta(blueprint).key,
+        blueprint
+      ]).filter((entry) => entry[0] !== void 0)));
+    };
+    updateActive();
+    return context.subscribeBlueprints(updateActive);
+  }, [
+    context
+  ]);
+  return active;
+};
+var useBlueprintHandlers = ({ db, context, registry }) => {
+  const onUpdateBlueprint = useCallback(async (key, checked) => {
+    if (!context) {
+      return;
+    }
+    if (checked) {
+      const registryBlueprint = registry?.query(Filter.type(Blueprint.Blueprint)).runSync().find((b) => Obj.getMeta(b).key === key);
+      if (registryBlueprint) {
+        await context.bind({
+          blueprints: [
+            Ref.fromURI(Blueprint.registryURI(key))
+          ]
+        });
+      } else {
+        const objects = await db.query(Filter.type(Blueprint.Blueprint)).run();
+        const storedBlueprint = objects.find((blueprint) => Obj.getMeta(blueprint).key === key);
+        if (storedBlueprint) {
+          await context.bind({
+            blueprints: [
+              Ref.make(storedBlueprint)
+            ]
+          });
+        }
+      }
+    } else {
+      const registryBlueprint = registry?.query(Filter.type(Blueprint.Blueprint)).runSync().find((b) => Obj.getMeta(b).key === key);
+      if (registryBlueprint) {
+        await context.unbind({
+          blueprints: [
+            Ref.fromURI(Blueprint.registryURI(key))
+          ]
+        });
+      } else {
+        const objects = await db.query(Filter.type(Blueprint.Blueprint)).run();
+        const storedBlueprint = objects.find((blueprint) => Obj.getMeta(blueprint).key === key);
+        if (storedBlueprint) {
+          await context.unbind({
+            blueprints: [
+              Ref.make(storedBlueprint)
+            ]
+          });
+        }
+      }
+    }
+  }, [
+    db,
+    context,
+    registry
+  ]);
+  return {
+    onUpdateBlueprint
+  };
+};
+
+// src/hooks/useChatKeymap.ts
+import { Prec } from "@codemirror/state";
+import { keymap } from "@codemirror/view";
+import { useMemo as useMemo2 } from "react";
+import { isTruthy } from "@dxos/util";
+var useChatKeymapExtensions = ({ event }) => {
+  return useMemo2(() => {
+    return [
+      Prec.highest(keymap.of([
+        {
+          key: "Mod-ArrowUp",
+          preventDefault: true,
+          run: () => {
+            event.emit({
+              type: "nav-previous"
+            });
+            return true;
+          },
+          shift: () => {
+            event.emit({
+              type: "thread-open"
+            });
+            return true;
+          }
+        },
+        {
+          key: "Mod-ArrowDown",
+          preventDefault: true,
+          run: () => {
+            event.emit({
+              type: "nav-next"
+            });
+            return true;
+          },
+          shift: () => {
+            event.emit({
+              type: "thread-close"
+            });
+            return true;
+          }
+        }
+      ]))
+    ].filter(isTruthy);
+  }, [
+    event
+  ]);
+};
+
+// src/hooks/useChatProcessor.ts
+import { RegistryContext } from "@effect-atom/atom-react";
+import * as Effect2 from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { useContext, useMemo as useMemo3, useState as useState2 } from "react";
+import { AiService, OpaqueToolkit } from "@dxos/ai";
+import { Capabilities } from "@dxos/app-framework";
+import { useCapability } from "@dxos/app-framework/ui";
+import { AiSession } from "@dxos/assistant";
+import { Credential, ServiceResolver } from "@dxos/compute";
+import { Database, Feed, Ref as Ref2, Registry } from "@dxos/echo";
+import { createFeedServiceLayer } from "@dxos/echo-client";
+import { EffectEx as EffectEx2 } from "@dxos/effect";
+import { AgentService as AgentService2 } from "@dxos/functions-runtime";
+import { log as log2 } from "@dxos/log";
+import { useAsyncEffect } from "@dxos/react-ui";
+
+// src/processor/presets.ts
+import * as Schema from "effect/Schema";
+var ModelProviders = [
+  "dxos-local",
+  "dxos-remote",
+  "lm-studio",
+  "ollama"
+];
+var ModelProvider = Schema.Literal(...ModelProviders);
+var createModelLabel = (model) => {
+  const parts = model.split(".");
+  return parts[parts.length - 1];
+};
+var AiServicePresets = [
+  // Sonnet is first so it is the default selection.
+  {
+    provider: "dxos-remote",
+    model: "ai.claude.model.claude-sonnet-4-6",
+    label: "Claude Sonnet"
+  },
+  {
+    provider: "dxos-remote",
+    model: "ai.claude.model.claude-opus-4-8",
+    label: "Claude Opus"
+  },
+  {
+    provider: "dxos-remote",
+    model: "ai.claude.model.claude-haiku-4-5",
+    label: "Claude Haiku"
+  },
+  {
+    provider: "ollama",
+    model: "ai.ollama.model.gpt-oss:20b"
+  },
+  {
+    provider: "ollama",
+    model: "ai.ollama.model.gemma4:latest"
+  },
+  {
+    provider: "lm-studio",
+    model: "ai.google.model.gemma-3-27b"
+  },
+  {
+    provider: "lm-studio",
+    model: "ai.meta.model.llama-3.2-3b-instruct"
+  },
+  {
+    model: "ai.ollama.model.deepseek-r1:latest",
+    provider: "dxos-local"
+  }
+].map(({ model, provider, label }, i) => ({
+  id: `preset-${i}`,
+  provider,
+  model,
+  label: label ?? createModelLabel(model)
+}));
+
+// src/processor/processor.ts
+import { Atom, Registry as AtomRegistry } from "@effect-atom/atom-react";
+import * as AiError from "@effect/ai/AiError";
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
+import * as Option from "effect/Option";
+import * as Stream from "effect/Stream";
+import { DEFAULT_EDGE_MODEL } from "@dxos/ai";
+import { AiContext, createSystemPrompt, formatSystemPrompt, McpServerError, PartialBlock, ToolExecutionServices } from "@dxos/assistant";
+import { Operation, Trace } from "@dxos/compute";
+import { Obj as Obj2 } from "@dxos/echo";
+import { EffectEx } from "@dxos/effect";
+import { AgentService } from "@dxos/functions-runtime";
+import { log } from "@dxos/log";
+import { Message } from "@dxos/types";
+import { AssistantOperation } from "#types";
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/processor/processor.ts";
+var defaultOptions = {
+  model: DEFAULT_EDGE_MODEL
+};
+var parseError = (err) => {
+  let message;
+  if (AiError.isAiError(err)) {
+    message = err.description?.trim() || err.message;
+  } else if (typeof err === "string") {
+    const [, model] = err.match(/model\s+'([^']+)'\s+not\s+found/i) || [];
+    if (model) {
+      message = `The model is not available: ${model}`;
+    }
+  }
+  if (!message) {
+    message = "An unexpected error occurred.";
+  }
+  return new Error(message, {
+    cause: err
+  });
+};
+var AiChatProcessor = class {
+  _conversation;
+  _runtime;
+  _feed;
+  _spaceLayer;
+  _options;
+  #registry;
+  /** Pending messages (finalized, non-streaming). */
+  #pending = Atom.make([]);
+  /** Currently streaming messages (from ephemeral trace events). */
+  #streaming = Atom.make([]);
+  /** Set of message IDs that have been finalized (non-pending delivered via ephemeral). */
+  #finalizedIds = /* @__PURE__ */ new Set();
+  /** Currently active request fiber. */
+  #requestFiber;
+  /** Last request (for retries). */
+  #lastRequest;
+  /** Streaming state. */
+  streaming = Atom.make((get) => get(this.#streaming).length > 0);
+  /** Active state. */
+  active = Atom.make(false);
+  /** Array of Messages (incl. the current message being streamed). */
+  messages = Atom.make((get) => [
+    ...get(this.#pending),
+    ...get(this.#streaming)
+  ]);
+  /** Last error. */
+  error = Atom.make(Option.none());
+  /**
+  * MCP server connection errors observed during the most recent request.
+  * Misconfigured/unreachable servers are dropped from the toolkit so the chat
+  * keeps working; the entries here let the UI display which servers failed.
+  */
+  mcpErrors = Atom.make([]);
+  constructor(_conversation, _runtime, _feed, _spaceLayer, _options = defaultOptions) {
+    this._conversation = _conversation;
+    this._runtime = _runtime;
+    this._feed = _feed;
+    this._spaceLayer = _spaceLayer;
+    this._options = _options;
+    this.#registry = this._options.observableRegistry ?? AtomRegistry.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 registry() {
+    return this._options.registry;
+  }
+  get system() {
+    return this._options.system ?? "";
+  }
+  async getTools() {
+    return this._runtime.runPromise(Effect.provide(this._conversation.getTools(), ToolExecutionServices).pipe(Effect.provide(this._spaceLayer)));
+  }
+  async getSystemPrompt() {
+    return this._runtime.runPromise(Effect.gen(this, function* () {
+      const blueprints = this.context.getBlueprints();
+      const objects = this.context.getObjects();
+      return yield* formatSystemPrompt({
+        system: this._options.system,
+        blueprints,
+        objects
+      });
+    }).pipe(Effect.provideService(AiContext.Service, {
+      binder: this.context
+    }), Effect.provide(this._spaceLayer), Effect.orDie));
+  }
+  /**
+  * Initiates a new request via AgentService.
+  */
+  async request(requestProp) {
+    if (this.#requestFiber) {
+      await this.cancel();
+    }
+    try {
+      this.#lastRequest = requestProp;
+      this.#registry.set(this.error, Option.none());
+      this.#registry.set(this.mcpErrors, []);
+      this.#registry.set(this.active, true);
+      const effect = Effect.gen(this, function* () {
+        log.info("init agent session", {
+          feed: Obj2.getURI(this._feed),
+          model: this._options.model
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 136, S: this });
+        const session = yield* AgentService.getSession(this._feed, {
+          model: this._options.model
+        });
+        const ephemeralStream = session.subscribeEphemeral();
+        yield* ephemeralStream.pipe(Stream.runForEach((message) => Effect.sync(() => {
+          for (const event of message.events) {
+            if (Trace.isOfType(PartialBlock, event)) {
+              this.#handleEphemeralMessage(event.data);
+            } else if (Trace.isOfType(McpServerError, event)) {
+              this.#handleMcpError(event.data);
+            }
+          }
+        })), Effect.fork);
+        log("chat processor submitting prompt", {
+          length: requestProp.message.length
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 153, S: this });
+        yield* session.submitPrompt(requestProp.message);
+        log("chat processor submitPrompt returned, waiting for agent", {}, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 157, S: this });
+        if (!this._options.chat?.target?.name) {
+          yield* this.#updateChatName(requestProp.message);
+        }
+        yield* session.waitForCompletion();
+        log.info("session complete", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 164, S: this });
+        this.#flushStreaming();
+      });
+      this.#requestFiber = this._runtime.runFork(effect.pipe(Effect.provide(this._spaceLayer)));
+      const exit = await this._runtime.runPromise(Fiber.await(this.#requestFiber));
+      if (Exit.isFailure(exit)) {
+        if (Cause.isInterruptedOnly(exit.cause)) {
+          return;
+        }
+        throw EffectEx.causeToError(exit.cause);
+      }
+      this.#registry.set(this.error, Option.none());
+      this.#lastRequest = void 0;
+      this.#requestFiber = void 0;
+    } catch (err) {
+      log.error("request failed", {
+        error: err
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 183, S: this });
+      this.#registry.set(this.error, Option.some(parseError(err)));
+    } finally {
+      log.info("setting active to false", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 188, S: this });
+      this.#registry.set(this.active, false);
+      this.#requestFiber = void 0;
+    }
+  }
+  /**
+  * Cancels the current request.
+  */
+  async cancel() {
+    await EffectEx.runAndForwardErrors(Effect.gen(this, function* () {
+      log.info("cancelling request", {
+        fiber: this.#requestFiber
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 197, S: this });
+      if (this.#requestFiber) {
+        yield* Fiber.interrupt(this.#requestFiber);
+      }
+      const session = yield* AgentService.getSession(this._feed);
+      yield* session.terminate();
+    }).pipe(Effect.provide(this._spaceLayer)));
+    this.#requestFiber = void 0;
+    this.#registry.set(this.active, false);
+  }
+  /**
+  * Retry last failed request.
+  */
+  async retry() {
+    if (this.#lastRequest) {
+      return this.request(this.#lastRequest);
+    }
+  }
+  /**
+  * Clears the recorded MCP server errors (e.g. after the user dismisses the warning banner).
+  */
+  dismissMcpErrors() {
+    this.#registry.set(this.mcpErrors, []);
+  }
+  /**
+  * Update the current chat's name.
+  */
+  async updateName(chat) {
+    const spaceId = Obj2.getDatabase(chat)?.spaceId;
+    if (!spaceId) {
+      return;
+    }
+    EffectEx.unwrapExit(await this._runtime.runPromiseExit(Operation.invoke(AssistantOperation.UpdateChatName, {
+      chat
+    }, {
+      spaceId
+    }).pipe(Effect.provide(this._spaceLayer))));
+  }
+  /**
+  * Handles an ephemeral message from the agent process.
+  * Both pending and completed blocks arrive here. Completed blocks are deduped
+  * against messages already written to the feed queue to handle the race between
+  * ephemeral delivery and feed replication.
+  */
+  #handleEphemeralMessage(event) {
+    const isPending = event.block.pending;
+    const message = Obj2.make(Message.Message, {
+      id: event.messageId,
+      created: (/* @__PURE__ */ new Date()).toISOString(),
+      sender: {
+        role: event.role
+      },
+      blocks: [
+        event.block
+      ]
+    });
+    if (isPending) {
+      if (this.#finalizedIds.has(event.messageId)) {
+        return;
+      }
+      this.#registry.update(this.#streaming, (streaming) => {
+        const idx = streaming.findIndex((existing) => existing.id === event.messageId);
+        if (idx >= 0) {
+          const updated = [
+            ...streaming
+          ];
+          updated[idx] = message;
+          return updated;
+        }
+        return [
+          ...streaming,
+          message
+        ];
+      });
+    } else {
+      this.#finalizedIds.add(event.messageId);
+      this.#registry.update(this.#streaming, (streaming) => streaming.filter((existing) => existing.id !== message.id));
+      this.#registry.update(this.#pending, (pending) => {
+        if (pending.some((existing) => existing.id === message.id)) {
+          return pending;
+        }
+        return [
+          ...pending,
+          message
+        ];
+      });
+    }
+  }
+  /**
+  * Records a per-server MCP failure, deduped by url+protocol so repeat misconfigurations
+  * across turns do not spam the UI.
+  */
+  #handleMcpError(event) {
+    log.warn("MCP server error", event, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 287, S: this });
+    this.#registry.update(this.mcpErrors, (errors) => {
+      if (errors.some((existing) => existing.url === event.url && existing.protocol === event.protocol)) {
+        return errors;
+      }
+      return [
+        ...errors,
+        event
+      ];
+    });
+  }
+  /**
+  * Move remaining streaming messages to pending (called when agent completes).
+  */
+  #flushStreaming() {
+    const remaining = this.#registry.get(this.#streaming);
+    if (remaining.length > 0) {
+      this.#registry.update(this.#pending, (pending) => [
+        ...pending,
+        ...remaining
+      ]);
+      this.#registry.set(this.#streaming, []);
+    }
+    this.#finalizedIds.clear();
+  }
+  /**
+  * Schedule a chat name update as a detached (fire-and-forget) operation.
+  * Called automatically on the first message; can also be invoked manually via the toolbar.
+  */
+  #updateChatName(prompt) {
+    const chat = this._options.chat?.target;
+    if (!chat) {
+      return Effect.void;
+    }
+    const spaceId = Obj2.getDatabase(chat)?.spaceId;
+    if (!spaceId) {
+      return Effect.void;
+    }
+    log.info("scheduling chat name update", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 323, S: this });
+    return Operation.schedule(AssistantOperation.UpdateChatName, {
+      chat,
+      prompt
+    }, {
+      spaceId
+    });
+  }
+};
+
+// src/hooks/useChatProcessor.ts
+var __dxlog_file2 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/hooks/useChatProcessor.ts";
+var useChatProcessor = ({ space, chat, preset, runtime: runtime3, registry, settings }) => {
+  const observableRegistry = useContext(RegistryContext);
+  const [session, setSession] = useState2();
+  useAsyncEffect(async () => {
+    if (!space || !chat) {
+      return;
+    }
+    const feedTarget = chat.feed.target;
+    if (!feedTarget) {
+      return;
+    }
+    const feedServiceLayer = createFeedServiceLayer(space.queues);
+    const runtime4 = await EffectEx2.runAndForwardErrors(Effect2.runtime().pipe(Effect2.provide(feedServiceLayer)));
+    const session2 = new AiSession.Session({
+      feed: feedTarget,
+      runtime: runtime4,
+      registry: observableRegistry
+    });
+    await session2.open();
+    setSession(session2);
+    return () => {
+      void session2.close();
+      setSession(void 0);
+    };
+  }, [
+    space,
+    chat?.feed.target
+  ]);
+  const feed = chat?.feed.target;
+  const serviceResolver = useCapability(Capabilities.ServiceResolver);
+  const processor = useMemo3(() => {
+    if (!runtime3 || !session || !chat || !feed || !space) {
+      return void 0;
+    }
+    const spaceLayer = ServiceResolver.provide({
+      space: space.id
+    }, Database.Service, Feed.FeedService, Credential.CredentialsService, AiService.AiService, AgentService2.AgentService, Registry.Service, OpaqueToolkit.OpaqueToolkitProvider).pipe(Layer.provide(Layer.succeed(ServiceResolver.ServiceResolver, serviceResolver)));
+    log2("creating processor", {
+      preset,
+      model: preset?.model,
+      settings
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 59, S: void 0 });
+    return new AiChatProcessor(session, runtime3, feed, spaceLayer, {
+      chat: chat ? Ref2.make(chat) : void 0,
+      observableRegistry,
+      registry,
+      model: preset?.model
+    });
+  }, [
+    runtime3,
+    session,
+    registry,
+    preset,
+    chat,
+    feed,
+    space?.id
+  ]);
+  return processor;
+};
+
+// src/hooks/useChatServices.ts
+import { Capabilities as Capabilities2 } from "@dxos/app-framework";
+import { useCapability as useCapability2 } from "@dxos/app-framework/ui";
+import { getPersonalSpace } from "@dxos/app-toolkit";
+import { useClient } from "@dxos/react-client";
+var useChatServices = ({ id }) => {
+  const client = useClient();
+  id ??= getPersonalSpace(client)?.id;
+  const runtime3 = useCapability2(Capabilities2.ProcessManagerRuntime);
+  return id ? runtime3 : void 0;
+};
+
+// src/hooks/useChatToolbarActions.ts
+import * as Effect3 from "effect/Effect";
+import { useOperationInvoker } from "@dxos/app-framework/ui";
+import { Chat } from "@dxos/assistant-toolkit";
+import { Filter as Filter2, Obj as Obj3, Query, Type } from "@dxos/echo";
+import { EffectEx as EffectEx3 } from "@dxos/effect";
+import { invariant } from "@dxos/invariant";
+import { MenuBuilder, useMenuBuilder } from "@dxos/react-ui-menu";
+import { meta } from "#meta";
+import { AssistantOperation as AssistantOperation2 } from "#types";
+var __dxlog_file3 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/hooks/useChatToolbarActions.ts";
+var useChatToolbarActions = ({ chat, companionTo }) => {
+  const { invoke } = useOperationInvoker();
+  const { db } = useChatContext("useChatToolbarActions");
+  return useMenuBuilder((get) => {
+    const chats = companionTo && db ? get(db.query(Query.select(Filter2.id(companionTo.id)).targetOf(Chat.CompanionTo).source()).atom) : [];
+    const builder = MenuBuilder.make().root({
+      label: [
+        "chat-toolbar.title",
+        {
+          ns: meta.id
+        }
+      ]
+    }).action("new", {
+      label: [
+        "new-thread.button",
+        {
+          ns: meta.id
+        }
+      ],
+      icon: "ph--plus--regular",
+      type: "new",
+      disabled: !companionTo
+    }, () => {
+      invariant(companionTo, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 38, S: void 0, A: ["companionTo", ""] });
+      return invoke(AssistantOperation2.SetCurrentChat, {
+        companionTo,
+        chat: void 0
+      }).pipe(EffectEx3.runAndForwardErrors);
+    }).action("rename", {
+      label: [
+        "rename-thread.button",
+        {
+          ns: meta.id
+        }
+      ],
+      icon: "ph--magic-wand--regular",
+      type: "rename",
+      disabled: !chat
+    }, () => Effect3.gen(function* () {
+      invariant(chat, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 54, S: this, A: ["chat", ""] });
+      yield* invoke(AssistantOperation2.UpdateChatName, {
+        chat
+      }, {
+        spaceId: db?.spaceId
+      });
+    }).pipe(EffectEx3.runAndForwardErrors)).action("branch", {
+      label: [
+        "branch-thread.menu",
+        {
+          ns: meta.id
+        }
+      ],
+      icon: "ph--git-branch--regular",
+      type: "branch",
+      disabled: !chat || !db
+    }, () => Effect3.gen(function* () {
+      invariant(chat, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 71, S: this, A: ["chat", ""] });
+      yield* invoke(AssistantOperation2.ForkChat, {
+        chat,
+        companionTo
+      }, {
+        spaceId: db?.spaceId
+      });
+    }).pipe(EffectEx3.runAndForwardErrors));
+    if (chats.length > 0) {
+      builder.group("chats", {
+        label: [
+          "chat-history.label",
+          {
+            ns: meta.id
+          }
+        ],
+        icon: "ph--clock-counter-clockwise--regular",
+        selectCardinality: "single",
+        variant: "dropdownMenu"
+      }, (builder2) => {
+        chats.toSorted((a, b) => a.id.localeCompare(b.id)).forEach((chat2) => {
+          get(Obj3.atomProperty(chat2, "name"));
+          builder2.action(chat2.id, {
+            label: Obj3.getLabel(chat2) ?? [
+              "object-name.placeholder",
+              {
+                ns: Type.getTypename(Chat.Chat)
+              }
+            ]
+          }, () => Effect3.gen(function* () {
+            invariant(companionTo, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 102, S: this, A: ["companionTo", ""] });
+            yield* invoke(AssistantOperation2.SetCurrentChat, {
+              companionTo,
+              chat: chat2
+            });
+          }).pipe(EffectEx3.runAndForwardErrors));
+        });
+      });
+    }
+    return builder.build();
+  }, [
+    db?.spaceId,
+    companionTo?.id,
+    chat?.id,
+    invoke
+  ]);
+};
+
+// src/hooks/useContextBinder.ts
+import { RegistryContext as RegistryContext2 } from "@effect-atom/atom-react";
+import * as Effect4 from "effect/Effect";
+import { useContext as useContext2, useState as useState3 } from "react";
+import { AiContext as AiContext2 } from "@dxos/assistant";
+import { createFeedServiceLayer as createFeedServiceLayer2 } from "@dxos/echo-client";
+import { EffectEx as EffectEx4 } from "@dxos/effect";
+import { useAsyncEffect as useAsyncEffect2 } from "@dxos/react-ui";
+var useContextBinder = (space, feed) => {
+  const registry = useContext2(RegistryContext2);
+  const [binder, setBinder] = useState3();
+  useAsyncEffect2(async () => {
+    setBinder(void 0);
+    if (!space || !feed) {
+      return;
+    }
+    const feedServiceLayer = createFeedServiceLayer2(space.queues);
+    const runtime3 = await EffectEx4.runAndForwardErrors(Effect4.runtime().pipe(Effect4.provide(feedServiceLayer)));
+    const binder2 = new AiContext2.Binder({
+      feed,
+      runtime: runtime3,
+      registry
+    });
+    await binder2.open();
+    setBinder(binder2);
+    return () => {
+      void binder2.close();
+    };
+  }, [
+    space,
+    feed
+  ]);
+  return binder;
+};
+
+// src/hooks/useContextObjects.ts
+import { Atom as Atom2, useAtomValue } from "@effect-atom/atom-react";
+import { useCallback as useCallback2 } from "react";
+var emptyObjectsAtom = Atom2.make([]);
+var useContextObjects = ({ db, context }) => {
+  const objects = useAtomValue(context?.objects ?? emptyObjectsAtom);
+  const handleUpdateObject = useCallback2(async (dxn, checked) => {
+    if (!db || !context) {
+      return;
+    }
+    const ref = db.makeRef(dxn);
+    await ref.load();
+    if (checked) {
+      await context.bind({
+        objects: [
+          ref
+        ]
+      });
+    } else {
+      await context.unbind({
+        objects: [
+          ref
+        ]
+      });
+    }
+  }, [
+    db,
+    context
+  ]);
+  return {
+    objects,
+    onUpdateObject: handleUpdateObject
+  };
+};
+
+// src/hooks/useDebug.ts
+import { useCallback as useCallback3 } from "react";
+import { trim } from "@dxos/util";
+var useDebug = ({ processor }) => {
+  return useCallback3(async () => {
+    const objects = processor.context.getObjects();
+    const blueprints = processor.context.getBlueprints();
+    const system = await processor.getSystemPrompt();
+    const tools = await processor.getTools() ?? {};
+    console.group("Chat", {
+      objects,
+      blueprints
+    });
+    try {
+      console.log(trim`
+        System Prompt:
+        ${system}
+      `);
+      console.log(trim`
+        Tools:
+        ${Object.values(tools).map((tool) => JSON.stringify(tool, null, 2)).join("\n")}
+      `);
+    } finally {
+      console.groupEnd();
+    }
+  }, [
+    processor
+  ]);
+};
+
+// src/hooks/useFilteredTypes.ts
+import * as Option2 from "effect/Option";
+import { useEffect as useEffect2, useState as useState4 } from "react";
+import { Type as Type2 } from "@dxos/echo";
+import { HiddenAnnotation, getTypeAnnotation } from "@dxos/echo/Annotation";
+import { Kind as EntityKind } from "@dxos/echo/Entity";
+var getFilteredTypes = (db) => Array.from(new Set(db.graph.registry.list().filter(Type2.isType).filter((schema) => getTypeAnnotation(Type2.getSchema(schema))?.kind !== EntityKind.Relation).filter((schema) => !HiddenAnnotation.get(Type2.getSchema(schema)).pipe(Option2.getOrElse(() => false)))));
+var useFilteredTypes = (db) => {
+  const [types, setTypes] = useState4([]);
+  useEffect2(() => {
+    if (!db) {
+      return;
+    }
+    setTypes(getFilteredTypes(db));
+    return db.graph.registry.changed.on(() => {
+      setTypes(getFilteredTypes(db));
+    });
+  }, [
+    db
+  ]);
+  return types;
+};
+
+// src/hooks/useFlush.ts
+import { useCallback as useCallback4, useRef, useState as useState5 } from "react";
+var useFlush = (space) => {
+  const [state, setState] = useState5("idle");
+  const resetTimer = useRef(null);
+  const handleFlush = useCallback4(() => {
+    if (!space) {
+      return;
+    }
+    queueMicrotask(async () => {
+      if (resetTimer.current) {
+        clearTimeout(resetTimer.current);
+      }
+      setState("flushing");
+      await space.db.flush();
+      setState("flushed");
+      resetTimer.current = setTimeout(() => {
+        setState("idle");
+        resetTimer.current = null;
+      }, 1e3);
+    });
+  }, [
+    space
+  ]);
+  return {
+    state,
+    handleFlush
+  };
+};
+
+// src/hooks/useOnline.ts
+import { useState as useState6 } from "react";
+var useOnline = () => {
+  const [online, setOnline] = useState6(true);
+  return [
+    online,
+    setOnline
+  ];
+};
+
+// src/hooks/usePresets.ts
+import { useCallback as useCallback5, useEffect as useEffect3, useMemo as useMemo4, useState as useState7 } from "react";
+var usePresets = (online) => {
+  const [preset, setPreset] = useState7();
+  const presets = useMemo4(() => AiServicePresets.filter((preset2) => online === (preset2.provider === "dxos-remote")), [
+    online
+  ]);
+  const presetOptions = useMemo4(() => presets.map(({ id, model, label }) => ({
+    id,
+    label: label ?? model
+  })), [
+    presets
+  ]);
+  useEffect3(() => {
+    setPreset(presets[0]);
+  }, [
+    presets
+  ]);
+  const handlePresetChange = useCallback5((id) => {
+    const preset2 = presets.find((preset3) => preset3.id === id);
+    if (preset2) {
+      setPreset(preset2);
+    }
+  }, [
+    presets
+  ]);
+  return {
+    preset,
+    presets: presetOptions,
+    onPresetChange: handlePresetChange
+  };
+};
+
+// src/hooks/useReferencesProvider.ts
+import { useMemo as useMemo5 } from "react";
+import { Filter as Filter3, Obj as Obj4 } from "@dxos/echo";
+var useReferencesProvider = (space) => {
+  return useMemo5(() => {
+    if (!space) {
+      return void 0;
+    }
+    return {
+      getReferences: async ({ query }) => {
+        const objects = await space.db.query(Filter3.everything()).run();
+        return objects.filter(Obj4.isObject).filter((object) => stringMatch(query, Obj4.getLabel(object) ?? "")).map((object) => ({
+          uri: Obj4.getURI(object),
+          label: Obj4.getLabel(object) ?? ""
+        }));
+      },
+      resolveReference: async ({ uri }) => {
+        const object = await space.db.query(Filter3.id(uri)).first();
+        return {
+          uri,
+          label: Obj4.getLabel(object) ?? ""
+        };
+      }
+    };
+  }, [
+    space
+  ]);
+};
+var stringMatch = (query, label) => label.toLowerCase().startsWith(query.toLowerCase());
+export {
+  useActiveBlueprints,
+  useBlueprintHandlers,
+  useBlueprints,
+  useChatKeymapExtensions,
+  useChatProcessor,
+  useChatServices,
+  useChatToolbarActions,
+  useContextBinder,
+  useContextObjects,
+  useDebug,
+  useFilteredTypes,
+  useFlush,
+  useOnline,
+  usePresets,
+  useReferencesProvider
+};
+//# sourceMappingURL=index.mjs.map