@dxos/plugin-automation 0.7.4-staging.f7e8224 → 0.7.5-labs.071a3e2

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

@@ -0,0 +1,1531 @@
+import {
+  AutomationCapabilities
+} from "./chunk-BQHXJZ4K.mjs";
+import {
+  ServiceType,
+  categoryIcons
+} from "./chunk-43WRHV2L.mjs";
+import {
+  AUTOMATION_PLUGIN
+} from "./chunk-DQ7ZSYJJ.mjs";
+
+// packages/plugins/experimental/plugin-automation/src/components/ChatContainer/ChatContainer.tsx
+import React7, { useCallback as useCallback3 } from "react";
+import { invariant as invariant7 } from "@dxos/invariant";
+import { StackItem } from "@dxos/react-ui-stack";
+
+// packages/plugins/experimental/plugin-automation/src/hooks/processor.ts
+import { batch, computed, signal } from "@preact/signals-core";
+import { Message } from "@dxos/artifact";
+import { isToolUse, runTools, MixedStreamParser } from "@dxos/assistant";
+import { createStatic } from "@dxos/echo-schema";
+import { invariant } from "@dxos/invariant";
+import { log } from "@dxos/log";
+var __dxlog_file = "/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 MixedStreamParser();
+    this._pending = signal([]);
+    this._block = signal(void 0);
+    this._history = [];
+    this.streaming = computed(() => this._block.value !== void 0);
+    this.messages = computed(() => {
+      const messages = [
+        ...this._pending.value
+      ];
+      if (this._block.value) {
+        const current = messages.pop();
+        invariant(current, void 0, {
+          F: __dxlog_file,
+          L: 78,
+          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) => {
+      batch(() => {
+        this._pending.value = [
+          ...this._pending.value,
+          message
+        ];
+        this._block.value = void 0;
+      });
+    });
+    this._parser.update.on((block) => {
+      batch(() => {
+        this._block.value = block;
+      });
+    });
+  }
+  /**
+  * Update tools.
+  */
+  setTools(tools) {
+    this._tools = tools;
+  }
+  /**
+  * Make GPT request.
+  */
+  async request(message, options = {}) {
+    batch(() => {
+      this._history = options.history ?? [];
+      this._pending.value = [
+        createStatic(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() {
+    log.info("cancelling...", void 0, {
+      F: __dxlog_file,
+      L: 141,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    this._stream?.abort();
+    return this._reset();
+  }
+  async _reset() {
+    const messages = this._pending.value;
+    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 {
+        log.info("requesting...", {
+          history: this._history.length,
+          messages: this._pending.value.length
+        }, {
+          F: __dxlog_file,
+          L: 165,
+          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();
+        log.info("response", {
+          messages: this._pending.value
+        }, {
+          F: __dxlog_file,
+          L: 178,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        more = false;
+        const message = this._pending.value.at(-1);
+        invariant(message, void 0, {
+          F: __dxlog_file,
+          L: 183,
+          S: this,
+          A: [
+            "message",
+            ""
+          ]
+        });
+        if (isToolUse(message)) {
+          log.info("tool request...", void 0, {
+            F: __dxlog_file,
+            L: 185,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          const response = await runTools({
+            message: this._pending.value.at(-1),
+            tools: this._tools ?? [],
+            extensions: this._extensions
+          });
+          log.info("tool response", {
+            response
+          }, {
+            F: __dxlog_file,
+            L: 192,
+            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);
+    } catch (err) {
+      log.catch("request failed", {
+        err
+      }, {
+        F: __dxlog_file,
+        L: 204,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    } finally {
+      log.info("done", void 0, {
+        F: __dxlog_file,
+        L: 206,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      this._stream = void 0;
+    }
+  }
+};
+
+// packages/plugins/experimental/plugin-automation/src/hooks/useChatProcessor.tsx
+import { useEffect, useMemo, useState } from "react";
+import { Capabilities, useCapabilities, useCapability, useIntentDispatcher } from "@dxos/app-framework";
+import { createSystemPrompt } from "@dxos/artifact";
+import { FunctionType } from "@dxos/functions";
+import { useConfig } from "@dxos/react-client";
+import { Filter, getSpace, useQuery } from "@dxos/react-client/echo";
+import { isNotNullOrUndefined } from "@dxos/util";
+
+// packages/plugins/experimental/plugin-automation/src/capabilities/index.ts
+import { lazy } from "@dxos/app-framework";
+var AiClient = lazy(() => import("./ai-client-UJLNYP7B.mjs"));
+var AppGraphBuilder = lazy(() => import("./app-graph-builder-3H5TCRG4.mjs"));
+var IntentResolver = lazy(() => import("./intent-resolver-5YVZJFS3.mjs"));
+var ReactSurface = lazy(() => import("./react-surface-WRHRCEV5.mjs"));
+
+// packages/plugins/experimental/plugin-automation/src/tools/function.ts
+import { defineTool, ToolResult } from "@dxos/artifact";
+import { toEffectSchema } from "@dxos/echo-schema";
+import { getInvocationUrl, getUserFunctionUrlInMetadata } from "@dxos/functions";
+import { log as log2 } from "@dxos/log";
+import { getMeta } from "@dxos/react-client/echo";
+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 = getUserFunctionUrlInMetadata(getMeta(fn));
+  if (!existingFunctionUrl) {
+    return void 0;
+  }
+  const url = getInvocationUrl(existingFunctionUrl, edgeUrl, {
+    spaceId
+  });
+  return defineTool({
+    name: fn.name,
+    description: fn.description,
+    schema: toEffectSchema(fn.inputSchema),
+    execute: async (input) => {
+      log2.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 ToolResult.Success(await response.text());
+    }
+  });
+};
+
+// packages/plugins/experimental/plugin-automation/src/tools/openapi.ts
+import jsonpointer from "jsonpointer";
+import { ToolResult as ToolResult2 } from "@dxos/artifact";
+import { JsonSchemaType, normalizeSchema, S, toEffectSchema as toEffectSchema2 } from "@dxos/echo-schema";
+import { invariant as invariant2 } from "@dxos/invariant";
+import { log as log3 } from "@dxos/log";
+import { deepMapValues } from "@dxos/util";
+var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/plugins/experimental/plugin-automation/src/tools/openapi.ts";
+var createToolsFromService = async (service) => {
+  invariant2(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];
+  invariant2(iface.schemaUrl, void 0, {
+    F: __dxlog_file3,
+    L: 24,
+    S: void 0,
+    A: [
+      "iface.schemaUrl",
+      ""
+    ]
+  });
+  invariant2(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();
+  log3("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;
+      log3("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) {
+        log3("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] = 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);
+          }
+        }
+      }
+      log3("inputSchema", {
+        inputSchema
+      }, {
+        F: __dxlog_file3,
+        L: 84,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+      S.validateSync(JsonSchemaType)(inputSchema);
+      const description = methodItem.description ?? methodItem.summary;
+      if (!description) {
+        log3.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 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) => {
+  log3.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 = toEffectSchema2(parameter.schema);
+        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";
+  }
+  log3.info("request", {
+    url,
+    request
+  }, {
+    F: __dxlog_file3,
+    L: 236,
+    S: void 0,
+    C: (f, a) => f(...a)
+  });
+  const response = await fetch(url, request);
+  log3.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;
+      }
+      log3.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();
+      log3.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 {
+    invariant2(!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": {
+      invariant2(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 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 {
+          log3.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 = (document) => {
+  return document.openapi === "3.0.1";
+};
+
+// packages/plugins/experimental/plugin-automation/src/hooks/useChatProcessor.tsx
+var useChatProcessor = (chat) => {
+  const aiClient = useCapability(AutomationCapabilities.AiClient);
+  const globalTools = useCapabilities(Capabilities.Tools);
+  const artifactDefinitions = useCapabilities(Capabilities.ArtifactDefinition);
+  const { dispatchPromise: dispatch } = useIntentDispatcher();
+  const space = getSpace(chat);
+  const services = useQuery(space, Filter.schema(ServiceType));
+  const [serviceTools, setServiceTools] = useState([]);
+  useEffect(() => {
+    queueMicrotask(async () => {
+      const tools2 = await Promise.all(services.map((service) => createToolsFromService(service)));
+      setServiceTools(tools2.flat());
+    });
+  }, [
+    services
+  ]);
+  const config = useConfig();
+  const functions2 = useQuery(space, Filter.schema(FunctionType));
+  const tools = useMemo(() => [
+    ...globalTools.flat(),
+    ...artifactDefinitions.flatMap((definition) => definition.tools),
+    ...serviceTools,
+    ...functions2.map((fn) => covertFunctionToTool(fn, config.values.runtime?.services?.edge?.url ?? "", space?.id)).filter(isNotNullOrUndefined)
+  ], [
+    globalTools,
+    artifactDefinitions,
+    serviceTools,
+    functions2,
+    space?.id
+  ]);
+  const systemPrompt = useMemo(() => createSystemPrompt({
+    artifacts: artifactDefinitions.map((definition) => definition.instructions)
+  }), [
+    artifactDefinitions
+  ]);
+  const processor = useMemo(() => new ChatProcessor(aiClient, tools, {
+    space,
+    dispatch
+  }, {
+    model: "@anthropic/claude-3-5-sonnet-20241022",
+    systemPrompt
+  }), [
+    aiClient,
+    tools,
+    space,
+    dispatch,
+    systemPrompt
+  ]);
+  return processor;
+};
+
+// packages/plugins/experimental/plugin-automation/src/hooks/useLocalTriggerManager.ts
+import { useEffect as useEffect2, useState as useState2 } from "react";
+import { Mutex } from "@dxos/async";
+import { Context } from "@dxos/context";
+import { createSubscriptionTrigger } from "@dxos/functions";
+import { FunctionTrigger } from "@dxos/functions";
+import { invariant as invariant4 } from "@dxos/invariant";
+import { log as log5 } from "@dxos/log";
+import { useClient } from "@dxos/react-client";
+import { Filter as Filter2, useQuery as useQuery2 } from "@dxos/react-client/echo";
+
+// packages/plugins/experimental/plugin-automation/src/hooks/invocation-handler.ts
+import { sleep } from "@dxos/async";
+import { getObjectCore, ResultFormat } from "@dxos/echo-db";
+import { FunctionType as FunctionType2 } from "@dxos/functions";
+import { invariant as invariant3 } from "@dxos/invariant";
+import { DXN, LOCAL_SPACE_TAG } from "@dxos/keys";
+import { log as log4 } from "@dxos/log";
+
+// packages/plugins/experimental/plugin-automation/src/hooks/useLocalTriggerManager.ts
+var registerTriggersMutex = new Mutex();
+
+// packages/plugins/experimental/plugin-automation/src/hooks/useMessageQueue.ts
+import { useMemo as useMemo2 } from "react";
+import { DXN as DXN2, QueueSubspaceTags } from "@dxos/keys";
+import { getSpace as getSpace2 } from "@dxos/react-client/echo";
+import { useEdgeClient, useQueue } from "@dxos/react-edge-client";
+var useMessageQueue = (chat) => {
+  const edgeClient = useEdgeClient();
+  const space = getSpace2(chat);
+  const queueDxn = useMemo2(() => new DXN2(DXN2.kind.QUEUE, [
+    QueueSubspaceTags.DATA,
+    space.id,
+    chat.queue.dxn.parts.at(-1)
+  ]), [
+    chat.queue.dxn
+  ]);
+  return useQueue(edgeClient, queueDxn);
+};
+
+// packages/plugins/experimental/plugin-automation/src/hooks/useServices.ts
+import { useEffect as useEffect3, useMemo as useMemo3, useState as useState3 } from "react";
+
+// packages/plugins/experimental/plugin-automation/src/testing/test-functions.ts
+import { createSystemPrompt as createSystemPrompt2 } from "@dxos/artifact";
+import { AST, S as S2, toJsonSchema } from "@dxos/echo-schema";
+var functions = [
+  {
+    name: "example.com/function/chess",
+    version: "0.1.0",
+    inputSchema: toJsonSchema(S2.Struct({
+      level: S2.Number.annotations({
+        [AST.TitleAnnotationId]: "Level"
+      })
+    }))
+  },
+  {
+    name: "example.com/function/forex",
+    version: "0.1.0",
+    binding: "FOREX",
+    inputSchema: toJsonSchema(S2.Struct({
+      from: S2.String.annotations({
+        [AST.TitleAnnotationId]: "Currency from"
+      }),
+      to: S2.String.annotations({
+        [AST.TitleAnnotationId]: "Currency to"
+      })
+    }))
+  }
+];
+
+// packages/plugins/experimental/plugin-automation/src/testing/test-services.ts
+import { createStatic as createStatic2 } from "@dxos/echo-schema";
+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 = [
+  createStatic2(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
+      }
+    ]
+  }),
+  createStatic2(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
+      }
+    ]
+  }),
+  createStatic2(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.
+  createStatic2(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) => createStatic2(ServiceType, {
+    serviceId: `example.com/service/test-${i}`,
+    name: `Test ${i}`,
+    description: `Test ${i}`,
+    category: Object.keys(categoryIcons)[Math.floor(Math.random() * Object.keys(categoryIcons).length)],
+    interfaces: [
+      {
+        kind: "api",
+        schemaUrl: "https://petstore.swagger.io/v2/swagger.json"
+      }
+    ]
+  }))
+];
+
+// packages/plugins/experimental/plugin-automation/src/hooks/useServices.ts
+var useServices = (space, query) => {
+  const registry = useMemo3(() => new MockServiceRegistry(), []);
+  const [services, setServices] = useState3([]);
+  useEffect3(() => {
+    const t = setTimeout(async () => {
+      const services2 = await registry.queryServices(query);
+      setServices(services2);
+    });
+    return () => clearTimeout(t);
+  }, [
+    query,
+    registry
+  ]);
+  return services;
+};
+
+// packages/plugins/experimental/plugin-automation/src/components/Thread/Thread.tsx
+import React6, { useCallback as useCallback2, useMemo as useMemo4, useRef as useRef3, useState as useState7 } from "react";
+import { IconButton, Input, useTranslation } from "@dxos/react-ui";
+import { Spinner } from "@dxos/react-ui-sfx";
+import { mx as mx6 } from "@dxos/react-ui-theme";
+
+// packages/plugins/experimental/plugin-automation/src/components/Thread/ScrollContainer.tsx
+import React, { forwardRef, useCallback, useEffect as useEffect4, useImperativeHandle, useRef, useState as useState4 } from "react";
+import { invariant as invariant5 } from "@dxos/invariant";
+import { mx } from "@dxos/react-ui-theme";
+var __dxlog_file4 = "/home/runner/work/dxos/dxos/packages/plugins/experimental/plugin-automation/src/components/Thread/ScrollContainer.tsx";
+var ScrollContainer = /* @__PURE__ */ forwardRef(({ children, classNames }, forwardedRef) => {
+  const containerRef = useRef(null);
+  const autoScrollRef = useRef(false);
+  useImperativeHandle(forwardedRef, () => ({
+    scrollToBottom: () => {
+      invariant5(containerRef.current, void 0, {
+        F: __dxlog_file4,
+        L: 41,
+        S: void 0,
+        A: [
+          "containerRef.current",
+          ""
+        ]
+      });
+      containerRef.current.scrollTo({
+        top: containerRef.current.scrollHeight,
+        behavior: "smooth"
+      });
+      autoScrollRef.current = false;
+    }
+  }), []);
+  const [sticky, setSticky] = useState4(true);
+  useEffect4(() => {
+    if (!sticky || !containerRef.current) {
+      return;
+    }
+    autoScrollRef.current = true;
+    containerRef.current.scrollTo({
+      top: containerRef.current.scrollHeight,
+      behavior: "smooth"
+    });
+  }, [
+    children
+  ]);
+  useEffect4(() => {
+    invariant5(containerRef.current, void 0, {
+      F: __dxlog_file4,
+      L: 62,
+      S: void 0,
+      A: [
+        "containerRef.current",
+        ""
+      ]
+    });
+    const handleScrollEnd = () => {
+      autoScrollRef.current = false;
+    };
+    containerRef.current.addEventListener("scrollend", handleScrollEnd);
+    return () => containerRef.current?.removeEventListener("scrollend", handleScrollEnd);
+  }, []);
+  const handleScroll = useCallback((ev) => {
+    if (autoScrollRef.current) {
+      return;
+    }
+    const { scrollTop, clientHeight, scrollHeight } = ev.currentTarget;
+    const sticky2 = scrollTop + clientHeight >= scrollHeight;
+    setSticky(sticky2);
+  }, []);
+  return /* @__PURE__ */ React.createElement("div", {
+    ref: containerRef,
+    onScroll: handleScroll,
+    className: mx("flex flex-col grow overflow-y-scroll scrollbar-none", classNames)
+  }, children);
+});
+
+// packages/plugins/experimental/plugin-automation/src/components/Thread/ThreadMessage.tsx
+import React5 from "react";
+import { invariant as invariant6 } from "@dxos/invariant";
+import { log as log6 } from "@dxos/log";
+import { Button, ButtonGroup, Icon as Icon2 } from "@dxos/react-ui";
+import { Json } from "@dxos/react-ui-syntax-highlighter";
+import { mx as mx5 } from "@dxos/react-ui-theme";
+import { safeParseJson } from "@dxos/util";
+
+// packages/plugins/experimental/plugin-automation/src/components/Thread/StatusLine.tsx
+import React2, { useEffect as useEffect5, useRef as useRef2, useState as useState5 } from "react";
+import { mx as mx2 } from "@dxos/react-ui-theme";
+var emptyLines = [];
+var StatusLine = ({ classNames, line = -1, lines = emptyLines, transition = 300, advance = 1e3, autoAdvance }) => {
+  const containerRef = useRef2(null);
+  const [currentLine, setCurrentLine] = useState5(line);
+  useEffect5(() => {
+    setCurrentLine(line);
+  }, [
+    line
+  ]);
+  useEffect5(() => {
+    if (!autoAdvance) {
+      return;
+    }
+    const next = () => {
+      setCurrentLine((prev) => {
+        if (prev >= lines.length - 1) {
+          clearInterval(interval);
+          return prev;
+        }
+        return prev + 1;
+      });
+    };
+    next();
+    const interval = setInterval(next, advance);
+    return () => clearInterval(interval);
+  }, [
+    lines.length,
+    autoAdvance,
+    advance
+  ]);
+  useEffect5(() => {
+    if (containerRef.current) {
+      containerRef.current.style.transition = `transform ${transition}ms ease-in-out`;
+      containerRef.current.style.transform = `translateY(-${currentLine * 24}px)`;
+    }
+  }, [
+    currentLine
+  ]);
+  return /* @__PURE__ */ React2.createElement("div", {
+    className: mx2("relative h-[24px] overflow-hidden", classNames)
+  }, /* @__PURE__ */ React2.createElement("div", {
+    ref: containerRef,
+    className: "h-[24px]"
+  }, /* @__PURE__ */ React2.createElement("div", {
+    className: "flex flex-col"
+  }, lines.map((line2, i) => /* @__PURE__ */ React2.createElement("div", {
+    key: i,
+    className: mx2("flex h-[24px] items-center")
+  }, /* @__PURE__ */ React2.createElement("span", {
+    className: "truncate"
+  }, line2))))));
+};
+
+// packages/plugins/experimental/plugin-automation/src/components/Thread/ToggleContainer.tsx
+import React3, { useEffect as useEffect6, useState as useState6 } from "react";
+import { Icon } from "@dxos/react-ui";
+import { mx as mx3 } from "@dxos/react-ui-theme";
+var ToggleContainer = ({ title, icon, toggle, defaultOpen, duration = 400, shrinkX = false, children, classNames }) => {
+  const [expand, setExpand] = useState6(defaultOpen || !toggle);
+  const [expandX, setExpandX] = useState6(shrinkX ? expand : true);
+  const [expandY, setExpandY] = useState6(expand);
+  useEffect6(() => {
+    let t;
+    if (expand) {
+      if (shrinkX) {
+        setExpandX(true);
+      }
+      t = setTimeout(() => {
+        setExpandY(true);
+      }, shrinkX ? duration : 0);
+    } else {
+      setExpandY(false);
+      if (shrinkX) {
+        t = setTimeout(() => {
+          setExpandX(false);
+        }, duration);
+      }
+    }
+    return () => clearTimeout(t);
+  }, [
+    expand
+  ]);
+  return /* @__PURE__ */ React3.createElement("div", {
+    className: mx3("overflow-hidden", classNames)
+  }, title && /* @__PURE__ */ React3.createElement("div", {
+    className: "flex gap-1 py-1 items-center text-sm text-subdued cursor-pointer select-none",
+    onClick: toggle ? () => setExpand((open) => !open) : void 0
+  }, toggle && /* @__PURE__ */ React3.createElement("div", {
+    className: "flex w-[24px] h-[24px] items-center justify-center"
+  }, /* @__PURE__ */ React3.createElement(Icon, {
+    size: 4,
+    icon: "ph--caret-right--regular",
+    style: {
+      transitionDuration: `${shrinkX ? duration * 2 : duration}ms`
+    },
+    classNames: [
+      "transition transition-transform ease-in-out",
+      expand ? "rotate-90" : "transform-none"
+    ]
+  })), /* @__PURE__ */ React3.createElement("div", {
+    className: "flex-1 pis-1 pie-1 truncate"
+  }, title), icon), /* @__PURE__ */ React3.createElement("div", {
+    style: {
+      transitionDuration: `${duration}ms`
+    },
+    className: mx3("grid transition-[grid-template-columns] ease-in-out", expandX ? "grid-cols-[1fr]" : "grid-cols-[0fr]")
+  }, /* @__PURE__ */ React3.createElement("div", {
+    className: "overflow-hidden"
+  }, /* @__PURE__ */ React3.createElement("div", {
+    style: {
+      transitionDuration: `${duration}ms`
+    },
+    className: mx3("grid transition-[grid-template-rows] ease-in-out", expandY ? "grid-rows-[1fr]" : "grid-rows-[0fr]")
+  }, /* @__PURE__ */ React3.createElement("div", {
+    className: mx3("flex overflow-hidden transition-opacity")
+  }, children)))));
+};
+
+// packages/plugins/experimental/plugin-automation/src/components/MarkdownViewer/MarkdownViewer.tsx
+import React4 from "react";
+import ReactMarkdown from "react-markdown";
+import { SyntaxHighlighter } from "@dxos/react-ui-syntax-highlighter";
+import { mx as mx4 } from "@dxos/react-ui-theme";
+import { omit } from "@dxos/util";
+var MarkdownViewer = ({ classNames, content = "" }) => {
+  return /* @__PURE__ */ React4.createElement("div", {
+    className: mx4("space-y-2", classNames)
+  }, /* @__PURE__ */ React4.createElement(ReactMarkdown, {
+    components: {
+      a: ({ node, children, href, ...props }) => /* @__PURE__ */ React4.createElement("a", {
+        href,
+        className: "text-primary-500 hover:text-primary-500",
+        target: "_blank",
+        rel: "noopener noreferrer",
+        ...props
+      }, children),
+      ol: ({ node, children, ...props }) => /* @__PURE__ */ React4.createElement("ol", {
+        className: "leading-tight list-decimal pl-6",
+        ...omit(props, [
+          "ordered"
+        ])
+      }, children),
+      ul: ({ node, children, ...props }) => /* @__PURE__ */ React4.createElement("ul", {
+        className: "leading-tight list-disc pl-6",
+        ...omit(props, [
+          "ordered"
+        ])
+      }, children),
+      li: ({ node, children, ...props }) => /* @__PURE__ */ React4.createElement("li", {
+        className: "",
+        ...omit(props, [
+          "ordered"
+        ])
+      }, children),
+      blockquote: ({ node, children, ...props }) => /* @__PURE__ */ React4.createElement("blockquote", {
+        className: "border-l-4 border-primary-500 pl-4 my-4 text-primary-500",
+        ...props
+      }, children),
+      code: ({ children, className }) => {
+        const [_, language] = /language-(\w+)/.exec(className || "") || [];
+        return /* @__PURE__ */ React4.createElement(SyntaxHighlighter, {
+          PreTag: "div",
+          language,
+          className: "p-0"
+        }, children);
+      }
+    }
+  }, content));
+};
+
+// packages/plugins/experimental/plugin-automation/src/components/Thread/ThreadMessage.tsx
+var __dxlog_file5 = "/home/runner/work/dxos/dxos/packages/plugins/experimental/plugin-automation/src/components/Thread/ThreadMessage.tsx";
+var ThreadMessage = ({ classNames, message, collapse, debug, onSuggest, onDelete }) => {
+  if (typeof message !== "object") {
+    return /* @__PURE__ */ React5.createElement("div", {
+      className: mx5(classNames)
+    }, message);
+  }
+  const { role, content = [] } = message;
+  const toolBlocks = content.filter((block) => block.type === "tool_use" || block.type === "tool_result");
+  if (collapse && toolBlocks.length > 0) {
+    let request;
+    const json = [];
+    const lines = toolBlocks.map((block) => {
+      switch (block.type) {
+        case "tool_use": {
+          request = block;
+          json.push(block);
+          return `Calling ${block.name}...`;
+        }
+        case "tool_result": {
+          if (!request) {
+            log6.warn("unexpected message", {
+              tool: block
+            }, {
+              F: __dxlog_file5,
+              L: 57,
+              S: void 0,
+              C: (f, a) => f(...a)
+            });
+            return "Error";
+          }
+          json.push(block);
+          return `Processed ${request.name}`;
+        }
+        default: {
+          request = void 0;
+          return "Error";
+        }
+      }
+    });
+    return /* @__PURE__ */ React5.createElement("div", {
+      className: mx5("flex", classNames)
+    }, /* @__PURE__ */ React5.createElement("div", {
+      className: "w-full p-1 px-2 overflow-hidden rounded-md bg-baseSurface"
+    }, /* @__PURE__ */ React5.createElement(ToggleContainer, {
+      title: /* @__PURE__ */ React5.createElement(StatusLine, {
+        lines,
+        autoAdvance: true
+      }),
+      toggle: true
+    }, /* @__PURE__ */ React5.createElement(Json, {
+      data: json,
+      classNames: "!p-1 text-xs"
+    }))));
+  }
+  return /* @__PURE__ */ React5.createElement("div", {
+    className: mx5("flex flex-col shrink-0 gap-2")
+  }, debug && /* @__PURE__ */ React5.createElement("div", {
+    className: "text-xs text-subdued"
+  }, message.id, " ", onDelete && /* @__PURE__ */ React5.createElement("span", {
+    className: "cursor-pointer underline",
+    onClick: () => onDelete(message.id)
+  }, "delete")), content.map((block, idx) => /* @__PURE__ */ React5.createElement("div", {
+    key: idx,
+    className: mx5("flex", classNames, block.type === "text" && role === "user" && "justify-end")
+  }, /* @__PURE__ */ React5.createElement(Block, {
+    role,
+    block,
+    onSuggest: onSuggest ?? (() => {
+    })
+  }))));
+};
+var Block = ({ block, role, onSuggest }) => {
+  const Component = componentMap[block.type] ?? componentMap.default;
+  return /* @__PURE__ */ React5.createElement("div", {
+    className: mx5("p-1 px-2 overflow-hidden rounded-md", (block.type !== "text" || block.disposition) && "w-full bg-baseSurface", block.type === "text" && role === "user" && "bg-primary-200 dark:bg-primary-500")
+  }, /* @__PURE__ */ React5.createElement(Component, {
+    block,
+    onSuggest
+  }));
+};
+var titles = {
+  ["cot"]: "Chain of thought",
+  ["artifact"]: "Artifact",
+  ["tool_use"]: "Tool request",
+  ["tool_result"]: "Tool result"
+};
+var componentMap = {
+  text: ({ block }) => {
+    invariant6(block.type === "text", void 0, {
+      F: __dxlog_file5,
+      L: 134,
+      S: void 0,
+      A: [
+        "block.type === 'text'",
+        ""
+      ]
+    });
+    const title = block.disposition ? titles[block.disposition] : void 0;
+    if (!title) {
+      return /* @__PURE__ */ React5.createElement(MarkdownViewer, {
+        content: block.text,
+        classNames: [
+          block.disposition === "cot" && "text-sm text-subdued"
+        ]
+      });
+    }
+    return /* @__PURE__ */ React5.createElement(ToggleContainer, {
+      title,
+      icon: block.pending ? /* @__PURE__ */ React5.createElement(Icon2, {
+        icon: "ph--circle-notch--regular",
+        classNames: "text-subdued ml-2 animate-spin",
+        size: 4
+      }) : void 0,
+      defaultOpen: block.disposition === "cot",
+      toggle: true
+    }, /* @__PURE__ */ React5.createElement(MarkdownViewer, {
+      content: block.text,
+      classNames: [
+        block.disposition === "cot" && "text-sm text-subdued"
+      ]
+    }));
+  },
+  json: ({ block, onSuggest }) => {
+    invariant6(block.type === "json", void 0, {
+      F: __dxlog_file5,
+      L: 159,
+      S: void 0,
+      A: [
+        "block.type === 'json'",
+        ""
+      ]
+    });
+    switch (block.disposition) {
+      case "suggest": {
+        const { text = "" } = safeParseJson(block.json ?? "{}") ?? {};
+        return /* @__PURE__ */ React5.createElement(Button, {
+          onClick: () => onSuggest(text)
+        }, text);
+      }
+      case "select": {
+        const { options = [] } = safeParseJson(block.json ?? "{}") ?? {};
+        return /* @__PURE__ */ React5.createElement(ButtonGroup, null, options.map((option) => /* @__PURE__ */ React5.createElement(Button, {
+          key: option,
+          onClick: () => onSuggest(option)
+        }, option)));
+      }
+      default: {
+        const title = block.disposition ? titles[block.disposition] : void 0;
+        return /* @__PURE__ */ React5.createElement(ToggleContainer, {
+          title: title ?? "JSON",
+          toggle: true
+        }, /* @__PURE__ */ React5.createElement(Json, {
+          data: safeParseJson(block.json ?? block),
+          classNames: "!p-1 text-xs"
+        }));
+      }
+    }
+  },
+  default: ({ block }) => {
+    let title = titles[block.type];
+    if (block.type === "tool_use") {
+      title = `Tool [${block.name}]`;
+    }
+    return /* @__PURE__ */ React5.createElement(ToggleContainer, {
+      title: title ?? "JSON",
+      toggle: true
+    }, /* @__PURE__ */ React5.createElement(Json, {
+      data: block,
+      classNames: "!p-1 text-xs"
+    }));
+  }
+};
+
+// packages/plugins/experimental/plugin-automation/src/components/Thread/Thread.tsx
+var Thread = ({ messages, streaming, collapse, debug, onSubmit, onStop, onSuggest, onDelete }) => {
+  const { t } = useTranslation(AUTOMATION_PLUGIN);
+  const scroller = useRef3(null);
+  const [text, setText] = useState7("");
+  const handleKeyDown = useCallback2((ev) => {
+    switch (ev.key) {
+      case "Escape": {
+        setText("");
+        break;
+      }
+      case "Enter": {
+        const value = text.trim();
+        if (value.length > 0) {
+          scroller.current?.scrollToBottom();
+          onSubmit?.(value);
+          setText("");
+        }
+        break;
+      }
+    }
+  }, [
+    text
+  ]);
+  const { messages: lines = [] } = useMemo4(() => {
+    if (!collapse) {
+      return {
+        messages: messages ?? []
+      };
+    }
+    return (messages ?? []).reduce(({ current, messages: messages2 }, 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
+                ]
+              };
+              messages2.push(current);
+            }
+            break;
+          }
+          case "text":
+          default: {
+            current = void 0;
+            messages2.push({
+              id: [
+                message.id,
+                i
+              ].join("_"),
+              role: message.role,
+              content: [
+                block
+              ]
+            });
+            break;
+          }
+        }
+        i++;
+      }
+      return {
+        current,
+        messages: messages2
+      };
+    }, {
+      messages: []
+    });
+  }, [
+    messages,
+    collapse
+  ]);
+  return /* @__PURE__ */ React6.createElement("div", {
+    className: "flex flex-col grow overflow-hidden"
+  }, /* @__PURE__ */ React6.createElement(ScrollContainer, {
+    ref: scroller,
+    classNames: "py-2 gap-2 overflow-x-hidden"
+  }, lines.map((message) => /* @__PURE__ */ React6.createElement(ThreadMessage, {
+    key: message.id,
+    classNames: "px-4",
+    message,
+    collapse,
+    debug,
+    onSuggest,
+    onDelete
+  }))), onSubmit && /* @__PURE__ */ React6.createElement("div", {
+    className: "flex p-4 gap-3 items-center"
+  }, /* @__PURE__ */ React6.createElement(Spinner, {
+    active: streaming
+  }), /* @__PURE__ */ React6.createElement(Input.Root, null, /* @__PURE__ */ React6.createElement(Input.TextInput, {
+    autoFocus: true,
+    classNames: "px-2 baseSurface rounded",
+    placeholder: t("chat input placeholder"),
+    value: text,
+    onChange: (ev) => setText(ev.target.value),
+    onKeyDown: handleKeyDown
+  })), onStop && /* @__PURE__ */ React6.createElement(IconButton, {
+    disabled: !streaming,
+    classNames: mx6("!p-1 !opacity-20 transition", streaming && "!opacity-80"),
+    variant: "ghost",
+    size: 5,
+    onClick: onStop,
+    icon: "ph--x--regular",
+    label: t("chat stop"),
+    iconOnly: true
+  })));
+};
+
+// packages/plugins/experimental/plugin-automation/src/components/ChatContainer/ChatContainer.tsx
+var __dxlog_file6 = "/home/runner/work/dxos/dxos/packages/plugins/experimental/plugin-automation/src/components/ChatContainer/ChatContainer.tsx";
+var ChatContainer = ({ chat, role }) => {
+  const processor = useChatProcessor(chat);
+  const messageQueue = useMessageQueue(chat);
+  const messages = [
+    ...messageQueue?.items ?? [],
+    ...processor.messages.value
+  ];
+  const handleSubmit = useCallback3(async (text) => {
+    if (processor.streaming.value) {
+      await processor.cancel();
+    }
+    invariant7(messageQueue, void 0, {
+      F: __dxlog_file6,
+      L: 25,
+      S: void 0,
+      A: [
+        "messageQueue",
+        ""
+      ]
+    });
+    await processor.request(text, {
+      history: messageQueue.items,
+      onComplete: (messages2) => messageQueue.append(messages2)
+    });
+  }, [
+    processor,
+    messageQueue
+  ]);
+  const handleStop = useCallback3(() => {
+    if (processor.streaming.value) {
+      void processor.cancel();
+    }
+  }, [
+    processor
+  ]);
+  return /* @__PURE__ */ React7.createElement(StackItem.Content, {
+    toolbar: false,
+    role
+  }, /* @__PURE__ */ React7.createElement(Thread, {
+    messages,
+    streaming: processor.streaming.value,
+    collapse: true,
+    onSubmit: handleSubmit,
+    onSuggest: handleSubmit,
+    onStop: handleStop
+  }));
+};
+
+// packages/plugins/experimental/plugin-automation/src/components/ChatContainer/index.ts
+var ChatContainer_default = ChatContainer;
+
+export {
+  useServices,
+  MarkdownViewer,
+  Thread,
+  ChatContainer,
+  ChatContainer_default,
+  AiClient,
+  AppGraphBuilder,
+  IntentResolver,
+  ReactSurface
+};
+//# sourceMappingURL=chunk-DL7XA62G.mjs.map