@nocobase/plugin-ai 2.2.0-beta.8 → 2.2.0

package/dist/server/resource/aiEmployees.js

@@ -36,16 +36,84 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var aiEmployees_exports = {};
 __export(aiEmployees_exports, {
+  create: () => create,
   getTemplates: () => getTemplates,
   list: () => list,
   listByUser: () => listByUser,
+  update: () => update,
   updateUserPrompt: () => updateUserPrompt
 });
 module.exports = __toCommonJS(aiEmployees_exports);
 var import_actions = __toESM(require("@nocobase/actions"));
+var import_database = require("@nocobase/database");
 var templates = __toESM(require("../ai-employees/templates"));
 var import_lodash = __toESM(require("lodash"));
 var import_ai_feature_manager = require("../manager/ai-feature-manager");
+var import_error_codes = require("../../common/error-codes");
+var import_ai_employee_validation = require("../../common/ai-employee-validation");
+var import_ai_knowledge_base = require("../ai-employees/ai-knowledge-base");
+const isUniqueConstraintError = (error) => error instanceof import_database.UniqueConstraintError || typeof error === "object" && error !== null && "name" in error && error.name === "SequelizeUniqueConstraintError";
+const throwUsernameConflict = (ctx) => ctx.throw(409, {
+  code: import_error_codes.AI_EMPLOYEE_USERNAME_CONFLICT,
+  message: ctx.t("Username already exists")
+});
+const isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const validateAndNormalizeProfileValues = (ctx) => {
+  const values = ctx.action.params.values;
+  if (!isRecord(values)) {
+    return;
+  }
+  if ("username" in values) {
+    if (typeof values.username !== "string" || !(0, import_ai_employee_validation.isValidAIEmployeeUsername)(values.username)) {
+      ctx.throw(400, {
+        code: import_error_codes.AI_EMPLOYEE_USERNAME_INVALID,
+        message: ctx.t("Use 1-64 letters, numbers, underscores, or hyphens.")
+      });
+    }
+    values.username = (0, import_ai_employee_validation.normalizeAIEmployeeName)(values.username);
+  }
+  if ("nickname" in values) {
+    if (typeof values.nickname !== "string" || !(0, import_ai_employee_validation.isValidAIEmployeeNickname)(values.nickname)) {
+      ctx.throw(400, {
+        code: import_error_codes.AI_EMPLOYEE_NICKNAME_INVALID,
+        message: ctx.t("Use 1-64 letters, numbers, spaces, or . _ - ' ( ) & \xB7.")
+      });
+    }
+    values.nickname = (0, import_ai_employee_validation.normalizeAIEmployeeName)(values.nickname);
+  }
+};
+const setDefaultKnowledgeBaseRetrievalStrategy = (ctx) => {
+  const values = ctx.action.params.values;
+  if (isRecord(values)) {
+    values.knowledgeBase = (0, import_ai_knowledge_base.withDefaultKnowledgeBaseRetrievalStrategy)(values.knowledgeBase);
+  }
+};
+const create = async (ctx, next) => {
+  var _a;
+  validateAndNormalizeProfileValues(ctx);
+  setDefaultKnowledgeBaseRetrievalStrategy(ctx);
+  const username = (_a = ctx.action.params.values) == null ? void 0 : _a.username;
+  if (typeof username === "string") {
+    const existingEmployee = await ctx.db.getRepository("aiEmployees").findOne({
+      filter: { username }
+    });
+    if (existingEmployee) {
+      throwUsernameConflict(ctx);
+    }
+  }
+  try {
+    await import_actions.default.create(ctx, next);
+  } catch (error) {
+    if (isUniqueConstraintError(error)) {
+      throwUsernameConflict(ctx);
+    }
+    throw error;
+  }
+};
+const update = async (ctx, next) => {
+  validateAndNormalizeProfileValues(ctx);
+  await import_actions.default.update(ctx, next);
+};
 const list = async (ctx, next) => {
   var _a, _b;
   const { paginate } = ctx.action.params || {};
@@ -227,8 +295,10 @@ const getTemplates = async (ctx, next) => {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  create,
   getTemplates,
   list,
   listByUser,
+  update,
   updateUserPrompt
 });

package/dist/server/resource/aiWorkflowTasks.js

