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

package/lib/loader/skills.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.
+ */
+import { DirectoryScanner, DirectoryScannerOptions, FileDescriptor } from './scanner';
+import { AIManager } from '../ai-manager';
+import { LoadAndRegister } from './types';
+import { Logger } from '@nocobase/logger';
+import { SkillsScope } from '../skills-manager';
+export type SkillsLoaderOptions = {
+    pluginName: string;
+    scan: DirectoryScannerOptions;
+    log?: Logger;
+};
+export declare class SkillsLoader extends LoadAndRegister<SkillsLoaderOptions> {
+    protected readonly ai: AIManager;
+    protected readonly options: SkillsLoaderOptions;
+    protected readonly scanner: DirectoryScanner;
+    protected files: FileDescriptor[];
+    protected skillsDescriptors: SkillsDescriptor[];
+    protected log: Logger;
+    constructor(ai: AIManager, options: SkillsLoaderOptions);
+    protected scan(): Promise<void>;
+    protected import(): Promise<void>;
+    protected register(): Promise<void>;
+}
+export type SkillsDescriptor = {
+    scope: SkillsScope;
+    name: string;
+    description: string;
+    content: string;
+    skillsFile: FileDescriptor;
+    skillsDir: FileDescriptor;
+    tools?: string[];
+    introduction?: {
+        title: string;
+        about?: string;
+    };
+};

package/lib/loader/skills.js

@@ -0,0 +1,138 @@
+/**
+ * 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 skills_exports = {};
+__export(skills_exports, {
+  SkillsLoader: () => SkillsLoader
+});
+module.exports = __toCommonJS(skills_exports);
+var import_scanner = require("./scanner");
+var import_promises = require("fs/promises");
+var import_fs = require("fs");
+var import_types = require("./types");
+var import_gray_matter = __toESM(require("gray-matter"));
+var import_path = __toESM(require("path"));
+const _SkillsLoader = class _SkillsLoader 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 = [];
+  skillsDescriptors = [];
+  log;
+  async scan() {
+    this.files = await this.scanner.scan();
+  }
+  async import() {
+    if (!this.files.length) {
+      return;
+    }
+    this.skillsDescriptors = await Promise.all(
+      this.files.map(async (skillsFile) => {
+        var _a, _b, _c;
+        if (skillsFile.basename !== "SKILLS.md") {
+          return null;
+        }
+        if (!(0, import_fs.existsSync)(skillsFile.path)) {
+          (_a = this.log) == null ? void 0 : _a.error(`skills [${skillsFile.directory}] ignored: can not find SKILLS.md at ${skillsFile.path}`);
+          return null;
+        }
+        const skillsDir = new import_scanner.FileDescriptor(import_path.default.dirname(skillsFile.path));
+        const name = skillsFile.directory;
+        const entry = { name, skillsFile, skillsDir };
+        try {
+          const skills = await (0, import_promises.readFile)(skillsFile.path, "utf-8");
+          const { data, content } = (0, import_gray_matter.default)(skills);
+          entry.scope = data["scope"] ?? "SPECIFIED";
+          entry.name = data["name"];
+          entry.description = data["description"];
+          entry.content = content;
+          entry.introduction = data["introduction"];
+          entry.tools = data["tools"] ?? [];
+        } catch (e) {
+          (_b = this.log) == null ? void 0 : _b.error(`skills [${name}] load fail: error occur when reading SKILLS.md at ${skillsFile.path}`, e);
+          return null;
+        }
+        try {
+          const toolsScanner = new import_scanner.DirectoryScanner({
+            basePath: skillsDir.path,
+            pattern: ["tools/**/*.ts", "tools/**/*.js", "!tools/**/*.d.ts"]
+          });
+          const toolsFiles = await toolsScanner.scan();
+          entry.tools = Array.from(
+            /* @__PURE__ */ new Set([
+              ...entry.tools,
+              ...toolsFiles.map(
+                (it) => it.basename === "index.ts" || it.basename === "index.js" ? it.directory : it.name
+              )
+            ])
+          );
+        } catch (e) {
+          (_c = this.log) == null ? void 0 : _c.error(`skills [${name}] load fail: error occur when loading tools at ${skillsDir.path}`, e);
+          return null;
+        }
+        return entry;
+      }).filter((it) => it != null)
+    );
+  }
+  async register() {
+    if (!this.skillsDescriptors.length) {
+      return;
+    }
+    const { skillsManager } = this.ai;
+    for (const descriptor of this.skillsDescriptors) {
+      await skillsManager.registerSkills({
+        scope: descriptor.scope,
+        name: descriptor.name,
+        description: descriptor.description,
+        content: descriptor.content,
+        tools: descriptor.tools,
+        introduction: descriptor.introduction
+      });
+    }
+  }
+};
+__name(_SkillsLoader, "SkillsLoader");
+let SkillsLoader = _SkillsLoader;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SkillsLoader
+});

