@nocobase/plugin-ai 2.1.0-alpha.20 → 2.1.0-alpha.21

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;

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

@@ -0,0 +1,133 @@
+/**
+ * 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 tools_exports = {};
+__export(tools_exports, {
+  getWorkflowTasks: () => getWorkflowTasks
+});
+module.exports = __toCommonJS(tools_exports);
+var import_plugin_workflow = require("@nocobase/plugin-workflow");
+const getWorkflowTasks = (plugin) => async (register, filter) => {
+  if (!(filter == null ? void 0 : filter.sessionId)) {
+    return;
+  }
+  const workflowPlugin = plugin.app.pm.get("workflow");
+  const task = await plugin.db.getRepository("aiWorkflowTasks").findOne({
+    filter: {
+      sessionId: filter == null ? void 0 : filter.sessionId
+    }
+  });
+  if (!task) {
+    return;
+  }
+  const execution = await plugin.db.getRepository("executions").findByTargetKey(task.executionId);
+  if (!execution) {
+    return;
+  }
+  const flowNode = await plugin.db.getRepository("flow_nodes").findByTargetKey(task.nodeId);
+  if (!flowNode) {
+    return;
+  }
+  const processor = workflowPlugin.createProcessor(execution);
+  const config = processor.getParsedValue(flowNode.config, flowNode.id);
+  const outputSchema = config.structuredOutput.schema;
+  const parsedOutputSchema = typeof outputSchema === "string" ? JSON.parse(outputSchema) : outputSchema;
+  const resultSchema = parsedOutputSchema && typeof parsedOutputSchema === "object" && !Array.isArray(parsedOutputSchema) ? {
+    ...parsedOutputSchema,
+    description: parsedOutputSchema.description || `Return the final structured output for this workflow task in this field.
+            The value must match the required schema exactly so the workflow can continue.
+            Do not include free-form text, extra fields, or any structure outside the defined schema.`
+  } : parsedOutputSchema;
+  const schema = {
+    type: "object",
+    properties: {
+      result: resultSchema
+    },
+    additionalProperties: false
+  };
+  if (config.requiresApproval === "ai_decision") {
+    schema.properties.requiresApproval = {
+      type: "boolean",
+      description: `This field is mandatory.
+      Set it to true whenever the human user still needs to review the result, confirm it, make a decision,
+      provide missing information, answer your follow-up questions, or correct the result.
+      Set it to false only when you have determined that the task is fully complete, the result you are returning fully satisfies the required schema and the task requirements,
+      and no human user needs to review the result or provide any additional information before the workflow continues.
+      Warning: if requiresApproval=false, this AI workflow node ends immediately, the workflow moves to the next node,
+      and the human will no longer be able to continue this conversation with the AI.
+      If a human may still need to say anything else, do not set it to false.`
+    };
+  }
+  register.registerTools({
+    scope: "SPECIFIED",
+    defaultPermission: config.requiresApproval !== "no_required" ? "ASK" : "ALLOW",
+    from: "workflow",
+    definition: {
+      name: "aiEmployeeWorkflowTaskOutput",
+      description: `Use this tool to return the structured output required by the workflow so execution can continue.
+      Every time you call it, you must provide the final data strictly under result and match the result schema exactly.
+      Do not return free-form text, extra fields, or any structure outside the defined result.`,
+      schema
+    },
+    invoke: async (_ctx, args) => {
+      const job = await plugin.db.getModel("jobs").findByPk(task.jobId);
+      if (!job) {
+        return {
+          status: "fail",
+          message: "job not existed"
+        };
+      }
+      if (job.status === import_plugin_workflow.JOB_STATUS.ABORTED) {
+        return {
+          status: "success"
+        };
+      }
+      await plugin.db.getRepository("aiWorkflowTasks").update({
+        values: {
+          status: "approved"
+        },
+        filter: {
+          id: task.id,
+          status: {
+            $ne: "aborted"
+          }
+        }
+      });
+      job.set({
+        status: import_plugin_workflow.JOB_STATUS.RESOLVED,
+        result: args.result
+      });
+      await workflowPlugin.resume(job);
+      return {
+        status: "success"
+      };
+    }
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getWorkflowTasks
+});

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

@@ -0,0 +1,35 @@
+/**
+ * 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.
+ */
+export type AIEmployeeInstructionConfig = {
+    username: string;
+    message: {
+        user: string;
+        system?: string;
+    };
+    skillSettings?: {
+        skills?: string[];
+        tools?: {
+            name: string;
+        }[];
+    };
+    webSearch?: boolean;
+    model: {
+        llmService: string;
+        model: string;
+    };
+    requiresApproval?: 'no_required' | 'ai_decision' | 'human_decision';
+    assignees?: string[];
+    userId: string;
+    files: AIEmployeeInstructionFiles[];
+};
+export type AIEmployeeInstructionFiles = {
+    type: 'file_id' | 'file_url';
+    collection?: string;
+    value: string;
+};