@@ -129,7 +129,7 @@ const aiWorkflowTasks = {
       await next();
     },
     getBySession: async (ctx, next) => {
-      var _a, _b, _c, _d, _e;
+      var _a, _b, _c, _d, _e, _f;
       const userId = (_a = ctx.auth) == null ? void 0 : _a.user.id;
       if (!userId) {
         return ctx.throw(403);
@@ -158,12 +158,20 @@ const aiWorkflowTasks = {
           id: task.nodeId
         }
       });
+      const conversation = await ctx.db.getRepository("aiConversations").findOne({
+        filter: {
+          sessionId
+        },
+        appends: ["aiEmployee"]
+      });
+      const aiEmployee = conversation == null ? void 0 : conversation.aiEmployee;
       const readonly = task.status !== "pending_approval" || task.acceptedUserId !== userId;
       ctx.body = {
         ...((_c = task == null ? void 0 : task.toJSON) == null ? void 0 : _c.call(task)) ?? task,
         read: (usersAiWorkflowTasks == null ? void 0 : usersAiWorkflowTasks.read) ?? true,
         config: (node == null ? void 0 : node.config) ?? null,
         structuredOutputSchema: ((_e = (_d = node == null ? void 0 : node.config) == null ? void 0 : _d.structuredOutput) == null ? void 0 : _e.schema) ?? null,
+        aiEmployee: ((_f = aiEmployee == null ? void 0 : aiEmployee.toJSON) == null ? void 0 : _f.call(aiEmployee)) ?? aiEmployee ?? null,
         readonly
       };
       await next();

package/dist/server/resource/llmServices.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 { Context, Next } from '@nocobase/actions';
+export declare const create: (ctx: Context, next: Next) => Promise<void>;
+export declare const update: (ctx: Context, next: Next) => Promise<void>;

package/dist/server/resource/llmServices.js

