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

package/lib/document-loader/vendor/langchain/document_loaders/fs/text.js

@@ -0,0 +1,99 @@
+/**
+ * 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 text_exports = {};
+__export(text_exports, {
+  TextLoader: () => TextLoader
+});
+module.exports = __toCommonJS(text_exports);
+var import_documents = require("@langchain/core/documents");
+var import_env = require("@langchain/core/utils/env");
+var import_base = require("@langchain/core/document_loaders/base");
+const _TextLoader = class _TextLoader extends import_base.BaseDocumentLoader {
+  filePathOrBlob;
+  constructor(filePathOrBlob) {
+    super();
+    this.filePathOrBlob = filePathOrBlob;
+  }
+  async parse(raw) {
+    return [raw];
+  }
+  async load() {
+    let text;
+    let metadata;
+    if (typeof this.filePathOrBlob === "string") {
+      const { readFile } = await _TextLoader.imports();
+      text = await readFile(this.filePathOrBlob, "utf8");
+      metadata = { source: this.filePathOrBlob };
+    } else {
+      text = await this.filePathOrBlob.text();
+      metadata = { source: "blob", blobType: this.filePathOrBlob.type };
+    }
+    const parsed = await this.parse(text);
+    parsed.forEach((pageContent, i) => {
+      if (typeof pageContent !== "string") {
+        throw new Error(`Expected string, at position ${i} got ${typeof pageContent}`);
+      }
+    });
+    return parsed.map(
+      (pageContent, i) => new import_documents.Document({
+        pageContent,
+        metadata: parsed.length === 1 ? metadata : {
+          ...metadata,
+          line: i + 1
+        }
+      })
+    );
+  }
+  static async imports() {
+    try {
+      const { readFile } = await import("node:fs/promises");
+      return { readFile };
+    } catch (e) {
+      console.error(e);
+      throw new Error(
+        `Failed to load fs/promises. TextLoader available only on environment 'node'. It appears you are running environment '${(0, import_env.getEnv)()}'. See https://<link to docs> for alternatives.`
+      );
+    }
+  }
+};
+__name(_TextLoader, "TextLoader");
+let TextLoader = _TextLoader;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TextLoader
+});

package/lib/document-loader/xlsx.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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 { Document } from '@langchain/core/documents';
+export declare const loadXlsx: (blob: Blob) => Promise<Document[]>;

package/lib/document-loader/xlsx.js

@@ -0,0 +1,100 @@
+/**
+ * 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 xlsx_exports = {};
+__export(xlsx_exports, {
+  loadXlsx: () => loadXlsx
+});
+module.exports = __toCommonJS(xlsx_exports);
+var import_documents = require("@langchain/core/documents");
+var XLSX = __toESM(require("xlsx"));
+const normalizeCellValue = /* @__PURE__ */ __name((value) => {
+  if (value === void 0 || value === null) {
+    return "";
+  }
+  return String(value);
+}, "normalizeCellValue");
+const trimTrailingEmptyCells = /* @__PURE__ */ __name((row) => {
+  let end = row.length;
+  while (end > 0 && normalizeCellValue(row[end - 1]).trim() === "") {
+    end -= 1;
+  }
+  return row.slice(0, end);
+}, "trimTrailingEmptyCells");
+const sheetToLines = /* @__PURE__ */ __name((sheet) => {
+  const rows = XLSX.utils.sheet_to_json(sheet, {
+    header: 1,
+    raw: false,
+    defval: "",
+    blankrows: false
+  });
+  return rows.map((row) => trimTrailingEmptyCells(Array.isArray(row) ? row : [])).filter((row) => row.length > 0).map((row) => row.map((cell) => normalizeCellValue(cell)).join("	")).filter((line) => line.trim().length > 0);
+}, "sheetToLines");
+const loadXlsx = /* @__PURE__ */ __name(async (blob) => {
+  const buffer = await blob.arrayBuffer();
+  const workbook = XLSX.read(buffer, {
+    type: "array",
+    cellText: true
+  });
+  const documents = [];
+  workbook.SheetNames.forEach((sheetName, index) => {
+    const sheet = workbook.Sheets[sheetName];
+    if (!sheet) {
+      return;
+    }
+    const lines = sheetToLines(sheet);
+    if (!lines.length) {
+      return;
+    }
+    documents.push(
+      new import_documents.Document({
+        pageContent: [`Sheet: ${sheetName}`, ...lines].join("\n"),
+        metadata: {
+          source: "blob",
+          blobType: blob.type,
+          sheetName,
+          sheetIndex: index
+        }
+      })
+    );
+  });
+  return documents;
+}, "loadXlsx");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  loadXlsx
+});

package/lib/index.d.ts

@@ -7,6 +7,11 @@
  * 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';
+export * from './document-loader';

package/lib/index.js

@@ -24,13 +24,23 @@ 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);
+__reExport(src_exports, require("./document-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("./loader")
+  ...require("./skills-manager"),
+  ...require("./mcp-manager"),
+  ...require("./loader"),
+  ...require("./document-loader")
 });

package/lib/loader/employee.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 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 = {
+    pluginName: string;
+    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,207 @@
+/**
+ * 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_promises = require("fs/promises");
+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);
+      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, _c;
+        const file = fds.find((fd) => fd.extname === ".ts" || fd.extname === ".js");
+        if (!file || !(0, import_fs.existsSync)(file.path)) {
+          return null;
+        }
+        const promptFile = fds.find((fd) => fd.basename === "prompt.md");
+        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;
+          if (promptFile && (0, import_fs.existsSync)(promptFile.path)) {
+            try {
+              employeeOptions.systemPrompt = await (0, import_promises.readFile)(promptFile.path, "utf-8");
+            } catch (e) {
+              (_b = this.log) == null ? void 0 : _b.error(
+                `ai employee [${name}] load fail: error occur when reading prompt.md at ${promptFile.path}`,
+                e
+              );
+              return null;
+            }
+          }
+          return {
+            name,
+            employeeRoot,
+            file,
+            options: {
+              ...employeeOptions,
+              skills: [...skills, ...await discoverSkills(employeeRoot)],
+              tools: [...tools, ...await discoverTools(employeeRoot)]
+            }
+          };
+        } catch (e) {
+          (_c = this.log) == null ? void 0 : _c.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(fd) {
+  if (fd.basename === "index.ts" || fd.basename === "index.js" || fd.basename === "prompt.md") {
+    return import_path.default.dirname(fd.path);
+  }
+  return fd.path;
+}
+__name(getEmployeeRoot, "getEmployeeRoot");
+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 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,35 @@
+/**
+ * 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 = {
+    pluginName: string;
+    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;
+};

package/lib/loader/mcp.js

@@ -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.
+ */
+
+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_exports = {};
+__export(mcp_exports, {
+  MCPLoader: () => MCPLoader
+});
+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;
+    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) {
+      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) {
+      return;
+    }
+    const { mcpManager } = this.ai;
+    for (const descriptor of this.mcpDescriptors) {
+      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);
+      }
+    }
+  }
+};
+__name(_MCPLoader, "MCPLoader");
+let MCPLoader = _MCPLoader;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MCPLoader
+});