@nocobase/ai 2.1.0-alpha.2 → 2.1.0-alpha.20

package/lib/mcp-manager/index.js

@@ -0,0 +1,341 @@
+/**
+ * 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 mcp_manager_exports = {};
+__export(mcp_manager_exports, {
+  DefaultMCPManager: () => DefaultMCPManager,
+  defineMCP: () => defineMCP
+});
+module.exports = __toCommonJS(mcp_manager_exports);
+var import_database = require("@nocobase/database");
+var import_utils = require("@nocobase/utils");
+var import_mcp_adapters = require("@langchain/mcp-adapters");
+__reExport(mcp_manager_exports, require("./types"), module.exports);
+const _DefaultMCPManager = class _DefaultMCPManager {
+  constructor(app) {
+    this.app = app;
+    this.provideCollectionManager = () => app.mainDataSource;
+  }
+  mcpRegistry = new import_utils.Registry();
+  provideCollectionManager;
+  mode = "memory";
+  client = null;
+  toolsMap = {};
+  toolsPermissionMap = {};
+  async init() {
+    if (this.mode === "memory") {
+      await this.persistence();
+      this.mode = "database";
+    }
+    try {
+      await this.rebuildClient();
+    } catch (e) {
+      this.app.log.error("fail to init mcp clients", e);
+    }
+  }
+  async registerMCP(registration) {
+    if (this.mode === "memory") {
+      for (const [name, options] of Object.entries(registration)) {
+        this.mcpRegistry.register(name, this.normalizeEntry(name, options));
+      }
+    } else {
+      for (const [name, options] of Object.entries(registration)) {
+        await this.persistenceEntry({
+          name,
+          ...this.normalizeEntry(name, options)
+        });
+      }
+    }
+  }
+  async getMCP(name) {
+    var _a, _b;
+    return (_b = await ((_a = this.aiMcpClientsModel) == null ? void 0 : _a.findOne({ where: { name } }))) == null ? void 0 : _b.toJSON();
+  }
+  async listMCP(filter = {}) {
+    var _a, _b;
+    const where = {};
+    if (filter.name) {
+      where["name"] = {
+        [import_database.Op.substring]: filter.name
+      };
+    }
+    if (filter.enabled != null) {
+      where["enabled"] = filter.enabled;
+    }
+    if (filter.transport) {
+      where["transport"] = filter.transport;
+    }
+    return ((_b = await ((_a = this.aiMcpClientsModel) == null ? void 0 : _a.findAll({ where }))) == null ? void 0 : _b.map((item) => item.toJSON())) ?? [];
+  }
+  async rebuildClient() {
+    if (this.client) {
+      try {
+        await this.client.close();
+      } catch (e) {
+      }
+      this.client = null;
+      this.toolsMap = {};
+    }
+    const entries = await this.listMCP({ enabled: true });
+    if (entries.length === 0) {
+      return;
+    }
+    const connections = {};
+    for (const entry of entries) {
+      connections[entry.name] = this.buildMCPConnection(entry);
+    }
+    this.client = new import_mcp_adapters.MultiServerMCPClient(connections);
+    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() {
+    return this.client;
+  }
+  getMCPToolsProvider() {
+    return async (register) => {
+      for (const [serverName, tools] of Object.entries(this.toolsMap)) {
+        for (const tool of tools) {
+          const toolName = `mcp-${serverName}-${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 listMCPTools() {
+    return Object.fromEntries(
+      Object.entries(this.toolsMap).map(([serverName, tools]) => [
+        serverName,
+        tools.map((tool) => {
+          const toolName = `mcp-${serverName}-${tool.name}`;
+          return {
+            name: toolName,
+            title: tool.name,
+            description: tool.description,
+            serverName,
+            permission: this.toolsPermissionMap[toolName] ?? "ASK"
+          };
+        })
+      ])
+    );
+  }
+  async updateMCPToolPermission(toolName, permission) {
+    this.toolsPermissionMap[toolName] = permission;
+  }
+  async testConnection(options) {
+    const { transport } = options;
+    if (!transport) {
+      return {
+        success: false,
+        error: "Transport type is required"
+      };
+    }
+    if (transport === "stdio" && !options.command) {
+      return {
+        success: false,
+        error: "Command is required for stdio transport"
+      };
+    }
+    if ((transport === "http" || transport === "sse") && !options.url) {
+      return {
+        success: false,
+        error: "URL is required for HTTP/SSE transport"
+      };
+    }
+    let client = null;
+    try {
+      const connection = this.buildMCPConnection(options);
+      const serverName = "test-server";
+      client = new import_mcp_adapters.MultiServerMCPClient({
+        [serverName]: connection
+      });
+      const toolsMap = await Promise.race([
+        client.initializeConnections(),
+        new Promise(
+          (_resolve, reject) => setTimeout(() => reject(new Error("Connection timeout (60s)")), 6e4)
+        )
+      ]);
+      const tools = toolsMap[serverName] || [];
+      const toolNames = tools.map((tool) => tool.name);
+      return {
+        success: true,
+        message: "Connection successful",
+        toolsCount: tools.length,
+        tools: toolNames.slice(0, 20),
+        // Limit to 20 tools for display
+        toolsTruncated: toolNames.length > 20
+      };
+    } catch (error) {
+      const errorMessage = (error == null ? void 0 : error.message) || "Failed to connect to MCP server";
+      let hint;
+      if (errorMessage.includes("EACCES") || errorMessage.includes("permission denied")) {
+        hint = "Try running: npm cache clean --force";
+      } else if (errorMessage.includes("ENOENT") || errorMessage.includes("not found")) {
+        hint = "Make sure the command exists and is accessible";
+      } else if (errorMessage.includes("timeout")) {
+        hint = "The server took too long to respond. Check if the server is running correctly.";
+      }
+      return {
+        success: false,
+        error: errorMessage,
+        details: hint ? `Hint: ${hint}
+
+${(error == null ? void 0 : error.stack) || ""}` : (error == null ? void 0 : error.stack) || ""
+      };
+    } finally {
+      if (client) {
+        try {
+          await client.close();
+        } catch (e) {
+        }
+      }
+    }
+  }
+  buildMCPConnection(options) {
+    const { transport, command, args, env, url, headers, restart } = options;
+    if (transport === "stdio") {
+      const connection2 = {
+        transport: "stdio",
+        command: command || "",
+        args: args || []
+      };
+      if (env && Object.keys(env).length > 0) {
+        connection2.env = env;
+      }
+      if (restart && typeof restart === "object" && !Array.isArray(restart)) {
+        connection2.restart = restart;
+      }
+      return connection2;
+    }
+    const connection = {
+      transport: transport === "sse" ? "sse" : "http",
+      url: url || ""
+    };
+    if (headers && Object.keys(headers).length > 0) {
+      connection.headers = headers;
+    }
+    return connection;
+  }
+  async persistence() {
+    for (const entry of this.mcpRegistry.getValues()) {
+      await this.persistenceEntry(entry);
+    }
+  }
+  async persistenceEntry(entry) {
+    await this.sequelize.transaction(async (transaction) => {
+      const existed = await this.aiMcpClientsModel.findOne({ where: { name: entry.name }, transaction });
+      if (existed) {
+        await existed.update(
+          {
+            transport: entry.transport,
+            command: entry.command,
+            args: entry.args,
+            env: entry.env,
+            url: entry.url,
+            headers: entry.headers,
+            restart: entry.restart
+          },
+          { transaction }
+        );
+        return;
+      }
+      await this.aiMcpClientsModel.create(
+        {
+          ...entry
+        },
+        { transaction }
+      );
+    });
+  }
+  normalizeEntry(name, options) {
+    return {
+      name,
+      enabled: true,
+      ...options,
+      args: options.args ?? [],
+      env: options.env ?? {}
+    };
+  }
+  get aiMcpClientsCollection() {
+    return this.collectionManager.getCollection("aiMcpClients");
+  }
+  get aiMcpClientsModel() {
+    var _a;
+    return (_a = this.aiMcpClientsCollection) == null ? void 0 : _a.model;
+  }
+  get sequelize() {
+    return this.collectionManager.db.sequelize;
+  }
+  get collectionManager() {
+    return this.provideCollectionManager().collectionManager;
+  }
+};
+__name(_DefaultMCPManager, "DefaultMCPManager");
+let DefaultMCPManager = _DefaultMCPManager;
+function defineMCP(options) {
+  return options;
+}
+__name(defineMCP, "defineMCP");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DefaultMCPManager,
+  defineMCP,
+  ...require("./types")
+});

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

@@ -0,0 +1,61 @@
+/**
+ * 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 { MultiServerMCPClient } from '@langchain/mcp-adapters';
+import type { DynamicToolsProvider, Permission } from '../tools-manager/types';
+export interface MCPManager extends MCPRegistration {
+    init(): Promise<void>;
+    getMCP(name: string): Promise<MCPEntry>;
+    listMCP(filter: MCPFilter): Promise<MCPEntry[]>;
+    testConnection(options: MCPOptions): Promise<MCPTestResult>;
+    rebuildClient(): Promise<void>;
+    getClient(): MultiServerMCPClient | null;
+    getMCPToolsProvider(): DynamicToolsProvider;
+    listMCPTools(): Promise<Record<string, MCPToolEntry[]>>;
+    updateMCPToolPermission(toolName: string, permission: Permission): Promise<void>;
+}
+export interface MCPRegistration {
+    registerMCP(registration: {
+        [key: string | symbol]: MCPOptions;
+    }): Promise<void>;
+}
+export type MCPOptions = {
+    transport: MCPTransport;
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    url?: string;
+    headers?: Record<string, string>;
+    restart?: Record<string, any>;
+};
+export type MCPEntry = MCPOptions & {
+    name: string;
+    enabled: boolean;
+};
+export type MCPFilter = {
+    name?: string;
+    enabled?: boolean;
+    transport?: MCPTransport;
+};
+export type MCPTransport = 'stdio' | 'sse' | 'http';
+export type MCPTestResult = {
+    success: boolean;
+    message?: string;
+    error?: string;
+    details?: string;
+    toolsCount?: number;
+    tools?: string[];
+    toolsTruncated?: boolean;
+};
+export type MCPToolEntry = {
+    name: string;
+    title: string;
+    description?: string;
+    serverName: string;
+    permission: Permission;
+};

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

@@ -0,0 +1,43 @@
+/**
+ * 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 McpTool = {
+    name: string;
+    description: string;
+    inputSchema?: any;
+    resourceName?: string;
+    actionName?: string;
+    path?: string;
+    method?: string;
+    call: (args: Record<string, any>, context?: McpToolCallContext) => Promise<any>;
+};
+export type McpToolCallContext = {
+    token?: string;
+    headers?: Record<string, string | string[] | undefined>;
+};
+export type McpToolResultPostProcessorContext = {
+    tool: McpTool;
+    args: Record<string, any>;
+    callContext?: McpToolCallContext;
+    response?: {
+        statusCode?: number;
+        headers?: Record<string, any>;
+        body?: any;
+    };
+};
+export type McpToolResultPostProcessor = (result: any, context: McpToolResultPostProcessorContext) => any | Promise<any>;
+export declare class McpToolsManager {
+    private tools;
+    private resultPostProcessors;
+    private getActionKey;
+    registerTools(tools: McpTool[]): void;
+    registerToolResultPostProcessor(resourceName: string, actionName: string, processor: McpToolResultPostProcessor): void;
+    postProcessToolResult(tool: McpTool, result: any, context: Omit<McpToolResultPostProcessorContext, 'tool'>): Promise<any>;
+    listTools(): McpTool[];
+    getTool(name: string): McpTool;
+}

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';