@dxos/plugin-automation 0.7.5-main.e9bb01b → 0.7.5-staging.2ff1350

package/dist/lib/node/chunk-BZFAEBME.cjs

@@ -0,0 +1,1747 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var chunk_BZFAEBME_exports = {};
+__export(chunk_BZFAEBME_exports, {
+  AiClient: () => AiClient,
+  AppGraphBuilder: () => AppGraphBuilder,
+  ChatContainer: () => ChatContainer,
+  ChatContainer_default: () => ChatContainer_default,
+  IntentResolver: () => IntentResolver,
+  ReactSurface: () => ReactSurface,
+  Thread: () => Thread,
+  ThreadContainer: () => ThreadContainer,
+  Toolbox: () => Toolbox,
+  ToolboxContainer: () => ToolboxContainer,
+  useServices: () => useServices
+});
+module.exports = __toCommonJS(chunk_BZFAEBME_exports);
+var import_chunk_VNBYGJ4K = require("./chunk-VNBYGJ4K.cjs");
+var import_chunk_NUOYHYAF = require("./chunk-NUOYHYAF.cjs");
+var import_chunk_BAQRBGOJ = require("./chunk-BAQRBGOJ.cjs");
+var import_react = __toESM(require("react"));
+var import_react_ui_stack = require("@dxos/react-ui-stack");
+var import_react2 = __toESM(require("react"));
+var import_app_framework = require("@dxos/app-framework");
+var import_plugin_transcription = require("@dxos/plugin-transcription");
+var import_halo = require("@dxos/react-client/halo");
+var import_react_ui_components = require("@dxos/react-ui-components");
+var import_react_ui_theme = require("@dxos/react-ui-theme");
+var import_util = require("@dxos/util");
+var import_react3 = __toESM(require("react"));
+var import_invariant = require("@dxos/invariant");
+var import_react_ui = require("@dxos/react-ui");
+var import_react_ui_components2 = require("@dxos/react-ui-components");
+var import_react_ui_syntax_highlighter = require("@dxos/react-ui-syntax-highlighter");
+var import_react_ui_theme2 = require("@dxos/react-ui-theme");
+var import_util2 = require("@dxos/util");
+var import_react4 = __toESM(require("react"));
+var import_log = require("@dxos/log");
+var import_react_ui_components3 = require("@dxos/react-ui-components");
+var import_react_ui_syntax_highlighter2 = require("@dxos/react-ui-syntax-highlighter");
+var import_react5 = __toESM(require("react"));
+var import_app_framework2 = require("@dxos/app-framework");
+var import_functions = require("@dxos/functions");
+var import_log2 = require("@dxos/log");
+var import_echo = require("@dxos/react-client/echo");
+var import_react_ui_theme3 = require("@dxos/react-ui-theme");
+var import_artifact = require("@dxos/artifact");
+var import_echo_schema = require("@dxos/echo-schema");
+var import_functions2 = require("@dxos/functions");
+var import_log3 = require("@dxos/log");
+var import_echo2 = require("@dxos/react-client/echo");
+var import_jsonpointer = __toESM(require("jsonpointer"));
+var import_artifact2 = require("@dxos/artifact");
+var import_echo_schema2 = require("@dxos/echo-schema");
+var import_invariant2 = require("@dxos/invariant");
+var import_log4 = require("@dxos/log");
+var import_util3 = require("@dxos/util");
+var import_react6 = __toESM(require("react"));
+var import_react_ui2 = require("@dxos/react-ui");
+var import_react_ui_editor = require("@dxos/react-ui-editor");
+var import_react_ui_theme4 = require("@dxos/react-ui-theme");
+var import_state = require("@codemirror/state");
+var import_view = require("@codemirror/view");
+var import_react7 = __toESM(require("react"));
+var import_plugin_transcription2 = require("@dxos/plugin-transcription");
+var import_react_ui3 = require("@dxos/react-ui");
+var import_react_ui_sfx = require("@dxos/react-ui-sfx");
+var import_react_ui_theme5 = require("@dxos/react-ui-theme");
+var import_react8 = __toESM(require("react"));
+var import_invariant3 = require("@dxos/invariant");
+var import_log5 = require("@dxos/log");
+var import_echo3 = require("@dxos/react-client/echo");
+var import_signals_core = require("@preact/signals-core");
+var import_artifact3 = require("@dxos/artifact");
+var import_assistant = require("@dxos/assistant");
+var import_echo_schema3 = require("@dxos/echo-schema");
+var import_invariant4 = require("@dxos/invariant");
+var import_log6 = require("@dxos/log");
+var import_react9 = require("react");
+var import_app_framework3 = require("@dxos/app-framework");
+var import_artifact4 = require("@dxos/artifact");
+var import_functions3 = require("@dxos/functions");
+var import_log7 = require("@dxos/log");
+var import_react_client = require("@dxos/react-client");
+var import_echo4 = require("@dxos/react-client/echo");
+var import_util4 = require("@dxos/util");
+var import_app_framework4 = require("@dxos/app-framework");
+var import_react10 = require("react");
+var import_async = require("@dxos/async");
+var import_context = require("@dxos/context");
+var import_functions4 = require("@dxos/functions");
+var import_functions5 = require("@dxos/functions");
+var import_invariant5 = require("@dxos/invariant");
+var import_log8 = require("@dxos/log");
+var import_react_client2 = require("@dxos/react-client");
+var import_echo5 = require("@dxos/react-client/echo");
+var import_async2 = require("@dxos/async");
+var import_echo_db = require("@dxos/echo-db");
+var import_functions6 = require("@dxos/functions");
+var import_invariant6 = require("@dxos/invariant");
+var import_keys = require("@dxos/keys");
+var import_log9 = require("@dxos/log");
+var import_react11 = require("react");
+var import_keys2 = require("@dxos/keys");
+var import_echo6 = require("@dxos/react-client/echo");
+var import_react_edge_client = require("@dxos/react-edge-client");
+var import_react12 = require("react");
+var import_artifact5 = require("@dxos/artifact");
+var import_echo_schema4 = require("@dxos/echo-schema");
+var import_echo_schema5 = require("@dxos/echo-schema");
+var import_react13 = require("react");
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/plugins/experimental/plugin-automation/src/components/Thread/ToolInvocations.tsx";
+var isToolMessage = (message) => {
+  return message.content.some((block) => block.type === "tool_use" || block.type === "tool_result");
+};
+var ToolBlock = ({ classNames, message }) => {
+  const { content = [] } = message;
+  let request;
+  const blocks = content.filter((block) => block.type === "tool_use" || block.type === "tool_result");
+  const items = blocks.map((block) => {
+    switch (block.type) {
+      case "tool_use": {
+        request = block;
+        return {
+          title: `Calling ${block.name}...`,
+          block
+        };
+      }
+      case "tool_result": {
+        if (!request) {
+          import_log.log.warn("unexpected message", {
+            block
+          }, {
+            F: __dxlog_file,
+            L: 34,
+            S: void 0,
+            C: (f, a) => f(...a)
+          });
+          return {
+            title: "Error",
+            block
+          };
+        }
+        return {
+          title: `Processed ${request.name}`,
+          block
+        };
+      }
+      default: {
+        request = void 0;
+        return {
+          title: "Error",
+          block
+        };
+      }
+    }
+  });
+  return /* @__PURE__ */ import_react4.default.createElement(ToolContainer, {
+    classNames,
+    items
+  });
+};
+var ToolContainer = ({ classNames, items }) => {
+  const lines = items.map((item) => item.title);
+  const tabsRef = (0, import_react4.useRef)(null);
+  const [selected, setSelected] = (0, import_react4.useState)(0);
+  const [open, setOpen] = (0, import_react4.useState)(false);
+  (0, import_react4.useEffect)(() => {
+    if (open) {
+      tabsRef.current?.focus();
+    }
+  }, [
+    open
+  ]);
+  const handleSelect = (index) => {
+    if (index === selected) {
+      setOpen(false);
+    } else {
+      setSelected(index);
+    }
+  };
+  return /* @__PURE__ */ import_react4.default.createElement(import_react_ui_components3.ToggleContainer, {
+    classNames: [
+      "flex flex-col",
+      classNames
+    ],
+    title: /* @__PURE__ */ import_react4.default.createElement(import_react_ui_components3.StatusRoll, {
+      lines,
+      autoAdvance: true
+    }),
+    open,
+    onChangeOpen: setOpen
+  }, /* @__PURE__ */ import_react4.default.createElement("div", {
+    className: "grid grid-cols-[32px_1fr]"
+  }, /* @__PURE__ */ import_react4.default.createElement(import_react_ui_components3.NumericTabs, {
+    ref: tabsRef,
+    length: items.length,
+    selected,
+    onSelect: handleSelect
+  }), /* @__PURE__ */ import_react4.default.createElement(import_react_ui_syntax_highlighter2.Json, {
+    data: items[selected].block,
+    classNames: "!p-1 text-xs"
+  })));
+};
+var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/plugins/experimental/plugin-automation/src/tools/function.ts";
+var covertFunctionToTool = (fn, edgeUrl, spaceId) => {
+  if (!fn.description || !fn.inputSchema) {
+    return void 0;
+  }
+  const existingFunctionUrl = (0, import_functions2.getUserFunctionUrlInMetadata)((0, import_echo2.getMeta)(fn));
+  if (!existingFunctionUrl) {
+    return void 0;
+  }
+  const url = (0, import_functions2.getInvocationUrl)(existingFunctionUrl, edgeUrl, {
+    spaceId
+  });
+  return (0, import_artifact.defineTool)({
+    name: fn.name,
+    description: fn.description,
+    schema: (0, import_echo_schema.toEffectSchema)(fn.inputSchema),
+    execute: async (input) => {
+      import_log3.log.info("execute function tool", {
+        name: fn.name,
+        url,
+        input
+      }, {
+        F: __dxlog_file2,
+        L: 36,
+        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 import_artifact.ToolResult.Success(await response.text());
+    }
+  });
+};
+var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/plugins/experimental/plugin-automation/src/tools/openapi.ts";
+var createToolsFromService = async (service) => {
+  (0, import_invariant2.invariant)(service.interfaces?.length === 1 && service.interfaces[0].kind === "api", void 0, {
+    F: __dxlog_file3,
+    L: 22,
+    S: void 0,
+    A: [
+      "service.interfaces?.length === 1 && service.interfaces[0].kind === 'api'",
+      ""
+    ]
+  });
+  const iface = service.interfaces[0];
+  (0, import_invariant2.invariant)(iface.schemaUrl, void 0, {
+    F: __dxlog_file3,
+    L: 24,
+    S: void 0,
+    A: [
+      "iface.schemaUrl",
+      ""
+    ]
+  });
+  (0, import_invariant2.invariant)(iface.schemaUrl, void 0, {
+    F: __dxlog_file3,
+    L: 25,
+    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();
+  (0, import_log4.log)("spec", {
+    spec
+  }, {
+    F: __dxlog_file3,
+    L: 32,
+    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;
+      (0, import_log4.log)("methodItem", {
+        path,
+        method,
+        methodItem
+      }, {
+        F: __dxlog_file3,
+        L: 44,
+        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) {
+        (0, import_log4.log)("parameter", {
+          parameter
+        }, {
+          F: __dxlog_file3,
+          L: 59,
+          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] = (0, import_echo_schema2.normalizeSchema)(parameter.schema);
+        } else if (typeof parameter.type === "string") {
+          const { name, in: _in, required, ...schema } = parameter;
+          inputSchema.properties[name] = (0, import_echo_schema2.normalizeSchema)(schema);
+          if (required) {
+            inputSchema.required ??= [];
+            inputSchema.required.push(name);
+          }
+        }
+      }
+      (0, import_log4.log)("inputSchema", {
+        inputSchema
+      }, {
+        F: __dxlog_file3,
+        L: 84,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+      import_echo_schema2.S.validateSync(import_echo_schema2.JsonSchemaType)(inputSchema);
+      const description = methodItem.description ?? methodItem.summary;
+      if (!description) {
+        import_log4.log.warn("no description", {
+          path,
+          method
+        }, {
+          F: __dxlog_file3,
+          L: 89,
+          S: void 0,
+          C: (f, a) => f(...a)
+        });
+        continue;
+      }
+      const endpoint = {
+        document: spec,
+        path,
+        method,
+        parameters: endpointParameters,
+        authorization: options?.authorization
+      };
+      tools.push({
+        name: getToolName(path, method, methodItem),
+        description: options?.instructions ? `${options.instructions}
+
+${description}` : description,
+        parameters: inputSchema,
+        execute: async (input) => {
+          const response = await callApiEndpoint(endpoint, input);
+          return import_artifact2.ToolResult.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) => {
+  import_log4.log.info("endpoint", {
+    method: endpoint.method,
+    name: endpoint.path,
+    input
+  }, {
+    F: __dxlog_file3,
+    L: 173,
+    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 = (0, import_echo_schema2.toEffectSchema)(parameter.schema);
+        import_echo_schema2.S.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";
+  }
+  import_log4.log.info("request", {
+    url,
+    request
+  }, {
+    F: __dxlog_file3,
+    L: 236,
+    S: void 0,
+    C: (f, a) => f(...a)
+  });
+  const response = await fetch(url, request);
+  import_log4.log.info("response", {
+    ok: response.ok,
+    status: response.status,
+    statusText: response.statusText
+  }, {
+    F: __dxlog_file3,
+    L: 239,
+    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;
+      }
+      import_log4.log.error("error", {
+        error
+      }, {
+        F: __dxlog_file3,
+        L: 257,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+      throw new Error(error.message);
+    } else {
+      const error = await response.text();
+      import_log4.log.error("error", {
+        error
+      }, {
+        F: __dxlog_file3,
+        L: 261,
+        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 {
+    (0, import_invariant2.invariant)(!isV3_1(endpoint.document), void 0, {
+      F: __dxlog_file3,
+      L: 272,
+      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": {
+      (0, import_invariant2.invariant)(authorization.placement.type === "authorization-header", void 0, {
+        F: __dxlog_file3,
+        L: 288,
+        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 (0, import_util3.deepMapValues)(schema, (value, recurse) => {
+    if (typeof value === "object" && value !== null && "$ref" in value && typeof value.$ref === "string") {
+      if (value.$ref.startsWith("#")) {
+        const resolved = import_jsonpointer.default.get(base, value.$ref.slice(1));
+        if (resolved) {
+          return recurse(resolved);
+        } else {
+          import_log4.log.warn("unresolved", {
+            ref: value.$ref,
+            base
+          }, {
+            F: __dxlog_file3,
+            L: 321,
+            S: void 0,
+            C: (f, a) => f(...a)
+          });
+        }
+      }
+    }
+    return recurse(value);
+  });
+};
+var isV3_1 = (document2) => {
+  return document2.openapi === "3.0.1";
+};
+var __dxlog_file4 = "/home/runner/work/dxos/dxos/packages/plugins/experimental/plugin-automation/src/components/Toolbox/Toolbox.tsx";
+var stripClassNames = "odd:bg-neutral-50 dark:odd:bg-neutral-800";
+var Toolbox = ({ classNames, artifacts, functions: functions2, services, striped }) => {
+  return /* @__PURE__ */ import_react5.default.createElement("div", {
+    className: (0, import_react_ui_theme3.mx)("flex overflow-hidden box-content py-2", classNames)
+  }, /* @__PURE__ */ import_react5.default.createElement("div", {
+    className: "grid grid-cols-[6rem_8rem_1fr] overflow-y-auto"
+  }, artifacts?.map(({ id, tools, ...rest }) => tools.map(({ name, description }, i) => /* @__PURE__ */ import_react5.default.createElement("div", {
+    key: `${id}-${i}`,
+    className: (0, import_react_ui_theme3.mx)("col-span-full grid grid-cols-subgrid text-xs px-2", striped && stripClassNames)
+  }, /* @__PURE__ */ import_react5.default.createElement("div", {
+    className: "text-primary-500 truncate"
+  }, i === 0 && id), /* @__PURE__ */ import_react5.default.createElement("div", {
+    className: "truncate"
+  }, name), /* @__PURE__ */ import_react5.default.createElement("div", {
+    className: "text-subdued line-clamp-3"
+  }, description)))), functions2?.map(({ name, description }) => /* @__PURE__ */ import_react5.default.createElement("div", {
+    key: name,
+    className: (0, import_react_ui_theme3.mx)("col-span-full grid grid-cols-subgrid text-xs px-2", striped && stripClassNames)
+  }, /* @__PURE__ */ import_react5.default.createElement("div", {
+    className: "text-primary-500 truncate"
+  }, "function"), /* @__PURE__ */ import_react5.default.createElement("div", {
+    className: "truncate"
+  }, name), /* @__PURE__ */ import_react5.default.createElement("div", {
+    className: "truncate"
+  }, description))), services?.map(({ service, tools }) => tools.map(({ name, description }, i) => /* @__PURE__ */ import_react5.default.createElement("div", {
+    key: `${service.id}-${name}`,
+    className: (0, import_react_ui_theme3.mx)("col-span-full grid grid-cols-subgrid text-xs px-2", striped && stripClassNames)
+  }, /* @__PURE__ */ import_react5.default.createElement("div", {
+    className: "text-primary-500 truncate"
+  }, i === 0 && service.serviceId), /* @__PURE__ */ import_react5.default.createElement("div", {
+    className: "truncate"
+  }, name), /* @__PURE__ */ import_react5.default.createElement("div", {
+    className: "truncate"
+  }, description))))));
+};
+var ToolboxContainer = ({ classNames, space }) => {
+  const artifactDefinitions = (0, import_app_framework2.useCapabilities)(import_app_framework2.Capabilities.ArtifactDefinition);
+  const functions2 = (0, import_echo.useQuery)(space, import_echo.Filter.schema(import_functions.FunctionType));
+  const services = (0, import_echo.useQuery)(space, import_echo.Filter.schema(import_chunk_NUOYHYAF.ServiceType));
+  const [serviceTools, setServiceTools] = (0, import_react5.useState)([]);
+  (0, import_react5.useEffect)(() => {
+    (0, import_log2.log)("creating service tools...", void 0, {
+      F: __dxlog_file4,
+      L: 77,
+      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
+  ]);
+  return /* @__PURE__ */ import_react5.default.createElement(Toolbox, {
+    classNames,
+    artifacts: artifactDefinitions,
+    functions: functions2,
+    services: serviceTools
+  });
+};
+var __dxlog_file5 = "/home/runner/work/dxos/dxos/packages/plugins/experimental/plugin-automation/src/components/Thread/ThreadMessage.tsx";
+var userClassNames = "bg-[--user-fill]";
+var panelClassNames = "flex flex-col w-full bg-groupSurface rounded-md";
+var ToggleContainer2 = (props) => {
+  return /* @__PURE__ */ import_react3.default.createElement(import_react_ui_components2.ToggleContainer, {
+    ...props,
+    classNames: (0, import_react_ui_theme2.mx)(panelClassNames, props.classNames)
+  });
+};
+var MessageContainer = ({ children, classNames, user }) => {
+  return /* @__PURE__ */ import_react3.default.createElement("div", {
+    role: "list-item",
+    className: (0, import_react_ui_theme2.mx)("flex w-full", user && "justify-end", classNames)
+  }, /* @__PURE__ */ import_react3.default.createElement("div", {
+    className: (0, import_react_ui_theme2.mx)(user ? [
+      "px-2 py-1 rounded-md",
+      userClassNames
+    ] : "w-full")
+  }, children));
+};
+var ThreadMessage = ({ classNames, space, message, onPrompt }) => {
+  const { role, content = [] } = message;
+  if (isToolMessage(message)) {
+    return /* @__PURE__ */ import_react3.default.createElement(MessageContainer, {
+      classNames
+    }, /* @__PURE__ */ import_react3.default.createElement(ToolBlock, {
+      space,
+      classNames: panelClassNames,
+      message
+    }));
+  }
+  return /* @__PURE__ */ import_react3.default.createElement("div", {
+    role: "none",
+    className: "flex flex-col gap-2"
+  }, content.map((block, idx) => /* @__PURE__ */ import_react3.default.createElement(MessageContainer, {
+    key: idx,
+    classNames,
+    user: block.type === "text" && role === "user"
+  }, /* @__PURE__ */ import_react3.default.createElement(Block, {
+    space,
+    block,
+    onPrompt
+  }))));
+};
+var Block = ({ space, block, onPrompt }) => {
+  const Component = components[block.type] ?? components.default;
+  return /* @__PURE__ */ import_react3.default.createElement(Component, {
+    space,
+    block,
+    onPrompt
+  });
+};
+var components = {
+  //
+  // Text
+  //
+  ["text"]: ({ block }) => {
+    (0, import_invariant.invariant)(block.type === "text", void 0, {
+      F: __dxlog_file5,
+      L: 85,
+      S: void 0,
+      A: [
+        "block.type === 'text'",
+        ""
+      ]
+    });
+    const title = block.disposition ? titles[block.disposition] : void 0;
+    if (!title) {
+      return /* @__PURE__ */ import_react3.default.createElement(import_react_ui_components2.MarkdownViewer, {
+        content: block.text
+      });
+    }
+    return /* @__PURE__ */ import_react3.default.createElement(ToggleContainer2, {
+      // open={open}
+      defaultOpen: block.disposition === "cot" && block.pending,
+      title,
+      icon: block.pending ? /* @__PURE__ */ import_react3.default.createElement(import_react_ui.Icon, {
+        icon: "ph--circle-notch--regular",
+        classNames: "text-subdued ml-2 animate-spin",
+        size: 4
+      }) : void 0
+    }, /* @__PURE__ */ import_react3.default.createElement(import_react_ui_components2.MarkdownViewer, {
+      content: block.text,
+      classNames: [
+        "pbe-2",
+        block.disposition === "cot" && "text-sm text-subdued"
+      ]
+    }));
+  },
+  //
+  // JSON
+  //
+  ["json"]: ({ space, block, onPrompt }) => {
+    (0, import_invariant.invariant)(block.type === "json", void 0, {
+      F: __dxlog_file5,
+      L: 123,
+      S: void 0,
+      A: [
+        "block.type === 'json'",
+        ""
+      ]
+    });
+    switch (block.disposition) {
+      case "tool_list": {
+        return /* @__PURE__ */ import_react3.default.createElement(ToggleContainer2, {
+          title: titles[block.disposition],
+          defaultOpen: true
+        }, /* @__PURE__ */ import_react3.default.createElement(ToolboxContainer, {
+          space
+        }));
+      }
+      case "suggest": {
+        const { text = "" } = (0, import_util2.safeParseJson)(block.json ?? "{}") ?? {};
+        return /* @__PURE__ */ import_react3.default.createElement(import_react_ui.IconButton, {
+          icon: "ph--lightning--regular",
+          label: text,
+          onClick: () => onPrompt?.(text)
+        });
+      }
+      case "select": {
+        const { options = [] } = (0, import_util2.safeParseJson)(block.json ?? "{}") ?? {};
+        return /* @__PURE__ */ import_react3.default.createElement(import_react_ui.ButtonGroup, null, options.map((option) => /* @__PURE__ */ import_react3.default.createElement(import_react_ui.Button, {
+          key: option,
+          onClick: () => onPrompt?.(option)
+        }, option)));
+      }
+      default: {
+        const title = block.disposition ? titles[block.disposition] : void 0;
+        return /* @__PURE__ */ import_react3.default.createElement(ToggleContainer2, {
+          title: title ?? "JSON"
+        }, /* @__PURE__ */ import_react3.default.createElement(import_react_ui_syntax_highlighter.Json, {
+          data: (0, import_util2.safeParseJson)(block.json ?? block),
+          classNames: "!p-1 text-xs"
+        }));
+      }
+    }
+  },
+  //
+  // Default
+  //
+  default: ({ block }) => {
+    let title = titles[block.type];
+    if (block.type === "tool_use") {
+      title = `Tool [${block.name}]`;
+    }
+    return /* @__PURE__ */ import_react3.default.createElement(ToggleContainer2, {
+      title: title ?? "JSON"
+    }, /* @__PURE__ */ import_react3.default.createElement(import_react_ui_syntax_highlighter.Json, {
+      data: block,
+      classNames: "!p-1 text-xs"
+    }));
+  }
+};
+var titles = {
+  ["cot"]: "Chain of thought",
+  ["artifact"]: "Artifact",
+  ["tool_use"]: "Tool request",
+  ["tool_result"]: "Tool result",
+  ["tool_list"]: "Tools"
+};
+var messageReducer = ({ current, messages }, message) => {
+  let i = 0;
+  for (const block of message.content) {
+    switch (block.type) {
+      case "tool_use":
+      case "tool_result": {
+        if (current) {
+          current.content.push(block);
+        } else {
+          current = {
+            id: [
+              message.id,
+              i
+            ].join("_"),
+            role: message.role,
+            content: [
+              block
+            ]
+          };
+          messages.push(current);
+        }
+        break;
+      }
+      case "text":
+      default: {
+        current = void 0;
+        messages.push({
+          id: [
+            message.id,
+            i
+          ].join("_"),
+          role: message.role,
+          content: [
+            block
+          ]
+        });
+        break;
+      }
+    }
+    i++;
+  }
+  return {
+    current,
+    messages
+  };
+};
+var createAutocompleteExtension = ({ onSubmit, onSuggest }) => {
+  const suggestionPlugin = import_view.ViewPlugin.fromClass(class {
+    constructor(view) {
+      this._currentSuggestion = null;
+      this._decorations = this.computeDecorations(view);
+    }
+    update(update) {
+      if (update.docChanged || update.selectionSet) {
+        this._decorations = this.computeDecorations(update.view);
+      }
+    }
+    computeDecorations(view) {
+      const text = view.state.doc.toString();
+      const suggestions = onSuggest?.(text) ?? [];
+      if (!suggestions.length) {
+        this._currentSuggestion = null;
+        return import_view.Decoration.none;
+      }
+      this._currentSuggestion = suggestions[0];
+      const suffix = this._currentSuggestion.slice(text.length);
+      if (!suffix) {
+        return import_view.Decoration.none;
+      }
+      return import_view.Decoration.set([
+        import_view.Decoration.widget({
+          widget: new InlineSuggestionWidget(suffix),
+          side: 1
+        }).range(view.state.doc.length)
+      ]);
+    }
+    completeSuggestion(view) {
+      if (!this._currentSuggestion) {
+        return false;
+      }
+      const text = view.state.doc.toString();
+      const suffix = this._currentSuggestion.slice(text.length);
+      if (!suffix) {
+        return false;
+      }
+      view.dispatch({
+        changes: {
+          from: view.state.doc.length,
+          insert: suffix
+        },
+        selection: {
+          anchor: view.state.doc.length + suffix.length
+        }
+      });
+      return true;
+    }
+  }, {
+    decorations: (v) => v._decorations
+  });
+  return [
+    suggestionPlugin,
+    import_view.EditorView.theme({
+      ".cm-inline-suggestion": {
+        opacity: 0.4
+      }
+    }),
+    // Accept the current suggestion.
+    import_state.Prec.highest(import_view.keymap.of([
+      {
+        key: "Tab",
+        preventDefault: true,
+        run: (view) => {
+          const plugin = view.plugin(suggestionPlugin);
+          return plugin?.completeSuggestion(view) ?? false;
+        }
+      },
+      {
+        key: "ArrowRight",
+        preventDefault: true,
+        run: (view) => {
+          if (view.state.selection.main.head !== view.state.doc.length) {
+            return false;
+          }
+          const plugin = view.plugin(suggestionPlugin);
+          return plugin?.completeSuggestion(view) ?? false;
+        }
+      },
+      {
+        key: "Enter",
+        preventDefault: true,
+        run: (view) => {
+          const text = view.state.doc.toString().trim();
+          if (text.length > 0 && onSubmit) {
+            const reset = onSubmit(text);
+            if (reset) {
+              view.dispatch({
+                changes: {
+                  from: 0,
+                  to: view.state.doc.length,
+                  insert: ""
+                }
+              });
+            }
+          }
+          return true;
+        }
+      },
+      {
+        key: "Shift-Enter",
+        preventDefault: true,
+        run: (view) => {
+          view.dispatch({
+            changes: {
+              from: view.state.selection.main.head,
+              insert: "\n"
+            },
+            selection: {
+              anchor: view.state.selection.main.head + 1,
+              head: view.state.selection.main.head + 1
+            }
+          });
+          return true;
+        }
+      },
+      {
+        key: "Escape",
+        preventDefault: true,
+        run: (view) => {
+          view.dispatch({
+            changes: {
+              from: 0,
+              to: view.state.doc.length,
+              insert: ""
+            }
+          });
+          return true;
+        }
+      }
+    ]))
+  ];
+};
+var InlineSuggestionWidget = class extends import_view.WidgetType {
+  constructor(suffix) {
+    super();
+    this.suffix = suffix;
+  }
+  toDOM() {
+    const span = document.createElement("span");
+    span.textContent = this.suffix;
+    span.className = "cm-inline-suggestion";
+    return span;
+  }
+  eq(other) {
+    return other.suffix === this.suffix;
+  }
+};
+var Prompt = /* @__PURE__ */ (0, import_react6.forwardRef)(({ classNames, autoFocus, lineWrapping = false, placeholder, onSubmit, onSuggest }, forwardRef2) => {
+  const { themeMode } = (0, import_react_ui2.useThemeContext)();
+  const { parentRef, view } = (0, import_react_ui_editor.useTextEditor)({
+    autoFocus,
+    extensions: [
+      (0, import_react_ui_editor.createBasicExtensions)({
+        bracketMatching: false,
+        lineWrapping,
+        placeholder
+      }),
+      (0, import_react_ui_editor.createThemeExtensions)({
+        themeMode
+      }),
+      createAutocompleteExtension({
+        onSubmit,
+        onSuggest
+      })
+    ]
+  }, [
+    themeMode,
+    onSubmit,
+    onSuggest
+  ]);
+  (0, import_react6.useImperativeHandle)(forwardRef2, () => {
+    return {
+      focus: () => {
+        view?.focus();
+      },
+      setText: (text) => {
+        view?.dispatch({
+          changes: {
+            from: 0,
+            to: view.state.doc.length,
+            insert: text
+          },
+          selection: {
+            anchor: text.length,
+            head: text.length
+          }
+        });
+      }
+    };
+  }, [
+    view,
+    onSubmit
+  ]);
+  return /* @__PURE__ */ import_react6.default.createElement("div", {
+    ref: parentRef,
+    className: (0, import_react_ui_theme4.mx)("w-full overflow-hidden", classNames)
+  });
+});
+var PromptBar = ({ classNames, placeholder, processing, error, microphone, onCancel, ...props }) => {
+  const { t } = (0, import_react_ui3.useTranslation)(import_chunk_BAQRBGOJ.AUTOMATION_PLUGIN);
+  const promptRef = (0, import_react7.useRef)(null);
+  const [active, setActive] = (0, import_react7.useState)(false);
+  const { recording } = (0, import_plugin_transcription2.useVoiceInput)({
+    active,
+    onUpdate: (text) => {
+      promptRef.current?.setText(text);
+      promptRef.current?.focus();
+    }
+  });
+  return /* @__PURE__ */ import_react7.default.createElement("div", {
+    className: (0, import_react_ui_theme5.mx)("flex shrink-0 w-full grid grid-cols-[var(--rail-action)_1fr_var(--rail-action)] overflow-hidden", classNames)
+  }, /* @__PURE__ */ import_react7.default.createElement("div", {
+    className: "flex w-[--rail-action] h-[--rail-action] items-center justify-center"
+  }, error && /* @__PURE__ */ import_react7.default.createElement(import_react_ui3.Icon, {
+    icon: "ph--warning-circle--regular",
+    classNames: import_react_ui_theme5.errorText,
+    size: 5
+  }) || /* @__PURE__ */ import_react7.default.createElement(import_react_ui_sfx.Spinner, {
+    active: processing
+  })), /* @__PURE__ */ import_react7.default.createElement(Prompt, {
+    ref: promptRef,
+    autoFocus: true,
+    classNames: "pbs-2",
+    lineWrapping: true,
+    placeholder: placeholder ?? t("prompt placeholder"),
+    ...props
+  }), (onCancel || microphone) && /* @__PURE__ */ import_react7.default.createElement("div", {
+    className: "flex w-[--rail-action] h-[--rail-action] items-center justify-center"
+  }, processing && onCancel && /* @__PURE__ */ import_react7.default.createElement(import_react_ui3.IconButton, {
+    classNames: "px-1.5",
+    variant: "ghost",
+    size: 5,
+    icon: "ph--x--regular",
+    iconOnly: true,
+    label: t("cancel processing button"),
+    onClick: onCancel
+  }), !processing && microphone && /* @__PURE__ */ import_react7.default.createElement(import_react_ui3.IconButton, {
+    classNames: (0, import_react_ui_theme5.mx)("px-1.5", recording && "bg-primary-500"),
+    variant: "ghost",
+    size: 5,
+    icon: "ph--microphone--regular",
+    iconOnly: true,
+    noTooltip: true,
+    label: t("microphone button"),
+    onMouseDown: () => setActive(true),
+    onMouseUp: () => setActive(false),
+    onTouchStart: () => setActive(true),
+    onTouchEnd: () => setActive(false)
+  })));
+};
+var Thread = ({ classNames, space, messages, collapse = true, processing, error, debug, onSubmit, onCancel, onPrompt, onDelete }) => {
+  const hasTrascription = (0, import_app_framework.useCapabilities)(import_plugin_transcription.TranscriptionCapabilities.Transcription).length > 0;
+  const scroller = (0, import_react2.useRef)(null);
+  const identity = (0, import_halo.useIdentity)();
+  const fallbackValue = (0, import_util.keyToFallback)(identity.identityKey);
+  const userHue = identity.profile?.data?.hue || fallbackValue.hue;
+  const handleSubmit = (0, import_react2.useCallback)((value) => {
+    onSubmit?.(value);
+    scroller.current?.scrollToBottom();
+    return true;
+  }, [
+    onSubmit
+  ]);
+  const { messages: filteredMessages = [] } = (0, import_react2.useMemo)(() => {
+    if (collapse) {
+      return (messages ?? []).reduce(messageReducer, {
+        messages: []
+      });
+    } else {
+      return {
+        messages: messages ?? []
+      };
+    }
+  }, [
+    messages,
+    collapse
+  ]);
+  return /* @__PURE__ */ import_react2.default.createElement(import_react2.default.Fragment, null, /* @__PURE__ */ import_react2.default.createElement(import_react_ui_components.ScrollContainer, {
+    ref: scroller,
+    fade: true
+  }, /* @__PURE__ */ import_react2.default.createElement("div", {
+    role: "none",
+    className: (0, import_react_ui_theme.mx)(filteredMessages.length > 0 && "pbs-6 pbe-6", classNames),
+    style: {
+      "--user-fill": `var(--dx-${userHue}Fill)`
+    }
+  }, filteredMessages.map((message) => /* @__PURE__ */ import_react2.default.createElement(ThreadMessage, {
+    key: message.id,
+    classNames: "px-4 pbe-4",
+    space,
+    message,
+    debug,
+    onPrompt,
+    onDelete
+  })))), onSubmit && /* @__PURE__ */ import_react2.default.createElement(PromptBar, {
+    microphone: hasTrascription,
+    processing,
+    error,
+    onSubmit: handleSubmit,
+    onCancel
+  }));
+};
+var __dxlog_file6 = "/home/runner/work/dxos/dxos/packages/plugins/experimental/plugin-automation/src/hooks/processor.ts";
+var defaultOptions = {
+  model: "@anthropic/claude-3-5-sonnet-20241022",
+  systemPrompt: "you are a helpful assistant"
+};
+var ChatProcessor = class {
+  constructor(_client, _tools, _extensions, _options = defaultOptions) {
+    this._client = _client;
+    this._tools = _tools;
+    this._extensions = _extensions;
+    this._options = _options;
+    this._parser = new import_assistant.MixedStreamParser();
+    this._pending = (0, import_signals_core.signal)([]);
+    this._block = (0, import_signals_core.signal)(void 0);
+    this._history = [];
+    this.streaming = (0, import_signals_core.computed)(() => this._block.value !== void 0);
+    this.error = (0, import_signals_core.signal)(void 0);
+    this.messages = (0, import_signals_core.computed)(() => {
+      const messages = [
+        ...this._pending.value
+      ];
+      if (this._block.value) {
+        const current = messages.pop();
+        (0, import_invariant4.invariant)(current, void 0, {
+          F: __dxlog_file6,
+          L: 84,
+          S: this,
+          A: [
+            "current",
+            ""
+          ]
+        });
+        const { content, ...rest } = current;
+        const message = {
+          ...rest,
+          content: [
+            ...content,
+            this._block.value
+          ]
+        };
+        messages.push(message);
+      }
+      return messages;
+    });
+    this._parser.message.on((message) => {
+      (0, import_signals_core.batch)(() => {
+        this._pending.value = [
+          ...this._pending.value,
+          message
+        ];
+        this._block.value = void 0;
+      });
+    });
+    this._parser.update.on((block) => {
+      (0, import_signals_core.batch)(() => {
+        this._block.value = block;
+      });
+    });
+  }
+  /**
+  * Update tools.
+  */
+  setTools(tools) {
+    this._tools = tools;
+  }
+  /**
+  * Make GPT request.
+  */
+  async request(message, options = {}) {
+    (0, import_signals_core.batch)(() => {
+      this._history = options.history ?? [];
+      this._pending.value = [
+        (0, import_echo_schema3.createStatic)(import_artifact3.Message, {
+          role: "user",
+          content: [
+            {
+              type: "text",
+              text: message
+            }
+          ]
+        })
+      ];
+      this._block.value = void 0;
+    });
+    await this._generate();
+    options.onComplete?.(this._pending.value);
+    return this._reset();
+  }
+  /**
+  * Cancel pending requests.
+  * @returns Pending requests (incl. the request message).
+  */
+  async cancel() {
+    import_log6.log.info("cancelling...", void 0, {
+      F: __dxlog_file6,
+      L: 147,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    this._stream?.abort();
+    return this._reset();
+  }
+  async _reset() {
+    const messages = this._pending.value;
+    (0, import_signals_core.batch)(() => {
+      this._history = [];
+      this._pending.value = [];
+      this._block.value = void 0;
+    });
+    return messages;
+  }
+  /**
+  * Generate a response from the AI service.
+  * Iterates over tool requests.
+  */
+  async _generate() {
+    try {
+      let more = false;
+      do {
+        import_log6.log.info("requesting", {
+          history: this._history.length,
+          messages: this._pending.value.length
+        }, {
+          F: __dxlog_file6,
+          L: 171,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        this._stream = await this._client.generate({
+          ...this._options,
+          // TODO(burdon): Rename messages or separate history/message.
+          history: [
+            ...this._history,
+            ...this._pending.value
+          ],
+          tools: this._tools
+        });
+        await this._parser.parse(this._stream);
+        await this._stream.complete();
+        import_log6.log.info("response", {
+          messages: this._pending.value
+        }, {
+          F: __dxlog_file6,
+          L: 184,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        more = false;
+        const message = this._pending.value.at(-1);
+        (0, import_invariant4.invariant)(message, void 0, {
+          F: __dxlog_file6,
+          L: 189,
+          S: this,
+          A: [
+            "message",
+            ""
+          ]
+        });
+        if ((0, import_assistant.isToolUse)(message)) {
+          import_log6.log.info("tool request...", void 0, {
+            F: __dxlog_file6,
+            L: 191,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          const response = await (0, import_assistant.runTools)({
+            message: this._pending.value.at(-1),
+            tools: this._tools ?? [],
+            extensions: this._extensions
+          });
+          import_log6.log.info("tool response", {
+            response
+          }, {
+            F: __dxlog_file6,
+            L: 198,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          switch (response.type) {
+            case "continue": {
+              this._pending.value = [
+                ...this._pending.value,
+                response.message
+              ];
+              more = true;
+              break;
+            }
+          }
+        }
+      } while (more);
+      import_log6.log.info("done", void 0, {
+        F: __dxlog_file6,
+        L: 209,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    } catch (err) {
+      import_log6.log.catch(err, void 0, {
+        F: __dxlog_file6,
+        L: 211,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      this.error.value = new Error("AI service error", {
+        cause: err
+      });
+    } finally {
+      this._stream = void 0;
+      this.error.value = void 0;
+    }
+  }
+};
+var AiClient = (0, import_app_framework4.lazy)(() => import("./ai-client-L5GUSAER.cjs"));
+var AppGraphBuilder = (0, import_app_framework4.lazy)(() => import("./app-graph-builder-OCSH5R6U.cjs"));
+var IntentResolver = (0, import_app_framework4.lazy)(() => import("./intent-resolver-KQGTYVF2.cjs"));
+var ReactSurface = (0, import_app_framework4.lazy)(() => import("./react-surface-IXKIJFRP.cjs"));
+var __dxlog_file7 = "/home/runner/work/dxos/dxos/packages/plugins/experimental/plugin-automation/src/hooks/useChatProcessor.tsx";
+var useChatProcessor = (space) => {
+  const aiClient = (0, import_app_framework3.useCapability)(import_chunk_VNBYGJ4K.AutomationCapabilities.AiClient);
+  const globalTools = (0, import_app_framework3.useCapabilities)(import_app_framework3.Capabilities.Tools);
+  const artifactDefinitions = (0, import_app_framework3.useCapabilities)(import_app_framework3.Capabilities.ArtifactDefinition);
+  const { dispatchPromise: dispatch } = (0, import_app_framework3.useIntentDispatcher)();
+  const services = (0, import_echo4.useQuery)(space, import_echo4.Filter.schema(import_chunk_NUOYHYAF.ServiceType));
+  const [serviceTools, setServiceTools] = (0, import_react9.useState)([]);
+  (0, import_react9.useEffect)(() => {
+    (0, import_log7.log)("creating service tools...", void 0, {
+      F: __dxlog_file7,
+      L: 33,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+    queueMicrotask(async () => {
+      const tools2 = await Promise.all(services.map((service) => createToolsFromService(service)));
+      setServiceTools(tools2.flat());
+    });
+  }, [
+    services
+  ]);
+  const config = (0, import_react_client.useConfig)();
+  const functions2 = (0, import_echo4.useQuery)(space, import_echo4.Filter.schema(import_functions3.FunctionType));
+  const [tools, extensions] = (0, import_react9.useMemo)(() => {
+    (0, import_log7.log)("creating tools...", void 0, {
+      F: __dxlog_file7,
+      L: 44,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+    const tools2 = [
+      ...globalTools.flat(),
+      ...artifactDefinitions.flatMap((definition) => definition.tools),
+      ...serviceTools,
+      ...functions2.map((fn) => covertFunctionToTool(fn, config.values.runtime?.services?.edge?.url ?? "", space?.id)).filter(import_util4.isNonNullable)
+    ];
+    const extensions2 = {
+      space,
+      dispatch
+    };
+    return [
+      tools2,
+      extensions2
+    ];
+  }, [
+    dispatch,
+    globalTools,
+    artifactDefinitions,
+    space,
+    serviceTools,
+    functions2
+  ]);
+  const systemPrompt = (0, import_react9.useMemo)(() => (0, import_artifact4.createSystemPrompt)({
+    artifacts: artifactDefinitions.map((definition) => definition.instructions)
+  }), [
+    artifactDefinitions
+  ]);
+  const processor = (0, import_react9.useMemo)(() => {
+    import_log7.log.info("creating processor...", void 0, {
+      F: __dxlog_file7,
+      L: 66,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+    return new ChatProcessor(aiClient, tools, extensions, {
+      // TODO(burdon): Move to settings.
+      model: "@anthropic/claude-3-5-sonnet-20241022",
+      systemPrompt
+    });
+  }, [
+    aiClient,
+    tools,
+    extensions,
+    systemPrompt
+  ]);
+  return processor;
+};
+var registerTriggersMutex = new import_async.Mutex();
+var useMessageQueue = (chat) => {
+  const space = (0, import_echo6.getSpace)(chat);
+  const queueDxn = (0, import_react11.useMemo)(() => {
+    const dxn = space && chat?.queue.dxn;
+    return dxn ? new import_keys2.DXN(import_keys2.DXN.kind.QUEUE, [
+      import_keys2.QueueSubspaceTags.DATA,
+      space.id,
+      dxn.parts.at(-1)
+    ]) : void 0;
+  }, [
+    space,
+    chat?.queue.dxn
+  ]);
+  const edgeClient = (0, import_react_edge_client.useEdgeClient)();
+  return (0, import_react_edge_client.useQueue)(edgeClient, queueDxn);
+};
+var functions = [
+  {
+    name: "example.com/function/chess",
+    version: "0.1.0",
+    inputSchema: (0, import_echo_schema4.toJsonSchema)(import_echo_schema4.S.Struct({
+      level: import_echo_schema4.S.Number.annotations({
+        [import_echo_schema4.AST.TitleAnnotationId]: "Level"
+      })
+    }))
+  },
+  {
+    name: "example.com/function/forex",
+    version: "0.1.0",
+    binding: "FOREX",
+    inputSchema: (0, import_echo_schema4.toJsonSchema)(import_echo_schema4.S.Struct({
+      from: import_echo_schema4.S.String.annotations({
+        [import_echo_schema4.AST.TitleAnnotationId]: "Currency from"
+      }),
+      to: import_echo_schema4.S.String.annotations({
+        [import_echo_schema4.AST.TitleAnnotationId]: "Currency to"
+      })
+    }))
+  }
+];
+var MockServiceRegistry = class {
+  async queryServices(query) {
+    return TEST_SERVICES;
+  }
+};
+var AMADEUS_AUTH = {
+  type: "oauth",
+  clientId: "BOEnpLd1sMyKjAPGKYeAPFFy60u53QEG",
+  clientSecret: "n4qldSN7usvD57gm",
+  tokenUrl: "https://test.api.amadeus.com/v1/security/oauth2/token",
+  grantType: "client_credentials"
+};
+var VISUAL_CROSSING_CREDENTIALS = {
+  type: "api-key",
+  key: "FDPRVS953KB4GQQLD25GRT975",
+  placement: {
+    type: "query",
+    name: "key"
+  }
+};
+var TEST_SERVICES = [
+  (0, import_echo_schema5.createStatic)(import_chunk_NUOYHYAF.ServiceType, {
+    serviceId: "amadeus.com/service/FlightSearch",
+    name: "Amadeus Flight Search",
+    description: "Search for local and international flights.",
+    category: "travel",
+    interfaces: [
+      {
+        kind: "api",
+        schemaUrl: "https://api.apis.guru/v2/specs/amadeus.com/amadeus-flight-availabilities-search/1.0.2/swagger.json",
+        authorization: AMADEUS_AUTH
+      }
+    ]
+  }),
+  (0, import_echo_schema5.createStatic)(import_chunk_NUOYHYAF.ServiceType, {
+    serviceId: "amadeus.com/service/HotelSearch",
+    name: "Amadeus Hotel Search",
+    description: "Search for local and international hotels.",
+    category: "travel",
+    interfaces: [
+      {
+        kind: "api",
+        schemaUrl: "https://api.apis.guru/v2/specs/amadeus.com/amadeus-hotel-search/3.0.8/swagger.json",
+        authorization: AMADEUS_AUTH
+      }
+    ]
+  }),
+  (0, import_echo_schema5.createStatic)(import_chunk_NUOYHYAF.ServiceType, {
+    serviceId: "visualcrossing.com/service/Weather",
+    name: "Visual Crossing Weather",
+    description: "Search for global weather forecasts.",
+    category: "weather",
+    interfaces: [
+      {
+        kind: "api",
+        schemaUrl: "https://api.apis.guru/v2/specs/visualcrossing.com/weather/4.6/openapi.json",
+        authorization: VISUAL_CROSSING_CREDENTIALS
+      }
+    ]
+  }),
+  // TODO(burdon): Needs auth.
+  (0, import_echo_schema5.createStatic)(import_chunk_NUOYHYAF.ServiceType, {
+    serviceId: "abstractapi.com/service/GeoLocation",
+    name: "Abstract GeoLocation",
+    description: "Get the location of any IP address.",
+    category: "geolocation",
+    interfaces: [
+      {
+        kind: "api",
+        schemaUrl: "https://api.apis.guru/v2/specs/abstractapi.com/geolocation/1.0.0/openapi.json"
+      }
+    ]
+  }),
+  //
+  // Testing
+  //
+  ...Array.from({
+    length: 20
+  }, (_, i) => (0, import_echo_schema5.createStatic)(import_chunk_NUOYHYAF.ServiceType, {
+    serviceId: `example.com/service/test-${i}`,
+    name: `Test ${i}`,
+    description: `Test ${i}`,
+    category: Object.keys(import_chunk_NUOYHYAF.categoryIcons)[Math.floor(Math.random() * Object.keys(import_chunk_NUOYHYAF.categoryIcons).length)],
+    interfaces: [
+      {
+        kind: "api",
+        schemaUrl: "https://petstore.swagger.io/v2/swagger.json"
+      }
+    ]
+  }))
+];
+var useServices = (space, query) => {
+  const registry = (0, import_react12.useMemo)(() => new MockServiceRegistry(), []);
+  const [services, setServices] = (0, import_react12.useState)([]);
+  (0, import_react12.useEffect)(() => {
+    const t = setTimeout(async () => {
+      const services2 = await registry.queryServices(query);
+      setServices(services2);
+    });
+    return () => clearTimeout(t);
+  }, [
+    query,
+    registry
+  ]);
+  return services;
+};
+var __dxlog_file8 = "/home/runner/work/dxos/dxos/packages/plugins/experimental/plugin-automation/src/components/Thread/ThreadContainer.tsx";
+var ThreadContainer = ({ classNames, chat, onOpenChange }) => {
+  const space = (0, import_echo3.getSpace)(chat);
+  const processor = useChatProcessor(space);
+  const messageQueue = useMessageQueue(chat);
+  const messages = [
+    ...messageQueue?.items ?? [],
+    ...processor.messages.value
+  ];
+  const handleSubmit = (0, import_react8.useCallback)((text) => {
+    if (processor.streaming.value) {
+      import_log5.log.warn("still processing", void 0, {
+        F: __dxlog_file8,
+        L: 31,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+      return false;
+    }
+    onOpenChange?.(true);
+    (0, import_invariant3.invariant)(messageQueue, void 0, {
+      F: __dxlog_file8,
+      L: 37,
+      S: void 0,
+      A: [
+        "messageQueue",
+        ""
+      ]
+    });
+    void processor.request(text, {
+      history: messageQueue.items,
+      onComplete: (messages2) => {
+        messageQueue.append(messages2);
+      }
+    });
+    return true;
+  }, [
+    processor,
+    messageQueue,
+    onOpenChange
+  ]);
+  const handleCancel = (0, import_react8.useCallback)(() => {
+    if (processor.streaming.value) {
+      void processor.cancel();
+    }
+  }, [
+    processor
+  ]);
+  return /* @__PURE__ */ import_react8.default.createElement(Thread, {
+    classNames,
+    space,
+    messages,
+    processing: processor.streaming.value,
+    error: processor.error.value,
+    onSubmit: handleSubmit,
+    onCancel: handleCancel
+  });
+};
+var ChatContainer = ({ chat, role }) => {
+  return /* @__PURE__ */ import_react.default.createElement(import_react_ui_stack.StackItem.Content, {
+    toolbar: false,
+    role,
+    classNames: "mli-auto w-full max-w-[50rem]"
+  }, /* @__PURE__ */ import_react.default.createElement(ThreadContainer, {
+    chat
+  }));
+};
+var ChatContainer_default = ChatContainer;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AiClient,
+  AppGraphBuilder,
+  ChatContainer,
+  ChatContainer_default,
+  IntentResolver,
+  ReactSurface,
+  Thread,
+  ThreadContainer,
+  Toolbox,
+  ToolboxContainer,
+  useServices
+});
+//# sourceMappingURL=chunk-BZFAEBME.cjs.map