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

package/lib/mcp-tools-manager.js

@@ -0,0 +1,77 @@
+/**
+ * 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mcp_tools_manager_exports = {};
+__export(mcp_tools_manager_exports, {
+  McpToolsManager: () => McpToolsManager
+});
+module.exports = __toCommonJS(mcp_tools_manager_exports);
+var import_utils = require("@nocobase/utils");
+const _McpToolsManager = class _McpToolsManager {
+  tools = new import_utils.Registry();
+  resultPostProcessors = /* @__PURE__ */ new Map();
+  getActionKey(resourceName, actionName) {
+    return `${resourceName}:${actionName}`;
+  }
+  registerTools(tools) {
+    for (const tool of tools) {
+      this.tools.register(tool.name, tool);
+    }
+  }
+  registerToolResultPostProcessor(resourceName, actionName, processor) {
+    const key = this.getActionKey(resourceName, actionName);
+    const processors = this.resultPostProcessors.get(key) || [];
+    processors.push(processor);
+    this.resultPostProcessors.set(key, processors);
+  }
+  async postProcessToolResult(tool, result, context) {
+    if (!tool.resourceName || !tool.actionName) {
+      return result;
+    }
+    const processors = this.resultPostProcessors.get(this.getActionKey(tool.resourceName, tool.actionName)) || [];
+    let current = result;
+    for (const processor of processors) {
+      current = await processor(current, {
+        ...context,
+        tool
+      });
+    }
+    return current;
+  }
+  listTools() {
+    return [...this.tools.getValues()];
+  }
+  getTool(name) {
+    return this.tools.get(name);
+  }
+};
+__name(_McpToolsManager, "McpToolsManager");
+let McpToolsManager = _McpToolsManager;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  McpToolsManager
+});

package/lib/skills-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 { SkillsEntry, SkillsManager, SkillsOptions, SkillsFilter } from './types';
+export declare class DefaultSkillsManager implements SkillsManager {
+    private readonly app;
+    private readonly skills;
+    private readonly provideCollectionManager;
+    private mode;
+    constructor(app: any);
+    init(): Promise<void>;
+    getSkills(name: string[]): Promise<SkillsEntry[]>;
+    getSkills(name: string): Promise<SkillsEntry>;
+    listSkills(filter: SkillsFilter): Promise<SkillsEntry[]>;
+    registerSkills(options: SkillsOptions): Promise<void>;
+    persistence(): Promise<void>;
+    private registerSkillsInMemory;
+    registerSkillsInDatabase(options: SkillsOptions): Promise<void>;
+    private get aiSkillsCollection();
+    private get aiSkillsModel();
+    private get sequelize();
+    private get collectionManager();
+}
+export * from './types';

package/lib/skills-manager/index.js

