@nocobase/ai 2.1.0-alpha.10 → 2.1.0-alpha.12

package/lib/ai-employee-manager/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 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 { AIEmployeeEntry, AIEmployeeFilter, AIEmployeeManager, AIEmployeeOptions } from './types';
+export declare class DefaultAIEmployeeManager implements AIEmployeeManager {
+    private readonly app;
+    private readonly employees;
+    private readonly provideCollectionManager;
+    private mode;
+    constructor(app: any);
+    init(): Promise<void>;
+    getEmployee(username: string): Promise<AIEmployeeEntry>;
+    listEmployees(filter?: AIEmployeeFilter): Promise<AIEmployeeEntry[]>;
+    registerEmployee(options: AIEmployeeOptions): Promise<void>;
+    persistence(): Promise<void>;
+    private registerEmployeeInMemory;
+    private registerEmployeeInDatabase;
+    private get aiEmployeesCollection();
+    private get aiEmployeesModel();
+    private get sequelize();
+    private get collectionManager();
+}
+export declare function defineAIEmployee(options: AIEmployeeOptions): AIEmployeeOptions;
+export * from './types';

package/lib/ai-employee-manager/index.js

@@ -0,0 +1,165 @@
+/**
+ * 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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ai_employee_manager_exports = {};
+__export(ai_employee_manager_exports, {
+  DefaultAIEmployeeManager: () => DefaultAIEmployeeManager,
+  defineAIEmployee: () => defineAIEmployee
+});
+module.exports = __toCommonJS(ai_employee_manager_exports);
+var import_database = require("@nocobase/database");
+var import_utils = require("@nocobase/utils");
+__reExport(ai_employee_manager_exports, require("./types"), module.exports);
+const DEFAULT_KNOWLEDGE_BASE = {
+  topK: 3,
+  score: "0.6",
+  knowledgeBaseIds: []
+};
+const DEFAULT_KNOWLEDGE_BASE_PROMPT = "From knowledge base:\n{knowledgeBaseData}\nanswer user's question using this information.";
+const _DefaultAIEmployeeManager = class _DefaultAIEmployeeManager {
+  constructor(app) {
+    this.app = app;
+    this.provideCollectionManager = () => app.mainDataSource;
+  }
+  employees = new import_utils.Registry();
+  provideCollectionManager;
+  mode = "memory";
+  async init() {
+    if (this.mode === "memory") {
+      await this.persistence();
+      this.mode = "database";
+    }
+  }
+  async getEmployee(username) {
+    var _a;
+    return (_a = await this.aiEmployeesModel.findOne({ where: { username } })) == null ? void 0 : _a.toJSON();
+  }
+  async listEmployees(filter = {}) {
+    const where = {};
+    if (filter.builtIn != null) {
+      where["builtIn"] = filter.builtIn;
+    }
+    if (filter.username) {
+      where["username"] = {
+        [import_database.Op.substring]: filter.username
+      };
+    }
+    return (await this.aiEmployeesModel.findAll({ where })).map((it) => it.toJSON());
+  }
+  async registerEmployee(options) {
+    if (this.mode === "memory") {
+      return this.registerEmployeeInMemory(options);
+    }
+    return this.registerEmployeeInDatabase(options);
+  }
+  async persistence() {
+    const employees = [...this.employees.getValues()];
+    for (const employee of employees) {
+      await this.registerEmployeeInDatabase(employee);
+    }
+  }
+  registerEmployeeInMemory(options) {
+    this.employees.register(options.username, options);
+  }
+  async registerEmployeeInDatabase(options) {
+    const employee = options;
+    await this.sequelize.transaction(async (transaction) => {
+      const existed = await this.aiEmployeesModel.findOne({ where: { username: employee.username }, transaction });
+      if (!existed) {
+        await this.aiEmployeesModel.create(
+          {
+            username: employee.username,
+            nickname: employee.nickname,
+            position: employee.position,
+            avatar: employee.avatar,
+            bio: employee.bio,
+            greeting: employee.greeting,
+            about: null,
+            defaultPrompt: employee.systemPrompt,
+            skillSettings: {
+              skills: employee.skills,
+              tools: employee.tools
+            },
+            enableKnowledgeBase: false,
+            knowledgeBase: DEFAULT_KNOWLEDGE_BASE,
+            knowledgeBasePrompt: DEFAULT_KNOWLEDGE_BASE_PROMPT,
+            enabled: true,
+            builtIn: true
+          },
+          { transaction }
+        );
+        return;
+      }
+      const current = existed.toJSON();
+      let { tools } = (current == null ? void 0 : current.skillSettings) ?? { tools: [] };
+      tools = (tools == null ? void 0 : tools.length) ? tools.filter((s) => {
+        var _a;
+        return (_a = s.name) == null ? void 0 : _a.startsWith("workflowCaller-");
+      }) : [];
+      const mergedTools = /* @__PURE__ */ new Set([...tools, ...employee.tools]);
+      const values = {
+        nickname: employee.nickname ?? current.nickname,
+        position: employee.position ?? current.position,
+        avatar: employee.avatar ?? current.avatar,
+        bio: employee.bio ?? current.bio,
+        greeting: employee.greeting ?? current.greeting,
+        defaultPrompt: employee.systemPrompt,
+        skillSettings: {
+          skills: [...employee.skills],
+          tools: [...mergedTools]
+        }
+      };
+      await existed.update(values, { transaction });
+    });
+  }
+  get aiEmployeesCollection() {
+    return this.collectionManager.getCollection("aiEmployees");
+  }
+  get aiEmployeesModel() {
+    var _a;
+    return (_a = this.aiEmployeesCollection) == null ? void 0 : _a.model;
+  }
+  get sequelize() {
+    return this.collectionManager.db.sequelize;
+  }
+  get collectionManager() {
+    return this.provideCollectionManager().collectionManager;
+  }
+};
+__name(_DefaultAIEmployeeManager, "DefaultAIEmployeeManager");
+let DefaultAIEmployeeManager = _DefaultAIEmployeeManager;
+function defineAIEmployee(options) {
+  return options;
+}
+__name(defineAIEmployee, "defineAIEmployee");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DefaultAIEmployeeManager,
+  defineAIEmployee,
+  ...require("./types")
+});

