@nocobase/ai 2.3.0-beta.22 → 2.3.0-beta.24

package/lib/loader/mcp.d.ts

@@ -6,30 +6,14 @@
  * 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';
+import type { Logger } from '@nocobase/logger';
+import type { MCPRegistration } from '../mcp-manager/types';
 export type MCPLoaderOptions = {
-    pluginName: string;
-    scan: DirectoryScannerOptions;
-    log?: Logger;
+    log?: Pick<Logger, 'error'>;
 };
-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 declare class MCPLoader {
+    private readonly manager;
+    private readonly options;
+    constructor(manager: MCPRegistration, options?: MCPLoaderOptions);
+    load(): Promise<void>;
 }
-export type MCPDescriptor = {
-    name: string;
-    file: FileDescriptor;
-    options: MCPOptions;
-};

package/lib/loader/mcp.js

@@ -31,73 +31,73 @@ __export(mcp_exports, {
 });
 module.exports = __toCommonJS(mcp_exports);
 var import_utils = require("@nocobase/utils");
-var import_fs = require("fs");
-var import_types = require("./types");
-var import_scanner = require("./scanner");
-var import_utils2 = require("./utils");
-const _MCPLoader = class _MCPLoader extends import_types.LoadAndRegister {
-  constructor(ai, options) {
-    super(ai, options);
-    this.ai = ai;
+var import_promises = require("node:fs/promises");
+var import_options_renderer = require("../mcp-manager/options-renderer");
+const _MCPLoader = class _MCPLoader {
+  constructor(manager, options = {}) {
+    this.manager = manager;
     this.options = options;
-    this.log = options.log;
-    this.scanner = new import_scanner.DirectoryScanner(this.options.scan);
   }
-  scanner;
-  files = [];
-  mcpDescriptors = [];
-  log;
-  async scan() {
-    this.files = await this.scanner.scan();
-  }
-  async import() {
-    if (!this.files.length) {
+  async load() {
+    var _a, _b, _c, _d, _e, _f;
+    const filePath = (0, import_utils.storagePathJoin)("ai", "mcp", "servers.json");
+    let content;
+    try {
+      content = await (0, import_promises.readFile)(filePath, "utf8");
+    } catch (error) {
+      if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+        return;
+      }
+      (_a = this.options.log) == null ? void 0 : _a.error(`MCP file ignored at ${filePath}: unable to read file`);
       return;
     }
-    const descriptors = await Promise.all(
-      this.files.map(async (file) => {
-        var _a, _b, _c;
-        const name = file.name;
-        if (!(0, import_fs.existsSync)(file.path)) {
-          (_a = this.log) == null ? void 0 : _a.error(`mcp [${name}] ignored: can not find definition file at ${file.path}`);
-          return null;
-        }
-        try {
-          const imported = await (0, import_utils.importModule)(file.path);
-          const mod = (imported == null ? void 0 : imported.default) ?? imported;
-          const options = typeof mod === "function" ? mod() : mod;
-          if (!(0, import_utils2.isNonEmptyObject)(options)) {
-            (_b = this.log) == null ? void 0 : _b.warn(`mcp [${name}] register ignored: invalid definition at ${file.path}`);
-            return null;
-          }
-          return {
-            name,
-            file,
-            options
-          };
-        } catch (e) {
-          (_c = this.log) == null ? void 0 : _c.error(`mcp [${name}] load fail: error occur when import ${file.path}`, e);
-          return null;
-        }
-      })
-    );
-    this.mcpDescriptors = descriptors.filter((item) => Boolean(item));
-  }
-  async register() {
-    var _a;
-    if (!this.mcpDescriptors.length) {
+    let definitions;
+    try {
+      definitions = JSON.parse(content);
+    } catch {
+      (_b = this.options.log) == null ? void 0 : _b.error(`MCP file ignored at ${filePath}: invalid JSON`);
+      return;
+    }
+    if (!Array.isArray(definitions)) {
+      (_c = this.options.log) == null ? void 0 : _c.error(`MCP file ignored at ${filePath}: expected an array`);
       return;
     }
-    const { mcpManager } = this.ai;
-    for (const descriptor of this.mcpDescriptors) {
+    const registration = /* @__PURE__ */ Object.create(null);
+    for (const [index, value] of definitions.entries()) {
+      const definition = value;
+      let reason;
+      if (!value || typeof value !== "object" || Array.isArray(value)) {
+        reason = "expected an object";
+      } else if (typeof definition.name !== "string" || !definition.name.trim()) {
+        reason = "name is required";
+      } else if (!["stdio", "http", "sse"].includes(definition.transport)) {
+        reason = "unsupported or missing transport";
+      } else if (Object.hasOwn(value, "enabled") || Object.hasOwn(value, "fromFile")) {
+        reason = "enabled and fromFile cannot be specified";
+      } else if (Object.hasOwn(registration, definition.name)) {
+        reason = "duplicate name";
+      }
+      if (reason) {
+        (_d = this.options.log) == null ? void 0 : _d.error(`MCP file ignored at ${filePath}, entry ${index + 1}: ${reason}`);
+        return;
+      }
       try {
-        await mcpManager.registerMCP({
-          [descriptor.name]: descriptor.options
-        });
-      } catch (e) {
-        (_a = this.log) == null ? void 0 : _a.error(`mcp [${descriptor.name}] register ignored: error occur when invoke registerMCP`, e);
+        registration[definition.name] = (0, import_options_renderer.normalizeMCPOptions)({ ...definition, fromFile: true });
+      } catch {
+        (_e = this.options.log) == null ? void 0 : _e.error(
+          `MCP file ignored at ${filePath}, entry ${index + 1}: unable to normalize configuration`
+        );
+        return;
       }
     }
+    if (!Object.keys(registration).length) {
+      return;
+    }
+    try {
+      await this.manager.registerMCP(registration);
+    } catch {
+      (_f = this.options.log) == null ? void 0 : _f.error(`MCP registration failed at ${filePath}`);
+    }
   }
 };
 __name(_MCPLoader, "MCPLoader");

package/lib/mcp-manager/errors.d.ts

@@ -0,0 +1,12 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+export declare class MCPToolPermissionError extends Error {
+    readonly code: 'INVALID_PERMISSION' | 'TOOL_NOT_FOUND_OR_AMBIGUOUS';
+    constructor(code: 'INVALID_PERMISSION' | 'TOOL_NOT_FOUND_OR_AMBIGUOUS');
+}

package/lib/mcp-manager/errors.js

@@ -0,0 +1,45 @@
+/**
+ * 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 errors_exports = {};
+__export(errors_exports, {
+  MCPToolPermissionError: () => MCPToolPermissionError
+});
+module.exports = __toCommonJS(errors_exports);
+const _MCPToolPermissionError = class _MCPToolPermissionError extends Error {
+  constructor(code) {
+    super(code);
+    this.code = code;
+    this.name = "MCPToolPermissionError";
+  }
+};
+__name(_MCPToolPermissionError, "MCPToolPermissionError");
+let MCPToolPermissionError = _MCPToolPermissionError;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MCPToolPermissionError
+});

package/lib/mcp-manager/index.d.ts

@@ -17,7 +17,6 @@ export declare class DefaultMCPManager implements MCPManager {
     private mode;
     private client;
     private toolsMap;
-    private toolsPermissionMap;
     private readonly userContextClientManager;
     constructor(app: any);
     init(): Promise<void>;
@@ -29,11 +28,11 @@ export declare class DefaultMCPManager implements MCPManager {
     rebuildClient(): Promise<void>;
     getClient(): MultiServerMCPClient | null;
     getMCPToolsProvider(): DynamicToolsProvider;
-    private registerToolsFromMap;
-    private ensureToolPermission;
+    private getActiveToolsMap;
+    private readToolPermissions;
+    private resolveToolPermission;
     listMCPTools(ctx?: Context): Promise<Record<string, MCPToolEntry[]>>;
-    private formatMCPTools;
-    updateMCPToolPermission(toolName: string, permission: Permission): Promise<void>;
+    updateMCPToolPermission(toolName: string, permission: Permission, ctx?: Context): Promise<void>;
     clearUserContextCache(): Promise<void>;
     testConnection(options: MCPOptions, ctx?: Context): Promise<MCPTestResult>;
     private buildMCPConnection;
@@ -47,3 +46,4 @@ export declare class DefaultMCPManager implements MCPManager {
 }
 export declare function defineMCP(options: MCPOptions): MCPOptions;
 export * from './types';
+export * from './errors';

package/lib/mcp-manager/index.js

@@ -37,7 +37,9 @@ var import_utils = require("@nocobase/utils");
 var import_mcp_adapters = require("@langchain/mcp-adapters");
 var import_options_renderer = require("./options-renderer");
 var import_user_context_client_manager = require("./user-context-client-manager");
+var import_errors = require("./errors");
 __reExport(mcp_manager_exports, require("./types"), module.exports);
+__reExport(mcp_manager_exports, require("./errors"), module.exports);
 const _DefaultMCPManager = class _DefaultMCPManager {
   constructor(app) {
     this.app = app;
@@ -48,12 +50,11 @@ const _DefaultMCPManager = class _DefaultMCPManager {
       buildConnection: /* @__PURE__ */ __name((options) => this.buildMCPConnection(options), "buildConnection")
     });
   }
-  mcpRegistry = new import_utils.Registry();
+  mcpRegistry = new import_utils.Registry({ override: true });
   provideCollectionManager;
   mode = "memory";
   client = null;
   toolsMap = {};
-  toolsPermissionMap = {};
   userContextClientManager;
   async init() {
     if (this.mode === "memory") {
@@ -67,9 +68,12 @@ const _DefaultMCPManager = class _DefaultMCPManager {
     }
   }
   async registerMCP(registration) {
+    var _a;
     if (this.mode === "memory") {
       for (const [name, options] of Object.entries(registration)) {
-        this.mcpRegistry.register(name, this.normalizeEntry(name, options));
+        const entry = this.normalizeEntry(name, options);
+        entry.fromFile = entry.fromFile === true || ((_a = this.mcpRegistry.get(name)) == null ? void 0 : _a.fromFile) === true;
+        this.mcpRegistry.register(name, entry);
       }
     } else {
       for (const [name, options] of Object.entries(registration)) {
@@ -112,8 +116,8 @@ const _DefaultMCPManager = class _DefaultMCPManager {
       } catch (e) {
       }
       this.client = null;
-      this.toolsMap = {};
     }
+    this.toolsMap = {};
     const entries = await this.listMCP({ enabled: true, useUserContext: false });
     if (entries.length === 0) {
       return;
@@ -126,12 +130,6 @@ const _DefaultMCPManager = class _DefaultMCPManager {
     const toolsMap = await this.client.initializeConnections();
     for (const [serverName, tools] of Object.entries(toolsMap)) {
       this.toolsMap[serverName] = tools;
-      for (const tool of tools) {
-        const toolName = `mcp-${serverName}-${tool.name}`;
-        if (!(toolName in this.toolsPermissionMap)) {
-          this.toolsPermissionMap[toolName] = tool.name.startsWith("get") ? "ALLOW" : "ASK";
-        }
-      }
     }
   }
   getClient() {
@@ -139,82 +137,110 @@ const _DefaultMCPManager = class _DefaultMCPManager {
   }
   getMCPToolsProvider() {
     return async (register, filter) => {
-      for (const [serverName, tools] of Object.entries(this.toolsMap)) {
-        this.registerToolsFromMap(register, serverName, tools);
-      }
-      if (!(filter == null ? void 0 : filter.ctx)) {
-        return;
-      }
-      const userToolsMap = await this.userContextClientManager.getToolsMap(filter.ctx);
-      for (const [serverName, tools] of Object.entries(userToolsMap)) {
-        this.registerToolsFromMap(register, serverName, tools);
+      const toolsMap = await this.getActiveToolsMap(filter == null ? void 0 : filter.ctx);
+      const permissions = await this.readToolPermissions(Object.keys(toolsMap));
+      for (const [serverName, tools] of Object.entries(toolsMap)) {
+        for (const tool of tools) {
+          register.registerTools({
+            scope: "GENERAL",
+            from: "mcp",
+            defaultPermission: this.resolveToolPermission(permissions, serverName, tool.name),
+            introduction: { title: tool.name, about: tool.description },
+            definition: {
+              name: `mcp-${serverName}-${tool.name}`,
+              description: tool.description || `MCP tool: ${tool.name} from ${serverName}`,
+              schema: tool.schema
+            },
+            invoke: /* @__PURE__ */ __name(async (ctx, args) => {
+              const entry = await this.getMCP(serverName);
+              if (!(entry == null ? void 0 : entry.enabled)) {
+                throw new Error(ctx.t("MCP server is disabled or deleted", { ns: "@nocobase/plugin-ai" }));
+              }
+              try {
+                return await tool.invoke(args);
+              } catch (error) {
+                return {
+                  status: "error",
+                  content: error instanceof Error ? error.message : "Tool invocation failed"
+                };
+              }
+            }, "invoke")
+          });
+        }
       }
     };
   }
-  registerToolsFromMap(register, serverName, tools) {
-    for (const tool of tools) {
-      const toolName = `mcp-${serverName}-${tool.name}`;
-      this.ensureToolPermission(toolName, tool.name);
-      const toolOptions = {
-        scope: "GENERAL",
-        from: "mcp",
-        defaultPermission: this.toolsPermissionMap[toolName],
-        introduction: {
-          title: tool.name,
-          about: tool.description
-        },
-        definition: {
-          name: toolName,
-          description: tool.description || `MCP tool: ${tool.name} from ${serverName}`,
-          schema: tool.schema
-        },
-        invoke: /* @__PURE__ */ __name(async (_ctx, args) => {
-          try {
-            const result = await tool.invoke(args);
-            return result;
-          } catch (error) {
-            return {
-              status: "error",
-              content: (error == null ? void 0 : error.message) || "Tool invocation failed"
-            };
-          }
-        }, "invoke")
-      };
-      register.registerTools(toolOptions);
-    }
+  async getActiveToolsMap(ctx) {
+    const entries = await this.listMCP({ enabled: true });
+    const sharedServers = new Set(entries.filter((entry) => !entry.useUserContext).map((entry) => entry.name));
+    const userServers = new Set(entries.filter((entry) => entry.useUserContext).map((entry) => entry.name));
+    const userToolsMap = ctx ? await this.userContextClientManager.getToolsMap(ctx) : {};
+    return {
+      ...Object.fromEntries(Object.entries(this.toolsMap).filter(([name]) => sharedServers.has(name))),
+      ...Object.fromEntries(Object.entries(userToolsMap).filter(([name]) => userServers.has(name)))
+    };
   }
-  ensureToolPermission(toolName, rawToolName) {
-    if (!(toolName in this.toolsPermissionMap)) {
-      this.toolsPermissionMap[toolName] = rawToolName.startsWith("get") ? "ALLOW" : "ASK";
+  async readToolPermissions(serverNames) {
+    if (!serverNames.length) {
+      return /* @__PURE__ */ new Map();
     }
+    const records = await this.collectionManager.getCollection("aiMcpToolPermissions").model.findAll({
+      where: { serverName: { [import_database.Op.in]: serverNames } }
+    });
+    return new Map(
+      records.map((record) => [
+        JSON.stringify([record.get("serverName"), record.get("toolName")]),
+        record.get("permission") === "ALLOW" ? "ALLOW" : "ASK"
+      ])
+    );
   }
-  async listMCPTools(ctx) {
-    const toolsMap = {
-      ...this.toolsMap,
-      ...ctx ? await this.userContextClientManager.getToolsMap(ctx) : {}
-    };
-    return this.formatMCPTools(toolsMap);
+  resolveToolPermission(permissions, serverName, toolName) {
+    return permissions.get(JSON.stringify([serverName, toolName])) ?? (toolName.startsWith("get") ? "ALLOW" : "ASK");
   }
-  formatMCPTools(toolsMap) {
+  async listMCPTools(ctx) {
+    const toolsMap = await this.getActiveToolsMap(ctx);
+    const permissions = await this.readToolPermissions(Object.keys(toolsMap));
     return Object.fromEntries(
       Object.entries(toolsMap).map(([serverName, tools]) => [
         serverName,
-        tools.map((tool) => {
-          const toolName = `mcp-${serverName}-${tool.name}`;
-          this.ensureToolPermission(toolName, tool.name);
-          return {
-            name: toolName,
-            title: tool.name,
-            description: tool.description,
-            serverName,
-            permission: this.toolsPermissionMap[toolName] ?? "ASK"
-          };
-        })
+        tools.map((tool) => ({
+          name: `mcp-${serverName}-${tool.name}`,
+          title: tool.name,
+          description: tool.description,
+          serverName,
+          permission: this.resolveToolPermission(permissions, serverName, tool.name)
+        }))
       ])
     );
   }
-  async updateMCPToolPermission(toolName, permission) {
-    this.toolsPermissionMap[toolName] = permission;
+  async updateMCPToolPermission(toolName, permission, ctx) {
+    if (typeof toolName !== "string" || !toolName.trim() || !["ASK", "ALLOW"].includes(permission)) {
+      throw new import_errors.MCPToolPermissionError("INVALID_PERMISSION");
+    }
+    const matches = Object.values(await this.listMCPTools(ctx)).flat().filter((tool2) => tool2.name === toolName);
+    if (matches.length !== 1) {
+      throw new import_errors.MCPToolPermissionError("TOOL_NOT_FOUND_OR_AMBIGUOUS");
+    }
+    const tool = matches[0];
+    await this.sequelize.transaction({ type: import_database.Transaction.TYPES.IMMEDIATE }, async (transaction) => {
+      const server = await this.aiMcpClientsModel.findOne({
+        where: { name: tool.serverName, enabled: true },
+        transaction,
+        lock: transaction.LOCK.UPDATE
+      });
+      if (!server) {
+        throw new import_errors.MCPToolPermissionError("TOOL_NOT_FOUND_OR_AMBIGUOUS");
+      }
+      const permissionModel = this.collectionManager.getCollection("aiMcpToolPermissions").model;
+      await permissionModel.upsert(
+        { serverName: tool.serverName, toolName: tool.title, permission },
+        {
+          transaction,
+          // Sequelize expects physical column names here, including when underscored is enabled.
+          conflictFields: ["serverName", "toolName"].map((name) => permissionModel.getAttributes()[name].field || name)
+        }
+      );
+    });
   }
   async clearUserContextCache() {
     await this.userContextClientManager.clear();
@@ -333,7 +359,8 @@ ${(error == null ? void 0 : error.stack) || ""}` : (error == null ? void 0 : err
             url: normalizedEntry.url,
             headers: normalizedEntry.headers,
             restart: normalizedEntry.restart,
-            useUserContext: normalizedEntry.useUserContext
+            useUserContext: normalizedEntry.useUserContext,
+            fromFile: normalizedEntry.fromFile === true || existed.get("fromFile") === true
           },
           { transaction }
         );
@@ -382,5 +409,6 @@ __name(defineMCP, "defineMCP");
 0 && (module.exports = {
   DefaultMCPManager,
   defineMCP,
-  ...require("./types")
+  ...require("./types"),
+  ...require("./errors")
 });

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

@@ -18,7 +18,7 @@ export interface MCPManager extends MCPRegistration {
     getClient(): MultiServerMCPClient | null;
     getMCPToolsProvider(): DynamicToolsProvider;
     listMCPTools(ctx?: Context): Promise<Record<string, MCPToolEntry[]>>;
-    updateMCPToolPermission(toolName: string, permission: Permission): Promise<void>;
+    updateMCPToolPermission(toolName: string, permission: Permission, ctx?: Context): Promise<void>;
     clearUserContextCache(): Promise<void>;
 }
 export interface MCPRegistration {
@@ -35,9 +35,12 @@ export type MCPOptions = {
     headers?: Record<string, string>;
     restart?: Record<string, any>;
     useUserContext?: boolean;
+    fromFile?: boolean;
 };
 export type MCPEntry = MCPOptions & {
     name: string;
+    title?: string;
+    description?: string;
     enabled: boolean;
 };
 export type MCPFilter = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/ai",
-  "version": "2.3.0-beta.22",
+  "version": "2.3.0-beta.24",
   "description": "",
   "license": "Apache-2.0",
   "main": "./lib/index.js",
@@ -17,10 +17,10 @@
     "@langchain/mcp-adapters": "1.1.3",
     "@langchain/ollama": "1.2.7",
     "@langchain/openai": "1.4.7",
-    "@nocobase/data-source-manager": "2.3.0-beta.22",
-    "@nocobase/logger": "2.3.0-beta.22",
-    "@nocobase/resourcer": "2.3.0-beta.22",
-    "@nocobase/utils": "2.3.0-beta.22",
+    "@nocobase/data-source-manager": "2.3.0-beta.24",
+    "@nocobase/logger": "2.3.0-beta.24",
+    "@nocobase/resourcer": "2.3.0-beta.24",
+    "@nocobase/utils": "2.3.0-beta.24",
     "d3-dsv": "2",
     "fast-glob": "^3.3.2",
     "flexsearch": "^0.8.2",
@@ -37,5 +37,5 @@
     "url": "git+https://github.com/nocobase/nocobase.git",
     "directory": "packages/ai"
   },
-  "gitHead": "b64f83147d5d2149878d961d294622c4137efe21"
+  "gitHead": "9780899cbaa5fc4657ac9ea16da2ac99978d748d"
 }