@@ -0,0 +1,169 @@
+/**
+ * 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 __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 skills_manager_exports = {};
+__export(skills_manager_exports, {
+  DefaultSkillsManager: () => DefaultSkillsManager
+});
+module.exports = __toCommonJS(skills_manager_exports);
+var import_database = require("@nocobase/database");
+var import_utils = require("@nocobase/utils");
+var import_lodash = __toESM(require("lodash"));
+__reExport(skills_manager_exports, require("./types"), module.exports);
+const _DefaultSkillsManager = class _DefaultSkillsManager {
+  constructor(app) {
+    this.app = app;
+    this.provideCollectionManager = () => app.mainDataSource;
+  }
+  skills = new import_utils.Registry();
+  provideCollectionManager;
+  mode = "memory";
+  async init() {
+    if (this.mode === "memory") {
+      await this.persistence();
+      this.mode = "database";
+    }
+  }
+  async getSkills(name) {
+    var _a;
+    if (import_lodash.default.isArray(name)) {
+      return (await this.aiSkillsModel.findAll({ where: { name: { [import_database.Op.in]: name } } })).map((it) => it.toJSON()).map(converterSkillsEntry);
+    } else {
+      return converterSkillsEntry((_a = await this.aiSkillsModel.findOne({ where: { name } })) == null ? void 0 : _a.toJSON());
+    }
+  }
+  async listSkills(filter) {
+    const where = {};
+    if (filter == null ? void 0 : filter.scope) {
+      where["scope"] = filter.scope;
+    }
+    if (filter == null ? void 0 : filter.name) {
+      where["name"] = {
+        [import_database.Op.substring]: filter.name
+      };
+    }
+    return (await this.aiSkillsModel.findAll({ where })).map((it) => it.toJSON()).map(converterSkillsEntry);
+  }
+  async registerSkills(options) {
+    if (this.mode === "memory") {
+      return this.registerSkillsInMemory(options);
+    }
+    return this.registerSkillsInDatabase(options);
+  }
+  async persistence() {
+    const skillsList = [...this.skills.getValues()];
+    for (const skill of skillsList) {
+      await this.registerSkillsInDatabase(skill);
+    }
+  }
+  registerSkillsInMemory(options) {
+    const skillsEntry = { ...options };
+    this.skills.register(options.name, skillsEntry);
+  }
+  async registerSkillsInDatabase(options) {
+    var _a, _b;
+    const title = (_a = options.introduction) == null ? void 0 : _a.title;
+    const about = (_b = options.introduction) == null ? void 0 : _b.about;
+    const from = options.from || "loader";
+    await this.sequelize.transaction(async (transaction) => {
+      const existed = await this.aiSkillsModel.findOne({ where: { name: options.name }, transaction });
+      if (existed) {
+        await this.aiSkillsModel.update(
+          {
+            scope: options.scope,
+            description: options.description,
+            content: options.content,
+            tools: options.tools,
+            title,
+            about,
+            from
+          },
+          {
+            where: { name: options.name },
+            transaction
+          }
+        );
+      } else {
+        await this.aiSkillsModel.create(
+          {
+            name: options.name,
+            scope: options.scope,
+            description: options.description,
+            content: options.content,
+            tools: options.tools,
+            title,
+            about,
+            from
+          },
+          {
+            transaction
+          }
+        );
+      }
+    });
+  }
+  get aiSkillsCollection() {
+    return this.collectionManager.getCollection("aiSkills");
+  }
+  get aiSkillsModel() {
+    var _a;
+    return (_a = this.aiSkillsCollection) == null ? void 0 : _a.model;
+  }
+  get sequelize() {
+    return this.collectionManager.db.sequelize;
+  }
+  get collectionManager() {
+    return this.provideCollectionManager().collectionManager;
+  }
+};
+__name(_DefaultSkillsManager, "DefaultSkillsManager");
+let DefaultSkillsManager = _DefaultSkillsManager;
+const converterSkillsEntry = /* @__PURE__ */ __name((model) => {
+  return {
+    ...model ?? {},
+    introduction: (model == null ? void 0 : model.title) ? {
+      title: model.title,
+      about: model == null ? void 0 : model.about
+    } : void 0
+  };
+}, "converterSkillsEntry");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DefaultSkillsManager,
+  ...require("./types")
+});

package/lib/skills-manager/types.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 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 interface SkillsManager {
+    init(): Promise<void>;
+    getSkills(name: string[]): Promise<SkillsEntry[]>;
+    getSkills(name: string): Promise<SkillsEntry>;
+    listSkills(filter?: SkillsFilter): Promise<SkillsEntry[]>;
+    registerSkills(options: SkillsOptions): Promise<void>;
+}
+export type SkillsOptions = {
+    scope: SkillsScope;
+    name: string;
+    description: string;
+    content: string;
+    tools?: string[];
+    introduction?: {
+        title: string;
+        about?: string;
+    };
+    from?: string;
+};
+export type SkillsEntry = SkillsOptions;
+export type SkillsFilter = {
+    scope?: SkillsScope;
+    name?: string;
+};
+export type SkillsScope = 'SPECIFIED' | 'GENERAL' | 'CUSTOM';

package/lib/skills-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/tools-manager/index.d.ts