package/lib/ai-employee-manager/types.d.ts

@@ -0,0 +1,55 @@
+/**
+ * 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 AIEmployeeLocalizedProfile = {
+    avatar?: string;
+    nickname?: string;
+    position?: string;
+    bio?: string;
+    greeting?: string;
+    about?: string;
+};
+export type AIEmployeeKnowledgeBase = {
+    topK: number;
+    score: string;
+    knowledgeBaseIds: string[];
+};
+export type AIEmployeeToolSetting = {
+    name: string;
+    autoCall?: boolean;
+};
+export type AIEmployeeOptions = {
+    username: string;
+    description?: string;
+    skills?: string[];
+    tools?: AIEmployeeToolSetting[];
+    avatar?: string;
+    nickname?: string;
+    position?: string;
+    bio?: string;
+    greeting?: string;
+    systemPrompt?: string | null;
+};
+export type AIEmployeeEntry = Omit<AIEmployeeOptions, 'skills' | 'tools' | 'systemPrompt'> & {
+    about?: string;
+    defaultPrompt?: string;
+    skillSettings: {
+        skills: string[];
+        tools: AIEmployeeToolSetting[];
+    };
+};
+export type AIEmployeeFilter = {
+    builtIn?: boolean;
+    username?: string;
+};
+export interface AIEmployeeManager {
+    init(): Promise<void>;
+    getEmployee(username: string): Promise<AIEmployeeEntry>;
+    listEmployees(filter?: AIEmployeeFilter): Promise<AIEmployeeEntry[]>;
+    registerEmployee(options: AIEmployeeOptions): Promise<void>;
+}

package/lib/ai-employee-manager/types.js

@@ -0,0 +1,24 @@
+/**
+ * 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 __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 types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/lib/ai-manager.d.ts

@@ -8,11 +8,17 @@
  */
 import { DocumentManager } from './document-manager';
 import { ToolsManager } from './tools-manager';
+import { SkillsManager } from './skills-manager';
+import { AIEmployeeManager } from './ai-employee-manager';
+import { MCPManager } from './mcp-manager';
 import { McpToolsManager } from './mcp-tools-manager';
 export declare class AIManager {
     protected readonly app: any;
     documentManager: DocumentManager;
     toolsManager: ToolsManager;
+    skillsManager: SkillsManager;
+    employeeManager: AIEmployeeManager;
+    mcpManager: MCPManager;
     mcpToolsManager: McpToolsManager;
     constructor(app: any);
 }

