@dxos/plugin-assistant 0.8.4-main.67995b8 → 0.8.4-main.dedc0f3

package/dist/lib/browser/chunk-PL4O4ZJU.mjs

@@ -0,0 +1,1974 @@
+import {
+  AssistantCapabilities
+} from "./chunk-EZUSNS2J.mjs";
+import {
+  meta
+} from "./chunk-O4LUJEDV.mjs";
+
+// 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 = ({ blueprintRegistry }) => useMemo(() => blueprintRegistry?.query() ?? [], [
+  blueprintRegistry
+]);
+var useActiveBlueprints = ({ context }) => {
+  var _effect = _useSignals();
+  try {
+    const [active, setActive] = useState(/* @__PURE__ */ new Map());
+    useSignalEffect(() => {
+      const refs = [
+        ...context?.blueprints.value ?? []
+      ];
+      const blueprints = refs.map((ref) => ref.target).filter(isNonNullable);
+      setActive(new Map(blueprints.map((blueprint) => [
+        blueprint.key,
+        blueprint
+      ])));
+    });
+    return active;
+  } finally {
+    _effect.f();
+  }
+};
+var useBlueprintHandlers = ({ space, context, blueprintRegistry }) => {
+  const onUpdateBlueprint = useCallback(async (key, checked) => {
+    if (!context || !blueprintRegistry) {
+      return;
+    }
+    const { objects } = await space.db.query(Filter.type(Blueprint.Blueprint)).run();
+    let storedBlueprint = objects.find((blueprint) => blueprint.key === key);
+    if (checked) {
+      if (!storedBlueprint) {
+        const blueprint = blueprintRegistry.getByKey(key);
+        if (!blueprint) {
+          return;
+        }
+        storedBlueprint = space.db.add(Obj.clone(blueprint));
+      }
+      await context.bind({
+        blueprints: [
+          Ref.make(storedBlueprint)
+        ]
+      });
+    } else if (storedBlueprint) {
+      await context.unbind({
+        blueprints: [
+          Ref.make(storedBlueprint)
+        ]
+      });
+    }
+  }, [
+    space,
+    context,
+    blueprintRegistry
+  ]);
+  return {
+    onUpdateBlueprint
+  };
+};
+
+// src/hooks/useChatProcessor.ts
+import { RegistryContext } from "@effect-rx/rx-react";
+import { useContext, useMemo as useMemo2 } from "react";
+import { AiConversation } from "@dxos/assistant";
+import { log as log2 } from "@dxos/log";
+
+// src/processor/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-sonnet-4-0"
+  },
+  {
+    provider: "dxos-remote",
+    model: "@anthropic/claude-3-5-haiku-20241022"
+  },
+  {
+    provider: "lm-studio",
+    model: "@google/gemma-3-27b"
+  },
+  {
+    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/processor/processor.ts
+import { Registry, Rx } from "@effect-rx/rx-react";
+import { Cause, Effect, Exit, Fiber, Option, Runtime } from "effect";
+import { AiService, DEFAULT_EDGE_MODEL } from "@dxos/ai";
+import { AiSession, ArtifactDiffResolver, GenerationObserver, createSystemPrompt } from "@dxos/assistant";
+import { Obj as Obj2 } from "@dxos/echo";
+import { throwCause } from "@dxos/effect";
+import { log } from "@dxos/log";
+import { DataType } from "@dxos/schema";
+import { trim } from "@dxos/util";
+function _define_property(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/processor/processor.ts";
+var defaultOptions = {
+  model: DEFAULT_EDGE_MODEL
+};
+var AiChatProcessor = class {
+  get context() {
+    return this._conversation.context;
+  }
+  get conversation() {
+    return this._conversation;
+  }
+  get blueprintRegistry() {
+    return this._options.blueprintRegistry;
+  }
+  /**
+  * Initiates a new request.
+  */
+  async request(requestParam) {
+    if (this._fiber) {
+      await this.cancel();
+    }
+    try {
+      this._lastRequest = requestParam;
+      this._rx.set(this.error, Option.none());
+      this._rx.set(this.active, true);
+      const request = this._conversation.createRequest({
+        system: this._options.system,
+        prompt: requestParam.message,
+        observer: this._observer
+      });
+      const runtime = await this._services();
+      this._fiber = request.pipe(
+        Effect.provide(AiService.model(this._options.model ?? DEFAULT_EDGE_MODEL)),
+        // TODO(dmaretskyi): Move ArtifactDiffResolver upstream.
+        Effect.provideService(ArtifactDiffResolver, this._artifactDiffResolver),
+        Effect.asVoid,
+        Effect.tapErrorCause((cause) => {
+          log.error("request failed", {
+            cause
+          }, {
+            F: __dxlog_file,
+            L: 170,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          return Effect.void;
+        }),
+        Runtime.runFork(runtime)
+      );
+      const response = await this._fiber.pipe(Fiber.join, Effect.runPromiseExit);
+      if (!Exit.isSuccess(response) && !Cause.isInterruptedOnly(response.cause)) {
+        throwCause(response.cause);
+      }
+      this._rx.set(this.error, Option.none());
+      this._lastRequest = void 0;
+      this._fiber = void 0;
+    } catch (err) {
+      log.error("request failed", {
+        err
+      }, {
+        F: __dxlog_file,
+        L: 186,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      this._rx.set(this.error, Option.some(new Error("AI service error", {
+        cause: err
+      })));
+    } finally {
+      this._fiber = void 0;
+      this._rx.set(this.active, false);
+    }
+  }
+  /**
+  * Cancels the current request.
+  */
+  async cancel() {
+    await Effect.runPromise(Effect.gen(this, function* () {
+      if (this._fiber) {
+        yield* this._fiber.pipe(Fiber.interrupt);
+      }
+    }));
+    this._fiber = void 0;
+    this._rx.set(this.active, false);
+  }
+  /**
+  * Retry last failed request.
+  */
+  async retry() {
+    if (this._lastRequest) {
+      return this.request(this._lastRequest);
+    }
+  }
+  /**
+  * Update the current chat's name.
+  */
+  async updateName(chat) {
+    const runtime = await this._services();
+    const system = trim`
+      It is extremely important that you respond only with the title and nothing else.
+      If you cannot do this effectively respond with "New Chat".
+    `;
+    const history = await this._conversation.getHistory();
+    const fiber = Effect.gen(this, function* () {
+      const session = new AiSession();
+      return yield* session.run({
+        system,
+        prompt: "Suggest a name for this chat",
+        history
+      });
+    }).pipe(
+      // TODO(burdon): Use simpler model.
+      Effect.provide(AiService.model(this._options.model ?? DEFAULT_EDGE_MODEL)),
+      Effect.tap((messages) => {
+        const message = messages.find((message2) => message2.sender.role === "assistant");
+        const title = message?.blocks.find((b) => b._tag === "text")?.text;
+        if (title) {
+          chat.name = title;
+        }
+      }),
+      Runtime.runFork(runtime)
+    );
+    const response = await fiber.pipe(Fiber.join, Effect.runPromiseExit);
+    if (!Exit.isSuccess(response)) {
+      throwCause(response.cause);
+    }
+  }
+  constructor(_conversation, _services, _options = defaultOptions) {
+    _define_property(this, "_conversation", void 0);
+    _define_property(this, "_services", void 0);
+    _define_property(this, "_options", void 0);
+    _define_property(this, "_rx", void 0);
+    _define_property(this, "_observer", void 0);
+    _define_property(this, "_fiber", void 0);
+    _define_property(this, "_lastRequest", void 0);
+    _define_property(this, "_pending", void 0);
+    _define_property(this, "_streaming", void 0);
+    _define_property(this, "streaming", void 0);
+    _define_property(this, "active", void 0);
+    _define_property(this, "messages", void 0);
+    _define_property(this, "error", void 0);
+    _define_property(this, "_artifactDiffResolver", void 0);
+    _define_property(this, "_onMessage", void 0);
+    _define_property(this, "_onBlock", void 0);
+    this._conversation = _conversation;
+    this._services = _services;
+    this._options = _options;
+    this._pending = Rx.make([]);
+    this._streaming = Rx.make(Option.none());
+    this.streaming = Rx.make((get) => Option.isSome(get(this._streaming)));
+    this.active = Rx.make(false);
+    this.messages = Rx.make((get) => Option.match(get(this._streaming), {
+      onNone: () => get(this._pending),
+      onSome: (streaming) => [
+        ...get(this._pending),
+        streaming
+      ]
+    }));
+    this.error = Rx.make(Option.none());
+    this._artifactDiffResolver = {
+      resolve: async (_artifacts) => {
+        const versions = /* @__PURE__ */ new Map();
+        return versions;
+      }
+    };
+    this._onMessage = Effect.fn(function* (message) {
+      this._rx.set(this._streaming, Option.none());
+      this._rx.update(this._pending, (pending) => [
+        ...pending,
+        message
+      ]);
+    }.bind(this));
+    this._onBlock = Effect.fn(function* (block) {
+      this._rx.update(this._streaming, (streaming) => {
+        const blocks = streaming.pipe(Option.map((streaming2) => streaming2.blocks.filter((b) => !b.pending)), Option.getOrElse(() => []));
+        return Option.some(Obj2.make(DataType.Message, {
+          created: (/* @__PURE__ */ new Date()).toISOString(),
+          sender: {
+            role: "assistant"
+          },
+          blocks: [
+            ...blocks,
+            block
+          ]
+        }));
+      });
+    }.bind(this));
+    this._rx = this._options.observableRegistry ?? Registry.make();
+    this._observer = GenerationObserver.make({
+      onBlock: this._onBlock,
+      onMessage: this._onMessage
+    });
+    if (this._options.model && !this._options.system) {
+      const capabilities = this._options.modelRegistry?.getCapabilities(this._options.model) ?? {};
+      this._options.system = createSystemPrompt(capabilities);
+    }
+  }
+};
+
+// src/hooks/useChatProcessor.ts
+var __dxlog_file2 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/hooks/useChatProcessor.ts";
+var useChatProcessor = ({ chat, preset, services, blueprintRegistry, settings }) => {
+  const observableRegistry = useContext(RegistryContext);
+  const conversation = useMemo2(() => {
+    if (!chat?.queue.target) {
+      return;
+    }
+    return new AiConversation({
+      queue: chat.queue.target
+    });
+  }, [
+    chat?.queue.target
+  ]);
+  const processor = useMemo2(() => {
+    if (!services || !conversation) {
+      return void 0;
+    }
+    log2("creating processor", {
+      preset,
+      model: preset?.model,
+      settings
+    }, {
+      F: __dxlog_file2,
+      L: 52,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+    return new AiChatProcessor(conversation, services, {
+      observableRegistry,
+      blueprintRegistry,
+      model: preset?.model
+    });
+  }, [
+    services,
+    conversation,
+    blueprintRegistry,
+    preset
+  ]);
+  return processor;
+};
+
+// src/hooks/useChatServices.ts
+import { Effect as Effect2 } from "effect";
+import { useMemo as useMemo3 } from "react";
+import { useCapability } from "@dxos/app-framework";
+import { TracingService } from "@dxos/functions";
+import { useClient } from "@dxos/react-client";
+
+// src/capabilities/index.ts
+import { lazy } from "@dxos/app-framework";
+var AiService2 = lazy(() => import("./ai-service-YC2EQPHA.mjs"));
+var AppGraphBuilder = lazy(() => import("./app-graph-builder-3C43MLCD.mjs"));
+var AssistantState = lazy(() => import("./state-AINRYS5W.mjs"));
+var BlueprintDefinition = lazy(() => import("./blueprint-definition-VHFSRTEJ.mjs"));
+var EdgeModelResolver = lazy(() => import("./edge-model-resolver-JNEB355N.mjs"));
+var IntentResolver = lazy(() => import("./intent-resolver-I6M3ZDAS.mjs"));
+var LocalModelResolver = lazy(() => import("./local-model-resolver-EUXSRZ7X.mjs"));
+var ReactSurface = lazy(() => import("./react-surface-WNLA2636.mjs"));
+var Settings = lazy(() => import("./settings-36V3VUMW.mjs"));
+var Toolkit = lazy(() => import("./toolkit-Y5OYX5PO.mjs"));
+var ComputeRuntime = lazy(() => import("./compute-runtime-X6IREJN3.mjs"));
+
+// src/hooks/useChatServices.ts
+var useChatServices = ({ space, chat }) => {
+  const client = useClient();
+  space ?? (space = client.spaces.default);
+  const computeRuntimeResolver = useCapability(AssistantCapabilities.ComputeRuntime);
+  return useMemo3(() => {
+    const runtime = computeRuntimeResolver.getRuntime(space.id);
+    return () => runtime.runPromise(Effect2.gen(function* () {
+      return yield* Effect2.runtime().pipe(Effect2.provide(chat?.traceQueue?.target ? TracingService.layerQueue(chat.traceQueue?.target) : TracingService.layerNoop));
+    }));
+  }, [
+    space,
+    chat?.traceQueue?.target
+  ]);
+};
+
+// src/hooks/useContextBinder.ts
+import { useMemo as useMemo4 } from "react";
+import { AiContextBinder } from "@dxos/assistant";
+var useContextBinder = (chat) => {
+  const binder = useMemo4(() => {
+    const queue = chat?.queue.target;
+    return queue && new AiContextBinder(queue);
+  }, [
+    chat
+  ]);
+  return binder;
+};
+
+// src/hooks/useOnline.ts
+import { useState as useState2 } from "react";
+var useOnline = () => {
+  const [online, setOnline] = useState2(true);
+  return [
+    online,
+    setOnline
+  ];
+};
+
+// src/hooks/usePresets.ts
+import { useCallback as useCallback2, useEffect, useMemo as useMemo5, useState as useState3 } from "react";
+var usePresets = (online) => {
+  const [preset, setPreset] = useState3();
+  const presets = useMemo5(() => AiServicePresets.filter((preset2) => online === (preset2.provider === "dxos-remote")), [
+    online
+  ]);
+  const presetOptions = useMemo5(() => presets.map(({ id, model, label }) => ({
+    id,
+    label: label ?? model
+  })), [
+    presets
+  ]);
+  useEffect(() => {
+    setPreset(presets[0]);
+  }, [
+    presets
+  ]);
+  const handlePresetChange = useCallback2((id) => {
+    const preset2 = presets.find((preset3) => preset3.id === id);
+    if (preset2) {
+      setPreset(preset2);
+    }
+  }, [
+    presets
+  ]);
+  return {
+    preset,
+    presets: presetOptions,
+    onPresetChange: handlePresetChange
+  };
+};
+
+// src/hooks/useContextObjects.ts
+import { useSignals as _useSignals2 } from "@preact-signals/safe-react/tracking";
+import { useCallback as useCallback3 } from "react";
+import { Ref as Ref2 } from "@dxos/echo";
+import { log as log3 } from "@dxos/log";
+import { isNonNullable as isNonNullable2 } from "@dxos/util";
+var __dxlog_file3 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/hooks/useContextObjects.ts";
+var useContextObjects = ({ space, context }) => {
+  var _effect = _useSignals2();
+  try {
+    const objects = context?.objects.value.map((ref) => ref.target).filter(isNonNullable2) ?? [];
+    const handleUpdateObject = useCallback3(async (dxn, checked) => {
+      if (!space || !context) {
+        return;
+      }
+      const id = dxn.asEchoDXN();
+      const object = id && await space.db.getObjectById(id.echoId);
+      if (!object) {
+        log3.warn("Object not found", {
+          dxn,
+          id
+        }, {
+          F: __dxlog_file3,
+          L: 40,
+          S: void 0,
+          C: (f, a) => f(...a)
+        });
+        return;
+      }
+      const ref = Ref2.fromDXN(dxn);
+      if (checked) {
+        await context.bind({
+          objects: [
+            ref
+          ]
+        });
+      } else {
+        await context.unbind({
+          objects: [
+            ref
+          ]
+        });
+      }
+    }, [
+      space,
+      context
+    ]);
+    return {
+      objects,
+      onUpdateObject: handleUpdateObject
+    };
+  } finally {
+    _effect.f();
+  }
+};
+
+// src/hooks/useExecutionGraph.ts
+import { useMemo as useMemo6 } from "react";
+import { Obj as Obj4 } from "@dxos/echo";
+import { useQueue } from "@dxos/react-client/echo";
+
+// src/execution-graph/execution-graph.ts
+import { AgentStatus } from "@dxos/ai";
+import { Obj as Obj3 } from "@dxos/echo";
+import { MESSAGE_PROPERTY_TOOL_CALL_ID } from "@dxos/functions";
+import { LogLevel } from "@dxos/log";
+import { ContentBlock, DataType as DataType2 } from "@dxos/schema";
+import { isNotFalsy } from "@dxos/util";
+function _define_property2(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+var ExecutionGraph = class {
+  /**
+  * Adds events to the graph.
+  */
+  addEvents(events) {
+    for (const event of events) {
+      if (Obj3.instanceOf(DataType2.Message, event)) {
+        const messageCommits = messageToCommit(event);
+        this._commits.push(...messageCommits);
+        messageCommits.map((c) => c.branch).forEach((branch) => this._branchNames.add(branch));
+      } else if (Obj3.instanceOf(AgentStatus, event)) {
+        const branch = getBranchName({
+          parentMessage: event.parentMessage,
+          toolCallId: event.toolCallId
+        });
+        this._branchNames.add(branch);
+        this._commits.push({
+          id: event.id,
+          branch,
+          message: event.message,
+          icon: "ph--flag--regular",
+          parents: event.parentMessage && event.toolCallId ? [
+            getToolCallId(event.parentMessage, event.toolCallId)
+          ] : void 0
+        });
+      }
+    }
+  }
+  /**
+  * Returns the current state of the graph.
+  */
+  getGraph(lastRequest = false) {
+    const idx = lastRequest ? this._commits.findLastIndex((c) => c.tags?.includes("user")) : -1;
+    const commits = idx === -1 ? this._commits : this._commits.slice(idx);
+    return {
+      branches: Array.from(this._branchNames),
+      commits
+    };
+  }
+  constructor() {
+    _define_property2(this, "_commits", []);
+    _define_property2(this, "_branchNames", /* @__PURE__ */ new Set());
+  }
+};
+var messageToCommit = (message) => {
+  return message.blocks.map((block, idx) => {
+    const branch = getMessageBranch(message);
+    const parent = getParentId(message);
+    const parents = parent ? [
+      parent
+    ] : [];
+    switch (block._tag) {
+      case "text":
+        if (!block.text.trim().length) {
+          return null;
+        }
+        return {
+          id: getGenericBlockId(message.id, idx),
+          branch,
+          parents,
+          ...message.sender.role === "user" ? {
+            icon: "ph--user--regular",
+            tags: [
+              "user"
+            ],
+            message: "Processing request..."
+          } : {
+            icon: "ph--robot--regular",
+            message: `Response (${block.text.split(" ").length} words)`
+          }
+        };
+      case "toolCall":
+        return {
+          id: getToolCallId(message.id, block.toolCallId),
+          branch,
+          parents,
+          icon: "ph--wrench--regular",
+          level: LogLevel.INFO,
+          // TODO(burdon): Lookup tool name/description?
+          message: `Calling tool (${block.name})`
+        };
+      case "toolResult":
+        return {
+          id: getToolResultId(message.id, block.toolCallId),
+          branch,
+          parents,
+          icon: block.error ? "ph--x-circle--regular" : "ph--check-circle--regular",
+          level: block.error ? LogLevel.ERROR : LogLevel.INFO,
+          message: block.error ? "Tool error: " + block.error : "Tool call succeeded"
+        };
+      case "summary":
+        return {
+          id: getGenericBlockId(message.id, idx),
+          branch,
+          parents,
+          icon: "ph--rocket--regular",
+          level: LogLevel.INFO,
+          message: ContentBlock.createSummaryMessage(block)
+        };
+      case "status":
+        return {
+          id: getGenericBlockId(message.id, idx),
+          branch,
+          parents,
+          message: block.statusText,
+          level: LogLevel.INFO,
+          icon: "ph--flag--regular"
+        };
+      case "reasoning":
+        return {
+          id: getGenericBlockId(message.id, idx),
+          branch,
+          parents,
+          message: block.reasoningText ?? "Thinking...",
+          icon: "ph--brain--regular"
+        };
+      case "reference":
+        return {
+          id: getGenericBlockId(message.id, idx),
+          branch,
+          parents,
+          icon: "ph--link--regular",
+          message: stringifyRef(block.reference)
+        };
+      default:
+        return null;
+    }
+  }).filter(isNotFalsy);
+};
+var getToolCallId = (messageId, toolCallId) => `${messageId}_toolCall_${toolCallId}`;
+var getToolResultId = (messageId, toolCallId) => `${messageId}_toolResult_${toolCallId}`;
+var getGenericBlockId = (messageId, idx) => `${messageId}_block_${idx}`;
+var getBranchName = (options) => {
+  if (options.parentMessage && options.toolCallId) {
+    return `${options.parentMessage}_${options.toolCallId}`;
+  } else if (options.parentMessage) {
+    return options.parentMessage;
+  } else {
+    return "main";
+  }
+};
+var getMessageBranch = (message) => {
+  return getBranchName({
+    parentMessage: message.parentMessage,
+    toolCallId: message.properties?.[MESSAGE_PROPERTY_TOOL_CALL_ID]
+  });
+};
+var getParentId = (message) => {
+  if (message.parentMessage && message.properties?.[MESSAGE_PROPERTY_TOOL_CALL_ID]) {
+    return getToolCallId(message.parentMessage, message.properties[MESSAGE_PROPERTY_TOOL_CALL_ID]);
+  } else {
+    return void 0;
+  }
+};
+var stringifyRef = (ref) => {
+  if (ref.target) {
+    return stringifyObject(ref.target);
+  }
+  return ref.dxn.asEchoDXN()?.echoId ?? ref.dxn.asQueueDXN()?.objectId ?? "";
+};
+var stringifyObject = (obj) => {
+  return Obj3.getLabel(obj) ?? Obj3.getTypename(obj) ?? obj.id;
+};
+
+// src/hooks/useExecutionGraph.ts
+var useExecutionGraph = (queueRef, lastRequest = false) => {
+  const queue = useQueue(queueRef?.dxn);
+  return useMemo6(() => {
+    const graph = new ExecutionGraph();
+    graph.addEvents(queue?.objects.filter(Obj4.isObject) ?? []);
+    return graph.getGraph(lastRequest);
+  }, [
+    queue?.objects,
+    lastRequest
+  ]);
+};
+
+// src/hooks/useFlush.ts
+import { useCallback as useCallback4, useRef, useState as useState4 } from "react";
+
+// src/hooks/useItemTypes.ts
+import { Option as Option2 } from "effect";
+import { useEffect as useEffect2, useState as useState5 } from "react";
+import { ItemAnnotation } from "@dxos/schema";
+var useItemTypes = (space) => {
+  const [types, setTypes] = useState5([]);
+  useEffect2(() => {
+    if (!space) {
+      return;
+    }
+    return space.db.schemaRegistry.query().subscribe((query) => {
+      const types2 = Array.from(new Set([
+        ...space.db.graph.schemaRegistry.schemas,
+        ...query.results
+      ].filter((type) => Option2.isSome(ItemAnnotation.get(type)))));
+      setTypes(types2);
+    }, {
+      fire: true
+    });
+  }, [
+    space
+  ]);
+  return types;
+};
+
+// src/hooks/useReferencesProvider.ts
+import { useMemo as useMemo7 } from "react";
+import { Capabilities as Capabilities2, useCapabilities as useCapabilities2 } from "@dxos/app-framework";
+import { Filter as Filter2, Obj as Obj5 } from "@dxos/echo";
+var useReferencesProvider = (space) => {
+  const blueprints = useCapabilities2(Capabilities2.BlueprintDefinition);
+  return useMemo7(() => {
+    if (!space) {
+      return void 0;
+    }
+    return {
+      getReferences: async ({ query }) => {
+        const { objects } = await space.db.query(Filter2.everything()).run();
+        return objects.filter((object) => stringMatch(query, Obj5.getLabel(object) ?? "")).filter((object) => !!Obj5.getDXN(object)).map((object) => ({
+          uri: Obj5.getDXN(object).toString(),
+          label: Obj5.getLabel(object) ?? ""
+        }));
+      },
+      resolveReference: async ({ uri }) => {
+        const object = await space.db.query(Filter2.ids(uri)).first();
+        return {
+          uri,
+          label: Obj5.getLabel(object) ?? ""
+        };
+      }
+    };
+  }, [
+    space,
+    blueprints
+  ]);
+};
+var stringMatch = (query, label) => label.toLowerCase().startsWith(query.toLowerCase());
+
+// src/hooks/useComputeRuntimeCallback.ts
+import { useCallback as useCallback5 } from "react";
+import { useCapability as useCapability2 } from "@dxos/app-framework";
+
+// src/components/Chat/Chat.tsx
+import { useSignals as _useSignals11 } from "@preact-signals/safe-react/tracking";
+import { Prec } from "@codemirror/state";
+import { keymap } from "@codemirror/view";
+import { useRxValue } from "@effect-rx/rx-react";
+import { createContext } from "@radix-ui/react-context";
+import { Array as Array2, Option as Option3 } from "effect";
+import React9, { useCallback as useCallback7, useEffect as useEffect6, useMemo as useMemo11, useRef as useRef3, useState as useState10 } from "react";
+import { Event } from "@dxos/async";
+import { Obj as Obj8 } from "@dxos/echo";
+import { useVoiceInput } from "@dxos/plugin-transcription";
+import { getSpace, useQueue as useQueue2 } from "@dxos/react-client/echo";
+import { useIdentity } from "@dxos/react-client/halo";
+import { Input, useDynamicRef, useTranslation as useTranslation5 } from "@dxos/react-ui";
+import { ChatEditor, references } from "@dxos/react-ui-chat";
+import { mx as mx5 } from "@dxos/react-ui-theme";
+import { DataType as DataType3 } from "@dxos/schema";
+import { isNotFalsy as isNotFalsy2 } from "@dxos/util";
+
+// src/components/ChatPrompt/ChatActions.tsx
+import { useSignals as _useSignals3 } from "@preact-signals/safe-react/tracking";
+import React from "react";
+import { IconButton, useTranslation } from "@dxos/react-ui";
+import { mx } from "@dxos/react-ui-theme";
+var ChatActions = ({ classNames, children, microphone, recording, processing, onEvent }) => {
+  var _effect = _useSignals3();
+  try {
+    const { t } = useTranslation(meta.id);
+    return /* @__PURE__ */ React.createElement("div", {
+      className: mx("flex items-center mie-1", classNames)
+    }, children, /* @__PURE__ */ React.createElement(IconButton, {
+      disabled: !processing,
+      variant: "ghost",
+      size: 5,
+      icon: "ph--x--regular",
+      iconOnly: true,
+      label: t("button cancel processing"),
+      onClick: () => onEvent?.({
+        type: "cancel"
+      })
+    }), microphone && /* @__PURE__ */ React.createElement(IconButton, {
+      disabled: !processing,
+      classNames: mx(recording && "bg-primary-500"),
+      variant: "ghost",
+      size: 5,
+      icon: "ph--microphone--regular",
+      iconOnly: true,
+      noTooltip: true,
+      label: t("button microphone"),
+      onMouseDown: () => onEvent?.({
+        type: "record-start"
+      }),
+      onMouseUp: () => onEvent?.({
+        type: "record-stop"
+      }),
+      onTouchStart: () => onEvent?.({
+        type: "record-start"
+      }),
+      onTouchEnd: () => onEvent?.({
+        type: "record-stop"
+      })
+    }));
+  } finally {
+    _effect.f();
+  }
+};
+
+// src/components/ChatPrompt/ChatOptions.tsx
+import { useSignals as _useSignals4 } from "@preact-signals/safe-react/tracking";
+import React2, { useMemo as useMemo8, useState as useState6 } from "react";
+import { Filter as Filter3, Obj as Obj6, Type } from "@dxos/echo";
+import { useQuery } from "@dxos/react-client/echo";
+import { Icon, IconButton as IconButton2, Popover, Select, useTranslation as useTranslation2 } from "@dxos/react-ui";
+import { SearchList } from "@dxos/react-ui-searchlist";
+import { Tabs } from "@dxos/react-ui-tabs";
+var panelClassNames = "is-[calc(100dvw-.5rem)] sm:is-max md:is-[25rem] max-is-[--text-content]";
+var ChatOptions = ({ space, context, blueprintRegistry, presets, preset, onPresetChange }) => {
+  var _effect = _useSignals4();
+  try {
+    const { t } = useTranslation2(meta.id);
+    return /* @__PURE__ */ React2.createElement("div", {
+      role: "none",
+      className: "flex gap-0.5"
+    }, /* @__PURE__ */ React2.createElement(Popover.Root, null, /* @__PURE__ */ React2.createElement(Popover.Trigger, {
+      asChild: true
+    }, /* @__PURE__ */ React2.createElement(IconButton2, {
+      variant: "ghost",
+      icon: "ph--plus--regular",
+      iconOnly: true,
+      size: 5,
+      label: t("button context objects")
+    })), /* @__PURE__ */ React2.createElement(Popover.Portal, null, /* @__PURE__ */ React2.createElement(Popover.Content, {
+      side: "top",
+      classNames: panelClassNames
+    }, /* @__PURE__ */ React2.createElement(ObjectsPanel, {
+      space,
+      context
+    }), /* @__PURE__ */ React2.createElement(Popover.Arrow, null)))), /* @__PURE__ */ React2.createElement(Popover.Root, null, /* @__PURE__ */ React2.createElement(Popover.Trigger, {
+      asChild: true
+    }, /* @__PURE__ */ React2.createElement(IconButton2, {
+      variant: "ghost",
+      icon: "ph--sliders-horizontal--regular",
+      iconOnly: true,
+      size: 5,
+      label: t("button context settings")
+    })), /* @__PURE__ */ React2.createElement(Popover.Portal, null, /* @__PURE__ */ React2.createElement(Popover.Content, {
+      side: "top",
+      classNames: panelClassNames
+    }, /* @__PURE__ */ React2.createElement(Tabs.Root, {
+      orientation: "horizontal",
+      defaultValue: "blueprints",
+      defaultActivePart: "list"
+    }, /* @__PURE__ */ React2.createElement(Tabs.Viewport, {
+      classNames: 'max-bs-[--radix-popover-content-available-height] grid grid-rows-[1fr_min-content] [&_[cmdk-root]]:contents [&_[role="tabpanel"]]:grid [&_[role="tabpanel"]]:grid-rows-[1fr_min-content] [&_[role="listbox"]]:min-bs-0 [&_[role="listbox"]]:overflow-y-auto [&_[role="tabpanel"]]:min-bs-0 [&_[role="tabpanel"]]:pli-cardSpacingChrome [&_[role="tabpanel"][data-state="active"]]:order-first [&_[role="tabpanel"][data-state="inactive"]]:hidden'
+    }, /* @__PURE__ */ React2.createElement(Tabs.Tabpanel, {
+      value: "blueprints"
+    }, /* @__PURE__ */ React2.createElement(BlueprintsPanel, {
+      blueprintRegistry,
+      space,
+      context
+    })), /* @__PURE__ */ React2.createElement(Tabs.Tabpanel, {
+      value: "model"
+    }, /* @__PURE__ */ React2.createElement(ModelsPanel, {
+      presets,
+      preset,
+      onPresetChange
+    })), /* @__PURE__ */ React2.createElement(Tabs.Tablist, {
+      classNames: "sm:overflow-x-hidden justify-center p-[--dx-cardSpacingChrome] border-bs border-subduedSeparator order-last"
+    }, /* @__PURE__ */ React2.createElement(Tabs.IconTab, {
+      value: "blueprints",
+      icon: "ph--blueprint--regular",
+      label: t("blueprints in context title")
+    }), /* @__PURE__ */ React2.createElement(Tabs.IconTab, {
+      value: "model",
+      label: t("chat model title"),
+      icon: "ph--cpu--regular"
+    })))), /* @__PURE__ */ React2.createElement(Popover.Arrow, null)))));
+  } finally {
+    _effect.f();
+  }
+};
+var BlueprintsPanel = ({ blueprintRegistry, space, context }) => {
+  var _effect = _useSignals4();
+  try {
+    const { t } = useTranslation2(meta.id);
+    const blueprints = useBlueprints({
+      blueprintRegistry
+    });
+    const activeBlueprints = useActiveBlueprints({
+      context
+    });
+    const { onUpdateBlueprint } = useBlueprintHandlers({
+      space,
+      context,
+      blueprintRegistry
+    });
+    return /* @__PURE__ */ React2.createElement(SearchList.Root, null, /* @__PURE__ */ React2.createElement(SearchList.Content, {
+      classNames: "plb-cardSpacingChrome"
+    }, blueprints.map((blueprint) => {
+      const isActive = activeBlueprints.has(blueprint.key);
+      return /* @__PURE__ */ React2.createElement(SearchList.Item, {
+        classNames: "flex items-center overflow-hidden",
+        key: blueprint.key,
+        value: blueprint.name,
+        onSelect: () => onUpdateBlueprint?.(blueprint.key, !isActive)
+      }, /* @__PURE__ */ React2.createElement("div", {
+        className: "grow truncate"
+      }, blueprint.name), /* @__PURE__ */ React2.createElement(Icon, {
+        icon: "ph--check--regular",
+        classNames: [
+          !isActive && "invisible"
+        ]
+      }));
+    })), /* @__PURE__ */ React2.createElement(SearchList.Input, {
+      placeholder: t("search placeholder"),
+      classNames: "mbe-cardSpacingChrome"
+    }));
+  } finally {
+    _effect.f();
+  }
+};
+var ModelsPanel = ({ presets, preset, onPresetChange }) => {
+  var _effect = _useSignals4();
+  try {
+    return /* @__PURE__ */ React2.createElement("ul", {
+      role: "listbox",
+      className: "plb-cardSpacingChrome"
+    }, presets?.map(({ id, label }) => {
+      const isActive = preset === id;
+      return /* @__PURE__ */ React2.createElement("li", {
+        role: "option",
+        key: id,
+        "aria-selected": isActive,
+        tabIndex: 0,
+        className: "overflow-hidden dx-focus-ring flex gap-2 p-1 pis-2 pie-2 items-center rounded-sm select-none cursor-pointer hover:bg-hoverOverlay",
+        onClick: () => onPresetChange?.(id)
+      }, /* @__PURE__ */ React2.createElement("div", {
+        className: "grow truncate"
+      }, label), /* @__PURE__ */ React2.createElement(Icon, {
+        icon: "ph--check--regular",
+        classNames: [
+          !isActive && "invisible"
+        ]
+      }));
+    }));
+  } finally {
+    _effect.f();
+  }
+};
+var ANY = "__any__";
+var ObjectsPanel = ({ space, context }) => {
+  var _effect = _useSignals4();
+  try {
+    const { t } = useTranslation2(meta.id);
+    const types = useItemTypes(space);
+    const typenames = useMemo8(() => {
+      const typenames2 = types.map((type) => {
+        const typename2 = Type.getTypename(type);
+        return {
+          typename: typename2,
+          label: t("typename label", {
+            ns: typename2,
+            defaultValue: typename2
+          })
+        };
+      });
+      typenames2.sort((a, b) => a.label.localeCompare(b.label));
+      return typenames2;
+    }, [
+      types
+    ]);
+    const [typename, setTypename] = useState6(ANY);
+    const anyFilter = useMemo8(() => Filter3.or(...typenames.map(({ typename: typename2 }) => Filter3.typename(typename2))), [
+      typenames
+    ]);
+    const objects = useQuery(space, typename === ANY ? anyFilter : Filter3.typename(typename));
+    const { objects: contextObjects, onUpdateObject } = useContextObjects({
+      space,
+      context
+    });
+    return /* @__PURE__ */ React2.createElement(SearchList.Root, {
+      classNames: "pis-2 pie-2"
+    }, /* @__PURE__ */ React2.createElement(SearchList.Content, {
+      classNames: "plb-cardSpacingChrome [&:has([cmdk-list-sizer]:empty)]:plb-0"
+    }, objects.length ? objects.map((object) => {
+      const label = Obj6.getLabel(object) ?? Obj6.getTypename(object) ?? object.id;
+      const isActive = contextObjects.findIndex((obj) => obj.id === object.id) !== -1;
+      return /* @__PURE__ */ React2.createElement(SearchList.Item, {
+        classNames: "flex items-center overflow-hidden",
+        key: object.id,
+        value: object.id,
+        onSelect: () => onUpdateObject?.(Obj6.getDXN(object), !isActive)
+      }, /* @__PURE__ */ React2.createElement("div", {
+        className: "grow truncate"
+      }, label), /* @__PURE__ */ React2.createElement(Icon, {
+        icon: "ph--check--regular",
+        classNames: [
+          !isActive && "invisible"
+        ]
+      }));
+    }) : /* @__PURE__ */ React2.createElement(SearchList.Item, null, t("no results"))), /* @__PURE__ */ React2.createElement("div", {
+      role: "none",
+      className: "grid grid-cols-[min-content_1fr] gap-2 mbe-cardSpacingChrome"
+    }, /* @__PURE__ */ React2.createElement(Select.Root, {
+      value: typename === ANY ? void 0 : typename,
+      onValueChange: setTypename
+    }, /* @__PURE__ */ React2.createElement(Select.TriggerButton, {
+      density: "fine",
+      placeholder: t("type filter placeholder")
+    }), /* @__PURE__ */ React2.createElement(Select.Portal, null, /* @__PURE__ */ React2.createElement(Select.Content, null, /* @__PURE__ */ React2.createElement(Select.ScrollUpButton, null), /* @__PURE__ */ React2.createElement(Select.Viewport, null, /* @__PURE__ */ React2.createElement(Select.Option, {
+      value: ANY
+    }, t("any type filter label")), typenames.map(({ typename: typename2, label }) => /* @__PURE__ */ React2.createElement(Select.Option, {
+      key: typename2,
+      value: typename2
+    }, label))), /* @__PURE__ */ React2.createElement(Select.ScrollDownButton, null), /* @__PURE__ */ React2.createElement(Select.Arrow, null)))), /* @__PURE__ */ React2.createElement(SearchList.Input, {
+      placeholder: t("search placeholder"),
+      classNames: "mbe-0"
+    })));
+  } finally {
+    _effect.f();
+  }
+};
+
+// src/components/ChatPrompt/ChatPresets.tsx
+import { useSignals as _useSignals5 } from "@preact-signals/safe-react/tracking";
+import React3 from "react";
+import { Select as Select2 } from "@dxos/react-ui";
+
+// src/components/ChatPrompt/ChatReferences.tsx
+import { useSignals as _useSignals6 } from "@preact-signals/safe-react/tracking";
+import React4 from "react";
+import { Obj as Obj7 } from "@dxos/echo";
+import { IconButton as IconButton3, toLocalizedString, useTranslation as useTranslation3 } from "@dxos/react-ui";
+import { mx as mx2 } from "@dxos/react-ui-theme";
+var ChatReferences = ({ classNames, context, space }) => {
+  var _effect = _useSignals6();
+  try {
+    const { t } = useTranslation3(meta.id);
+    const { objects, onUpdateObject } = useContextObjects({
+      space,
+      context
+    });
+    return /* @__PURE__ */ React4.createElement("ul", {
+      className: mx2("flex flex-wrap", classNames)
+    }, objects.map((obj) => {
+      const dxn = Obj7.getDXN(obj);
+      const typename = Obj7.getTypename(obj);
+      const label = Obj7.getLabel(obj) ?? (typename ? [
+        "object name placeholder",
+        {
+          ns: typename
+        }
+      ] : obj.id);
+      return /* @__PURE__ */ React4.createElement("li", {
+        key: dxn.toString(),
+        className: "dx-tag plb-0 pis-2 flex items-center",
+        "data-hue": "neutral"
+      }, toLocalizedString(label, t), /* @__PURE__ */ React4.createElement(IconButton3, {
+        iconOnly: true,
+        variant: "ghost",
+        label: t("remove object in context label"),
+        classNames: "p-0 hover:bg-transparent",
+        size: 3,
+        icon: "ph--x--bold",
+        onClick: () => onUpdateObject?.(dxn, false)
+      }));
+    }));
+  } finally {
+    _effect.f();
+  }
+};
+
+// src/components/ChatPrompt/ChatStatusIndicator.tsx
+import { useSignals as _useSignals7 } from "@preact-signals/safe-react/tracking";
+import React5, { useEffect as useEffect3, useState as useState7 } from "react";
+import { Tooltip, useTimeout } from "@dxos/react-ui";
+import { Spinner } from "@dxos/react-ui-sfx";
+import { mx as mx3 } from "@dxos/react-ui-theme";
+var period = 3e3;
+var ChatStatusIndicator = ({ classNames, preset, processing, error, ...props }) => {
+  var _effect = _useSignals7();
+  try {
+    const [init, setInit] = useState7(false);
+    useEffect3(() => setInit(false), [
+      preset
+    ]);
+    useTimeout(async () => {
+      setInit(true);
+    }, period / 2, [
+      preset
+    ]);
+    return /* @__PURE__ */ React5.createElement("div", {
+      role: "none",
+      className: mx3("relative flex", classNames)
+    }, /* @__PURE__ */ React5.createElement(Spinner, {
+      duration: period,
+      state: !init ? "flash" : error ? "error" : processing ? "spin" : "pulse",
+      ...props
+    }), error && /* @__PURE__ */ React5.createElement(Tooltip.Trigger, {
+      asChild: true,
+      content: error.message
+    }, /* @__PURE__ */ React5.createElement("div", {
+      className: "absolute inset-0"
+    })));
+  } finally {
+    _effect.f();
+  }
+};
+
+// src/components/ChatThread/ChatThread.tsx
+import { useSignals as _useSignals10 } from "@preact-signals/safe-react/tracking";
+import React8, { forwardRef, useCallback as useCallback6, useEffect as useEffect5, useImperativeHandle, useMemo as useMemo10, useState as useState9 } from "react";
+import { PublicKey } from "@dxos/keys";
+import { MarkdownStream } from "@dxos/react-ui-components";
+import { mx as mx4 } from "@dxos/react-ui-theme";
+import { keyToFallback } from "@dxos/util";
+
+// src/components/ChatThread/registry.tsx
+import { useSignals as _useSignals9 } from "@preact-signals/safe-react/tracking";
+import React7 from "react";
+import { log as log4 } from "@dxos/log";
+import { PromptWidget, ReferenceWidget, SelectWidget, SuggestionWidget, SummaryWidget, ToggleContainer as ToggleContainer2 } from "@dxos/react-ui-components";
+import { Json as Json2 } from "@dxos/react-ui-syntax-highlighter";
+import { ContentBlock as ContentBlock2 } from "@dxos/schema";
+
+// src/components/ToolBlock/ToolBlock.tsx
+import { useSignals as _useSignals8 } from "@preact-signals/safe-react/tracking";
+import React6, { useEffect as useEffect4, useMemo as useMemo9, useRef as useRef2, useState as useState8 } from "react";
+import { useTranslation as useTranslation4 } from "@dxos/react-ui";
+import { NumericTabs, TextCrawl, ToggleContainer, chatMessageJson, chatMessagePanel, chatMessagePanelContent, chatMessagePanelHeader } from "@dxos/react-ui-components";
+import { Json } from "@dxos/react-ui-syntax-highlighter";
+import { isNonNullable as isNonNullable3 } from "@dxos/util";
+import { safeParseJson } from "@dxos/util";
+var ToolBlock = ({ blocks = [] }) => {
+  var _effect = _useSignals8();
+  try {
+    const { t } = useTranslation4(meta.id);
+    const getToolCaption = (tool, status) => {
+      if (!tool) {
+        return t("calling tool label");
+      }
+      return status?.message ?? tool.description ?? [
+        t("calling label"),
+        tool.name
+      ].join(" ");
+    };
+    const items = useMemo9(() => {
+      let lastToolCall;
+      const tools = [];
+      return blocks.filter((block) => block._tag === "toolCall" || block._tag === "toolResult" || block._tag === "summary").map((block) => {
+        switch (block._tag) {
+          case "toolCall": {
+            if (block.pending && lastToolCall?.block.toolCallId === block.toolCallId) {
+              return null;
+            }
+            const tool = tools.find((tool2) => tool2.name === block.name);
+            lastToolCall = {
+              tool,
+              block
+            };
+            return {
+              title: getToolCaption(lastToolCall?.tool),
+              content: {
+                ...block,
+                input: safeParseJson(block.input)
+              }
+            };
+          }
+          case "toolResult": {
+            if (block.error) {
+              return {
+                title: t("error label"),
+                content: block
+              };
+            }
+            const title = getToolCaption(lastToolCall?.tool ?? t("tool result label"));
+            lastToolCall = void 0;
+            return {
+              title,
+              content: {
+                ...block,
+                result: safeParseJson(block.result)
+              }
+            };
+          }
+          case "summary": {
+            if (!lastToolCall) {
+              return null;
+            }
+            return {
+              title: t("summary label"),
+              content: block
+            };
+          }
+        }
+      }).filter(isNonNullable3);
+    }, [
+      blocks
+    ]);
+    if (!items.length) {
+      return null;
+    }
+    return /* @__PURE__ */ React6.createElement(ToolContainer, {
+      items
+    });
+  } finally {
+    _effect.f();
+  }
+};
+ToolBlock.displayName = "ToolBlock";
+var ToolContainer = ({ items }) => {
+  var _effect = _useSignals8();
+  try {
+    const tabsRef = useRef2(null);
+    const [selected, setSelected] = useState8(0);
+    const [open, setOpen] = useState8(false);
+    useEffect4(() => {
+      if (open) {
+        tabsRef.current?.focus();
+      }
+    }, [
+      open
+    ]);
+    const handleSelect = (index) => {
+      setSelected(index);
+    };
+    const data = items[selected]?.content;
+    return /* @__PURE__ */ React6.createElement(ToggleContainer.Root, {
+      classNames: chatMessagePanel,
+      open,
+      onChangeOpen: setOpen
+    }, /* @__PURE__ */ React6.createElement(ToggleContainer.Header, {
+      classNames: chatMessagePanelHeader
+    }, /* @__PURE__ */ React6.createElement(TextCrawl, {
+      key: "status-roll",
+      lines: items.map((item) => item.title)
+    })), /* @__PURE__ */ React6.createElement(ToggleContainer.Content, {
+      classNames: [
+        "grid grid-cols-[32px_1fr]",
+        chatMessagePanelContent
+      ]
+    }, /* @__PURE__ */ React6.createElement(NumericTabs, {
+      ref: tabsRef,
+      classNames: "p-1",
+      length: items.length,
+      selected,
+      onSelect: handleSelect
+    }), /* @__PURE__ */ React6.createElement(Json, {
+      data,
+      classNames: chatMessageJson,
+      replacer: {
+        maxDepth: 3,
+        maxArrayLen: 10,
+        maxStringLen: 128
+      }
+    })));
+  } finally {
+    _effect.f();
+  }
+};
+
+// src/components/ChatThread/registry.tsx
+var __dxlog_file4 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/components/ChatThread/registry.tsx";
+var Fallback = ({ _tag, ...props }) => {
+  var _effect = _useSignals9();
+  try {
+    return /* @__PURE__ */ React7.createElement(ToggleContainer2.Root, {
+      classNames: "rounded-sm"
+    }, /* @__PURE__ */ React7.createElement(ToggleContainer2.Header, {
+      classNames: "bg-groupSurface"
+    }, _tag), /* @__PURE__ */ React7.createElement(ToggleContainer2.Content, {
+      classNames: "bg-modalSurface"
+    }, /* @__PURE__ */ React7.createElement(Json2, {
+      classNames: "!p-2 text-sm",
+      data: props
+    })));
+  } finally {
+    _effect.f();
+  }
+};
+var getTextChild = (children) => {
+  const child = children?.[0];
+  return typeof child === "string" ? child : null;
+};
+var componentRegistry = {
+  //
+  // Widgets
+  //
+  ["prompt"]: {
+    block: true,
+    factory: (props) => {
+      const text = getTextChild(props.children);
+      return text ? new PromptWidget(text) : null;
+    }
+  },
+  ["reference"]: {
+    block: false,
+    factory: (props) => {
+      const text = getTextChild(props.children);
+      return text && props.ref ? new ReferenceWidget(text, props.ref) : null;
+    }
+  },
+  ["select"]: {
+    block: true,
+    factory: (props) => {
+      const options = props.children?.map((option) => option._tag === "option" && getTextChild(option.children)).filter(Boolean);
+      return options?.length ? new SelectWidget(options) : null;
+    }
+  },
+  ["suggestion"]: {
+    block: true,
+    factory: (props) => {
+      const text = getTextChild(props.children);
+      return text ? new SuggestionWidget(text) : null;
+    }
+  },
+  ["summary"]: {
+    block: true,
+    factory: (props) => {
+      const text = getTextChild(props.children);
+      return text ? new SummaryWidget(text) : null;
+    }
+  },
+  //
+  // React
+  //
+  ["toolCall"]: {
+    block: true,
+    Component: ToolBlock
+  },
+  ["toolResult"]: {
+    block: true,
+    Component: Fallback
+  },
+  ["toolkit"]: {
+    block: true,
+    Component: Fallback
+  },
+  //
+  // Fallback
+  //
+  ["json"]: {
+    block: true,
+    Component: Fallback
+  }
+};
+var blockToMarkdown = (context, message, block) => {
+  let str = _blockToMarkdown(context, message, block);
+  if (str && !block.pending) {
+    return str += "\n";
+  }
+  return str;
+};
+var _blockToMarkdown = (context, message, block) => {
+  log4("blockToMarkdown", {
+    block: JSON.stringify(block)
+  }, {
+    F: __dxlog_file4,
+    L: 130,
+    S: void 0,
+    C: (f, a) => f(...a)
+  });
+  switch (block._tag) {
+    case "text": {
+      if (message.sender.role === "user") {
+        return `
+<prompt>${block.text}</prompt>
+`;
+      } else {
+        const text = block.text.trim();
+        if (text.length > 0) {
+          return text;
+        }
+      }
+      break;
+    }
+    case "suggestion": {
+      if (block.pending) {
+        return;
+      }
+      return `<suggestion>${block.text}</suggestion>`;
+    }
+    case "select": {
+      if (block.pending || block.options.length === 0) {
+        return;
+      }
+      return `<select>${block.options.map((option) => `<option>${option}</option>`).join("")}</select>`;
+    }
+    // TODO(burdon): Need label.
+    case "reference": {
+      return `<reference ref="${block.reference.dxn.toString()}">Ref</reference>`;
+    }
+    // case 'toolkit': {
+    //   return `<toolkit />`;
+    // }
+    case "toolCall": {
+      context.updateWidget(block.toolCallId, {
+        blocks: [
+          block
+        ]
+      });
+      return `<toolCall id="${block.toolCallId}" />`;
+    }
+    case "toolResult": {
+      context.updateWidget(block.toolCallId, ({ blocks = [] }) => ({
+        blocks: [
+          ...blocks,
+          block
+        ]
+      }));
+      break;
+    }
+    case "summary": {
+      return `<summary>${ContentBlock2.createSummaryMessage(block)}</summary>`;
+    }
+    // TODO(burdon): Need stable ID.
+    default: {
+      return `<json id="${message.id}">
+${JSON.stringify(block)}
+</json>`;
+    }
+  }
+};
+
+// src/components/ChatThread/sync.ts
+import { log as log5 } from "@dxos/log";
+function _define_property3(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+var __dxlog_file5 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/components/ChatThread/sync.ts";
+var MessageThreadContext = class {
+  updateWidget(id, value) {
+    this._widgetState?.updateWidget(id, value);
+  }
+  constructor(_widgetState) {
+    _define_property3(this, "_widgetState", void 0);
+    this._widgetState = _widgetState;
+  }
+};
+var MessageSyncer = class {
+  get context() {
+    return this._context;
+  }
+  reset() {
+    log5("reset", void 0, {
+      F: __dxlog_file5,
+      L: 58,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    this._initialMessageId = void 0;
+    this._currentMessageIndex = 0;
+    this._currentBlockIndex = 0;
+    this._currentBlockContent = void 0;
+    void this._model.reset("");
+  }
+  sync(messages) {
+    log5("sync", {
+      messages: messages.map((m) => m.blocks.length),
+      currentMessageIndex: this._currentMessageIndex,
+      currentBlockIndex: this._currentBlockIndex,
+      currentBlockContent: this._currentBlockContent
+    }, {
+      F: __dxlog_file5,
+      L: 67,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    if (this._initialMessageId !== messages[0]?.id) {
+      this.reset();
+      this._initialMessageId = messages[0]?.id;
+    }
+    let i = this._currentMessageIndex;
+    for (const message of messages.slice(this._currentMessageIndex)) {
+      if (i > this._currentMessageIndex) {
+        this._currentBlockIndex = 0;
+      }
+      this._currentMessageIndex = i;
+      let j = this._currentBlockIndex;
+      for (const block of message.blocks.slice(this._currentBlockIndex)) {
+        this._currentBlockIndex = j;
+        const currentBlockContent = this._blockRenderer(this._context, message, block);
+        if (currentBlockContent) {
+          let content = "";
+          if (this._currentBlockContent && currentBlockContent.startsWith(this._currentBlockContent)) {
+            content = currentBlockContent.slice(this._currentBlockContent.length);
+          } else {
+            content = currentBlockContent;
+          }
+          void this._model.append(content);
+          this._currentBlockContent = currentBlockContent;
+          log5("append", {
+            message: i,
+            block: j,
+            content
+          }, {
+            F: __dxlog_file5,
+            L: 99,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+        }
+        if (block.pending) {
+          return;
+        } else {
+          this._currentBlockContent = void 0;
+          this._currentBlockIndex++;
+        }
+        j++;
+      }
+      i++;
+    }
+  }
+  constructor(_model, _blockRenderer) {
+    _define_property3(this, "_model", void 0);
+    _define_property3(this, "_blockRenderer", void 0);
+    _define_property3(this, "_initialMessageId", void 0);
+    _define_property3(this, "_currentMessageIndex", void 0);
+    _define_property3(this, "_currentBlockIndex", void 0);
+    _define_property3(this, "_currentBlockContent", void 0);
+    _define_property3(this, "_context", void 0);
+    this._model = _model;
+    this._blockRenderer = _blockRenderer;
+    this._currentMessageIndex = 0;
+    this._currentBlockIndex = 0;
+    this._context = new MessageThreadContext(this._model);
+  }
+};
+
+// src/components/ChatThread/ChatThread.tsx
+var ChatThread = /* @__PURE__ */ forwardRef(({ classNames, identity, messages = [], error, cursor = false, fadeIn = true, onEvent }, forwardedRef) => {
+  var _effect = _useSignals10();
+  try {
+    const userHue = useMemo10(() => {
+      return identity?.profile?.data?.hue || keyToFallback(identity?.identityKey ?? PublicKey.random()).hue;
+    }, [
+      identity
+    ]);
+    const [controller, setController] = useState9(null);
+    useImperativeHandle(forwardedRef, () => controller ? controller : null, [
+      controller
+    ]);
+    useEffect5(() => {
+      controller?.scrollToBottom();
+    }, [
+      controller,
+      error
+    ]);
+    const syncer = useMemo10(() => controller && new MessageSyncer(controller, blockToMarkdown), [
+      controller
+    ]);
+    useEffect5(() => {
+      syncer?.sync(messages);
+    }, [
+      syncer,
+      messages
+    ]);
+    const handleEvent = useCallback6((ev) => {
+      switch (ev.type) {
+        case "submit": {
+          ev.value && onEvent?.({
+            type: "submit",
+            text: ev.value
+          });
+          break;
+        }
+      }
+    }, [
+      onEvent
+    ]);
+    return /* @__PURE__ */ React8.createElement("div", {
+      className: mx4("flex bs-full is-full justify-center overflow-hidden", classNames),
+      style: {
+        "--user-fill": `var(--dx-${userHue}Fill)`
+      }
+    }, /* @__PURE__ */ React8.createElement(MarkdownStream, {
+      ref: setController,
+      classNames: "bs-full max-is-prose overflow-hidden",
+      registry: componentRegistry,
+      cursor,
+      fadeIn,
+      onEvent: handleEvent
+    }));
+  } finally {
+    _effect.f();
+  }
+});
+
+// src/components/Chat/Chat.tsx
+var [ChatContextProvider, useChatContext] = createContext("Chat");
+var ChatRoot = ({ classNames, children, chat, processor, onEvent, ...props }) => {
+  var _effect = _useSignals11();
+  try {
+    const [debug, setDebug] = useState10(false);
+    const space = getSpace(chat);
+    const queue = useQueue2(chat?.queue.dxn);
+    const pending = useRxValue(processor.messages);
+    const streaming = useRxValue(processor.streaming);
+    const lastPrompt = useRef3(void 0);
+    const messages = useMemo11(() => {
+      const queueMessages = queue?.objects?.filter(Obj8.instanceOf(DataType3.Message)) ?? [];
+      return Array2.dedupeWith([
+        ...queueMessages,
+        ...pending
+      ], (a, b) => a.id === b.id);
+    }, [
+      queue?.objects,
+      pending
+    ]);
+    const event = useMemo11(() => new Event(), []);
+    useEffect6(() => {
+      return event.on((ev) => {
+        switch (ev.type) {
+          case "toggle-debug": {
+            setDebug((current) => !current);
+            break;
+          }
+          case "submit": {
+            const text = ev.text.trim();
+            if (!streaming && text.length) {
+              lastPrompt.current = ev.text;
+              void processor.request({
+                message: text
+              });
+            }
+            break;
+          }
+          case "retry": {
+            if (!streaming) {
+              void processor.retry();
+            }
+            break;
+          }
+          case "cancel": {
+            if (streaming) {
+              void processor.cancel();
+              if (lastPrompt.current) {
+                event.emit({
+                  type: "update-prompt",
+                  text: lastPrompt.current
+                });
+              }
+            }
+            break;
+          }
+          default: {
+            onEvent?.(ev);
+          }
+        }
+      });
+    }, [
+      event,
+      processor,
+      streaming,
+      onEvent
+    ]);
+    if (!space) {
+      return null;
+    }
+    return /* @__PURE__ */ React9.createElement(ChatContextProvider, {
+      debug,
+      event,
+      chat,
+      space,
+      messages,
+      processor,
+      ...props
+    }, /* @__PURE__ */ React9.createElement("div", {
+      role: "none",
+      className: mx5("flex flex-col h-full overflow-hidden", classNames)
+    }, children));
+  } finally {
+    _effect.f();
+  }
+};
+ChatRoot.displayName = "Chat.Root";
+var ChatPrompt = ({ classNames, outline, placeholder, expandable, online, presets, preset, onPresetChange, onOnlineChange }) => {
+  var _effect = _useSignals11();
+  try {
+    const { t } = useTranslation5(meta.id);
+    const { space, event, processor } = useChatContext(ChatPrompt.displayName);
+    const error = useRxValue(processor.error).pipe(Option3.getOrUndefined);
+    const streaming = useRxValue(processor.streaming);
+    const active = useRxValue(processor.active);
+    const activeRef = useDynamicRef(active);
+    const editorRef = useRef3(null);
+    const [recordingState, setRecordingState] = useState10(false);
+    useEffect6(() => {
+      return event.on((event2) => {
+        switch (event2.type) {
+          case "update-prompt":
+            if (!editorRef.current?.getText()?.length) {
+              editorRef.current?.setText(event2.text);
+              editorRef.current?.focus();
+            }
+            break;
+          case "record-start":
+            setRecordingState(true);
+            break;
+          case "record-stop":
+            setRecordingState(false);
+            break;
+        }
+      });
+    }, [
+      event
+    ]);
+    const { recording } = useVoiceInput({
+      active: recordingState,
+      onUpdate: (text) => {
+        editorRef.current?.setText(text);
+        editorRef.current?.focus();
+      }
+    });
+    const referencesProvider = useReferencesProvider(space);
+    const extensions = useMemo11(() => {
+      return [
+        referencesProvider && references({
+          provider: referencesProvider
+        }),
+        Prec.highest(keymap.of([
+          {
+            key: "cmd-d",
+            preventDefault: true,
+            run: () => {
+              event.emit({
+                type: "toggle-debug"
+              });
+              return true;
+            }
+          },
+          expandable && {
+            key: "cmd-ArrowUp",
+            preventDefault: true,
+            run: () => {
+              event.emit({
+                type: "thread-open"
+              });
+              return true;
+            }
+          },
+          expandable && {
+            key: "cmd-ArrowDown",
+            preventDefault: true,
+            run: () => {
+              event.emit({
+                type: "thread-close"
+              });
+              return true;
+            }
+          }
+        ].filter(isNotFalsy2)))
+      ].filter(isNotFalsy2);
+    }, [
+      event,
+      expandable,
+      referencesProvider
+    ]);
+    const handleSubmit = useCallback7((text) => {
+      if (!activeRef.current) {
+        event.emit({
+          type: "submit",
+          text
+        });
+        return true;
+      }
+    }, [
+      event
+    ]);
+    const handleEvent = useCallback7((ev) => {
+      event.emit(ev);
+    }, [
+      event
+    ]);
+    return /* @__PURE__ */ React9.createElement("div", {
+      className: mx5("is-full flex flex-col density-fine", outline && [
+        "p-2 bg-groupSurface border border-subduedSeparator transition transition-border [&:has(.cm-content:focus)]:border-separator rounded"
+      ], classNames)
+    }, /* @__PURE__ */ React9.createElement("div", {
+      className: "flex gap-2"
+    }, /* @__PURE__ */ React9.createElement(ChatStatusIndicator, {
+      classNames: "p-1",
+      preset,
+      error,
+      processing: streaming
+    }), /* @__PURE__ */ React9.createElement(ChatEditor, {
+      ref: editorRef,
+      autoFocus: true,
+      lineWrapping: true,
+      classNames: "col-span-2 pbs-0.5",
+      placeholder: placeholder ?? t("prompt placeholder"),
+      extensions,
+      onSubmit: handleSubmit
+    })), /* @__PURE__ */ React9.createElement("div", {
+      className: "flex pbs-2 items-center"
+    }, /* @__PURE__ */ React9.createElement(ChatOptions, {
+      space,
+      blueprintRegistry: processor.blueprintRegistry,
+      context: processor.context,
+      preset,
+      presets,
+      onPresetChange
+    }), /* @__PURE__ */ React9.createElement("div", {
+      role: "none",
+      className: "pli-cardSpacingChrome grow"
+    }, /* @__PURE__ */ React9.createElement(ChatReferences, {
+      space,
+      context: processor.context
+    })), /* @__PURE__ */ React9.createElement(ChatActions, {
+      classNames: "col-span-2",
+      microphone: true,
+      recording,
+      processing: streaming,
+      onEvent: handleEvent
+    }, online !== void 0 && /* @__PURE__ */ React9.createElement(Input.Root, null, /* @__PURE__ */ React9.createElement(Input.Switch, {
+      classNames: "mis-2 mie-2",
+      checked: online,
+      onCheckedChange: onOnlineChange
+    })))));
+  } finally {
+    _effect.f();
+  }
+};
+ChatPrompt.displayName = "Chat.Prompt";
+var ChatThread2 = (props) => {
+  var _effect = _useSignals11();
+  try {
+    const { event, messages, processor } = useChatContext(ChatThread2.displayName);
+    const identity = useIdentity();
+    const error = useRxValue(processor.error).pipe(Option3.getOrUndefined);
+    const scrollerRef = useRef3(null);
+    useEffect6(() => {
+      return event.on((event2) => {
+        switch (event2.type) {
+          case "submit":
+          case "scroll-to-bottom":
+            scrollerRef.current?.scrollToBottom();
+            break;
+        }
+      });
+    }, [
+      event
+    ]);
+    const handleEvent = useCallback7((ev) => {
+      event.emit(ev);
+    }, [
+      event
+    ]);
+    if (!identity) {
+      return null;
+    }
+    return /* @__PURE__ */ React9.createElement(ChatThread, {
+      ...props,
+      ref: scrollerRef,
+      identity,
+      messages,
+      error,
+      onEvent: handleEvent
+    });
+  } finally {
+    _effect.f();
+  }
+};
+ChatThread2.displayName = "Chat.Thread";
+var Chat = {
+  Root: ChatRoot,
+  Prompt: ChatPrompt,
+  Thread: ChatThread2
+};
+
+export {
+  useBlueprintRegistry,
+  useChatProcessor,
+  useChatServices,
+  useContextBinder,
+  useExecutionGraph,
+  useOnline,
+  usePresets,
+  ChatContextProvider,
+  useChatContext,
+  Chat,
+  AiService2 as AiService,
+  AppGraphBuilder,
+  AssistantState,
+  BlueprintDefinition,
+  EdgeModelResolver,
+  IntentResolver,
+  LocalModelResolver,
+  ReactSurface,
+  Settings,
+  Toolkit,
+  ComputeRuntime
+};
+//# sourceMappingURL=chunk-PL4O4ZJU.mjs.map