@@ -12,8 +12,9 @@ export declare class DefaultToolsManager implements ToolsManager {
     private readonly tools;
     private readonly dynamicTools;
     constructor(tools?: Registry<ToolsOptions>, dynamicTools?: DynamicToolsProvider[]);
-    getTools(toolName: string): Promise<ToolsEntry>;
+    getTools(toolName: string, filter?: ToolsFilter): Promise<ToolsEntry>;
     listTools(filter?: ToolsFilter): Promise<ToolsEntry[]>;
+    isToolsExisted(toolName: string): boolean;
     registerTools(options: ToolsOptions | ToolsOptions[]): void;
     registerDynamicTools(provider: DynamicToolsProvider): void;
     private getToolsList;

package/lib/tools-manager/index.js

@@ -50,16 +50,16 @@ const _DefaultToolsManager = class _DefaultToolsManager {
     this.tools = tools;
     this.dynamicTools = dynamicTools;
   }
-  async getTools(toolName) {
+  async getTools(toolName, filter) {
     const target = this.tools.get(toolName);
     if (target) {
       return target;
     }
-    const dynamicTools = await this.syncDynamicTools();
+    const dynamicTools = await this.syncDynamicTools(filter);
     return dynamicTools.find((x) => x.definition.name === toolName);
   }
   async listTools(filter) {
-    const toolsList = await this.getToolsList();
+    const toolsList = await this.getToolsList(filter);
     return toolsList.filter((x) => {
       if (!filter) {
         return true;
@@ -77,10 +77,20 @@ const _DefaultToolsManager = class _DefaultToolsManager {
       return result;
     });
   }
+  isToolsExisted(toolName) {
+    const target = this.tools.get(toolName);
+    if (target) {
+      return true;
+    }
+    return false;
+  }
   registerTools(options) {
     const list = import_lodash.default.isArray(options) ? options : [options];
     for (const item of list) {
       const toolsEntry = { ...item };
+      if (!toolsEntry.from) {
+        toolsEntry.from = "loader";
+      }
       if (!toolsEntry.execution) {
         toolsEntry.execution = "backend";
       }
@@ -99,17 +109,17 @@ const _DefaultToolsManager = class _DefaultToolsManager {
   registerDynamicTools(provider) {
     this.dynamicTools.push(provider);
   }
-  async getToolsList() {
-    const dynamicTools = await this.syncDynamicTools();
+  async getToolsList(filter) {
+    const dynamicTools = await this.syncDynamicTools(filter);
     return [...this.tools.getValues(), ...dynamicTools];
   }
-  async syncDynamicTools() {
+  async syncDynamicTools(filter) {
     if (this.dynamicTools.length === 0) {
       return [];
     }
     const registry = new import_utils.Registry();
     const ephemeral = new _DefaultToolsManager(registry);
-    await Promise.all(this.dynamicTools.map((register) => register(ephemeral)));
+    await Promise.all(this.dynamicTools.map((register) => register(ephemeral, filter)));
     return [...registry.getValues()];
   }
 };

package/lib/tools-manager/types.d.ts

@@ -8,15 +8,17 @@
  */
 import type { Context } from '@nocobase/actions';
 export interface ToolsManager extends ToolsRegistration {
-    getTools(toolName: string): Promise<ToolsEntry>;
+    getTools(toolName: string, filter?: ToolsFilter): Promise<ToolsEntry>;
     listTools(filter?: ToolsFilter): Promise<ToolsEntry[]>;
+    isToolsExisted(toolName: string): boolean;
 }
 export interface ToolsRegistration {
     registerTools(options: ToolsOptions | ToolsOptions[]): void;
-    registerDynamicTools(provider: (register: ToolsRegistration) => Promise<void>): void;
+    registerDynamicTools(provider: DynamicToolsProvider): void;
 }
 export type ToolsOptions = {
     scope: Scope;
+    from?: From;
     execution?: 'frontend' | 'backend';
     defaultPermission?: Permission;
     silence?: boolean;
@@ -29,14 +31,20 @@ export type ToolsOptions = {
         description: string;
         schema?: any;
     };
-    invoke: (ctx: Context, args: any, id: string) => Promise<any>;
+    invoke: (ctx: Context, args: any, runtime: ToolsRuntime) => Promise<any>;
+};
+export type ToolsRuntime = {
+    toolCallId: string;
+    writer: (chunk: any) => void;
 };
 export type ToolsEntry = ToolsOptions;
 export type Scope = 'SPECIFIED' | 'GENERAL' | 'CUSTOM';
 export type Permission = 'ASK' | 'ALLOW';
-export type DynamicToolsProvider = (register: ToolsRegistration) => Promise<void>;
+export type From = 'loader' | 'workflow' | 'mcp';
+export type DynamicToolsProvider = (register: ToolsRegistration, filter?: ToolsFilter) => Promise<void>;
 export type ToolsFilter = {
     scope?: Scope;
     defaultPermission?: Permission;
     silence?: boolean;
+    sessionId?: string;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/ai",
-  "version": "2.1.0-beta.14",
+  "version": "2.1.0-beta.16",
   "description": "",
   "license": "Apache-2.0",
   "main": "./lib/index.js",
@@ -14,23 +14,28 @@
     "@langchain/google-genai": "^2.1.18",
     "@langchain/langgraph": "^1.1.4",
     "@langchain/langgraph-checkpoint": "^1.0.0",
+    "@langchain/mcp-adapters": "^1.1.3",
     "@langchain/ollama": "^1.2.2",
     "@langchain/openai": "^1.2.7",
-    "@nocobase/logger": "2.1.0-beta.14",
-    "@nocobase/resourcer": "2.1.0-beta.14",
-    "@nocobase/utils": "2.1.0-beta.14",
+    "@nocobase/data-source-manager": "2.1.0-beta.16",
+    "@nocobase/logger": "2.1.0-beta.16",
+    "@nocobase/resourcer": "2.1.0-beta.16",
+    "@nocobase/utils": "2.1.0-beta.16",
+    "d3-dsv": "2",
     "fast-glob": "^3.3.2",
     "flexsearch": "^0.8.2",
+    "gray-matter": "^4.0.3",
     "langchain": "^1.2.24",
     "mammoth": "^1.10.0",
     "officeparser": "^5.2.0",
     "pdf-parse": "^1.1.1",
-    "word-extractor": "^1.0.4"
+    "word-extractor": "^1.0.4",
+    "xlsx": "^0.18.5"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/nocobase/nocobase.git",
     "directory": "packages/ai"
   },
-  "gitHead": "cd55c9a14596d834c30c83a82c38f1f719f7aac4"
+  "gitHead": "b9a191705a440a336c85d82fd877fdf152bec70f"
 }

package/src/__tests__/ai-employees.test.ts

@@ -0,0 +1,108 @@
+/**
+ * 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 { createMockServer, MockServer } from '@nocobase/test';
+import { AIEmployeeLoader } from '../loader';
+import path from 'path';
+import { AIManager } from '../ai-manager';
+import { AIEmployeeManager, AIEmployeeEntry } from '../ai-employee-manager';
+
+const normalizeEOL = (value: string) => value.replace(/\r\n?/g, '\n');
+const normalizeTools = (entry: AIEmployeeEntry) =>
+  [...(entry.skillSettings?.tools ?? [])].sort((a, b) => a.name.localeCompare(b.name));
+const normalizeSkills = (entry: AIEmployeeEntry) => [...(entry.skillSettings?.skills ?? [])].sort();
+
+describe('AI employee loader test cases', () => {
+  const basePath = path.resolve(__dirname, 'resource', 'ai');
+  let app: MockServer;
+  let aiManager: AIManager;
+  let employeeManager: AIEmployeeManager;
+  let loader: AIEmployeeLoader;
+
+  beforeEach(async () => {
+    app = await createMockServer({
+      plugins: ['nocobase'],
+    });
+    await app.pm.enable('ai');
+    aiManager = app.aiManager;
+    employeeManager = aiManager.employeeManager;
+    loader = new AIEmployeeLoader(aiManager, {
+      scan: {
+        basePath,
+        pattern: [
+          '**/ai-employees/*.ts',
+          '**/ai-employees/*/index.ts',
+          '**/ai-employees/*.js',
+          '**/ai-employees/*/index.js',
+          '**/ai-employees/*/prompt.md',
+          '!**/ai-employees/**/*.d.ts',
+        ],
+      },
+    });
+  });
+
+  afterEach(async () => {
+    await app.destroy();
+  });
+
+  it('should load ai employee from named file', async () => {
+    await loader.load();
+    const employee = await employeeManager.getEmployee('named-file-employee');
+
+    expect(employee).toBeDefined();
+    expect(employee.username).toBe('named-file-employee');
+    expect(employee.nickname).toBe('Named File Employee');
+    expect(normalizeTools(employee)).toEqual([]);
+    expect(normalizeSkills(employee)).toEqual([]);
+  });
+
+  it('should load ai employee from index file', async () => {
+    await loader.load();
+    const employee = await employeeManager.getEmployee('index-employee');
+
+    expect(employee).toBeDefined();
+    expect(employee.username).toBe('index-employee');
+    expect(employee.nickname).toBe('Index Employee');
+    expect(normalizeEOL(employee.defaultPrompt)).toBe('Prompt from markdown file.\n');
+    expect(normalizeTools(employee)).toEqual([]);
+    expect(normalizeSkills(employee)).toEqual([]);
+  });
+
+  it('should load ai employee with tools directory', async () => {
+    await loader.load();
+    const employee = await employeeManager.getEmployee('with-tools');
+
+    expect(employee).toBeDefined();
+    expect(normalizeTools(employee)).toEqual([{ name: 'discoveredTool' }]);
+  });
+
+  it('should load ai employee with skills directory', async () => {
+    await loader.load();
+    const employee = await employeeManager.getEmployee('with-skills');
+
+    expect(employee).toBeDefined();
+    expect(normalizeSkills(employee)).toEqual(['analysis']);
+  });
+
+  it('should merge ai employee tools directory with tools config', async () => {
+    await loader.load();
+    const employee = await employeeManager.getEmployee('with-tools-merge');
+
+    expect(employee).toBeDefined();
+    expect(normalizeTools(employee)).toEqual([{ autoCall: true, name: 'configuredTool' }, { name: 'discoveredTool' }]);
+  });
+
+  it('should merge ai employee skills directory with skills config', async () => {
+    await loader.load();
+    const employee = await employeeManager.getEmployee('with-skills-merge');
+
+    expect(employee).toBeDefined();
+    expect(normalizeSkills(employee)).toEqual(['configured-skill', 'discovered-skill']);
+  });
+});