@dxos/plugin-assistant 0.8.4-main.7ace549 → 0.8.4-main.8baae0fced

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

@@ -0,0 +1,938 @@
+import "../chunk-J5LGTIGS.mjs";
+
+// src/hooks/useBlueprintRegistry.ts
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { useCapabilities } from "@dxos/app-framework/ui";
+import { AppCapabilities } from "@dxos/app-toolkit";
+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 useBlueprintRegistry = () => {
+  const blueprintDefinitions = useCapabilities(AppCapabilities.BlueprintDefinition);
+  return useMemo(() => new Blueprint.Registry(blueprintDefinitions.map((blueprint) => blueprint.make())), [
+    blueprintDefinitions
+  ]);
+};
+var useBlueprints = ({ blueprintRegistry, db }) => {
+  const staticBlueprints = useMemo(() => blueprintRegistry?.query() ?? [], [
+    blueprintRegistry
+  ]);
+  const spaceBlueprints = useQuery(db, Filter.type(Blueprint.Blueprint));
+  return useMemo(() => {
+    const blueprints = distinctBy([
+      ...staticBlueprints,
+      ...spaceBlueprints
+    ], (b) => Obj.getMeta(b).key);
+    blueprints.sort(({ name: a }, { name: b }) => a.localeCompare(b));
+    return blueprints;
+  }, [
+    staticBlueprints,
+    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, blueprintRegistry }) => {
+  const onUpdateBlueprint = useCallback(async (key, checked) => {
+    if (!context || !blueprintRegistry) {
+      return;
+    }
+    const objects = await db.query(Filter.type(Blueprint.Blueprint)).run();
+    let storedBlueprint = objects.find((blueprint) => Obj.getMeta(blueprint).key === key);
+    if (checked) {
+      if (!storedBlueprint) {
+        const blueprint = blueprintRegistry.getByKey(key);
+        if (!blueprint) {
+          return;
+        }
+        storedBlueprint = db.add(Obj.clone(blueprint));
+      }
+      await context.bind({
+        blueprints: [
+          Ref.make(storedBlueprint)
+        ]
+      });
+    } else if (storedBlueprint) {
+      await context.unbind({
+        blueprints: [
+          Ref.make(storedBlueprint)
+        ]
+      });
+    }
+  }, [
+    db,
+    context,
+    blueprintRegistry
+  ]);
+  return {
+    onUpdateBlueprint
+  };
+};
+
+// src/hooks/useChatKeymap.ts
+import { Prec } from "@codemirror/state";
+import { keymap } 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, OperationRegistry, ServiceResolver } from "@dxos/compute";
+import { Database, Feed, Ref as Ref2 } from "@dxos/echo";
+import { createFeedServiceLayer } from "@dxos/echo-db";
+import { runAndForwardErrors as runAndForwardErrors2 } from "@dxos/effect";
+import { QueueService } from "@dxos/functions";
+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 = [
+  {
+    provider: "dxos-remote",
+    model: "@anthropic/claude-opus-4-6"
+  },
+  {
+    provider: "dxos-remote",
+    model: "@anthropic/claude-sonnet-4-5"
+  },
+  {
+    provider: "dxos-remote",
+    model: "@anthropic/claude-3-5-haiku-20241022"
+  },
+  {
+    provider: "ollama",
+    model: "gpt-oss:20b"
+  },
+  {
+    provider: "ollama",
+    model: "gemma4:latest"
+  },
+  {
+    provider: "lm-studio",
+    model: "@google/gemma-3-27b"
+  },
+  {
+    provider: "lm-studio",
+    model: "@meta/llama-3.2-3b-instruct"
+  },
+  {
+    model: "deepseek-r1:latest",
+    provider: "dxos-local"
+  }
+].map(({ model, provider }, i) => ({
+  id: `preset-${i}`,
+  provider,
+  model,
+  label: createModelLabel(model)
+}));
+
+// src/processor/processor.ts
+import { Atom, Registry } from "@effect-atom/atom-react";
+import * as Effect from "effect/Effect";
+import * as Fiber from "effect/Fiber";
+import * as 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 { runAndForwardErrors, unwrapExit } 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,
+  autoUpdateNameChance: 0.1
+};
+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 ?? Registry.make();
+    if (this._options.model && !this._options.system) {
+      const capabilities = this._options.modelRegistry?.getCapabilities(this._options.model) ?? {};
+      this._options.system = createSystemPrompt(capabilities);
+    }
+  }
+  get context() {
+    return this._conversation.context;
+  }
+  get conversation() {
+    return this._conversation;
+  }
+  get blueprintRegistry() {
+    return this._options.blueprintRegistry;
+  }
+  get system() {
+    return this._options.system ?? "";
+  }
+  async getTools() {
+    return this._runtime.runPromise(Effect.provide(this._conversation.getTools(), ToolExecutionServices).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.getDXN(this._feed).toString(),
+          model: this._options.model
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 109, 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: 126, S: this });
+        yield* session.submitPrompt(requestProp.message);
+        log("chat processor submitPrompt returned, waiting for agent", {}, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 130, S: this });
+        yield* session.waitForCompletion();
+        log.info("session complete", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 132, S: this });
+        this.#flushStreaming();
+        yield* this.#maybeUpdateChatName();
+      });
+      this.#requestFiber = this._runtime.runFork(effect.pipe(Effect.provide(this._spaceLayer)));
+      try {
+        await this._runtime.runPromise(Fiber.join(this.#requestFiber));
+      } catch (err) {
+        if (err._tag === "InterruptedException" || err.message?.includes("interrupted")) {
+          return;
+        }
+        throw err;
+      }
+      this.#registry.set(this.error, Option.none());
+      this.#lastRequest = void 0;
+      this.#requestFiber = void 0;
+    } catch (err) {
+      log.error("request failed", {
+        error: err
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 149, S: this });
+      this.#registry.set(this.error, Option.some(new Error("AI service error", {
+        cause: err
+      })));
+    } finally {
+      log.info("setting active to false", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 156, S: this });
+      this.#registry.set(this.active, false);
+      this.#requestFiber = void 0;
+    }
+  }
+  /**
+  * Cancels the current request.
+  */
+  async cancel() {
+    await runAndForwardErrors(Effect.gen(this, function* () {
+      if (this.#requestFiber) {
+        yield* Fiber.interrupt(this.#requestFiber);
+      }
+    }));
+    this.#requestFiber = void 0;
+    this.#registry.set(this.active, false);
+  }
+  /**
+  * Retry last failed request.
+  */
+  async retry() {
+    if (this.#lastRequest) {
+      return this.request(this.#lastRequest);
+    }
+  }
+  /**
+  * 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) {
+    unwrapExit(await this._runtime.runPromiseExit(Operation.invoke(AssistantOperation.UpdateChatName, {
+      chat
+    }).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: 244, 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();
+  }
+  /**
+  * Conditionally schedule chat name update in detached fork mode.
+  * Updates if chat has no name OR based on random chance (default 10%).
+  */
+  #maybeUpdateChatName() {
+    const chat = this._options.chat?.target;
+    if (!chat) {
+      return Effect.void;
+    }
+    const chance = this._options.autoUpdateNameChance ?? defaultOptions.autoUpdateNameChance ?? 0.1;
+    const shouldUpdate = !chat.name || Math.random() < chance;
+    if (!shouldUpdate) {
+      return Effect.void;
+    }
+    log.info("scheduling chat name update", {
+      hasName: !!chat.name,
+      chance
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 282, S: this });
+    return Operation.schedule(AssistantOperation.UpdateChatName, {
+      chat
+    });
+  }
+};
+
+// 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, blueprintRegistry, 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 runAndForwardErrors2(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, QueueService, Feed.FeedService, Credential.CredentialsService, AiService.AiService, AgentService2.AgentService, OperationRegistry.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: 60, S: void 0 });
+    return new AiChatProcessor(session, runtime3, feed, spaceLayer, {
+      chat: chat ? Ref2.make(chat) : void 0,
+      observableRegistry,
+      blueprintRegistry,
+      model: preset?.model
+    });
+  }, [
+    runtime3,
+    session,
+    blueprintRegistry,
+    preset,
+    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 } from "@dxos/echo";
+import { runAndForwardErrors as runAndForwardErrors3 } from "@dxos/effect";
+import { invariant } from "@dxos/invariant";
+import { useQuery as useQuery2 } from "@dxos/react-client/echo";
+import { MenuBuilder, useMenuBuilder } from "@dxos/react-ui-menu";
+import { useChatContext } from "#components";
+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");
+  const query = companionTo ? Query.select(Filter2.id(companionTo.id)).targetOf(Chat.CompanionTo).source() : Query.select(Filter2.nothing());
+  const chats = useQuery2(db, query);
+  const chatsVersion = chats.map((chat2) => `${chat2.id}:${Obj3.getLabel(chat2) ?? ""}`).join("|");
+  return useMenuBuilder(() => {
+    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: 44, S: void 0, A: ["companionTo", ""] });
+      return invoke(AssistantOperation2.SetCurrentChat, {
+        companionTo,
+        chat: void 0
+      }).pipe(runAndForwardErrors3);
+    }).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: 60, S: this, A: ["chat", ""] });
+      yield* invoke(AssistantOperation2.UpdateChatName, {
+        chat
+      });
+    }).pipe(runAndForwardErrors3)).action("branch", {
+      label: [
+        "branch-thread.menu",
+        {
+          ns: meta.id
+        }
+      ],
+      icon: "ph--git-branch--regular",
+      type: "branch",
+      disabled: true
+    }, () => {
+    });
+    if (chats.length > 0) {
+      builder.group("chats", {
+        label: [
+          "chat-history.label",
+          {
+            ns: meta.id
+          }
+        ],
+        icon: "ph--clock-counter-clockwise--regular",
+        selectCardinality: "single",
+        variant: "dropdownMenu"
+      }, (builder2) => {
+        chats.toSorted((a, b) => a.id.localeCompare(b.id)).forEach((chat2) => {
+          builder2.action(chat2.id, {
+            label: Obj3.getLabel(chat2) ?? [
+              "object-name.placeholder",
+              {
+                ns: Chat.Chat.typename
+              }
+            ]
+          }, () => Effect3.gen(function* () {
+            invariant(companionTo, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 97, S: this, A: ["companionTo", ""] });
+            yield* invoke(AssistantOperation2.SetCurrentChat, {
+              companionTo,
+              chat: chat2
+            });
+          }).pipe(runAndForwardErrors3));
+        });
+      });
+    }
+    return builder.build();
+  }, [
+    chatsVersion,
+    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-db";
+import { runAndForwardErrors as runAndForwardErrors4 } from "@dxos/effect";
+import { useAsyncEffect as useAsyncEffect2 } from "@dxos/react-ui";
+var useContextBinder = (space, feed) => {
+  const registry = useContext2(RegistryContext2);
+  const [binder, setBinder] = useState3();
+  useAsyncEffect2(async () => {
+    setBinder(void 0);
+    if (!space || !feed) {
+      return;
+    }
+    const feedServiceLayer = createFeedServiceLayer2(space.queues);
+    const runtime3 = await runAndForwardErrors4(Effect4.runtime().pipe(Effect4.provide(feedServiceLayer)));
+    const binder2 = new 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 { EntityKind, SystemTypeAnnotation, getTypeAnnotation } from "@dxos/echo/internal";
+var useFilteredTypes = (db) => {
+  const [types, setTypes] = useState4([]);
+  useEffect2(() => {
+    if (!db) {
+      return;
+    }
+    return db.schemaRegistry.query({
+      location: [
+        "database",
+        "runtime"
+      ]
+    }).subscribe((query) => {
+      const types2 = Array.from(new Set(query.results.filter((schema) => getTypeAnnotation(schema)?.kind !== EntityKind.Relation).filter((schema) => !SystemTypeAnnotation.get(schema).pipe(Option2.getOrElse(() => false)))));
+      setTypes(types2);
+    }, {
+      fire: true
+    });
+  }, [
+    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((object) => stringMatch(query, Obj4.getLabel(object) ?? "")).filter((object) => !!Obj4.getDXN(object)).map((object) => ({
+          uri: Obj4.getDXN(object).toString(),
+          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,
+  useBlueprintRegistry,
+  useBlueprints,
+  useChatKeymapExtensions,
+  useChatProcessor,
+  useChatServices,
+  useChatToolbarActions,
+  useContextBinder,
+  useContextObjects,
+  useDebug,
+  useFilteredTypes,
+  useFlush,
+  useOnline,
+  usePresets,
+  useReferencesProvider
+};
+//# sourceMappingURL=index.mjs.map