package/lib/ai-manager.js

@@ -32,16 +32,25 @@ __export(ai_manager_exports, {
 module.exports = __toCommonJS(ai_manager_exports);
 var import_document_manager = require("./document-manager");
 var import_tools_manager = require("./tools-manager");
+var import_skills_manager = require("./skills-manager");
+var import_ai_employee_manager = require("./ai-employee-manager");
+var import_mcp_manager = require("./mcp-manager");
 var import_mcp_tools_manager = require("./mcp-tools-manager");
 const _AIManager = class _AIManager {
   constructor(app) {
     this.app = app;
     this.documentManager = new import_document_manager.DocumentManager();
     this.toolsManager = new import_tools_manager.DefaultToolsManager();
+    this.skillsManager = new import_skills_manager.DefaultSkillsManager(app);
+    this.employeeManager = new import_ai_employee_manager.DefaultAIEmployeeManager(app);
+    this.mcpManager = new import_mcp_manager.DefaultMCPManager(app);
     this.mcpToolsManager = new import_mcp_tools_manager.McpToolsManager();
   }
   documentManager;
   toolsManager;
+  skillsManager;
+  employeeManager;
+  mcpManager;
   mcpToolsManager;
 };
 __name(_AIManager, "AIManager");

package/lib/index.d.ts

@@ -7,7 +7,10 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 export * from './ai-manager';
+export * from './ai-employee-manager';
 export * from './document-manager';
 export * from './mcp-tools-manager';
 export * from './tools-manager';
+export * from './skills-manager';
+export * from './mcp-manager';
 export * from './loader';

package/lib/index.js

@@ -24,15 +24,21 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 module.exports = __toCommonJS(src_exports);
 __reExport(src_exports, require("./ai-manager"), module.exports);
+__reExport(src_exports, require("./ai-employee-manager"), module.exports);
 __reExport(src_exports, require("./document-manager"), module.exports);
 __reExport(src_exports, require("./mcp-tools-manager"), module.exports);
 __reExport(src_exports, require("./tools-manager"), module.exports);
+__reExport(src_exports, require("./skills-manager"), module.exports);
+__reExport(src_exports, require("./mcp-manager"), module.exports);
 __reExport(src_exports, require("./loader"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ...require("./ai-manager"),
+  ...require("./ai-employee-manager"),
   ...require("./document-manager"),
   ...require("./mcp-tools-manager"),
   ...require("./tools-manager"),
+  ...require("./skills-manager"),
+  ...require("./mcp-manager"),
   ...require("./loader")
 });

package/lib/loader/employee.d.ts

@@ -0,0 +1,36 @@
+/**
+ * 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 { DirectoryScanner, DirectoryScannerOptions, FileDescriptor } from './scanner';
+import { AIManager } from '../ai-manager';
+import { LoadAndRegister } from './types';
+import { Logger } from '@nocobase/logger';
+import { AIEmployeeOptions, AIEmployeeToolSetting } from '../ai-employee-manager';
+export type AIEmployeeLoaderOptions = {
+    scan: DirectoryScannerOptions;
+    log?: Logger;
+};
+export declare class AIEmployeeLoader extends LoadAndRegister<AIEmployeeLoaderOptions> {
+    protected readonly ai: AIManager;
+    protected readonly options: AIEmployeeLoaderOptions;
+    protected readonly scanner: DirectoryScanner;
+    protected files: FileDescriptor[];
+    protected employeeDescriptors: AIEmployeeDescriptor[];
+    protected log: Logger;
+    constructor(ai: AIManager, options: AIEmployeeLoaderOptions);
+    protected scan(): Promise<void>;
+    protected import(): Promise<void>;
+    protected register(): Promise<void>;
+}
+export type AIEmployeeDescriptor = {
+    name: string;
+    employeeRoot: string;
+    file: FileDescriptor;
+    options: AIEmployeeOptions;
+};
+export declare function normalizeAIEmployeeToolSetting(tool?: string | AIEmployeeToolSetting): AIEmployeeToolSetting | undefined;

package/lib/loader/employee.js

@@ -0,0 +1,211 @@
+/**
+ * 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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 employee_exports = {};
+__export(employee_exports, {
+  AIEmployeeLoader: () => AIEmployeeLoader,
+  normalizeAIEmployeeToolSetting: () => normalizeAIEmployeeToolSetting
+});
+module.exports = __toCommonJS(employee_exports);
+var import_utils = require("@nocobase/utils");
+var import_scanner = require("./scanner");
+var import_fs = require("fs");
+var import_types = require("./types");
+var import_path = __toESM(require("path"));
+const _AIEmployeeLoader = class _AIEmployeeLoader extends import_types.LoadAndRegister {
+  constructor(ai, options) {
+    super(ai, options);
+    this.ai = ai;
+    this.options = options;
+    this.log = options.log;
+    this.scanner = new import_scanner.DirectoryScanner(this.options.scan);
+  }
+  scanner;
+  files = [];
+  employeeDescriptors = [];
+  log;
+  async scan() {
+    this.files = await this.scanner.scan();
+  }
+  async import() {
+    if (!this.files.length) {
+      return;
+    }
+    const grouped = /* @__PURE__ */ new Map();
+    for (const fd of this.files) {
+      const employeeRoot = getEmployeeRoot(fd.path);
+      const group = grouped.get(employeeRoot) ?? [];
+      group.push(fd);
+      grouped.set(employeeRoot, group);
+    }
+    const descriptors = await Promise.all(
+      Array.from(grouped.entries()).map(async ([employeeRoot, fds]) => {
+        var _a, _b;
+        const file = selectEmployeeDefinitionFile(fds, employeeRoot, this.log);
+        if (!file || !(0, import_fs.existsSync)(file.path)) {
+          return null;
+        }
+        const name = import_path.default.basename(employeeRoot);
+        try {
+          const imported = await (0, import_utils.importModule)(file.path);
+          const mod = (imported == null ? void 0 : imported.default) ?? imported;
+          const employeeOptions = typeof mod === "function" ? mod() : mod;
+          if (!employeeOptions || !employeeOptions.username) {
+            (_a = this.log) == null ? void 0 : _a.warn(`ai employee [${name}] register ignored: invalid definition at ${file.path}`);
+            return null;
+          }
+          const { skills = [], tools = [] } = employeeOptions;
+          return {
+            name,
+            employeeRoot,
+            file,
+            options: {
+              ...employeeOptions,
+              skills: [...skills, ...await discoverSkills(employeeRoot)],
+              tools: [...tools, ...await discoverTools(employeeRoot)]
+            }
+          };
+        } catch (e) {
+          (_b = this.log) == null ? void 0 : _b.error(`ai employee [${name}] load fail: error occur when import ${file.path}`, e);
+          return null;
+        }
+      })
+    );
+    this.employeeDescriptors = descriptors.filter((item) => Boolean(item));
+  }
+  async register() {
+    if (!this.employeeDescriptors.length) {
+      return;
+    }
+    const { employeeManager } = this.ai;
+    for (const descriptor of this.employeeDescriptors) {
+      await employeeManager.registerEmployee(descriptor.options);
+    }
+  }
+};
+__name(_AIEmployeeLoader, "AIEmployeeLoader");
+let AIEmployeeLoader = _AIEmployeeLoader;
+function getEmployeeRoot(filePath) {
+  if (isIndexFile(filePath)) {
+    return import_path.default.dirname(filePath);
+  }
+  const { dir, name } = import_path.default.parse(filePath);
+  return import_path.default.join(dir, name);
+}
+__name(getEmployeeRoot, "getEmployeeRoot");
+function selectEmployeeDefinitionFile(files, employeeRoot, log) {
+  const direct = files.find((fd) => !isIndexFile(fd.path));
+  const nested = files.find((fd) => isIndexFile(fd.path));
+  if (direct && nested) {
+    log == null ? void 0 : log.warn(
+      `ai employee [${import_path.default.basename(employeeRoot)}] duplicate definition found, use ${direct.path} instead of ${nested.path}`
+    );
+  }
+  return direct ?? nested;
+}
+__name(selectEmployeeDefinitionFile, "selectEmployeeDefinitionFile");
+async function discoverSkills(employeeRoot) {
+  const skillsDir = import_path.default.join(employeeRoot, "skills");
+  if (!(0, import_fs.existsSync)(skillsDir)) {
+    return [];
+  }
+  const scanner = new import_scanner.DirectoryScanner({
+    basePath: employeeRoot,
+    pattern: ["skills/**/SKILLS.md"]
+  });
+  const skillFiles = await scanner.scan();
+  return uniq(skillFiles.map((it) => it.directory).filter(Boolean));
+}
+__name(discoverSkills, "discoverSkills");
+async function discoverTools(employeeRoot) {
+  const toolsDir = import_path.default.join(employeeRoot, "tools");
+  if (!(0, import_fs.existsSync)(toolsDir)) {
+    return [];
+  }
+  const scanner = new import_scanner.DirectoryScanner({
+    basePath: employeeRoot,
+    pattern: ["tools/**/*.ts", "tools/**/*.js", "!tools/**/*.d.ts"]
+  });
+  const toolFiles = await scanner.scan();
+  return uniqBy(
+    toolFiles.map(
+      (it) => normalizeAIEmployeeToolSetting(
+        it.basename === "index.ts" || it.basename === "index.js" ? it.directory : it.name
+      )
+    ).filter((tool) => Boolean(tool == null ? void 0 : tool.name)),
+    "name"
+  );
+}
+__name(discoverTools, "discoverTools");
+function isIndexFile(filePath) {
+  const basename = import_path.default.basename(filePath);
+  return basename === "index.ts" || basename === "index.js";
+}
+__name(isIndexFile, "isIndexFile");
+function uniq(values) {
+  return [...new Set(values)];
+}
+__name(uniq, "uniq");
+function uniqBy(values, key) {
+  const valueMap = /* @__PURE__ */ new Map();
+  for (const value of values) {
+    valueMap.set(value[key], value);
+  }
+  return [...valueMap.values()];
+}
+__name(uniqBy, "uniqBy");
+function normalizeAIEmployeeToolSetting(tool) {
+  if (!tool) {
+    return;
+  }
+  if (typeof tool === "string") {
+    return { name: tool };
+  }
+  if (!tool.name) {
+    return;
+  }
+  return {
+    name: tool.name,
+    ...tool.autoCall != null ? { autoCall: tool.autoCall } : {}
+  };
+}
+__name(normalizeAIEmployeeToolSetting, "normalizeAIEmployeeToolSetting");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AIEmployeeLoader,
+  normalizeAIEmployeeToolSetting
+});