@@ -0,0 +1,85 @@
+/**
+ * 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 llmServices_exports = {};
+__export(llmServices_exports, {
+  create: () => create,
+  update: () => update
+});
+module.exports = __toCommonJS(llmServices_exports);
+var import_actions = __toESM(require("@nocobase/actions"));
+var import_package = require("../../../package.json");
+var import_error_codes = require("../../common/error-codes");
+var import_llm_service_models = require("../../common/llm-service-models");
+const isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const validateAndNormalizeEnabledModels = (ctx) => {
+  const values = ctx.action.params.values;
+  if (!isRecord(values) || !("enabledModels" in values)) {
+    return;
+  }
+  const enabledModels = (0, import_llm_service_models.normalizeCustomModelIds)(values.enabledModels);
+  const issue = (0, import_llm_service_models.getCustomModelIdIssues)(enabledModels)[0];
+  if (issue) {
+    const required = issue.type === "required";
+    ctx.throw(400, {
+      code: required ? import_error_codes.LLM_SERVICE_MODEL_ID_REQUIRED : import_error_codes.LLM_SERVICE_MODEL_ID_DUPLICATE,
+      message: ctx.t(required ? "Model ID is required" : "Model ID already exists", { ns: import_package.name }),
+      data: { index: issue.index }
+    });
+  }
+  ctx.action.mergeParams(
+    {
+      values: {
+        ...values,
+        enabledModels
+      }
+    },
+    { values: "overwrite" }
+  );
+};
+const create = async (ctx, next) => {
+  validateAndNormalizeEnabledModels(ctx);
+  await import_actions.default.create(ctx, next);
+};
+const update = async (ctx, next) => {
+  validateAndNormalizeEnabledModels(ctx);
+  await import_actions.default.update(ctx, next);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  create,
+  update
+});

package/dist/server/types/ai-message.type.d.ts

@@ -27,6 +27,10 @@ export type WorkContext = {
 export type AIMessageContent = {
     type: string;
     content: unknown;
+    reference?: {
+        title: string;
+        url: string;
+    }[];
 };
 export type AIToolCall = {
     id: string;

package/dist/server/types/knowledge-base.type.d.ts

@@ -19,13 +19,17 @@ export type KnowledgeBase = {
     name: string;
     description: string;
     vectorStoreProvider: string;
-    vectorStoreConfigKey?: string;
+    vectorDatabaseKey?: string;
+    llmService?: string;
+    embeddingModel?: string;
     vectorStoreProps?: VectorStoreProp[];
     enabled: boolean;
 };
 export type VectorStoreConfig = {
     vectorStoreProvider: string;
-    vectorStoreConfigKey?: string;
+    vectorDatabaseKey?: string;
+    llmService?: string;
+    embeddingModel?: string;
 };
 export type KnowledgeBaseGroup = {
     vectorStoreConfig: VectorStoreConfig;
@@ -41,8 +45,9 @@ export type DocumentSegmentedWithScore = DocumentSegmented & {
     score: number;
 };
 export type SearchOptions = {
-    knowledgeBaseKeys: string[];
+    knowledgeBaseKeys?: string[];
     query: string;
     topK?: number;
     score?: string;
+    roleNames?: string[];
 };

package/dist/server/utils.d.ts

@@ -6,9 +6,11 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
+/// <reference types="node" />
 import { Model } from '@nocobase/database';
 import { Context } from '@nocobase/actions';
 import { ToolsEntry } from '@nocobase/ai';
+import type { Readable } from 'stream';
 export declare function sendSSEError(ctx: Context, error: Error | string, errorName?: string): void;
 export declare function stripToolCallTags(content: string): string | null;
 export declare function parseResponseMessage(row: Model): {
@@ -17,8 +19,9 @@ export declare function parseResponseMessage(row: Model): {
     content: any;
     role: any;
 };
-export declare function encodeLocalFile(url: string): Promise<string>;
-export declare function encodeFile(ctx: Context, url: string): Promise<string>;
+export declare function encodeLocalFile(_url: string): Promise<void>;
+export declare function encodeFile(ctx: Context, url: string): Promise<string | void>;
+export declare function encodeReadableStream(stream: Readable): Promise<string>;
 export declare function parseVariables(ctx: Context, value: string): Promise<any>;
 export declare const buildTool: (toolsEntry: ToolsEntry) => import("@langchain/core/dist/tools").DynamicTool<any, unknown>;
 export declare class ResourceActionError extends Error {

package/dist/server/utils.js

@@ -7,11 +7,9 @@
  * 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)
@@ -25,14 +23,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   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 utils_exports = {};
 __export(utils_exports, {
@@ -40,14 +30,13 @@ __export(utils_exports, {
   buildTool: () => buildTool,
   encodeFile: () => encodeFile,
   encodeLocalFile: () => encodeLocalFile,
+  encodeReadableStream: () => encodeReadableStream,
   parseResponseMessage: () => parseResponseMessage,
   parseVariables: () => parseVariables,
   sendSSEError: () => sendSSEError,
   stripToolCallTags: () => stripToolCallTags
 });
 module.exports = __toCommonJS(utils_exports);
-var import_path = __toESM(require("path"));
-var import_fs = __toESM(require("fs"));
 var import_utils = require("@nocobase/utils");
 var import_langchain = require("langchain");
 function sendSSEError(ctx, error, errorName) {
@@ -91,13 +80,8 @@ function parseResponseMessage(row) {
     role
   };
 }
-async function encodeLocalFile(url) {
-  if (process.env.APP_PUBLIC_PATH && url.startsWith(process.env.APP_PUBLIC_PATH)) {
-    url = url.slice(process.env.APP_PUBLIC_PATH.length);
-  }
-  url = import_path.default.join(process.cwd(), url);
-  const data = await import_fs.default.promises.readFile(url);
-  return Buffer.from(data).toString("base64");
+async function encodeLocalFile(_url) {
+  throw new Error("Local file path is not allowed");
 }
 async function encodeFile(ctx, url) {
   if (!url.startsWith("http")) {
@@ -117,6 +101,13 @@ async function encodeFile(ctx, url) {
   });
   return Buffer.from(response.data).toString("base64");
 }
+async function encodeReadableStream(stream) {
+  const chunks = [];
+  for await (const chunk of stream) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString("base64");
+}
 async function getUser(ctx, fields) {
   const userFields = fields.filter((f) => f && ctx.db.getFieldByPath("users." + f));
   if (!ctx.state.currentUser) {
@@ -193,6 +184,7 @@ class ResourceActionError extends Error {
   buildTool,
   encodeFile,
   encodeLocalFile,
+  encodeReadableStream,
   parseResponseMessage,
   parseVariables,
   sendSSEError,

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

@@ -9,7 +9,9 @@
 import { AIEmployeeInstructionFiles } from './types';
 import { Plugin } from '@nocobase/server';
 export declare abstract class Files {
-    static resolvers(plugin: Plugin, attachmentPart: Record<string, any>): {
+    static resolvers(plugin: Plugin, attachmentPart: {
+        attachments?: unknown[];
+    }): {
         resolveAttachments: (files: AIEmployeeInstructionFiles[]) => Promise<void>;
         resolveFileIds: (files: AIEmployeeInstructionFiles[]) => Promise<void>;
         resolveUrls: (files: AIEmployeeInstructionFiles[]) => Promise<void>;

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

@@ -45,10 +45,25 @@ 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");
+var import_attachments = require("../../../attachments");
+function appendSource(record, source) {
+  if (!record || typeof record !== "object" || Array.isArray(record)) {
+    return record;
+  }
+  return {
+    ...record,
+    source
+  };
+}
 class Files {
   static resolvers(plugin, attachmentPart) {
     const resolveAttachments = async (files) => {
-      const attachments = files.filter((it) => it.type === "attachments").flatMap((it) => import_lodash.default.isArray(it.value) ? it.value : [it.value]);
+      const attachments = files.filter((it) => it.type === "attachments").flatMap((it) => import_lodash.default.isArray(it.value) ? it.value : [it.value]).map(
+        (attachment) => appendSource(attachment, {
+          ...(0, import_attachments.getAttachmentSource)(attachment) ?? {},
+          trustworthy: true
+        })
+      );
       if (attachments.length) {
         attachmentPart.attachments = [...attachmentPart.attachments ?? [], ...attachments];
       }
@@ -78,7 +93,13 @@ class Files {
           }
           attachmentPart.attachments = [
             ...attachmentPart.attachments ?? [],
-            ...attachmentModels.map((it) => it.toJSON())
+            ...attachmentModels.map(
+              (it) => appendSource(it.toJSON(), {
+                dataSourceKey: "main",
+                collectionName: collection,
+                trustworthy: true
+              })
+            )
           ];
         }
       }
@@ -106,14 +127,19 @@ class Files {
                 filePath: tempFilePath,
                 storageName,
                 values: {
-                  ...fileIdentity,
+                  title: fileIdentity.title,
                   mimetype: contentType,
                   meta: {
-                    sourceUrl: url
+                    sourceUrl: url,
+                    originalFilename: fileIdentity.filename
                   }
                 }
               });
-              return created.toJSON();
+              return appendSource(created.toJSON(), {
+                dataSourceKey: "main",
+                collectionName: "aiFiles",
+                trustworthy: true
+              });
             } finally {
               await import_promises.default.rm(tempFilePath, { force: true });
             }

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

@@ -120,27 +120,29 @@ ${typeof message.system === "object" ? JSON.stringify(message.system) : message.
         });
         const plugin = this.workflow.app.pm.get("ai");
         const resolvedModel = await plugin.aiEmployeesManager.resolveModel(employee, model);
-        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: resolvedModel
-                }
-              }
+        const aiEmployeeContext = {
+          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: resolvedModel
+              }
+            }
+          }
+        };
+        const aiEmployeeActionValues = aiEmployeeContext.action.params.values;
+        const aiEmployee = new import_ai_employee.AIEmployee({
+          ctx: aiEmployeeContext,
           employee,
           sessionId: conversation.sessionId,
           systemMessage,
@@ -158,6 +160,7 @@ ${typeof message.system === "object" ? JSON.stringify(message.system) : message.
         }
         let result;
         let isToolInvoke = false;
+        let recoveredFromGraphRecursion = false;
         let retry = 0;
         do {
           const userMessages = [
@@ -170,36 +173,76 @@ ${typeof message.system === "object" ? JSON.stringify(message.system) : message.
               ...attachmentPart
             }
           ];
-          if (retry > 0) {
-            if (retry < 2) {
-              abortHandle.throwIfAborted();
-              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, signal: abortHandle.signal });
-            } else {
-              result = await aiEmployee.invoke({
-                signal: abortHandle.signal,
-                userMessages: [
-                  {
-                    role: "user",
-                    content: {
-                      type: "text",
-                      content: `You failed to call the required tool "${import_ai.SYSTEM_TOOLS.WORK_FLOW_TASK_OUTPUT}" in your previous response.
-Call "${import_ai.SYSTEM_TOOLS.WORK_FLOW_TASK_OUTPUT}" now to submit the workflow outcome.
+          try {
+            if (retry > 0) {
+              if (retry < 2) {
+                abortHandle.throwIfAborted();
+                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, signal: abortHandle.signal });
+              } else {
+                result = await aiEmployee.invoke({
+                  signal: abortHandle.signal,
+                  userMessages: [
+                    {
+                      role: "user",
+                      content: {
+                        type: "text",
+                        content: `You failed to call the required tool "${toolName}" in your previous response.
+Call "${toolName}" now to submit the workflow outcome.
 Do not send another normal assistant response without invoking it.
                   `
+                      }
                     }
-                  }
-                ]
-              });
+                  ]
+                });
+              }
+            } else {
+              result = await aiEmployee.invoke({ userMessages, signal: abortHandle.signal });
             }
-          } else {
-            result = await aiEmployee.invoke({ userMessages, signal: abortHandle.signal });
+          } catch (error) {
+            if (!isGraphRecursionError(error) || recoveredFromGraphRecursion) {
+              throw error;
+            }
+            recoveredFromGraphRecursion = true;
+            processor.logger.warn(`ai employee invoke reached graph recursion limit, trying workflow output recovery`, {
+              node: node.id,
+              stack: error.stack,
+              chatOptions: node.config
+            });
+            const latestMessage = await this.workflow.db.getRepository("aiConversations.messages", conversation.sessionId).findOne({
+              sort: ["-messageId"]
+            });
+            const recoveryAIEmployee = new import_ai_employee.AIEmployee({
+              ctx: {
+                ...aiEmployeeContext,
+                action: {
+                  params: {
+                    values: {
+                      ...aiEmployeeActionValues,
+                      important: "GraphRecursionError"
+                    }
+                  }
+                }
+              },
+              employee,
+              sessionId: conversation.sessionId,
+              systemMessage,
+              skillSettings,
+              webSearch,
+              model: resolvedModel,
+              tools: [{ name: toolName }]
+            });
+            abortHandle.throwIfAborted();
+            result = await recoveryAIEmployee.invoke({
+              messageId: latestMessage == null ? void 0 : latestMessage.messageId,
+              signal: abortHandle.signal
+            });
           }
           abortHandle.throwIfAborted();
           isToolInvoke = result.messages.filter((it) => it.type === "ai").flatMap((it) => it.tool_calls).some((it) => it.name === toolName);
@@ -270,7 +313,7 @@ Do not send another normal assistant response without invoking it.
           username
         },
         title: userMessage.slice(0, 30),
-        from: "sub-agent",
+        from: "main-agent",
         options: {
           systemMessage,
           skillSettings,
@@ -464,6 +507,9 @@ async function parseAssignees(node, processor) {
   }
   return assignees;
 }
+function isGraphRecursionError(error) {
+  return typeof error === "object" && error !== null && ("name" in error || "lc_error_code" in error) && (error.name === "GraphRecursionError" || error.lc_error_code === "GRAPH_RECURSION_LIMIT");
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AIEmployeeInstruction,

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

@@ -29,6 +29,7 @@ __export(tools_exports, {
   getWorkflowTasks: () => getWorkflowTasks
 });
 module.exports = __toCommonJS(tools_exports);
+var import_singletons = require("@langchain/core/singletons");
 var import_plugin_workflow = require("@nocobase/plugin-workflow");
 var import_constants = require("./constants");
 const getWorkflowTasks = (plugin) => async (register, filter) => {
@@ -141,7 +142,13 @@ const getWorkflowTasks = (plugin) => async (register, filter) => {
         status: import_plugin_workflow.JOB_STATUS.RESOLVED,
         result: args.result
       });
-      await workflowPlugin.resume(job);
+      setImmediate(() => {
+        import_singletons.AsyncLocalStorageProviderSingleton.getInstance().run(void 0, () => {
+          workflowPlugin.resume(job).catch((error) => {
+            plugin.app.logger.error(error);
+          });
+        });
+      });
       return {
         status: "success"
       };