@nocobase/plugin-ai 2.3.0-alpha.1 → 3.0.0-alpha.1

package/dist/server/ai-employees/middleware/conversation.js

@@ -98,8 +98,9 @@ const conversationMiddleware = (aiEmployee, options) => {
       })
     }),
     beforeAgent: async (state) => {
-      const lastHumanMessageIndex = state.lastMessageIndex.lastHumanMessageIndex;
-      const userMessages = state.messages.filter((x) => x.type === "human").slice(lastHumanMessageIndex).map((x) => x).map(convertHumanMessage);
+      const humanMessages = state.messages.filter((x) => x.type === "human");
+      const currentHumanMessageIndex = humanMessages.length;
+      const userMessages = (aiEmployee.userMessageCount ? humanMessages.slice(-aiEmployee.userMessageCount) : []).map((x) => x).map(convertHumanMessage);
       await aiEmployee.aiChatConversation.withTransaction(async (conversation, transaction) => {
         if (agentThread) {
           await aiEmployee.updateThread(transaction, agentThread);
@@ -111,6 +112,12 @@ const conversationMiddleware = (aiEmployee, options) => {
           await conversation.addMessages(userMessages);
         }
       });
+      return {
+        lastMessageIndex: {
+          ...state.lastMessageIndex,
+          lastHumanMessageIndex: currentHumanMessageIndex
+        }
+      };
     },
     afterAgent: async () => {
       aiEmployee.removeAbortController();

package/dist/server/collections/ai-conversations.js

@@ -57,6 +57,11 @@ var ai_conversations_default = (0, import_database.defineCollection)({
       defaultValue: "main-agent",
       allowNull: false
     },
+    {
+      name: "scope",
+      type: "string",
+      index: true
+    },
     {
       name: "user",
       type: "belongsTo",

package/dist/server/document-loader/constants.js

@@ -33,12 +33,12 @@ module.exports = __toCommonJS(constants_exports);
 const DOCUMENT_PARSE_META_KEY = "documentParse";
 const SUPPORTED_DOCUMENT_EXTNAMES = [
   ".pdf",
-  ".ppt",
   ".pptx",
   ".doc",
   ".docx",
   ".xls",
   ".xlsx",
+  ".xlsm",
   ".txt",
   ".md",
   ".json",

package/dist/server/frontend-tools.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 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 type { Context } from '@nocobase/actions';
+import { type FrontendToolManifest } from '../common/frontend-tools';
+import type { WorkContext } from './types/ai-message.type';
+export declare const extractFrontendToolManifests: (workContext: WorkContext[]) => FrontendToolManifest[];
+export declare const listCurrentFrontendTools: (ctx: Context, sessionId?: string) => Promise<FrontendToolManifest[]>;
+export declare const findCurrentFrontendTool: (ctx: Context, toolId: string, sessionId?: string) => Promise<FrontendToolManifest | undefined>;
+export declare const shouldAutoExecuteFrontendTool: (tools: FrontendToolManifest[], args: unknown) => boolean;
+export declare const prepareToolsForFrontendConversation: <T extends {
+    definition: {
+        name: string;
+        description: string;
+    };
+}>(tools: T[], frontendTools: FrontendToolManifest[]) => T[];
+export declare const readFrontendToolResult: (ctx: Context, toolCallId: string) => {
+    provided: true;
+    value: unknown;
+} | undefined;

package/dist/server/frontend-tools.js

@@ -0,0 +1,171 @@
+/**
+ * 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 frontend_tools_exports = {};
+__export(frontend_tools_exports, {
+  extractFrontendToolManifests: () => extractFrontendToolManifests,
+  findCurrentFrontendTool: () => findCurrentFrontendTool,
+  listCurrentFrontendTools: () => listCurrentFrontendTools,
+  prepareToolsForFrontendConversation: () => prepareToolsForFrontendConversation,
+  readFrontendToolResult: () => readFrontendToolResult,
+  shouldAutoExecuteFrontendTool: () => shouldAutoExecuteFrontendTool
+});
+module.exports = __toCommonJS(frontend_tools_exports);
+var import_zod = require("zod");
+var import_frontend_tools = require("../common/frontend-tools");
+const isRecord = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+const isMessageLike = (value) => !!value && typeof value === "object";
+const normalizeFrontendToolManifests = (value) => {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const manifests = /* @__PURE__ */ new Map();
+  for (const manifest of value) {
+    if ((0, import_frontend_tools.isFrontendToolManifest)(manifest) && manifest.id === `${manifest.blockUid}:${manifest.name}`) {
+      manifests.set(manifest.id, manifest);
+    }
+  }
+  return Array.from(manifests.values());
+};
+const extractFrontendToolManifests = (workContext) => {
+  const manifests = /* @__PURE__ */ new Map();
+  for (const item of workContext) {
+    const frontendTools = Array.isArray(item == null ? void 0 : item.frontendTools) ? item.frontendTools : [];
+    for (const frontendTool of frontendTools) {
+      if ((0, import_frontend_tools.isFrontendToolManifest)(frontendTool) && frontendTool.blockUid === item.uid && frontendTool.id === `${item.uid}:${frontendTool.name}`) {
+        manifests.set(frontendTool.id, frontendTool);
+      }
+    }
+  }
+  return Array.from(manifests.values());
+};
+const findRequestFrontendTools = (ctx) => {
+  var _a, _b;
+  const values = (_b = (_a = ctx.action) == null ? void 0 : _a.params) == null ? void 0 : _b.values;
+  const messages = Array.isArray(values == null ? void 0 : values.messages) ? values.messages.filter(isMessageLike) : [];
+  for (const message of messages) {
+    if (message.role !== "user") {
+      continue;
+    }
+    const frontendTools = extractFrontendToolManifests(Array.isArray(message.workContext) ? message.workContext : []);
+    if (frontendTools.length) {
+      return frontendTools;
+    }
+  }
+  return [];
+};
+const listCurrentFrontendTools = async (ctx, sessionId) => {
+  var _a, _b, _c;
+  const requestSessionId = (_c = (_b = (_a = ctx.action) == null ? void 0 : _a.params) == null ? void 0 : _b.values) == null ? void 0 : _c.sessionId;
+  const currentSessionId = sessionId ?? (typeof requestSessionId === "string" ? requestSessionId : "");
+  if (!currentSessionId) {
+    return findRequestFrontendTools(ctx);
+  }
+  const conversationRepository = ctx.db.getRepository("aiConversations");
+  const conversation = await conversationRepository.findOne({
+    filter: {
+      sessionId: currentSessionId
+    }
+  });
+  const options = conversation == null ? void 0 : conversation.options;
+  const boundTools = normalizeFrontendToolManifests(isRecord(options) ? options.frontendTools : void 0);
+  if (boundTools.length) {
+    return boundTools;
+  }
+  const frontendTools = findRequestFrontendTools(ctx);
+  if (!frontendTools.length || !conversation) {
+    return frontendTools;
+  }
+  await conversationRepository.update({
+    filter: {
+      sessionId: currentSessionId
+    },
+    values: {
+      options: {
+        ...isRecord(options) ? options : {},
+        frontendTools
+      }
+    }
+  });
+  return frontendTools;
+};
+const findCurrentFrontendTool = async (ctx, toolId, sessionId) => {
+  const tools = await listCurrentFrontendTools(ctx, sessionId);
+  return tools.find((tool) => tool.id === toolId);
+};
+const shouldAutoExecuteFrontendTool = (tools, args) => {
+  var _a;
+  if (!isRecord(args) || typeof args.toolId !== "string") {
+    return false;
+  }
+  return ((_a = tools.find((tool) => tool.id === args.toolId)) == null ? void 0 : _a.permission) === "ALLOW";
+};
+const prepareToolsForFrontendConversation = (tools, frontendTools) => {
+  if (!frontendTools.length) {
+    return tools.filter(
+      (tool) => tool.definition.name !== import_frontend_tools.LOAD_FRONTEND_TOOL_NAME && tool.definition.name !== import_frontend_tools.EXECUTE_FRONTEND_TOOL_NAME
+    );
+  }
+  const catalog = frontendTools.map(({ id, name, title, description }) => ({ id, name, title, description }));
+  const toolIds = frontendTools.map((tool) => tool.id);
+  const toolIdSchema = import_zod.z.enum(toolIds).describe(`Use an exact tool id from this catalog: ${JSON.stringify(catalog)}`);
+  return tools.map((tool) => {
+    if (tool.definition.name !== import_frontend_tools.LOAD_FRONTEND_TOOL_NAME && tool.definition.name !== import_frontend_tools.EXECUTE_FRONTEND_TOOL_NAME) {
+      return tool;
+    }
+    const isLoader = tool.definition.name === import_frontend_tools.LOAD_FRONTEND_TOOL_NAME;
+    return {
+      ...tool,
+      definition: {
+        ...tool.definition,
+        description: `${tool.definition.description}
+
+frontendToolCatalog: ${JSON.stringify(catalog)}`,
+        schema: isLoader ? import_zod.z.object({ toolId: toolIdSchema }) : import_zod.z.object({
+          toolId: toolIdSchema,
+          args: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).default({})
+        })
+      }
+    };
+  });
+};
+const readFrontendToolResult = (ctx, toolCallId) => {
+  var _a, _b, _c;
+  const toolCallResults = (_c = (_b = (_a = ctx.action) == null ? void 0 : _a.params) == null ? void 0 : _b.values) == null ? void 0 : _c.toolCallResults;
+  const result = Array.isArray(toolCallResults) ? toolCallResults.find(
+    (item) => isRecord(item) && item.id === toolCallId && "result" in item
+  ) : void 0;
+  return result ? { provided: true, value: result.result } : void 0;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  extractFrontendToolManifests,
+  findCurrentFrontendTool,
+  listCurrentFrontendTools,
+  prepareToolsForFrontendConversation,
+  readFrontendToolResult,
+  shouldAutoExecuteFrontendTool
+});

package/dist/server/manager/work-context-handler.js

@@ -41,6 +41,7 @@ __export(work_context_handler_exports, {
 module.exports = __toCommonJS(work_context_handler_exports);
 var import_utils = require("@nocobase/utils");
 var import_lodash = __toESM(require("lodash"));
+const MODEL_EXCLUDED_FIELDS = /* @__PURE__ */ new Set(["frontendTools"]);
 const createWorkContextHandler = (plugin) => new WorkContextHandlerImpl(plugin);
 class WorkContextHandlerImpl {
   constructor(plugin) {
@@ -82,11 +83,17 @@ class WorkContextHandlerImpl {
     if (!contextItem) {
       return "";
     }
-    const { resolve } = this.strategies.get(contextItem.type) ?? {};
+    const modelContext = this.excludeInternalFields(contextItem);
+    const { resolve } = this.strategies.get(modelContext.type) ?? {};
     if (resolve) {
-      return await resolve(ctx, contextItem);
+      return await resolve(ctx, modelContext);
     }
-    return await ((_b = (_a = this.defaultStrategy).resolve) == null ? void 0 : _b.call(_a, ctx, contextItem));
+    return await ((_b = (_a = this.defaultStrategy).resolve) == null ? void 0 : _b.call(_a, ctx, modelContext));
+  }
+  excludeInternalFields(contextItem) {
+    return Object.fromEntries(
+      Object.entries(contextItem).filter(([field]) => !MODEL_EXCLUDED_FIELDS.has(field))
+    );
   }
 }
 const Stringify = (_plugin) => async (_ctx, contextItem) => {

package/dist/server/plugin.d.ts

@@ -62,6 +62,7 @@ export declare class PluginAIServer extends Plugin {
     get repositories(): {
         aiContextDatasources: import("@nocobase/database").Repository<any, any>;
     };
+    private registerAIFileAccessAuthorizer;
     get fileManager(): PluginFileManagerServer;
     private repository;
 }

package/dist/server/plugin.js

@@ -56,6 +56,7 @@ var import_ai_employees_manager = require("./ai-employees/ai-employees-manager")
 var import_ai_conversations = require("./ai-employees/ai-conversations");
 var import_snowflake = __toESM(require("./snowflake"));
 var aiEmployeeActions = __toESM(require("./resource/aiEmployees"));
+var llmServiceActions = __toESM(require("./resource/llmServices"));
 var import_google_genai = require("./llm-providers/google-genai");
 var import_ai_employee = require("./workflow/triggers/ai-employee");
 var import_tools = require("./tools");
@@ -169,6 +170,7 @@ class PluginAIServer extends import_server.Plugin {
     this.defineResources();
     this.registerMcpClientEvents();
     this.setPermissions();
+    this.registerAIFileAccessAuthorizer();
     this.registerWorkflow();
     this.registerWorkContextResolveStrategy();
     (0, import_employee.registerAIEmployeeTaskNotification)(this);
@@ -235,6 +237,9 @@ class PluginAIServer extends import_server.Plugin {
     Object.entries(aiEmployeeActions).forEach(([name, action]) => {
       this.app.resourceManager.registerActionHandler(`aiEmployees:${name}`, action);
     });
+    Object.entries(llmServiceActions).forEach(([name, action]) => {
+      this.app.resourceManager.registerActionHandler(`llmServices:${name}`, action);
+    });
   }
   registerMcpClientEvents() {
     this.db.on("aiMcpClients.afterCreate", (model, { transaction } = {}) => {
@@ -370,6 +375,26 @@ class PluginAIServer extends import_server.Plugin {
       aiContextDatasources: this.repository("aiContextDatasources")
     };
   }
+  registerAIFileAccessAuthorizer() {
+    this.fileManager.registerFileAccessAuthorizer({
+      name: "ai-files",
+      authorize: async (ctx, params) => {
+        var _a;
+        const currentUserId = (_a = ctx.state.currentUser) == null ? void 0 : _a.id;
+        if (params.dataSourceKey !== "main" || params.collectionName !== "aiFiles" || !currentUserId) {
+          return false;
+        }
+        const file = await ctx.db.getRepository("aiFiles").findOne({
+          filter: {
+            id: params.id,
+            createdById: currentUserId
+          },
+          fields: ["id"]
+        });
+        return Boolean(file);
+      }
+    });
+  }
   get fileManager() {
     return this.app.pm.get("file-manager");
   }

package/dist/server/resource/aiConversations.d.ts

@@ -7,6 +7,8 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import { Context, Next } from '@nocobase/actions';
+import { Model } from '@nocobase/database';
+export declare function isAIEmployeeEnabled(employee: Model | null | undefined): boolean;
 declare function loginInCheck(ctx: Context, next: Next): Promise<never>;
 declare const _default: {
     name: string;

package/dist/server/resource/aiConversations.js

@@ -36,7 +36,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var aiConversations_exports = {};
 __export(aiConversations_exports, {
-  default: () => aiConversations_default
+  default: () => aiConversations_default,
+  isAIEmployeeEnabled: () => isAIEmployeeEnabled
 });
 module.exports = __toCommonJS(aiConversations_exports);
 var import_actions = __toESM(require("@nocobase/actions"));
@@ -44,6 +45,8 @@ var import_database = require("@nocobase/database");
 var import_utils = require("../utils");
 var import_ai_employee = require("../ai-employees/ai-employee");
 var import_ai_chat_conversation = require("../manager/ai-chat-conversation");
+var import_frontend_tools = require("../../common/frontend-tools");
+var import_frontend_tools2 = require("../frontend-tools");
 async function getAIEmployee(ctx, username) {
   var _a;
   const filter = {
@@ -57,6 +60,10 @@ async function getAIEmployee(ctx, username) {
   });
   return employee;
 }
+function isAIEmployeeEnabled(employee) {
+  var _a;
+  return ((_a = employee == null ? void 0 : employee.get) == null ? void 0 : _a.call(employee, "enabled")) !== false;
+}
 function setupSSEHeaders(ctx) {
   ctx.set({
     "Content-Type": "text/event-stream",
@@ -142,12 +149,14 @@ var aiConversations_default = {
       var _a;
       const userId = (_a = ctx.auth) == null ? void 0 : _a.user.id;
       const filter = ctx.action.params.filter || {};
+      const scope = ctx.action.params.scope;
       ctx.action.mergeParams({
         filter: {
           ...filter,
           userId,
           from: filter.from ?? "main-agent",
-          category: "chat"
+          category: "chat",
+          ...typeof scope === "string" && scope ? { scope } : {}
         }
       });
       return import_actions.default.list(ctx, next);
@@ -197,15 +206,20 @@ var aiConversations_default = {
       var _a;
       const plugin = ctx.app.pm.get("ai");
       const userId = (_a = ctx.auth) == null ? void 0 : _a.user.id;
-      const { aiEmployee, systemMessage, skillSettings, conversationSettings, modelSettings } = ctx.action.params.values || {};
+      const { aiEmployee, systemMessage, skillSettings, conversationSettings, modelSettings, scope } = ctx.action.params.values || {};
+      const normalizedScope = typeof scope === "string" ? scope : void 0;
       const employee = await getAIEmployee(ctx, aiEmployee.username);
       if (!employee) {
         ctx.throw(400, "AI employee not found");
       }
+      if (!isAIEmployeeEnabled(employee)) {
+        ctx.throw(400, "AI employee is disabled");
+      }
       try {
         ctx.body = await plugin.aiConversationsManager.create({
           userId,
           aiEmployee,
+          scope: normalizedScope,
           options: {
             systemMessage,
             skillSettings,
@@ -672,6 +686,17 @@ var aiConversations_default = {
       if (!(toolCalls == null ? void 0 : toolCalls.length)) {
         ctx.throw(400);
       }
+      const selectedToolCall = toolCalls.find((toolCall2) => toolCall2.id === toolCallId);
+      if (!selectedToolCall) {
+        ctx.throw(400);
+      }
+      if (selectedToolCall.name === import_frontend_tools.EXECUTE_FRONTEND_TOOL_NAME) {
+        const toolId = isRecord(selectedToolCall.args) ? selectedToolCall.args.toolId : void 0;
+        const frontendTool = typeof toolId === "string" ? await (0, import_frontend_tools2.findCurrentFrontendTool)(ctx, toolId, message.sessionId) : void 0;
+        if (!frontendTool) {
+          ctx.throw(400, ctx.t("Frontend tool is unavailable"));
+        }
+      }
       const aiToolMessagesModel = ctx.db.getModel("aiToolMessages");
       const toolCall = await aiToolMessagesModel.findOne({
         where: { sessionId: message.sessionId, messageId: message.messageId, toolCallId }
@@ -715,6 +740,7 @@ var aiConversations_default = {
         toolCall2.auto = toolMessage == null ? void 0 : toolMessage.auto;
         toolCall2.status = toolMessage == null ? void 0 : toolMessage.status;
         toolCall2.content = toolMessage == null ? void 0 : toolMessage.content;
+        toolCall2.userDecision = toolMessage == null ? void 0 : toolMessage.userDecision;
         toolCall2.execution = tools == null ? void 0 : tools.execution;
         toolCall2.willInterrupt = (tools == null ? void 0 : tools.execution) === "frontend" || (toolMessage == null ? void 0 : toolMessage.auto) === false;
         toolCall2.defaultPermission = tools == null ? void 0 : tools.defaultPermission;
@@ -801,3 +827,7 @@ var aiConversations_default = {
     }
   }
 };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isAIEmployeeEnabled
+});

package/dist/server/resource/aiEmployees.d.ts

@@ -7,6 +7,8 @@
  * 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>;
 export declare const list: (ctx: Context, next: Next) => Promise<void>;
 export declare const listByUser: (ctx: Context, next: Next) => Promise<any>;
 export declare const updateUserPrompt: (ctx: Context, next: Next) => Promise<any>;

package/dist/server/resource/aiEmployees.js

@@ -36,16 +36,76 @@ 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");
+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 create = async (ctx, next) => {
+  var _a;
+  validateAndNormalizeProfileValues(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 +287,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>;