package/lib/loader/index.d.ts

@@ -9,3 +9,6 @@
 export * from './types';
 export * from './scanner';
 export * from './tools';
+export * from './skills';
+export * from './mcp';
+export * from './employee';

package/lib/loader/index.js

@@ -26,9 +26,15 @@ module.exports = __toCommonJS(loader_exports);
 __reExport(loader_exports, require("./types"), module.exports);
 __reExport(loader_exports, require("./scanner"), module.exports);
 __reExport(loader_exports, require("./tools"), module.exports);
+__reExport(loader_exports, require("./skills"), module.exports);
+__reExport(loader_exports, require("./mcp"), module.exports);
+__reExport(loader_exports, require("./employee"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ...require("./types"),
   ...require("./scanner"),
-  ...require("./tools")
+  ...require("./tools"),
+  ...require("./skills"),
+  ...require("./mcp"),
+  ...require("./employee")
 });

package/lib/loader/mcp.d.ts

@@ -0,0 +1,34 @@
+/**
+ * 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 { Logger } from '@nocobase/logger';
+import { AIManager } from '../ai-manager';
+import { MCPOptions } from '../mcp-manager';
+import { LoadAndRegister } from './types';
+import { DirectoryScanner, DirectoryScannerOptions, FileDescriptor } from './scanner';
+export type MCPLoaderOptions = {
+    scan: DirectoryScannerOptions;
+    log?: Logger;
+};
+export declare class MCPLoader extends LoadAndRegister<MCPLoaderOptions> {
+    protected readonly ai: AIManager;
+    protected readonly options: MCPLoaderOptions;
+    protected readonly scanner: DirectoryScanner;
+    protected files: FileDescriptor[];
+    protected mcpDescriptors: MCPDescriptor[];
+    protected log: Logger;
+    constructor(ai: AIManager, options: MCPLoaderOptions);
+    protected scan(): Promise<void>;
+    protected import(): Promise<void>;
+    protected register(): Promise<void>;
+}
+export type MCPDescriptor = {
+    name: string;
+    file: FileDescriptor;
+    options: MCPOptions;
+};