@dxos/plugin-assistant 0.8.3 → 0.8.4-main.c1de068

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

@@ -0,0 +1,2246 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  ServiceType
+} from "./chunk-BISJDTBK.mjs";
+import {
+  __export,
+  __reExport,
+  meta
+} from "./chunk-QN2H2EHV.mjs";
+
+// src/hooks/useChatProcessor.ts
+import { useEffect as useEffect2, useMemo as useMemo3, useState as useState2 } from "react";
+import { Capabilities as Capabilities3, useCapabilities as useCapabilities3, useIntentDispatcher } from "@dxos/app-framework";
+import { Conversation, createSystemPrompt } from "@dxos/assistant";
+import { FunctionType } from "@dxos/functions";
+import { log as log5 } from "@dxos/log";
+import { useConfig } from "@dxos/react-client";
+import { Filter as Filter3, fullyQualifiedId, useQuery } from "@dxos/react-client/echo";
+import { isNonNullable as isNonNullable2 } from "@dxos/util";
+
+// src/hooks/index.ts
+var hooks_exports = {};
+__export(hooks_exports, {
+  AiServiceOverloadedError: () => AiServiceOverloadedError,
+  AiServicePresets: () => AiServicePresets,
+  ChatProcessor: () => ChatProcessor,
+  Stable: () => Stable,
+  useBlueprints: () => useBlueprints,
+  useChatProcessor: () => useChatProcessor,
+  useChatServices: () => useChatServices,
+  useReferencesProvider: () => useReferencesProvider
+});
+
+// src/hooks/chat-processor.ts
+import { batch, computed, signal } from "@preact/signals-core";
+import { Effect } from "effect";
+import { AiService, DEFAULT_EDGE_MODEL } from "@dxos/ai";
+import { ArtifactDiffResolver } from "@dxos/assistant";
+import { Context } from "@dxos/context";
+import { Obj } from "@dxos/echo";
+import { runAndForwardErrors } from "@dxos/effect";
+import { log } from "@dxos/log";
+import { Filter, getVersion } from "@dxos/react-client/echo";
+import { DataType } from "@dxos/schema";
+function _ts_add_disposable_resource(env, value, async) {
+  if (value !== null && value !== void 0) {
+    if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+    var dispose, inner;
+    if (async) {
+      if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+      dispose = value[Symbol.asyncDispose];
+    }
+    if (dispose === void 0) {
+      if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+      dispose = value[Symbol.dispose];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    env.stack.push({
+      value,
+      dispose,
+      async
+    });
+  } else if (async) {
+    env.stack.push({
+      async: true
+    });
+  }
+  return value;
+}
+function _ts_dispose_resources(env) {
+  var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+  };
+  return (_ts_dispose_resources = function _ts_dispose_resources2(env2) {
+    function fail(e) {
+      env2.error = env2.hasError ? new _SuppressedError(e, env2.error, "An error was suppressed during disposal.") : e;
+      env2.hasError = true;
+    }
+    var r, s = 0;
+    function next() {
+      while (r = env2.stack.pop()) {
+        try {
+          if (!r.async && s === 1) return s = 0, env2.stack.push(r), Promise.resolve().then(next);
+          if (r.dispose) {
+            var result = r.dispose.call(r.value);
+            if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
+              fail(e);
+              return next();
+            });
+          } else s |= 1;
+        } catch (e) {
+          fail(e);
+        }
+      }
+      if (s === 1) return env2.hasError ? Promise.reject(env2.error) : Promise.resolve();
+      if (env2.hasError) throw env2.error;
+    }
+    return next();
+  })(env);
+}
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/hooks/chat-processor.ts";
+var defaultOptions = {
+  model: DEFAULT_EDGE_MODEL,
+  systemPrompt: "you are a helpful assistant"
+};
+var ChatProcessor = class {
+  constructor(_services, _conversation, _options = defaultOptions) {
+    this._services = _services;
+    this._conversation = _conversation;
+    this._options = _options;
+    this._pending = signal([]);
+    this._streaming = signal(void 0);
+    this.streaming = computed(() => this._streaming.value !== void 0);
+    this.error = signal(void 0);
+    this.messages = computed(() => {
+      const messages = [
+        ...this._pending.value
+      ];
+      if (this._streaming.value) {
+        messages.push(Obj.make(DataType.Message, this._streaming.value));
+      }
+      return messages;
+    });
+    this._session = void 0;
+    this._artifactDiffResolver = {
+      resolve: async (artifacts) => {
+        const space = this._options.extensions?.space;
+        if (!space) {
+          return /* @__PURE__ */ new Map();
+        }
+        const versions = /* @__PURE__ */ new Map();
+        await Promise.all(artifacts.map(async (artifact) => {
+          const { objects: [object] } = await space.db.query(Filter.ids(artifact.id)).run();
+          if (!object) {
+            return;
+          }
+          versions.set(artifact.id, {
+            version: getVersion(object),
+            diff: `Current state: ${JSON.stringify(object)}`
+          });
+        }));
+        return versions;
+      }
+    };
+    this._tools = [
+      ..._options.tools ?? []
+    ];
+  }
+  get conversation() {
+    return this._conversation;
+  }
+  get context() {
+    return this._conversation.context;
+  }
+  get blueprintRegistry() {
+    return this._options.blueprintRegistry;
+  }
+  get tools() {
+    return this._tools;
+  }
+  /**
+  * @deprecated Replace with blueprints
+  */
+  setTools(tools) {
+    this._tools = tools;
+  }
+  /**
+  * Make GPT request.
+  */
+  async request(message, options = {}) {
+    const env = {
+      stack: [],
+      error: void 0,
+      hasError: false
+    };
+    try {
+      const ctx = _ts_add_disposable_resource(env, Context.default(void 0, {
+        F: __dxlog_file,
+        L: 138
+      }), true);
+      this._conversation.onBegin.on(ctx, (session) => {
+        log.info("onBegin", {
+          session,
+          isDisposed: ctx.disposed
+        }, {
+          F: __dxlog_file,
+          L: 141,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        this._session = session;
+        ctx.onDispose(() => {
+          log.info("onDispose", {
+            session,
+            isDisposed: ctx.disposed
+          }, {
+            F: __dxlog_file,
+            L: 145,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          if (this._session === session) {
+            this._session = void 0;
+          }
+        });
+        session.userMessage.on((message2) => {
+          log.info("userMessage", {
+            message: message2
+          }, {
+            F: __dxlog_file,
+            L: 153,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          this._pending.value = [
+            ...this._pending.value,
+            message2
+          ];
+        });
+        session.message.on((message2) => {
+          batch(() => {
+            this._pending.value = [
+              ...this._pending.value,
+              message2
+            ];
+            this._streaming.value = void 0;
+          });
+        });
+        session.update.on((block) => {
+          batch(() => {
+            if (!this._streaming.value) {
+              this._streaming.value = Obj.make(DataType.Message, {
+                created: (/* @__PURE__ */ new Date()).toISOString(),
+                sender: {
+                  role: "assistant"
+                },
+                blocks: [
+                  block
+                ]
+              });
+            } else if (this._streaming.value.blocks.at(-1)?.pending === true) {
+              this._streaming.value.blocks[this._streaming.value.blocks.length - 1] = block;
+            } else {
+              this._streaming.value.blocks.push(block);
+            }
+          });
+        });
+        session.block.on((block) => {
+          if (!this._streaming.value) {
+            this._streaming.value = Obj.make(DataType.Message, {
+              created: (/* @__PURE__ */ new Date()).toISOString(),
+              sender: {
+                role: "assistant"
+              },
+              blocks: [
+                block
+              ]
+            });
+          } else if (this._streaming.value.blocks.at(-1)?.pending === true) {
+            this._streaming.value.blocks[this._streaming.value.blocks.length - 1] = block;
+          } else {
+            this._streaming.value.blocks.push(block);
+          }
+        });
+      });
+      try {
+        const messages = await runAndForwardErrors(this._conversation.run({
+          prompt: message,
+          // TODO(burdon): Construct from blueprints?
+          systemPrompt: this._options.systemPrompt
+        }).pipe(
+          //
+          Effect.provide(AiService.model(this._options.model ?? DEFAULT_EDGE_MODEL)),
+          // TODO(dmaretskyi): Move ArtifactDiffResolver upstream.
+          Effect.provideService(ArtifactDiffResolver, this._artifactDiffResolver),
+          Effect.provide(this._services),
+          Effect.tapErrorCause((cause) => {
+            log.error("error", {
+              cause
+            }, {
+              F: __dxlog_file,
+              L: 243,
+              S: this,
+              C: (f, a) => f(...a)
+            });
+            return Effect.void;
+          })
+        ));
+        log("completed", {
+          messages
+        }, {
+          F: __dxlog_file,
+          L: 249,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+      } catch (err) {
+        log.catch(err, void 0, {
+          F: __dxlog_file,
+          L: 251,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        if (err instanceof Error && err.message.includes("Overloaded")) {
+          this.error.value = new AiServiceOverloadedError("AI service overloaded", {
+            cause: err
+          });
+        } else {
+          this.error.value = new Error("AI service error", {
+            cause: err
+          });
+        }
+      }
+      return this._reset();
+    } catch (e) {
+      env.error = e;
+      env.hasError = true;
+    } finally {
+      const result = _ts_dispose_resources(env);
+      if (result) await result;
+    }
+  }
+  /**
+  * Cancel pending requests.
+  * @returns Pending requests (incl. the request message).
+  */
+  async cancel() {
+    log.info("cancelling...", void 0, {
+      F: __dxlog_file,
+      L: 267,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    this._session?.abort();
+    return this._reset();
+  }
+  async _reset() {
+    const messages = this._pending.value;
+    batch(() => {
+      this._pending.value = [];
+      this._streaming.value = void 0;
+    });
+    return messages;
+  }
+};
+var AiServiceOverloadedError = class extends Error {
+  constructor() {
+    super(...arguments);
+    this.code = "AI_SERVICE_OVERLOADED";
+  }
+};
+
+// src/hooks/presets.ts
+import { Schema } from "effect";
+var ModelProviders = [
+  "dxos-local",
+  "dxos-remote",
+  "lm-studio"
+];
+var ModelProvider = Schema.Literal(...ModelProviders);
+var createModelLabel = (model) => {
+  const parts = model.split("/");
+  return parts[parts.length - 1];
+};
+var AiServicePresets = [
+  {
+    provider: "dxos-remote",
+    model: "@anthropic/claude-3-5-haiku-20241022"
+  },
+  {
+    provider: "dxos-remote",
+    model: "@anthropic/claude-opus-4-0"
+  },
+  {
+    provider: "lm-studio",
+    model: "@google/gemma-3-12b"
+  },
+  {
+    provider: "lm-studio",
+    model: "@mlx-community/llama-3.2-3b-instruct"
+  }
+].map(({ model, provider }, i) => ({
+  id: `preset-${i}`,
+  provider,
+  model,
+  label: createModelLabel(model)
+}));
+
+// src/hooks/useBlueprints.ts
+import { useSignals as _useSignals } from "@preact-signals/safe-react/tracking";
+import { effect } from "@preact/signals-react";
+import { useCallback, useEffect, useState } from "react";
+import { Blueprint } from "@dxos/blueprints";
+import { Obj as Obj2, Ref } from "@dxos/echo";
+import { log as log2 } from "@dxos/log";
+import { isNonNullable } from "@dxos/util";
+var __dxlog_file2 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/hooks/useBlueprints.ts";
+var useBlueprints = (space, context, blueprintRegistry) => {
+  var _effect = _useSignals();
+  try {
+    const [blueprints, setBlueprints] = useState([]);
+    useEffect(() => {
+      let t;
+      effect(() => {
+        const refs = [
+          ...context.blueprints.value ?? []
+        ];
+        t = setTimeout(async () => {
+          const blueprints2 = (await Ref.Array.loadAll(refs)).filter(isNonNullable);
+          setBlueprints(blueprints2);
+        });
+      });
+      return () => clearTimeout(t);
+    }, [
+      context
+    ]);
+    const handleUpdate = useCallback((key, active) => {
+      log2.info("update", {
+        key,
+        active
+      }, {
+        F: __dxlog_file2,
+        L: 41,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+      if (active) {
+        const blueprint = blueprintRegistry?.getByKey(key);
+        if (blueprint) {
+          const { id: _id, ...data } = blueprint;
+          const obj = space.db.add(Obj2.make(Blueprint.Blueprint, data));
+          void context.bind({
+            blueprints: [
+              Ref.make(obj)
+            ]
+          });
+        }
+      }
+    }, [
+      space,
+      context
+    ]);
+    return [
+      blueprints,
+      handleUpdate
+    ];
+  } finally {
+    _effect.f();
+  }
+};
+
+// src/hooks/useChatServices.ts
+var useChatServices_exports = {};
+__export(useChatServices_exports, {
+  useChatServices: () => useChatServices
+});
+__reExport(useChatServices_exports, assistant_star);
+import { Layer } from "effect";
+import { useMemo } from "react";
+import { useDeepCompareMemoize } from "use-deep-compare-effect";
+import { ToolRegistry } from "@dxos/ai";
+import { AiServiceTestingPreset } from "@dxos/ai/testing";
+import { Capabilities, useCapabilities } from "@dxos/app-framework";
+import { makeToolExecutionServiceFromFunctions, makeToolResolverFromFunctions } from "@dxos/assistant";
+import { ConfiguredCredentialsService, CredentialsService, DatabaseService, EventLogger, FunctionCallService, QueueService, TracingService } from "@dxos/functions";
+import * as assistant_star from "@dxos/assistant";
+var useChatServices = ({ space }) => {
+  const toolRegistry = useToolRegistry();
+  const toolResolver = useToolResolver();
+  const toolExecutionService = useToolExecutionService();
+  return useMemo(() => {
+    return Layer.mergeAll(AiServiceTestingPreset("edge-remote").pipe(Layer.orDie), Layer.succeed(CredentialsService, new ConfiguredCredentialsService()), space ? Layer.succeed(DatabaseService, DatabaseService.make(space.db)) : DatabaseService.notAvailable, space ? Layer.succeed(QueueService, QueueService.make(space.queues)) : QueueService.notAvailable, Layer.succeed(FunctionCallService, FunctionCallService.mock()), Layer.succeed(TracingService, TracingService.noop), Layer.succeed(EventLogger, EventLogger.noop), toolResolver, toolExecutionService);
+  }, [
+    space,
+    toolRegistry,
+    toolResolver
+  ]);
+};
+var useToolResolver = () => {
+  const functions = useCapabilities(Capabilities.Functions).flat();
+  return useMemo(() => makeToolResolverFromFunctions(functions), [
+    useDeepCompareMemoize(functions.map((f) => f.name))
+  ]);
+};
+var useToolExecutionService = () => {
+  const functions = useCapabilities(Capabilities.Functions).flat();
+  return useMemo(() => makeToolExecutionServiceFromFunctions(functions), [
+    useDeepCompareMemoize(functions.map((f) => f.name))
+  ]);
+};
+var useToolRegistry = () => {
+  const tools = useCapabilities(Capabilities.Tools).flat();
+  return useMemo(() => {
+    const toolRegistry = new ToolRegistry([]);
+    for (const tool of tools) {
+      if (!toolRegistry.has(tool)) {
+        toolRegistry.register(tool);
+      }
+    }
+    return toolRegistry;
+  }, [
+    useDeepCompareMemoize(tools)
+  ]);
+};
+
+// src/hooks/index.ts
+__reExport(hooks_exports, useChatServices_exports);
+
+// src/hooks/useReferencesProvider.ts
+import { useMemo as useMemo2 } from "react";
+import { Capabilities as Capabilities2, useCapabilities as useCapabilities2 } from "@dxos/app-framework";
+import { Filter as Filter2, Obj as Obj3 } from "@dxos/echo";
+var useReferencesProvider = (space) => {
+  const artifactDefinitions = useCapabilities2(Capabilities2.ArtifactDefinition);
+  return useMemo2(() => {
+    if (!space) {
+      return void 0;
+    }
+    return {
+      getReferences: async ({ query }) => {
+        const schemas = artifactDefinitions.map((artifact) => artifact.schema);
+        const { objects } = await space.db.query(Filter2.or(...schemas.map((schema) => Filter2.type(schema)))).run();
+        return objects.filter((object) => stringMatch(query, Obj3.getLabel(object) ?? "")).filter((object) => !!Obj3.getDXN(object)).map((object) => ({
+          uri: Obj3.getDXN(object).toString(),
+          label: Obj3.getLabel(object) ?? ""
+        }));
+      },
+      resolveReference: async ({ uri }) => {
+        const object = await space.db.query(Filter2.ids(uri)).first();
+        return {
+          uri,
+          label: Obj3.getLabel(object) ?? ""
+        };
+      }
+    };
+  }, [
+    space,
+    artifactDefinitions
+  ]);
+};
+var stringMatch = (query, label) => label.toLowerCase().startsWith(query.toLowerCase());
+
+// src/tools/function.ts
+import { createTool, ToolResult } from "@dxos/ai";
+import { Type } from "@dxos/echo";
+import { getInvocationUrl, getUserFunctionUrlInMetadata } from "@dxos/functions";
+import { log as log3 } from "@dxos/log";
+import { getMeta } from "@dxos/react-client/echo";
+var __dxlog_file3 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/tools/function.ts";
+var convertFunctionToTool = (fn, edgeUrl, spaceId) => {
+  if (!fn.description || !fn.inputSchema) {
+    return void 0;
+  }
+  const existingFunctionUrl = getUserFunctionUrlInMetadata(getMeta(fn));
+  if (!existingFunctionUrl) {
+    return void 0;
+  }
+  const url = getInvocationUrl(existingFunctionUrl, edgeUrl, {
+    spaceId
+  });
+  return createTool("user-function", {
+    name: fn.name,
+    description: fn.description,
+    schema: Type.toEffectSchema(fn.inputSchema),
+    execute: async (input) => {
+      log3.info("execute function tool", {
+        name: fn.name,
+        url,
+        input
+      }, {
+        F: __dxlog_file3,
+        L: 34,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(input)
+      });
+      return ToolResult.Success(await response.text());
+    }
+  });
+};
+
+// src/tools/openapi.ts
+import { Schema as Schema2 } from "effect";
+import jsonpointer from "jsonpointer";
+import { ToolResult as ToolResult2, createRawTool } from "@dxos/ai";
+import { Type as Type2 } from "@dxos/echo";
+import { normalizeSchema } from "@dxos/echo-schema";
+import { invariant } from "@dxos/invariant";
+import { log as log4 } from "@dxos/log";
+import { deepMapValues } from "@dxos/util";
+var __dxlog_file4 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/tools/openapi.ts";
+var createToolsFromService = async (service) => {
+  invariant(service.interfaces?.length === 1 && service.interfaces[0].kind === "api", void 0, {
+    F: __dxlog_file4,
+    L: 24,
+    S: void 0,
+    A: [
+      "service.interfaces?.length === 1 && service.interfaces[0].kind === 'api'",
+      ""
+    ]
+  });
+  const iface = service.interfaces[0];
+  invariant(iface.schemaUrl, void 0, {
+    F: __dxlog_file4,
+    L: 26,
+    S: void 0,
+    A: [
+      "iface.schemaUrl",
+      ""
+    ]
+  });
+  invariant(iface.schemaUrl, void 0, {
+    F: __dxlog_file4,
+    L: 27,
+    S: void 0,
+    A: [
+      "iface.schemaUrl",
+      ""
+    ]
+  });
+  return createToolsFromApi(iface.schemaUrl, {
+    authorization: iface.authorization
+  });
+};
+var createToolsFromApi = async (url, options) => {
+  const res = await fetch(url);
+  const spec = await res.json();
+  log4("spec", {
+    spec
+  }, {
+    F: __dxlog_file4,
+    L: 37,
+    S: void 0,
+    C: (f, a) => f(...a)
+  });
+  const tools = [];
+  for (const [path, pathItem] of Object.entries(spec.paths)) {
+    if (typeof pathItem !== "object") {
+      continue;
+    }
+    const { ...methods } = pathItem;
+    for (const [method, m] of Object.entries(methods)) {
+      const methodItem = m;
+      log4("methodItem", {
+        path,
+        method,
+        methodItem
+      }, {
+        F: __dxlog_file4,
+        L: 48,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+      const parametersResolved = methodItem.parameters?.map((parameter) => {
+        const resolved = resolveJsonSchema(parameter, spec);
+        return resolved;
+      }) ?? [];
+      const inputSchema = {
+        type: "object",
+        properties: {}
+      };
+      const endpointParameters = [];
+      for (const parameter of parametersResolved) {
+        log4("parameter", {
+          parameter
+        }, {
+          F: __dxlog_file4,
+          L: 63,
+          S: void 0,
+          C: (f, a) => f(...a)
+        });
+        if (options?.authorization?.type === "api-key" && options.authorization.placement.type === "query" && parameter.in === "query" && parameter.name === options.authorization.placement.name) {
+          continue;
+        }
+        endpointParameters.push(parameter);
+        if (parameter.schema) {
+          inputSchema.properties[parameter.name] = normalizeSchema(parameter.schema);
+        } else if (typeof parameter.type === "string") {
+          const { name, in: _in, required, ...schema } = parameter;
+          inputSchema.properties[name] = normalizeSchema(schema);
+          if (required) {
+            inputSchema.required ??= [];
+            inputSchema.required.push(name);
+          }
+        }
+      }
+      log4("inputSchema", {
+        inputSchema
+      }, {
+        F: __dxlog_file4,
+        L: 88,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+      Schema2.validateSync(Type2.JsonSchema)(inputSchema);
+      const description = methodItem.description ?? methodItem.summary;
+      if (!description) {
+        log4.warn("no description", {
+          path,
+          method
+        }, {
+          F: __dxlog_file4,
+          L: 93,
+          S: void 0,
+          C: (f, a) => f(...a)
+        });
+        continue;
+      }
+      const endpoint = {
+        document: spec,
+        path,
+        method,
+        parameters: endpointParameters,
+        authorization: options?.authorization
+      };
+      tools.push(
+        // TODO(burdon): Namespace?
+        createRawTool("openapi", {
+          name: getToolName(path, method, methodItem),
+          description: options?.instructions ? `${options.instructions}
+
+${description}` : description,
+          parameters: inputSchema,
+          execute: async (input) => {
+            const response = await callApiEndpoint(endpoint, input);
+            return ToolResult2.Success(response);
+          }
+        })
+      );
+    }
+  }
+  return tools;
+};
+var getToolName = (path, method, methodItem) => {
+  if (methodItem.operationId) {
+    return methodItem.operationId;
+  }
+  let name = `${method.toLowerCase()}_${path.replaceAll(/[{}/]/g, "_")}`;
+  while (name.length > MAX_TOOL_NAME_LENGTH) {
+    const lengthBefore = name.length;
+    for (const word of GENERIC_WORDS) {
+      if (name.includes(word)) {
+        name = name.replace(word, "");
+        break;
+      }
+    }
+    name = name.replaceAll("__", "_").replace(/_$/, "");
+    const lengthAfter = name.length;
+    if (lengthBefore === lengthAfter) {
+      break;
+    }
+  }
+  name = name.replaceAll("__", "_").replace(/_$/, "").replace(/^_/, "");
+  return name.slice(0, MAX_TOOL_NAME_LENGTH);
+};
+var MAX_TOOL_NAME_LENGTH = 64;
+var GENERIC_WORDS = [
+  "services",
+  "service",
+  "api",
+  "rest",
+  "endpoint",
+  "get",
+  "post",
+  "put",
+  "delete",
+  "patch",
+  "head",
+  "options",
+  "trace",
+  "service",
+  "api",
+  "endpoint"
+];
+var callApiEndpoint = async (endpoint, input) => {
+  log4.info("endpoint", {
+    method: endpoint.method,
+    name: endpoint.path,
+    input
+  }, {
+    F: __dxlog_file4,
+    L: 180,
+    S: void 0,
+    C: (f, a) => f(...a)
+  });
+  let url = getEndpointUrl(endpoint);
+  const request = {
+    method: endpoint.method,
+    headers: {}
+  };
+  const query = new URLSearchParams();
+  let body;
+  for (const parameter of endpoint.parameters) {
+    if (input[parameter.name] === void 0) {
+      continue;
+    }
+    switch (parameter.in) {
+      case "header": {
+        if (parameter.example) {
+          request.headers[parameter.name] = parameter.default;
+        }
+        break;
+      }
+      case "path": {
+        url = url.replace(`{${parameter.name}}`, encodeURIComponent(input[parameter.name]));
+        break;
+      }
+      case "body": {
+        const value = input[parameter.name];
+        const effectSchema = Type2.toEffectSchema(parameter.schema);
+        Schema2.validateSync(effectSchema)(value);
+        if (body) {
+          throw new Error(`Duplicate body parameter: ${parameter.name}`);
+        }
+        body = value;
+        break;
+      }
+      case "query": {
+        query.set(parameter.name, input[parameter.name]);
+        break;
+      }
+    }
+  }
+  if (endpoint.authorization?.type === "api-key" && endpoint.authorization.placement.type === "authorization-header" || endpoint.authorization?.type === "oauth") {
+    request.headers.Authorization = await resolveAuthorization(endpoint.authorization);
+  } else if (endpoint.authorization?.type === "api-key" && endpoint.authorization.placement.type === "query") {
+    query.set(endpoint.authorization.placement.name, endpoint.authorization.key);
+  }
+  if (query.size > 0) {
+    url += `?${query.toString()}`;
+  }
+  if (body) {
+    request.body = JSON.stringify(body);
+    request.headers["Content-Type"] = "application/json";
+  }
+  log4.info("request", {
+    url,
+    request
+  }, {
+    F: __dxlog_file4,
+    L: 243,
+    S: void 0,
+    C: (f, a) => f(...a)
+  });
+  const response = await fetch(url, request);
+  log4.info("response", {
+    ok: response.ok,
+    status: response.status,
+    statusText: response.statusText
+  }, {
+    F: __dxlog_file4,
+    L: 246,
+    S: void 0,
+    C: (f, a) => f(...a)
+  });
+  if (response.ok) {
+    const contentType = response.headers.get("Content-Type");
+    if (contentType?.includes("application/json")) {
+      return await response.json();
+    } else {
+      return await response.text();
+    }
+  } else {
+    if (response.headers.get("Content-Type")?.includes("application/json")) {
+      const responseBody = await response.text();
+      let error;
+      try {
+        error = JSON.parse(responseBody);
+      } catch {
+        error = responseBody;
+      }
+      log4.error("error", {
+        error
+      }, {
+        F: __dxlog_file4,
+        L: 264,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+      throw new Error(error.message);
+    } else {
+      const error = await response.text();
+      log4.error("error", {
+        error
+      }, {
+        F: __dxlog_file4,
+        L: 268,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+      throw new Error(error);
+    }
+  }
+};
+var getEndpointUrl = (endpoint) => {
+  let url = "";
+  if (isV3_1(endpoint.document) && endpoint.document.servers && endpoint.document.servers.length > 0) {
+    url = endpoint.document.servers[0].url;
+  } else {
+    invariant(!isV3_1(endpoint.document), void 0, {
+      F: __dxlog_file4,
+      L: 279,
+      S: void 0,
+      A: [
+        "!isV3_1(endpoint.document)",
+        ""
+      ]
+    });
+    url = `${endpoint.document.schemes?.[0] ?? "https"}://${endpoint.document.host}`;
+  }
+  if (!isV3_1(endpoint.document) && endpoint.document.basePath) {
+    url += endpoint.document.basePath;
+  }
+  url += endpoint.path;
+  return url;
+};
+var resolveAuthorization = async (authorization) => {
+  switch (authorization.type) {
+    case "api-key": {
+      invariant(authorization.placement.type === "authorization-header", void 0, {
+        F: __dxlog_file4,
+        L: 295,
+        S: void 0,
+        A: [
+          "authorization.placement.type === 'authorization-header'",
+          ""
+        ]
+      });
+      return `Bearer ${authorization.key}`;
+    }
+    case "oauth": {
+      const response = await fetch(authorization.tokenUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded"
+        },
+        body: `grant_type=${authorization.grantType}&client_id=${authorization.clientId}&client_secret=${authorization.clientSecret}`
+      });
+      const data = await response.json();
+      return `Bearer ${data.access_token}`;
+    }
+    default: {
+      throw new Error(`Unknown authorization type: ${authorization.type}`);
+    }
+  }
+};
+var resolveJsonSchema = (schema, base) => {
+  return deepMapValues(schema, (value, recurse) => {
+    if (typeof value === "object" && value !== null && "$ref" in value && typeof value.$ref === "string") {
+      if (value.$ref.startsWith("#")) {
+        const resolved = jsonpointer.get(base, value.$ref.slice(1));
+        if (resolved) {
+          return recurse(resolved);
+        } else {
+          log4.warn("unresolved", {
+            ref: value.$ref,
+            base
+          }, {
+            F: __dxlog_file4,
+            L: 328,
+            S: void 0,
+            C: (f, a) => f(...a)
+          });
+        }
+      }
+    }
+    return recurse(value);
+  });
+};
+var isV3_1 = (document) => {
+  return document.openapi === "3.0.1";
+};
+
+// src/hooks/useChatProcessor.ts
+var __dxlog_file5 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/hooks/useChatProcessor.ts";
+var useChatProcessor = ({ preset, space, chat, services, blueprintRegistry, settings, instructions, artifact, noPluginArtifacts }) => {
+  const { dispatchPromise: dispatch } = useIntentDispatcher();
+  const globalTools = useCapabilities3(Capabilities3.Tools);
+  let artifacts = useCapabilities3(Capabilities3.ArtifactDefinition);
+  if (noPluginArtifacts) {
+    artifacts = Stable.array;
+  }
+  const remoteServices = useQuery(space, Filter3.type(ServiceType));
+  const [serviceTools, setServiceTools] = useState2([]);
+  useEffect2(() => {
+    log5("creating service tools...", void 0, {
+      F: __dxlog_file5,
+      L: 68,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+    queueMicrotask(async () => {
+      const tools2 = await Promise.all(remoteServices.map((service) => createToolsFromService(service)));
+      setServiceTools(tools2.flat());
+    });
+  }, [
+    remoteServices
+  ]);
+  const config = useConfig();
+  const functions = useQuery(space, Filter3.type(FunctionType));
+  const chatId = useMemo3(() => chat ? fullyQualifiedId(chat) : void 0, [
+    chat
+  ]);
+  const [tools, extensions] = useMemo3(() => {
+    log5("creating tools...", void 0, {
+      F: __dxlog_file5,
+      L: 80,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+    const tools2 = [
+      ...globalTools.flat(),
+      ...serviceTools,
+      ...functions.map((fn) => convertFunctionToTool(fn, config.values.runtime?.services?.edge?.url ?? "", space?.id)).filter(isNonNullable2)
+    ];
+    const extensions2 = {
+      space,
+      dispatch,
+      pivotId: chatId
+    };
+    return [
+      tools2,
+      extensions2
+    ];
+  }, [
+    dispatch,
+    globalTools,
+    space,
+    chatId,
+    serviceTools,
+    functions
+  ]);
+  const systemPrompt = useMemo3(() => createSystemPrompt({
+    artifacts: artifacts.map((definition) => `${definition.name}
+${definition.instructions}`),
+    artifact,
+    instructions
+  }), [
+    artifacts,
+    artifact,
+    instructions
+  ]);
+  const conversation = useMemo3(() => {
+    if (!chat?.queue.target) {
+      return;
+    }
+    return new Conversation({
+      queue: chat.queue.target
+    });
+  }, [
+    chat?.queue.target
+  ]);
+  const processor = useMemo3(() => {
+    if (!services || !conversation) {
+      return void 0;
+    }
+    log5.info("creating processor", {
+      preset,
+      artifacts: artifacts.length,
+      systemPrompt: systemPrompt.length,
+      model: preset?.model,
+      settings
+    }, {
+      F: __dxlog_file5,
+      L: 118,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+    return new ChatProcessor(services, conversation, {
+      tools,
+      extensions,
+      blueprintRegistry,
+      artifacts,
+      systemPrompt,
+      model: preset?.model
+    });
+  }, [
+    services,
+    conversation,
+    tools,
+    blueprintRegistry,
+    artifacts,
+    extensions,
+    systemPrompt,
+    preset
+  ]);
+  return processor;
+};
+var Stable = Object.freeze({
+  array: [],
+  object: {}
+});
+
+// src/components/Toolbox/Toolbox.tsx
+import { useSignals as _useSignals2 } from "@preact-signals/safe-react/tracking";
+import React, { useState as useState3, useEffect as useEffect3, Fragment } from "react";
+import { parseToolName } from "@dxos/ai";
+import { Capabilities as Capabilities4, useCapabilities as useCapabilities4 } from "@dxos/app-framework";
+import { FunctionType as FunctionType2 } from "@dxos/functions";
+import { log as log6 } from "@dxos/log";
+import { Filter as Filter4, useQuery as useQuery2 } from "@dxos/react-client/echo";
+import { useTranslation } from "@dxos/react-ui";
+import { mx } from "@dxos/react-ui-theme";
+var __dxlog_file6 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/components/Toolbox/Toolbox.tsx";
+var Toolbox = ({ classNames, artifacts, functions, services, blueprints, activeBlueprints, striped }) => {
+  var _effect = _useSignals2();
+  try {
+    const { t } = useTranslation(meta.id);
+    return /* @__PURE__ */ React.createElement("div", {
+      className: mx("flex flex-col overflow-y-auto box-content", classNames)
+    }, blueprints && blueprints.length > 0 && /* @__PURE__ */ React.createElement(Section, {
+      title: "Blueprints",
+      items: blueprints.map(({ target }) => ({
+        name: target?.name ?? "",
+        description: target?.description ?? "",
+        subitems: target?.tools.map((toolId) => ({
+          name: `\u2219 ${parseToolName(toolId)}`
+        }))
+      }))
+    }), activeBlueprints && activeBlueprints.length > 0 && /* @__PURE__ */ React.createElement(Section, {
+      title: "Blueprints",
+      items: activeBlueprints.map(({ target }) => ({
+        name: target?.name ?? "",
+        description: target?.description ?? "",
+        subitems: target?.tools.map((toolId) => ({
+          name: `\u2219 ${parseToolName(toolId)}`
+        }))
+      }))
+    }), artifacts && artifacts.length > 0 && /* @__PURE__ */ React.createElement(Section, {
+      title: "Artifacts",
+      items: artifacts.map(({ name, description, tools }) => ({
+        name,
+        description,
+        subitems: tools.map(({ name: name2, description: description2 }) => ({
+          name: `\u2219 ${parseToolName(name2)}`,
+          description: description2
+        }))
+      }))
+    }), services && services.length > 0 && /* @__PURE__ */ React.createElement(Section, {
+      title: "Services",
+      items: services.map(({ service: { serviceId, name, description }, tools }) => ({
+        name: name ?? serviceId,
+        description,
+        subitems: tools.map(({ name: name2, description: description2 }) => ({
+          name: `\u2219 ${name2}`,
+          description: description2
+        }))
+      }))
+    }), functions && functions.length > 0 && /* @__PURE__ */ React.createElement(Section, {
+      title: "Functions",
+      items: functions.map(({ name, description }) => ({
+        name,
+        description
+      }))
+    }), !blueprints?.length && !activeBlueprints?.length && !artifacts?.length && !services?.length && !functions?.length && /* @__PURE__ */ React.createElement("div", null, t("no tools")));
+  } finally {
+    _effect.f();
+  }
+};
+var Section = ({ title, items, striped }) => {
+  var _effect = _useSignals2();
+  try {
+    const stripeClassNames = "odd:bg-neutral-50 dark:odd:bg-neutral-800";
+    const gridClassNames = "grid grid-cols-[8rem_1fr]";
+    const subGridClassNames = mx("col-span-full grid grid-cols-subgrid text-xs px-2", striped && stripeClassNames);
+    return /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement("h1", {
+      className: "px-2 text-sm"
+    }, title), /* @__PURE__ */ React.createElement("div", {
+      className: gridClassNames
+    }, items.map(({ name, description, subitems }, i) => /* @__PURE__ */ React.createElement(Fragment, {
+      key: i
+    }, name && /* @__PURE__ */ React.createElement("div", {
+      className: subGridClassNames
+    }, /* @__PURE__ */ React.createElement("div", {
+      className: "truncate text-primary-500"
+    }, name), /* @__PURE__ */ React.createElement("div", {
+      className: "line-clamp-2"
+    }, description)), subitems?.map(({ name: name2, description: description2 }, i2) => /* @__PURE__ */ React.createElement("div", {
+      key: i2,
+      className: mx(subGridClassNames, striped && stripeClassNames)
+    }, /* @__PURE__ */ React.createElement("div", {
+      className: "truncate"
+    }, name2), /* @__PURE__ */ React.createElement("div", {
+      className: "line-clamp-3 text-subdued"
+    }, description2)))))));
+  } finally {
+    _effect.f();
+  }
+};
+var ToolboxContainer = ({ classNames, space, processor }) => {
+  var _effect = _useSignals2();
+  try {
+    const artifactDefinitions = useCapabilities4(Capabilities4.ArtifactDefinition);
+    const services = useQuery2(space, Filter4.type(ServiceType));
+    const [serviceTools, setServiceTools] = useState3([]);
+    useEffect3(() => {
+      log6("creating service tools...", {
+        services: services.length
+      }, {
+        F: __dxlog_file6,
+        L: 150,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+      queueMicrotask(async () => {
+        const tools = await Promise.all(services.map(async (service) => ({
+          service,
+          tools: await createToolsFromService(service)
+        })));
+        setServiceTools(tools);
+      });
+    }, [
+      services
+    ]);
+    const functions = useQuery2(space, Filter4.type(FunctionType2));
+    return /* @__PURE__ */ React.createElement(Toolbox, {
+      classNames,
+      blueprints: processor?.context.blueprints.value,
+      artifacts: artifactDefinitions,
+      services: serviceTools,
+      functions
+    });
+  } finally {
+    _effect.f();
+  }
+};
+
+// 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 { createContext } from "@radix-ui/react-context";
+import { dedupeWith } from "effect/Array";
+import React10, { useCallback as useCallback3, useEffect as useEffect6, useMemo as useMemo7, useRef as useRef2, useState as useState6 } from "react";
+import { CollaborationActions, createIntent, useIntentDispatcher as useIntentDispatcher2 } from "@dxos/app-framework";
+import { Event } from "@dxos/async";
+import { DXN, Obj as Obj5, Ref as Ref3 } from "@dxos/echo";
+import { log as log8 } from "@dxos/log";
+import { useVoiceInput } from "@dxos/plugin-transcription";
+import { getSpace, useQueue } from "@dxos/react-client/echo";
+import { useIdentity } from "@dxos/react-client/halo";
+import { Input as Input2, useTranslation as useTranslation6 } from "@dxos/react-ui";
+import { ChatEditor, references } from "@dxos/react-ui-chat";
+import { mx as mx6 } from "@dxos/react-ui-theme";
+import { DataType as DataType2 } from "@dxos/schema";
+import { isNotFalsy as isNotFalsy2 } from "@dxos/util";
+
+// src/components/ChatPrompt/ChatActions.tsx
+import { useSignals as _useSignals3 } from "@preact-signals/safe-react/tracking";
+import React2 from "react";
+import { IconButton, useTranslation as useTranslation2 } from "@dxos/react-ui";
+import { mx as mx2 } from "@dxos/react-ui-theme";
+var ChatActions = ({ classNames, children, microphone, recording, processing, onEvent }) => {
+  var _effect = _useSignals3();
+  try {
+    const { t } = useTranslation2(meta.id);
+    return /* @__PURE__ */ React2.createElement("div", {
+      className: mx2("flex items-center mie-1", classNames)
+    }, children, processing && /* @__PURE__ */ React2.createElement(IconButton, {
+      disabled: !processing,
+      classNames: "px-1.5",
+      variant: "ghost",
+      size: 5,
+      icon: "ph--x--regular",
+      iconOnly: true,
+      label: t("button cancel processing"),
+      onClick: () => onEvent?.({
+        type: "cancel"
+      })
+    }) || /* @__PURE__ */ React2.createElement(IconButton, {
+      disabled: true,
+      classNames: "px-1.5",
+      variant: "ghost",
+      size: 5,
+      icon: "ph--arrow-down--regular",
+      iconOnly: true,
+      label: t("button scroll down"),
+      onClick: () => onEvent?.({
+        type: "scroll-to-bottom"
+      })
+    }), microphone && /* @__PURE__ */ React2.createElement(IconButton, {
+      disabled: !processing,
+      classNames: mx2("px-1.5", 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/ChatOptionsMenu.tsx
+import { useSignals as _useSignals4 } from "@preact-signals/safe-react/tracking";
+import React3, { useMemo as useMemo4 } from "react";
+import { DropdownMenu, IconButton as IconButton2, Input, useTranslation as useTranslation3 } from "@dxos/react-ui";
+var ChatOptionsMenu = ({ blueprintRegistry, blueprints, onChange }) => {
+  var _effect = _useSignals4();
+  try {
+    const { t } = useTranslation3(meta.id);
+    const blueprintOptions = useMemo4(() => blueprintRegistry?.query().map((blueprint) => ({
+      key: blueprint.key,
+      label: blueprint.name
+    })), [
+      blueprintRegistry
+    ]);
+    return /* @__PURE__ */ React3.createElement(DropdownMenu.Root, null, /* @__PURE__ */ React3.createElement(DropdownMenu.Trigger, {
+      asChild: true,
+      disabled: !blueprintOptions?.length
+    }, /* @__PURE__ */ React3.createElement(IconButton2, {
+      icon: "ph--plus--regular",
+      variant: "ghost",
+      size: 5,
+      iconOnly: true,
+      label: t("button add blueprint")
+    })), /* @__PURE__ */ React3.createElement(DropdownMenu.Portal, null, /* @__PURE__ */ React3.createElement(DropdownMenu.Content, {
+      side: "left"
+    }, /* @__PURE__ */ React3.createElement(DropdownMenu.Viewport, null, blueprintOptions?.map((option) => /* @__PURE__ */ React3.createElement(DropdownMenu.Item, {
+      key: option.key
+    }, /* @__PURE__ */ React3.createElement(Input.Root, null, /* @__PURE__ */ React3.createElement(Input.Checkbox, {
+      checked: !!blueprints?.find((blueprint) => blueprint.key === option.key),
+      onCheckedChange: (checked) => onChange?.(option.key, !!checked)
+    }), /* @__PURE__ */ React3.createElement(Input.Label, {
+      classNames: "m-0"
+    }, option.label))))), /* @__PURE__ */ React3.createElement(DropdownMenu.Arrow, null))));
+  } finally {
+    _effect.f();
+  }
+};
+
+// src/components/ChatPrompt/ChatPresets.tsx
+import { useSignals as _useSignals5 } from "@preact-signals/safe-react/tracking";
+import React4 from "react";
+import { Select } from "@dxos/react-ui";
+var ChatPresets = ({ presets, preset, onChange }) => {
+  var _effect = _useSignals5();
+  try {
+    return /* @__PURE__ */ React4.createElement(Select.Root, {
+      value: preset,
+      onValueChange: onChange
+    }, /* @__PURE__ */ React4.createElement(Select.TriggerButton, {
+      classNames: "text-sm"
+    }), /* @__PURE__ */ React4.createElement(Select.Content, null, presets?.map(({ id, label }) => /* @__PURE__ */ React4.createElement(Select.Option, {
+      key: id,
+      value: id,
+      classNames: "text-sm"
+    }, label))));
+  } finally {
+    _effect.f();
+  }
+};
+
+// src/components/ChatPrompt/ChatReferences.tsx
+import { useSignals as _useSignals6 } from "@preact-signals/safe-react/tracking";
+import React5, { useCallback as useCallback2 } from "react";
+import { Filter as Filter5, Obj as Obj4, Ref as Ref2 } from "@dxos/echo";
+import { useAsyncState, useTranslation as useTranslation4 } from "@dxos/react-ui";
+import { TagPicker } from "@dxos/react-ui-tag-picker";
+import { mx as mx3 } from "@dxos/react-ui-theme";
+import { isNonNullable as isNonNullable3 } from "@dxos/util";
+var ChatReferences = ({ classNames, space, context, onUpdate }) => {
+  var _effect = _useSignals6();
+  try {
+    const { t: _t } = useTranslation4(meta.id);
+    const [items] = useAsyncState(async () => {
+      const objects = await Ref2.Array.loadAll(context.objects.value ?? []);
+      return objects.filter(isNonNullable3).map((obj) => ({
+        id: obj.id,
+        label: Obj4.getLabel(obj) ?? obj.id
+      }));
+    }, [
+      context
+    ]);
+    const handleSearch = useCallback2((text, ids) => {
+      const objects = space.db.query(Filter5.everything()).runSync();
+      return objects.map(({ object }) => ({
+        id: object.id,
+        label: Obj4.getLabel(object) ?? ""
+      })).filter(({ id, label }) => !ids.includes(id) && label.toLocaleLowerCase().includes(text.toLocaleLowerCase()));
+    }, [
+      space
+    ]);
+    return /* @__PURE__ */ React5.createElement(TagPicker, {
+      classNames: mx3("h-[1.75rem] text-sm", classNames),
+      mode: "multi-select",
+      // placeholder={t('context objects placeholder')}
+      items,
+      onSearch: handleSearch,
+      onUpdate
+    });
+  } finally {
+    _effect.f();
+  }
+};
+
+// src/components/ChatPrompt/ChatStatusIndicator.tsx
+import { useSignals as _useSignals7 } from "@preact-signals/safe-react/tracking";
+import React6, { useEffect as useEffect4, useState as useState4 } from "react";
+import { Icon, Tooltip, useTimeout } from "@dxos/react-ui";
+import { Spinner } from "@dxos/react-ui-sfx";
+import { errorText } from "@dxos/react-ui-theme";
+var ChatStatusIndicator = ({ preset, error, processing }) => {
+  var _effect = _useSignals7();
+  try {
+    const [init, setInit] = useState4(false);
+    useEffect4(() => {
+      setInit(false);
+    }, [
+      preset
+    ]);
+    useTimeout(async () => {
+      setInit(true);
+    }, 1500, [
+      preset
+    ]);
+    if (error) {
+      return /* @__PURE__ */ React6.createElement(Tooltip.Trigger, {
+        content: error.message,
+        delayDuration: 0
+      }, /* @__PURE__ */ React6.createElement(Icon, {
+        icon: "ph--warning-circle--regular",
+        classNames: errorText,
+        size: 5
+      }));
+    }
+    return /* @__PURE__ */ React6.createElement(Spinner, {
+      state: !init ? "flash" : processing ? "spin" : "pulse"
+    });
+  } finally {
+    _effect.f();
+  }
+};
+
+// src/components/ChatThread/ChatThread.tsx
+import { useSignals as _useSignals10 } from "@preact-signals/safe-react/tracking";
+import React9, { forwardRef, useMemo as useMemo6 } from "react";
+import { PublicKey } from "@dxos/keys";
+import { ScrollContainer } from "@dxos/react-ui-components";
+import { mx as mx5 } from "@dxos/react-ui-theme";
+import { keyToFallback } from "@dxos/util";
+
+// src/components/ChatThread/ChatMessage.tsx
+import { useSignals as _useSignals9 } from "@preact-signals/safe-react/tracking";
+import React8, { Fragment as Fragment2 } from "react";
+import { Surface } from "@dxos/app-framework";
+import { invariant as invariant2 } from "@dxos/invariant";
+import { Button, Icon as Icon2, IconButton as IconButton3, useTranslation as useTranslation5 } from "@dxos/react-ui";
+import { MarkdownViewer, ToggleContainer as NativeToggleContainer } from "@dxos/react-ui-components";
+import { mx as mx4 } from "@dxos/react-ui-theme";
+import { safeParseJson } from "@dxos/util";
+
+// src/components/ChatThread/ToolBlock.tsx
+import { useSignals as _useSignals8 } from "@preact-signals/safe-react/tracking";
+import React7, { useEffect as useEffect5, useMemo as useMemo5, useRef, useState as useState5 } from "react";
+import { log as log7 } from "@dxos/log";
+import { NumericTabs, StatusRoll, ToggleContainer } from "@dxos/react-ui-components";
+import { Json as NativeJson } from "@dxos/react-ui-syntax-highlighter";
+import { isNonNullable as isNonNullable4, isNotFalsy } from "@dxos/util";
+var __dxlog_file7 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/components/ChatThread/ToolBlock.tsx";
+var isToolMessage = (message) => {
+  return message.blocks.some((block) => block._tag === "toolCall" || block._tag === "toolResult");
+};
+var getToolName2 = (tool) => {
+  return tool.namespace && tool.function ? `${tool.namespace}:${tool.function}` : tool.name.split("_").pop();
+};
+var getToolCaption = (tool, status) => {
+  if (!tool) {
+    return "Calling tool...";
+  }
+  return status?.message ?? tool.caption ?? `Calling ${getToolName2(tool)}...`;
+};
+var ToolBlock = ({ classNames, message, tools }) => {
+  var _effect = _useSignals8();
+  try {
+    const { blocks = [] } = message;
+    let request;
+    const toolBlocks = blocks.filter((block) => block._tag === "toolCall" || block._tag === "toolResult");
+    const items = toolBlocks.map((block) => {
+      switch (block._tag) {
+        case "toolCall": {
+          if (block.pending && request?.block.toolCallId === block.toolCallId) {
+            return null;
+          }
+          request = {
+            tool: tools?.find((tool) => tool.name === block.name),
+            block
+          };
+          return {
+            title: getToolCaption(request.tool, void 0),
+            block
+          };
+        }
+        case "toolResult": {
+          if (!request) {
+            log7.warn("unexpected message", {
+              block
+            }, {
+              F: __dxlog_file7,
+              L: 59,
+              S: void 0,
+              C: (f, a) => f(...a)
+            });
+            return {
+              title: "Error",
+              block
+            };
+          }
+          return {
+            title: `${getToolCaption(request.tool, void 0)} (Success)`,
+            block
+          };
+        }
+        default: {
+          request = void 0;
+          return {
+            title: "Error",
+            block
+          };
+        }
+      }
+    }).filter(isNonNullable4);
+    return /* @__PURE__ */ React7.createElement(ToolContainer, {
+      classNames,
+      items
+    });
+  } finally {
+    _effect.f();
+  }
+};
+var ToolContainer = ({ classNames, items }) => {
+  var _effect = _useSignals8();
+  try {
+    const tabsRef = useRef(null);
+    const [selected, setSelected] = useState5(0);
+    const [open, setOpen] = useState5(false);
+    useEffect5(() => {
+      if (open) {
+        tabsRef.current?.focus();
+      }
+    }, [
+      open
+    ]);
+    const handleSelect = (index) => {
+      if (index === selected) {
+        setOpen(false);
+      } else {
+        setSelected(index);
+      }
+    };
+    const title = useMemo5(() => {
+      const lines = items.map((item) => item.title).filter(isNotFalsy);
+      return /* @__PURE__ */ React7.createElement(StatusRoll, {
+        key: "status-roll",
+        lines,
+        duration: 1e3,
+        autoAdvance: true
+      });
+    }, [
+      items
+    ]);
+    return /* @__PURE__ */ React7.createElement(ToggleContainer, {
+      classNames: [
+        "flex flex-col",
+        classNames
+      ],
+      title,
+      open,
+      onChangeOpen: setOpen
+    }, /* @__PURE__ */ React7.createElement("div", {
+      className: "w-full grid grid-cols-[32px_1fr]"
+    }, /* @__PURE__ */ React7.createElement(NumericTabs, {
+      ref: tabsRef,
+      length: items.length,
+      selected,
+      onSelect: handleSelect
+    }), /* @__PURE__ */ React7.createElement(Json, {
+      data: items[selected].block
+    })));
+  } finally {
+    _effect.f();
+  }
+};
+var Json = ({ data }) => {
+  var _effect = _useSignals8();
+  try {
+    return /* @__PURE__ */ React7.createElement(NativeJson, {
+      data,
+      classNames: "!p-1 text-xs bg-transparent"
+    });
+  } finally {
+    _effect.f();
+  }
+};
+
+// src/components/ChatThread/ChatMessage.tsx
+var __dxlog_file8 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/components/ChatThread/ChatMessage.tsx";
+var ChatMessage = ({ classNames, debug, space, message, processor, tools, onEvent }) => {
+  var _effect = _useSignals9();
+  try {
+    const { t } = useTranslation5(meta.id);
+    const { sender: { role }, blocks } = message;
+    if (isToolMessage(message)) {
+      return /* @__PURE__ */ React8.createElement(MessageContainer, {
+        classNames: mx4(classNames, "animate-[fadeIn_0.5s]")
+      }, /* @__PURE__ */ React8.createElement(ToolBlock, {
+        classNames: panelClasses,
+        message,
+        tools
+      }));
+    }
+    return /* @__PURE__ */ React8.createElement(React8.Fragment, null, debug && /* @__PURE__ */ React8.createElement("div", {
+      className: mx4("flex justify-end text-subdued", marginClasses)
+    }, /* @__PURE__ */ React8.createElement("pre", {
+      className: "text-xs"
+    }, JSON.stringify({
+      created: message.created
+    }))), blocks.map((block, idx) => {
+      if (block._tag === "text" && block.text.replaceAll(/\s+/g, "").length === 0) {
+        return null;
+      }
+      const Component = components[block._tag] ?? components.default;
+      if (!Component) {
+        return null;
+      }
+      return /* @__PURE__ */ React8.createElement(Fragment2, {
+        key: idx
+      }, /* @__PURE__ */ React8.createElement(MessageContainer, {
+        classNames,
+        user: block._tag === "text" && role === "user"
+      }, /* @__PURE__ */ React8.createElement(Component, {
+        space,
+        processor,
+        block,
+        onEvent
+      })), debug && /* @__PURE__ */ React8.createElement("div", {
+        className: mx4("flex justify-end text-subdued", marginClasses)
+      }, /* @__PURE__ */ React8.createElement("pre", {
+        className: "text-xs"
+      }, JSON.stringify({
+        block: block._tag
+      }))));
+    }), /* @__PURE__ */ React8.createElement("div", {
+      className: mx4("flex justify-end pbs-2 pbe-2 opacity-50 hover:opacity-100", marginClasses)
+    }, /* @__PURE__ */ React8.createElement(IconButton3, {
+      classNames: "animate-[fadeIn_0.5s]",
+      icon: "ph--trash--regular",
+      iconOnly: true,
+      label: t("button delete message"),
+      onClick: () => onEvent?.({
+        type: "delete",
+        id: message.id
+      })
+    })));
+  } finally {
+    _effect.f();
+  }
+};
+var components = {
+  //
+  // Text
+  //
+  ["text"]: ({ block }) => {
+    invariant2(block._tag === "text", void 0, {
+      F: __dxlog_file8,
+      L: 113,
+      S: void 0,
+      A: [
+        "block._tag === 'text'",
+        ""
+      ]
+    });
+    const title = block.disposition ? titles[block.disposition] : void 0;
+    if (!title) {
+      return /* @__PURE__ */ React8.createElement(MarkdownViewer, {
+        content: block.text
+      });
+    }
+    return /* @__PURE__ */ React8.createElement(ToggleContainer2, {
+      // open={open}
+      defaultOpen: systemDispositions.includes(block.disposition ?? "") && block.pending,
+      title,
+      icon: block.pending ? /* @__PURE__ */ React8.createElement(Icon2, {
+        icon: "ph--circle-notch--regular",
+        classNames: "text-subdued animate-spin",
+        size: 4
+      }) : void 0
+    }, /* @__PURE__ */ React8.createElement(MarkdownViewer, {
+      content: block.text,
+      classNames: [
+        "pbe-2",
+        systemDispositions.includes(block.disposition ?? "") && "text-sm text-subdued"
+      ]
+    }));
+  },
+  //
+  // JSON
+  //
+  ["json"]: ({ space, processor, block, onEvent }) => {
+    invariant2(block._tag === "json", void 0, {
+      F: __dxlog_file8,
+      L: 151,
+      S: void 0,
+      A: [
+        "block._tag === 'json'",
+        ""
+      ]
+    });
+    switch (block.disposition) {
+      case "tool_list": {
+        return /* @__PURE__ */ React8.createElement(ToggleContainer2, {
+          title: titles[block.disposition],
+          defaultOpen: true
+        }, /* @__PURE__ */ React8.createElement(ToolboxContainer, {
+          space,
+          processor,
+          classNames: "pbe-2"
+        }));
+      }
+      case "suggest": {
+        const { text = "" } = safeParseJson(block.data ?? "{}") ?? {};
+        return /* @__PURE__ */ React8.createElement(IconButton3, {
+          icon: "ph--lightning--regular",
+          label: text,
+          onClick: () => onEvent?.({
+            type: "submit",
+            text
+          })
+        });
+      }
+      case "select": {
+        const { options = [] } = safeParseJson(block.data ?? "{}") ?? {};
+        return /* @__PURE__ */ React8.createElement("div", {
+          className: "flex flex-wrap gap-1"
+        }, options.map((text, idx) => /* @__PURE__ */ React8.createElement(Button, {
+          classNames: "animate-[fadeIn_0.5s] rounded-sm text-sm",
+          key: idx,
+          onClick: () => onEvent?.({
+            type: "submit",
+            text
+          })
+        }, text)));
+      }
+      case "graph": {
+        return /* @__PURE__ */ React8.createElement("div", {
+          className: "flex flex-wrap gap-1"
+        }, /* @__PURE__ */ React8.createElement(Surface, {
+          role: "card",
+          data: {
+            subject: JSON.parse(block.data ?? "{}")
+          },
+          limit: 1,
+          fallback: /* @__PURE__ */ React8.createElement("div", {
+            className: "font-mono text-xs text-pre"
+          }, block.data)
+        }), onEvent && /* @__PURE__ */ React8.createElement(IconButton3, {
+          icon: "ph--plus--regular",
+          label: "Add to graph",
+          onClick: () => onEvent?.({
+            type: "add",
+            object: JSON.parse(block.data ?? "{}")
+          })
+        }));
+      }
+      default: {
+        const title = block.disposition ? titles[block.disposition] : void 0;
+        return /* @__PURE__ */ React8.createElement(ToggleContainer2, {
+          title: title ?? "JSON"
+        }, /* @__PURE__ */ React8.createElement(Json, {
+          data: safeParseJson(block.data ?? block)
+        }));
+      }
+    }
+  },
+  //
+  // Default
+  //
+  default: ({ block }) => {
+    let title = titles[block._tag];
+    if (block._tag === "toolCall") {
+      title = `Tool [${block.name}]`;
+    } else {
+      title = block._tag;
+    }
+    return /* @__PURE__ */ React8.createElement(ToggleContainer2, {
+      title: title ?? "JSON"
+    }, /* @__PURE__ */ React8.createElement(Json, {
+      data: block
+    }));
+  }
+};
+var titles = {
+  ["cot"]: "Chain of thought",
+  ["artifact"]: "Artifact",
+  ["tool_use"]: "Tool request",
+  ["tool_result"]: "Tool result",
+  ["tool_list"]: "Tools",
+  ["artifact-update"]: "Artifact(s) changed"
+};
+var systemDispositions = [
+  "cot",
+  "artifact-update"
+];
+var panelClasses = "flex flex-col is-full bg-activeSurface rounded-sm";
+var marginClasses = "pie-4 pis-4";
+var paddingClasses = "pis-2 pie-2 pbs-0.5 pbe-0.5";
+var MessageContainer = ({ classNames, children, user }) => {
+  var _effect = _useSignals9();
+  try {
+    if (!children) {
+      return null;
+    }
+    return /* @__PURE__ */ React8.createElement("div", {
+      role: "list-item",
+      className: mx4("flex is-full", user && "justify-end", marginClasses, classNames)
+    }, /* @__PURE__ */ React8.createElement("div", {
+      className: mx4(user ? [
+        "rounded-sm",
+        "bg-[--user-fill] text-accentSurfaceText",
+        paddingClasses
+      ] : "is-full")
+    }, children));
+  } finally {
+    _effect.f();
+  }
+};
+var ToggleContainer2 = (props) => {
+  var _effect = _useSignals9();
+  try {
+    return /* @__PURE__ */ React8.createElement(NativeToggleContainer, {
+      ...props,
+      classNames: mx4(panelClasses, props.classNames)
+    });
+  } finally {
+    _effect.f();
+  }
+};
+
+// src/components/ChatThread/reducer.ts
+var messageReducer = ({ current, messages }, message) => {
+  let i = 0;
+  for (const block of message.blocks) {
+    switch (block._tag) {
+      case "toolCall":
+      case "toolResult": {
+        if (current) {
+          current.blocks.push(block);
+        } else {
+          current = {
+            ...message,
+            id: [
+              message.id,
+              i
+            ].join("_"),
+            blocks: [
+              block
+            ]
+          };
+          messages.push(current);
+        }
+        break;
+      }
+      case "text":
+      default: {
+        current = void 0;
+        messages.push({
+          ...message,
+          id: [
+            message.id,
+            i
+          ].join("_"),
+          blocks: [
+            block
+          ]
+        });
+        break;
+      }
+    }
+    i++;
+  }
+  return {
+    current,
+    messages
+  };
+};
+
+// src/components/ChatThread/ChatThread.tsx
+var ChatThread = /* @__PURE__ */ forwardRef(({ classNames, identity, messages, collapse = true, ...props }, forwardedRef) => {
+  var _effect = _useSignals10();
+  try {
+    const userHue = useMemo6(() => {
+      return identity?.profile?.data?.hue || keyToFallback(identity?.identityKey ?? PublicKey.random()).hue;
+    }, [
+      identity
+    ]);
+    const { messages: filteredMessages = [] } = useMemo6(() => {
+      if (collapse) {
+        return (messages ?? []).reduce(messageReducer, {
+          messages: []
+        });
+      } else {
+        return {
+          messages: messages ?? []
+        };
+      }
+    }, [
+      messages,
+      collapse
+    ]);
+    return /* @__PURE__ */ React9.createElement(ScrollContainer, {
+      ref: forwardedRef,
+      classNames,
+      fade: true
+    }, /* @__PURE__ */ React9.createElement("div", {
+      role: "none",
+      className: mx5(filteredMessages.length > 0 && "pbs-4 pbe-4"),
+      style: {
+        "--user-fill": `var(--dx-${userHue}Fill)`
+      }
+    }, filteredMessages.map((message) => /* @__PURE__ */ React9.createElement(ChatMessage, {
+      key: message.id,
+      message,
+      ...props
+    }))));
+  } finally {
+    _effect.f();
+  }
+});
+
+// src/components/Chat/Chat.tsx
+var __dxlog_file9 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/components/Chat/Chat.tsx";
+var Endcap = ({ children }) => {
+  var _effect = _useSignals11();
+  try {
+    return /* @__PURE__ */ React10.createElement("div", {
+      className: "grid w-[var(--rail-action)] h-[var(--rail-action)] items-center justify-center"
+    }, children);
+  } finally {
+    _effect.f();
+  }
+};
+var [ChatContextProvider, useChatContext] = createContext("Chat");
+var ChatRoot = ({ classNames, children, chat, processor, artifact, onEvent, ...props }) => {
+  var _effect = _useSignals11();
+  try {
+    const [debug, setDebug] = useState6(false);
+    const space = getSpace(chat);
+    const queue = useQueue(chat?.queue.dxn);
+    const messages = useMemo7(() => dedupeWith([
+      ...queue?.objects?.filter(Obj5.instanceOf(DataType2.Message)) ?? [],
+      ...processor?.messages.value ?? []
+    ], (a, b) => a.id === b.id), [
+      queue?.objects,
+      processor?.messages.value
+    ]);
+    const { dispatchPromise: dispatch } = useIntentDispatcher2();
+    useEffect6(() => {
+      if (!processor?.streaming.value && queue?.objects && artifact) {
+        const message = queue.objects[queue.objects.length - 1];
+        if (dispatch && space && chat && message) {
+          void dispatch(createIntent(CollaborationActions.InsertContent, {
+            target: artifact,
+            object: Ref3.fromDXN(new DXN(DXN.kind.QUEUE, [
+              ...chat.queue.dxn.parts,
+              message.id
+            ])),
+            label: "View proposal"
+          }));
+        }
+      }
+    }, [
+      queue,
+      processor?.streaming.value
+    ]);
+    const event = useMemo7(() => new Event(), []);
+    useEffect6(() => {
+      return event.on((event2) => {
+        switch (event2.type) {
+          case "toggle-debug": {
+            setDebug((debug2) => !debug2);
+            break;
+          }
+          case "submit": {
+            if (!processor.streaming.value) {
+              void processor.request(event2.text);
+            }
+            break;
+          }
+          case "cancel": {
+            void processor.cancel();
+            break;
+          }
+          default: {
+            onEvent?.(event2);
+          }
+        }
+      });
+    }, [
+      event,
+      onEvent
+    ]);
+    if (!space) {
+      return null;
+    }
+    return /* @__PURE__ */ React10.createElement(ChatContextProvider, {
+      debug,
+      event,
+      chat,
+      space,
+      processor,
+      messages,
+      ...props
+    }, /* @__PURE__ */ React10.createElement("div", {
+      role: "none",
+      className: mx6("flex flex-col h-full overflow-hidden", classNames)
+    }, children));
+  } finally {
+    _effect.f();
+  }
+};
+ChatRoot.displayName = "Chat.Root";
+var ChatThread2 = (props) => {
+  var _effect = _useSignals11();
+  try {
+    const { debug, event, space, processor, messages } = useChatContext(ChatThread2.displayName);
+    const identity = useIdentity();
+    const scrollerRef = useRef2(null);
+    useEffect6(() => {
+      return event.on((event2) => {
+        switch (event2.type) {
+          case "submit":
+          case "scroll-to-bottom":
+            scrollerRef.current?.scrollToBottom("smooth");
+            break;
+        }
+      });
+    }, [
+      event
+    ]);
+    if (!identity) {
+      return null;
+    }
+    return /* @__PURE__ */ React10.createElement(ChatThread, {
+      ...props,
+      ref: scrollerRef,
+      debug,
+      identity,
+      space,
+      messages,
+      tools: processor?.tools,
+      onEvent: (ev) => event.emit(ev)
+    });
+  } finally {
+    _effect.f();
+  }
+};
+ChatThread2.displayName = "Chat.Thread";
+var ChatPrompt = ({ classNames, placeholder, expandable, online, presets, preset, onChangePreset, onChangeOnline }) => {
+  var _effect = _useSignals11();
+  try {
+    const { t } = useTranslation6(meta.id);
+    const { space, event, processor } = useChatContext(ChatPrompt.displayName);
+    const [active, setActive] = useState6(false);
+    useEffect6(() => {
+      return event.on((event2) => {
+        switch (event2.type) {
+          case "record-start":
+            setActive(true);
+            break;
+          case "record-stop":
+            setActive(false);
+            break;
+        }
+      });
+    }, [
+      event
+    ]);
+    const editorRef = useRef2(null);
+    const { recording } = useVoiceInput({
+      active,
+      onUpdate: (text) => {
+        editorRef.current?.setText(text);
+        editorRef.current?.focus();
+      }
+    });
+    const [blueprints, handleUpdateBlueprints] = useBlueprints(space, processor.context, processor.blueprintRegistry);
+    const contextProvider = useReferencesProvider(space);
+    const extensions = useMemo7(() => {
+      return [
+        contextProvider && references({
+          provider: contextProvider
+        }),
+        expandable && Prec.highest(keymap.of([
+          {
+            key: "cmd-d",
+            preventDefault: true,
+            run: () => {
+              event.emit({
+                type: "toggle-debug"
+              });
+              return true;
+            }
+          },
+          {
+            key: "cmd-ArrowUp",
+            preventDefault: true,
+            run: () => {
+              event.emit({
+                type: "thread-open"
+              });
+              return true;
+            }
+          },
+          {
+            key: "cmd-ArrowDown",
+            preventDefault: true,
+            run: () => {
+              event.emit({
+                type: "thread-close"
+              });
+              return true;
+            }
+          }
+        ]))
+      ].filter(isNotFalsy2);
+    }, [
+      event,
+      expandable,
+      contextProvider
+    ]);
+    const handleSubmit = useCallback3((text) => {
+      if (!processor.streaming.value) {
+        event.emit({
+          type: "submit",
+          text
+        });
+        return true;
+      }
+    }, [
+      processor,
+      event
+    ]);
+    const handleEvent = useCallback3((ev) => {
+      event.emit(ev);
+    }, [
+      event
+    ]);
+    const handleUpdateReferences = useCallback3((ids) => {
+      log8.info("update", {
+        ids
+      }, {
+        F: __dxlog_file9,
+        L: 318,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+    }, []);
+    return /* @__PURE__ */ React10.createElement("div", {
+      className: mx6("is-full grid grid-cols-[var(--rail-action)_1fr_var(--rail-action)] grid-rows-[min-content_min-content_min-content]", classNames)
+    }, /* @__PURE__ */ React10.createElement(Endcap, null, /* @__PURE__ */ React10.createElement(ChatStatusIndicator, {
+      preset,
+      error: processor.error.value,
+      processing: processor.streaming.value
+    })), /* @__PURE__ */ React10.createElement(ChatEditor, {
+      ref: editorRef,
+      autoFocus: true,
+      lineWrapping: true,
+      classNames: "col-span-2 pis-1 pbs-2",
+      placeholder: placeholder ?? t("prompt placeholder"),
+      extensions,
+      onSubmit: handleSubmit
+    }), /* @__PURE__ */ React10.createElement("div", null), /* @__PURE__ */ React10.createElement(ChatReferences, {
+      classNames: "col-span-2 flex pis-1 items-center",
+      space,
+      context: processor.context,
+      onUpdate: handleUpdateReferences
+    }), /* @__PURE__ */ React10.createElement(ChatOptionsMenu, {
+      blueprintRegistry: processor.blueprintRegistry,
+      blueprints,
+      onChange: handleUpdateBlueprints
+    }), /* @__PURE__ */ React10.createElement(ChatActions, {
+      classNames: "col-span-2",
+      microphone: true,
+      recording,
+      processing: processor.streaming.value,
+      onEvent: handleEvent
+    }, /* @__PURE__ */ React10.createElement(React10.Fragment, null, /* @__PURE__ */ React10.createElement("div", {
+      className: "grow"
+    }), presets && /* @__PURE__ */ React10.createElement(ChatPresets, {
+      preset,
+      presets,
+      onChange: onChangePreset
+    }), online !== void 0 && /* @__PURE__ */ React10.createElement(Input2.Root, null, /* @__PURE__ */ React10.createElement(Input2.Switch, {
+      classNames: "mis-2 mie-2",
+      checked: online,
+      onCheckedChange: onChangeOnline
+    })))));
+  } finally {
+    _effect.f();
+  }
+};
+ChatPrompt.displayName = "Chat.Prompt";
+var Chat = {
+  Root: ChatRoot,
+  Thread: ChatThread2,
+  Prompt: ChatPrompt
+};
+
+export {
+  useChatProcessor,
+  useChatServices,
+  hooks_exports,
+  Toolbox,
+  ToolboxContainer,
+  Chat
+};
+//# sourceMappingURL=chunk-SENTQAEO.mjs.map