@nocobase/plugin-ai 2.1.0-beta.14 → 2.1.0-beta.16

package/dist/server/workflow/nodes/employee/files.js

@@ -0,0 +1,125 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+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 files_exports = {};
+__export(files_exports, {
+  Files: () => Files
+});
+module.exports = __toCommonJS(files_exports);
+var import_promises = __toESM(require("node:fs/promises"));
+var import_node_os = __toESM(require("node:os"));
+var import_node_path = __toESM(require("node:path"));
+var import_lodash = __toESM(require("lodash"));
+var import_axios = __toESM(require("axios"));
+var import_utils = require("../../utils");
+class Files {
+  static resolvers(plugin, attachmentPart) {
+    const resolveAttachments = async (files) => {
+      var _a;
+      const attachments = files.filter((it) => it.type === "file_id");
+      if (attachments.length) {
+        const attachmentGroup = import_lodash.default.groupBy(attachments, (it) => it.collection);
+        for (const collection of import_lodash.default.uniq(attachments.map((it) => it.collection))) {
+          const repository = plugin.db.getRepository(collection);
+          if (!repository) {
+            throw new Error(`Attachment collection [${collection}] not existed`);
+          }
+          const attachmentKeys = (_a = attachmentGroup[collection]) == null ? void 0 : _a.map((it) => it.value);
+          const attachmentModels = await repository.find({
+            filter: {
+              id: {
+                $in: attachmentKeys
+              }
+            }
+          });
+          if (!attachmentModels.length) {
+            throw new Error(`Attachment [${collection}] record not existed. Keys: [${attachmentKeys.join(",")}]`);
+          }
+          attachmentPart.attachments = [
+            ...attachmentPart.attachments ?? [],
+            ...attachmentModels.map((it) => it.toJSON())
+          ];
+        }
+      }
+    };
+    const resolveUrls = async (files) => {
+      var _a;
+      const urls = files.filter((it) => it.type === "file_url");
+      if (urls.length) {
+        const fileManager = plugin.pm.get("file-manager");
+        const settings = await plugin.db.getRepository("aiSettings").findOne();
+        const storageName = (_a = settings == null ? void 0 : settings.options) == null ? void 0 : _a.storage;
+        const attachments = await Promise.all(
+          urls.map(async ({ value: url }) => {
+            const response = await import_axios.default.get(url, {
+              responseType: "arraybuffer"
+            });
+            const contentType = (0, import_utils.resolveContentType)(response.headers);
+            const fileIdentity = (0, import_utils.resolveFileIdentity)(url, response.headers);
+            const tempFilePath = import_node_path.default.join(import_node_os.default.tmpdir(), `${Date.now()}-${import_lodash.default.random(1e9)}`);
+            await import_promises.default.writeFile(tempFilePath, response.data);
+            try {
+              const created = await fileManager.createFileRecord({
+                collectionName: "aiFiles",
+                filePath: tempFilePath,
+                storageName,
+                values: {
+                  ...fileIdentity,
+                  mimetype: contentType,
+                  meta: {
+                    sourceUrl: url
+                  }
+                }
+              });
+              return created.toJSON();
+            } finally {
+              await import_promises.default.rm(tempFilePath, { force: true });
+            }
+          })
+        );
+        attachmentPart.attachments = [...attachmentPart.attachments ?? [], ...attachments];
+      }
+    };
+    return {
+      resolveAttachments,
+      resolveUrls
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Files
+});

package/dist/server/workflow/nodes/employee/handler.d.ts

@@ -0,0 +1,11 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import PluginAIServer from '../../../plugin';
+export declare const registerOnJobAbortedHandler: (plugin: PluginAIServer) => void;
+export declare const registerAIEmployeeTaskNotification: (plugin: PluginAIServer) => void;

package/dist/server/workflow/nodes/employee/handler.js

@@ -0,0 +1,107 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var handler_exports = {};
+__export(handler_exports, {
+  registerAIEmployeeTaskNotification: () => registerAIEmployeeTaskNotification,
+  registerOnJobAbortedHandler: () => registerOnJobAbortedHandler
+});
+module.exports = __toCommonJS(handler_exports);
+var import_plugin_workflow = require("@nocobase/plugin-workflow");
+const registerOnJobAbortedHandler = (plugin) => {
+  plugin.db.on("jobs.afterBulkUpdate", async (options) => {
+    const { model, attributes, where, transaction } = options;
+    if (attributes.status !== import_plugin_workflow.JOB_STATUS.ABORTED) {
+      return;
+    }
+    const jobs = await model.findAll({ where, transaction });
+    const aiWorkflowTasks = await plugin.db.getRepository("aiWorkflowTasks").find({
+      filter: {
+        jobId: jobs.map((it) => it.id)
+      },
+      transaction
+    });
+    if (!aiWorkflowTasks.length) {
+      return;
+    }
+    for (const aiWorkflowTask of aiWorkflowTasks) {
+      await plugin.db.getRepository("aiWorkflowTasks").update({
+        values: { status: "aborted" },
+        filter: {
+          id: aiWorkflowTask.id
+        },
+        transaction
+      });
+    }
+  });
+};
+const registerAIEmployeeTaskNotification = (plugin) => {
+  plugin.db.on("aiWorkflowTasks.beforeSave", async (model, options) => {
+    var _a;
+    if (!model.isNewRecord && !model.changed("status")) {
+      return;
+    }
+    const values = model.toJSON();
+    (_a = options.transaction) == null ? void 0 : _a.afterCommit(async () => {
+      const assignees = await plugin.db.getRepository("usersAiWorkflowTasks").find({
+        filter: {
+          aiWorkflowTaskId: values.id
+        }
+      });
+      if (!(assignees == null ? void 0 : assignees.length)) {
+        return;
+      }
+      if (values.status === "pending_acceptance") {
+        await plugin.db.getRepository("usersAiWorkflowTasks").update({
+          values: {
+            read: false
+          },
+          filter: {
+            aiWorkflowTaskId: values.id
+          }
+        });
+      }
+      for (const assignee of assignees) {
+        plugin.app.emit("ws:sendToUser", {
+          userId: assignee.userId,
+          message: {
+            type: "ai-employee-tasks:status",
+            payload: {
+              taskId: values.id,
+              sessionId: values.sessionId,
+              status: values.status
+            }
+          }
+        });
+      }
+    });
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  registerAIEmployeeTaskNotification,
+  registerOnJobAbortedHandler
+});

package/dist/server/workflow/nodes/employee/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { FlowNodeModel, Instruction, Processor } from '@nocobase/plugin-workflow';
+export declare class AIEmployeeInstruction extends Instruction {
+    run(node: FlowNodeModel, input: any, processor: Processor): Promise<void>;
+    resume(node: FlowNodeModel, job: any, processor: Processor): any;
+    private createWorkflowTask;
+    private checkApproval;
+}
+export * from './handler';
+export * from './tools';

package/dist/server/workflow/nodes/employee/index.js

@@ -0,0 +1,391 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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 employee_exports = {};
+__export(employee_exports, {
+  AIEmployeeInstruction: () => AIEmployeeInstruction
+});
+module.exports = __toCommonJS(employee_exports);
+var import_plugin_workflow = require("@nocobase/plugin-workflow");
+var import_plugin = __toESM(require("../../../plugin"));
+var import_ai_employee = require("../../../ai-employees/ai-employee");
+var import_files = require("./files");
+var import_utils = require("@nocobase/utils");
+__reExport(employee_exports, require("./handler"), module.exports);
+__reExport(employee_exports, require("./tools"), module.exports);
+class AIEmployeeInstruction extends import_plugin_workflow.Instruction {
+  async run(node, input, processor) {
+    var _a, _b, _c, _d, _e;
+    const {
+      username,
+      message,
+      skillSettings,
+      webSearch,
+      model,
+      requiresApproval = "no_required",
+      userId,
+      files
+    } = processor.getParsedValue(node.config, node.id);
+    const toolName = "aiEmployeeWorkflowTaskOutput";
+    const workflowSystemPrompt = `
+You are operating inside a workflow.
+Your job is to complete the workflow task and return the final outcome to the workflow, not to reply freely as a normal assistant.
+Use normal assistant messages only for reasoning that leads to tool calls; do not place the final outcome in a normal assistant message.
+When the task is ready to be submitted, you must call **${toolName}** to return it to the workflow.
+Do not treat **${toolName}** as optional, and do not finish the task without calling it.
+`.trim();
+    const systemMessage = `${workflowSystemPrompt}
+
+${typeof message.system === "object" ? JSON.stringify(message.system) : message.system}`;
+    const userMessage = `Current workflow task description: 
+
+ ${typeof message.user === "object" ? JSON.stringify(message.user) : message.user}`;
+    const { id } = processor.saveJob({
+      status: import_plugin_workflow.JOB_STATUS.PENDING,
+      nodeId: node.id,
+      nodeKey: node.key,
+      upstreamId: (input == null ? void 0 : input.id) ?? null
+    });
+    await processor.exit();
+    try {
+      const { conversation, aiWorkflowTasks } = await this.createWorkflowTask({
+        username,
+        userMessage,
+        systemMessage,
+        skillSettings,
+        requiresApproval,
+        toolName,
+        node,
+        processor,
+        jobId: id
+      });
+      let currentRoles = (_a = input == null ? void 0 : input.result) == null ? void 0 : _a.roleName;
+      if (!currentRoles) {
+        const defaultRole = await this.workflow.db.getRepository("rolesUsers").findOne({
+          filter: {
+            userId: ((_c = (_b = input == null ? void 0 : input.result) == null ? void 0 : _b.user) == null ? void 0 : _c.id) ?? userId,
+            default: true
+          }
+        });
+        currentRoles = defaultRole == null ? void 0 : defaultRole.roleName;
+      }
+      const employee = await this.workflow.db.getRepository("aiEmployees").findOne({
+        filter: {
+          username
+        }
+      });
+      const aiEmployee = new import_ai_employee.AIEmployee({
+        ctx: {
+          app: this.workflow.app,
+          db: this.workflow.app.db,
+          log: this.workflow.app.log,
+          logger: this.workflow.app.log,
+          state: { currentRoles },
+          auth: {
+            user: {
+              id: ((_e = (_d = input == null ? void 0 : input.result) == null ? void 0 : _d.user) == null ? void 0 : _e.id) ?? userId
+            }
+          },
+          action: {
+            params: {
+              values: {
+                sessionId: conversation.sessionId,
+                model
+              }
+            }
+          }
+        },
+        employee,
+        sessionId: conversation.sessionId,
+        systemMessage,
+        skillSettings,
+        webSearch,
+        model,
+        tools: [{ name: toolName }]
+      });
+      const attachmentPart = {};
+      if (files == null ? void 0 : files.length) {
+        const { resolveAttachments, resolveUrls } = import_files.Files.resolvers(this.workflow, attachmentPart);
+        await resolveAttachments(files);
+        await resolveUrls(files);
+      }
+      let result;
+      let isToolInvoke = false;
+      let retry = 0;
+      do {
+        const userMessages = [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              content: userMessage
+            },
+            ...attachmentPart
+          }
+        ];
+        if (retry > 0) {
+          if (retry < 2) {
+            const firstUserMessage = await this.workflow.db.getRepository("aiConversations.messages", conversation.sessionId).findOne({
+              filter: {
+                role: "user"
+              },
+              sort: ["messageId"]
+            });
+            const messageId = firstUserMessage == null ? void 0 : firstUserMessage.messageId;
+            result = await aiEmployee.invoke({ messageId, userMessages });
+          } else {
+            result = await aiEmployee.invoke({
+              userMessages: [
+                {
+                  role: "user",
+                  content: {
+                    type: "text",
+                    content: `You failed to call the required tool "aiEmployeeWorkflowTaskOutput" in your previous response.
+Call "aiEmployeeWorkflowTaskOutput" now to submit the workflow outcome.
+Do not send another normal assistant response without invoking it.
+                  `
+                  }
+                }
+              ]
+            });
+          }
+        } else {
+          result = await aiEmployee.invoke({ userMessages });
+        }
+        isToolInvoke = result.messages.filter((it) => it.type === "ai").flatMap((it) => it.tool_calls).some((it) => it.name === toolName);
+      } while (!isToolInvoke && retry++ < 2);
+      if (!isToolInvoke) {
+        throw new Error("AI employee not do job correctly");
+      }
+      await this.checkApproval({ requiresApproval, conversation, aiWorkflowTasks, result, aiEmployee, toolName });
+    } catch (e) {
+      processor.logger.error(`ai employee invoke failed, ${e.message}`, {
+        node: node.id,
+        stack: e.stack,
+        chatOptions: node.config
+      });
+      const job = await this.workflow.app.db.getRepository("jobs").findOne({
+        filterByTk: id
+      });
+      job.set({
+        status: import_plugin_workflow.JOB_STATUS.ERROR,
+        result: e.message
+      });
+      await this.workflow.resume(job);
+    }
+  }
+  resume(node, job, processor) {
+    return job;
+  }
+  async createWorkflowTask({
+    username,
+    userMessage,
+    systemMessage,
+    skillSettings,
+    requiresApproval,
+    toolName,
+    node,
+    processor,
+    jobId
+  }) {
+    const ai = this.workflow.app.pm.get(import_plugin.default);
+    return await this.workflow.db.sequelize.transaction(async (transaction) => {
+      var _a;
+      const conversation = await ai.aiConversationsManager.create({
+        aiEmployee: {
+          username
+        },
+        title: userMessage.slice(0, 30),
+        from: "sub-agent",
+        options: {
+          systemMessage,
+          skillSettings,
+          tools: [{ name: toolName }]
+        },
+        transaction,
+        category: "task"
+      });
+      const aiWorkflowTasks = await this.workflow.db.getRepository("aiWorkflowTasks").create({
+        values: {
+          id: this.workflow.app.snowflakeIdGenerator.generate(),
+          workflowTitle: (_a = processor.execution.workflow) == null ? void 0 : _a.title,
+          nodeTitle: node.title,
+          requiresApproval,
+          status: "processing",
+          sessionId: conversation.sessionId,
+          jobId,
+          executionId: processor.execution.id,
+          nodeId: node.id,
+          workflowId: node.workflowId
+        },
+        transaction
+      });
+      const userIds = await parseAssignees(node, processor);
+      if (userIds == null ? void 0 : userIds.length) {
+        await this.workflow.db.getRepository("usersAiWorkflowTasks").create({
+          values: userIds.map((userId) => ({
+            userId,
+            aiWorkflowTaskId: aiWorkflowTasks.id,
+            read: true
+          })),
+          transaction
+        });
+      }
+      return { conversation, aiWorkflowTasks };
+    });
+  }
+  async checkApproval({
+    requiresApproval,
+    conversation,
+    aiWorkflowTasks,
+    result,
+    aiEmployee,
+    toolName
+  }) {
+    var _a;
+    const ai = this.workflow.app.pm.get(import_plugin.default);
+    const aiToolMessage = await this.workflow.db.getRepository("aiToolMessages").findOne({
+      filter: {
+        sessionId: conversation.sessionId,
+        messageId: result.messageId
+      }
+    });
+    if ((aiToolMessage == null ? void 0 : aiToolMessage.invokeStatus) !== "interrupted") {
+      return;
+    }
+    const aiMessage = await this.workflow.db.getRepository("aiMessages").findOne({
+      filter: {
+        messageId: result.messageId
+      }
+    });
+    const toolCalls = aiMessage == null ? void 0 : aiMessage.toolCalls;
+    if (!(toolCalls == null ? void 0 : toolCalls.length)) {
+      return;
+    }
+    const toolCall = toolCalls.find((it) => it.name === toolName);
+    if (((_a = toolCall == null ? void 0 : toolCall.args) == null ? void 0 : _a.requiresApproval) === false) {
+      const [updated] = await this.workflow.db.getModel("aiToolMessages").update(
+        { userDecision: { type: "approve" }, invokeStatus: "waiting" },
+        {
+          where: {
+            sessionId: conversation.sessionId,
+            messageId: result.messageId,
+            invokeStatus: "interrupted"
+          }
+        }
+      );
+      if (!updated) {
+        return;
+      }
+      const userDecisions = await ai.aiConversationsManager.getUserDecisions(result.messageId);
+      await aiEmployee.invoke({ userDecisions });
+      await this.workflow.db.getRepository("aiWorkflowTasks").update({
+        values: { status: "approved" },
+        filter: {
+          id: aiWorkflowTasks.id,
+          status: {
+            $ne: "aborted"
+          }
+        }
+      });
+    } else if (requiresApproval !== "no_required") {
+      await this.workflow.db.getRepository("aiWorkflowTasks").update({
+        values: { status: "pending_acceptance" },
+        filter: {
+          id: aiWorkflowTasks.id,
+          status: {
+            $ne: "aborted"
+          }
+        }
+      });
+    }
+  }
+}
+async function parseAssignees(node, processor) {
+  const configAssignees = processor.getParsedValue(node.config.assignees ?? [], node.id).flat().filter(Boolean);
+  const assignees = [];
+  const seen = /* @__PURE__ */ new Set();
+  const addAssignee = (id) => {
+    if (!seen.has(id)) {
+      seen.add(id);
+      assignees.push(id);
+    }
+  };
+  const UserRepo = processor.options.plugin.app.db.getRepository("users");
+  const plainIds = configAssignees.flatMap(
+    (item) => Array.isArray(item) ? item : typeof item !== "object" ? [item] : []
+  );
+  const validIdSet = /* @__PURE__ */ new Set();
+  if (plainIds.length) {
+    const users = await UserRepo.find({
+      filter: { id: { $in: plainIds } },
+      fields: ["id"],
+      transaction: processor.mainTransaction
+    });
+    users.forEach((u) => validIdSet.add(u.id));
+  }
+  for (const item of configAssignees) {
+    if (Array.isArray(item)) {
+      for (const id of item) {
+        if (validIdSet.has(id)) {
+          addAssignee(id);
+        }
+      }
+    } else if (typeof item === "object") {
+      if (!(0, import_utils.isValidFilter)(item.filter)) {
+        continue;
+      }
+      const result = await UserRepo.find({
+        ...item,
+        fields: ["id"],
+        transaction: processor.mainTransaction
+      });
+      result.forEach((user) => addAssignee(user.id));
+    } else {
+      if (validIdSet.has(item)) {
+        addAssignee(item);
+      }
+    }
+  }
+  return assignees;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AIEmployeeInstruction,
+  ...require("./handler"),
+  ...require("./tools")
+});

package/dist/server/workflow/nodes/employee/tools.d.ts

@@ -0,0 +1,12 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { DynamicToolsProvider } from '@nocobase/ai';
+import { Plugin } from '@nocobase/server';
+export type WorkflowTaskToolProvider = (plugin: Plugin) => DynamicToolsProvider;
+export declare const getWorkflowTasks: WorkflowTaskToolProvider;