package/lib/loader/tools.d.ts

@@ -12,6 +12,7 @@ import { AIManager } from '../ai-manager';
 import { LoadAndRegister } from './types';
 import { Logger } from '@nocobase/logger';
 export type ToolsLoaderOptions = {
+    pluginName: string;
     scan: DirectoryScannerOptions;
     log?: Logger;
 };

package/lib/loader/tools.js

@@ -111,7 +111,7 @@ const _ToolsLoader = class _ToolsLoader extends import_types.LoadAndRegister {
     )).filter((t) => t != null);
   }
   async register() {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     if (!this.toolsDescriptors.length) {
       return;
     }
@@ -124,7 +124,7 @@ const _ToolsLoader = class _ToolsLoader extends import_types.LoadAndRegister {
         continue;
       }
       const { name, toolsOptions, description } = descriptor;
-      if (await toolsManager.getTools(name)) {
+      if (toolsManager.isToolsExisted(name)) {
         (_b = this.log) == null ? void 0 : _b.warn(`tools [${descriptor.name}] register ignored: duplicate register for tools`);
         continue;
       }
@@ -136,8 +136,9 @@ const _ToolsLoader = class _ToolsLoader extends import_types.LoadAndRegister {
       }
       try {
         toolsManager.registerTools(toolsOptions);
+        (_c = this.log) == null ? void 0 : _c.info(`tools [${toolsOptions.definition.name}] registered from plugin [${this.options.pluginName}]`);
       } catch (e) {
-        (_c = this.log) == null ? void 0 : _c.error(`tools [${descriptor.name}] register ignored: error occur when invoke registerTools`, e);
+        (_d = this.log) == null ? void 0 : _d.error(`tools [${descriptor.name}] register ignored: error occur when invoke registerTools`, e);
         continue;
       }
     }

package/lib/mcp-manager/index.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.
+ */
+import { MultiServerMCPClient } from '@langchain/mcp-adapters';
+import { MCPEntry, MCPFilter, MCPManager, MCPOptions, MCPTestResult, MCPToolEntry } from './types';
+import type { DynamicToolsProvider, Permission } from '../tools-manager/types';
+export declare class DefaultMCPManager implements MCPManager {
+    private readonly app;
+    private readonly mcpRegistry;
+    private readonly provideCollectionManager;
+    private mode;
+    private client;
+    private toolsMap;
+    private toolsPermissionMap;
+    constructor(app: any);
+    init(): Promise<void>;
+    registerMCP(registration: {
+        [key: string | symbol]: MCPOptions;
+    }): Promise<void>;
+    getMCP(name: string): Promise<MCPEntry>;
+    listMCP(filter?: MCPFilter): Promise<MCPEntry[]>;
+    rebuildClient(): Promise<void>;
+    getClient(): MultiServerMCPClient | null;
+    getMCPToolsProvider(): DynamicToolsProvider;
+    listMCPTools(): Promise<Record<string, MCPToolEntry[]>>;
+    updateMCPToolPermission(toolName: string, permission: Permission): Promise<void>;
+    testConnection(options: MCPOptions): Promise<MCPTestResult>;
+    private buildMCPConnection;
+    persistence(): Promise<void>;
+    private persistenceEntry;
+    private normalizeEntry;
+    private get aiMcpClientsCollection();
+    private get aiMcpClientsModel();
+    private get sequelize();
+    private get collectionManager();
+}
+export declare function defineMCP(options: MCPOptions): MCPOptions;
+export * from './types';

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