@nocobase/plugin-mcp-server 2.1.0-alpha.9 → 2.1.0-beta.17

package/dist/server/mcp-server.d.ts

@@ -7,12 +7,14 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import type { McpToolsManager } from '@nocobase/ai';
+import type { McpTool } from '@nocobase/ai';
 export declare class McpServer {
     private readonly options;
     constructor(options: {
         name: string;
         version: string;
         toolsManager: McpToolsManager;
+        getTools?: (ctx: any) => Promise<McpTool[]>;
         logger: {
             error: (...args: any[]) => void;
         };

package/dist/server/mcp-server.js

@@ -94,9 +94,10 @@ class McpServer {
     this.options = options;
   }
   async handlePost(ctx) {
+    var _a;
     const body = ctx.request.body || {};
     const sdkModules = await getMcpSdkModules();
-    const server = this.createServer(sdkModules);
+    const server = this.createServer(sdkModules, ctx, (_a = ctx.getBearerToken) == null ? void 0 : _a.call(ctx));
     const transport = new sdkModules.StreamableHTTPServerTransport({
       sessionIdGenerator: void 0
     });
@@ -111,7 +112,7 @@ class McpServer {
     }
     ctx.respond = false;
   }
-  createServer(sdkModules) {
+  createServer(sdkModules, ctx, requestToken) {
     const server = new sdkModules.McpServer(
       {
         name: this.options.name,
@@ -124,8 +125,9 @@ class McpServer {
       }
     );
     server.server.setRequestHandler(sdkModules.ListToolsRequestSchema, async () => {
+      const tools = this.options.getTools ? await this.options.getTools(ctx) : this.options.toolsManager.listTools();
       return {
-        tools: this.options.toolsManager.listTools().map((tool) => {
+        tools: tools.map((tool) => {
           return {
             name: tool.name,
             description: tool.description,
@@ -141,11 +143,11 @@ class McpServer {
       var _a;
       const toolName = request.params.name;
       const args = request.params.arguments || {};
-      const tool = this.options.toolsManager.getTool(toolName);
+      const tool = this.options.getTools ? (await this.options.getTools(ctx)).find((item) => item.name === toolName) : this.options.toolsManager.getTool(toolName);
       if (!tool) {
         throw new Error(`Tool not found: ${toolName}`);
       }
-      const token = resolveTokenFromExtra(extra);
+      const token = requestToken || resolveTokenFromExtra(extra);
       try {
         const result = await tool.call(args, {
           token,

package/dist/server/mcp-tools.d.ts

@@ -7,17 +7,23 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import type { McpTool } from '@nocobase/ai';
+import { Application } from '@nocobase/server';
+type McpToolDefinitionWithBaseUrl = import('openapi-mcp-generator').McpToolDefinition & {
+    baseUrl?: string;
+};
+export declare const DEFAULT_MCP_PACKAGE_PATTERNS: any[];
+export declare function normalizePackageName(packageName: string): string;
+export declare function normalizePackagePatterns(packageNames?: string[]): string[];
+export declare function parseResourceActionFromPath(pathTemplate: string): {
+    resourceName?: undefined;
+    actionName?: undefined;
+} | {
+    resourceName: string;
+    actionName: string;
+};
+export declare function normalizeMcpToolName(tool: Pick<McpToolDefinitionWithBaseUrl, 'name' | 'pathTemplate'>): string;
 export declare function collectMcpToolsFromSwagger(options: {
-    app: {
-        db: any;
-        version: {
-            get: () => Promise<string>;
-        };
-        resourcer: {
-            options?: {
-                prefix?: string;
-            };
-        };
-        callback: () => any;
-    };
+    app: Application;
+    packagePatterns?: string[];
 }): Promise<McpTool[]>;
+export {};

package/dist/server/mcp-tools.js

@@ -36,13 +36,20 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var mcp_tools_exports = {};
 __export(mcp_tools_exports, {
-  collectMcpToolsFromSwagger: () => collectMcpToolsFromSwagger
+  DEFAULT_MCP_PACKAGE_PATTERNS: () => DEFAULT_MCP_PACKAGE_PATTERNS,
+  collectMcpToolsFromSwagger: () => collectMcpToolsFromSwagger,
+  normalizeMcpToolName: () => normalizeMcpToolName,
+  normalizePackageName: () => normalizePackageName,
+  normalizePackagePatterns: () => normalizePackagePatterns,
+  parseResourceActionFromPath: () => parseResourceActionFromPath
 });
 module.exports = __toCommonJS(mcp_tools_exports);
 var import_utils = require("@nocobase/utils");
 var import_utils2 = require("@nocobase/utils");
 var import_light_my_request = __toESM(require("light-my-request"));
+var import_schema_utils = require("./schema-utils");
 const SWAGGER_TARGETS = ["swagger.json", "swagger/index.json", "swagger"];
+const DEFAULT_MCP_PACKAGE_PATTERNS = [];
 function getSwaggerPrefixes() {
   if (process.env.NODE_ENV === "production") {
     return ["lib", "dist", "src"];
@@ -64,11 +71,89 @@ function loadSwagger(packageName) {
   }
   return {};
 }
+function normalizePackageName(packageName) {
+  const normalized = packageName.trim();
+  if (!normalized) {
+    return "";
+  }
+  if (normalized.startsWith("@")) {
+    return normalized;
+  }
+  return `@nocobase/${normalized}`;
+}
+function normalizePackagePatterns(packageNames = []) {
+  return [...new Set(packageNames.map(normalizePackageName).filter(Boolean))];
+}
+function matchesPackagePattern(packageName, pattern) {
+  if (pattern.endsWith("*")) {
+    return packageName.startsWith(pattern.slice(0, -1));
+  }
+  return packageName === pattern;
+}
+function shouldIncludePackage(packageName, patterns) {
+  const normalizedPatterns = (patterns == null ? void 0 : patterns.length) ? normalizePackagePatterns(patterns) : DEFAULT_MCP_PACKAGE_PATTERNS;
+  return normalizedPatterns.some((pattern) => matchesPackagePattern(packageName, pattern));
+}
 function mergeSwagger(target, source) {
   return (0, import_utils2.merge)(target, source, {
     arrayMerge: (destinationArray, sourceArray) => sourceArray.concat(destinationArray)
   });
 }
+function resolveLocalRef(document, ref) {
+  if (!ref.startsWith("#/")) {
+    return void 0;
+  }
+  return ref.slice(2).split("/").reduce((current, segment) => current == null ? void 0 : current[segment], document);
+}
+function dereferenceNode(node, document, seen = /* @__PURE__ */ new Set()) {
+  if (Array.isArray(node)) {
+    return node.map((item) => dereferenceNode(item, document, seen));
+  }
+  if (!node || typeof node !== "object") {
+    return node;
+  }
+  if (typeof node.$ref === "string") {
+    if (seen.has(node.$ref)) {
+      return {};
+    }
+    const resolved = resolveLocalRef(document, node.$ref);
+    if (!resolved) {
+      return node;
+    }
+    return dereferenceNode(resolved, document, /* @__PURE__ */ new Set([...seen, node.$ref]));
+  }
+  return Object.fromEntries(Object.entries(node).map(([key, value]) => [key, dereferenceNode(value, document, seen)]));
+}
+function prepareSwaggerForMcpTools(document) {
+  const swagger = {
+    ...document,
+    paths: {}
+  };
+  for (const [path, pathItem] of Object.entries(document.paths || {})) {
+    if (!pathItem) {
+      continue;
+    }
+    const nextPathItem = {
+      ...pathItem
+    };
+    if (Array.isArray(pathItem.parameters)) {
+      nextPathItem.parameters = dereferenceNode(pathItem.parameters, document);
+    }
+    for (const method of ["get", "post", "put", "patch", "delete", "options", "head", "trace"]) {
+      const operation = pathItem[method];
+      if (!operation) {
+        continue;
+      }
+      nextPathItem[method] = {
+        ...operation,
+        parameters: Array.isArray(operation.parameters) ? dereferenceNode(operation.parameters, document) : operation.parameters,
+        requestBody: operation.requestBody ? dereferenceNode(operation.requestBody, document) : operation.requestBody
+      };
+    }
+    swagger.paths[path] = nextPathItem;
+  }
+  return swagger;
+}
 function joinUrl(baseUrl, path) {
   if (!baseUrl) {
     return path;
@@ -77,6 +162,48 @@ function joinUrl(baseUrl, path) {
   const normalizedPath = path.startsWith("/") ? path : `/${path}`;
   return `${normalizedBase}${normalizedPath}`;
 }
+function parseResourceActionFromPath(pathTemplate) {
+  const normalizedPath = pathTemplate.replace(/^\/+/, "");
+  const separatorIndex = normalizedPath.lastIndexOf(":");
+  if (separatorIndex === -1) {
+    return {};
+  }
+  const resourcePath = normalizedPath.slice(0, separatorIndex);
+  const actionName = normalizedPath.slice(separatorIndex + 1);
+  const resourceName = resourcePath.split("/").filter((segment) => segment && !segment.startsWith("{")).join(".");
+  if (!resourceName || !actionName) {
+    return {};
+  }
+  return {
+    resourceName,
+    actionName
+  };
+}
+function buildQueryValue(value) {
+  if (typeof value === "undefined") {
+    return void 0;
+  }
+  if (value === null) {
+    return null;
+  }
+  if (Array.isArray(value)) {
+    return value;
+  }
+  if (typeof value === "object") {
+    return JSON.stringify(value);
+  }
+  return value;
+}
+function formatToolName(name) {
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[.:\-/\s]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "").toLowerCase().replace(/^(get|post|put|delete|patch|options|head|trace)_/, "");
+}
+function normalizeMcpToolName(tool) {
+  const actionMeta = parseResourceActionFromPath(tool.pathTemplate);
+  if (actionMeta.resourceName && actionMeta.actionName) {
+    return formatToolName(`${actionMeta.resourceName}_${actionMeta.actionName}`);
+  }
+  return formatToolName(tool.name);
+}
 function buildRequest(tool, args = {}, context) {
   var _a;
   const missingPathParams = [];
@@ -97,7 +224,7 @@ function buildRequest(tool, args = {}, context) {
       continue;
     }
     if (parameter.in === "query") {
-      query[parameter.name] = value;
+      query[parameter.name] = buildQueryValue(value);
       continue;
     }
     if (parameter.in === "header") {
@@ -133,7 +260,7 @@ function buildRequest(tool, args = {}, context) {
 }
 async function collectMcpToolsFromSwagger(options) {
   var _a;
-  const { app } = options;
+  const { app, packagePatterns } = options;
   const plugins = await app.db.getRepository("applicationPlugins").find({
     filter: {
       enabled: true
@@ -152,10 +279,12 @@ async function collectMcpToolsFromSwagger(options) {
       }
     ]
   };
-  swagger = mergeSwagger(swagger, loadSwagger("@nocobase/server"));
+  if (shouldIncludePackage("@nocobase/server", packagePatterns)) {
+    swagger = mergeSwagger(swagger, loadSwagger("@nocobase/server"));
+  }
   for (const plugin of plugins) {
     const packageName = plugin.get("packageName");
-    if (!packageName) {
+    if (!packageName || !shouldIncludePackage(packageName, packagePatterns)) {
       continue;
     }
     const pluginSwagger = loadSwagger(packageName);
@@ -164,13 +293,19 @@ async function collectMcpToolsFromSwagger(options) {
     }
     swagger = mergeSwagger(swagger, pluginSwagger);
   }
+  swagger = prepareSwaggerForMcpTools(swagger);
   const { getToolsFromOpenApi } = await import("openapi-mcp-generator");
   const mcpTools = await getToolsFromOpenApi(swagger);
   return mcpTools.map((tool) => {
-    return {
-      name: tool.name,
+    const actionMeta = parseResourceActionFromPath(tool.pathTemplate);
+    const mcpTool = {
+      name: normalizeMcpToolName(tool),
       description: tool.description,
-      inputSchema: tool.inputSchema,
+      resourceName: actionMeta.resourceName,
+      actionName: actionMeta.actionName,
+      path: tool.pathTemplate,
+      method: tool.method.toUpperCase(),
+      inputSchema: (0, import_schema_utils.sanitizeJsonSchemaForOpenAITools)(tool.inputSchema),
       call: async (args, context) => {
         const request = buildRequest(tool, args, context);
         if (request.missingPathParams.length > 0) {
@@ -200,12 +335,26 @@ async function collectMcpToolsFromSwagger(options) {
             })
           );
         }
-        return body;
+        return app.aiManager.mcpToolsManager.postProcessToolResult(mcpTool, body, {
+          args,
+          callContext: context,
+          response: {
+            statusCode: response.statusCode,
+            headers: response.headers,
+            body
+          }
+        });
       }
     };
+    return mcpTool;
   });
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  collectMcpToolsFromSwagger
+  DEFAULT_MCP_PACKAGE_PATTERNS,
+  collectMcpToolsFromSwagger,
+  normalizeMcpToolName,
+  normalizePackageName,
+  normalizePackagePatterns,
+  parseResourceActionFromPath
 });

package/dist/server/plugin.d.ts

@@ -9,7 +9,19 @@
 import { Plugin } from '@nocobase/server';
 export declare class PluginMcpServerServer extends Plugin {
     private mcpServer;
-    private readonly registerMcpTools;
+    private readonly mcpScopes;
+    private readonly mcpToolsCache;
+    private getApiBasePath;
+    private getMcpPath;
+    private getIdpOauthPlugin;
+    private getOauthMetadata;
+    private rewriteUnauthorizedResponse;
+    private registerProtectedResourceMetadataRoute;
+    private registerIdpResource;
+    private unregisterIdpResource;
+    private parsePackagePatterns;
+    private getMcpToolsCacheKey;
+    private getMcpTools;
     afterAdd(): Promise<void>;
     beforeLoad(): Promise<void>;
     load(): Promise<void>;

package/dist/server/plugin.js

@@ -34,29 +34,169 @@ var import_server = require("@nocobase/server");
 var import_mcp_tools = require("./mcp-tools");
 var import_mcp_server = require("./mcp-server");
 var import_crud_tool = require("./crud-tool");
+function normalizeBasePath(path = "") {
+  const normalized = path.replace(/\/+/g, "/").replace(/\/$/, "");
+  return normalized || "/";
+}
+const MCP_PACKAGES_HEADER = "x-mcp-packages";
 class PluginMcpServerServer extends import_server.Plugin {
   mcpServer;
-  registerMcpTools = async () => {
-    const apiTools = await (0, import_mcp_tools.collectMcpToolsFromSwagger)({
-      app: this.app
+  mcpScopes = ["mcp", "offline_access"];
+  mcpToolsCache = /* @__PURE__ */ new Map();
+  getApiBasePath() {
+    return normalizeBasePath(process.env.API_BASE_PATH || "/api");
+  }
+  getMcpPath() {
+    return `${this.getApiBasePath()}/mcp`;
+  }
+  getIdpOauthPlugin() {
+    return this.app.pm.get("idp-oauth");
+  }
+  getOauthMetadata(ctx) {
+    var _a, _b;
+    const issuer = (_b = (_a = this.getIdpOauthPlugin()) == null ? void 0 : _a.service) == null ? void 0 : _b.getProviderContext(ctx).issuer;
+    if (!issuer) {
+      return void 0;
+    }
+    return {
+      issuer,
+      resource: `${issuer}/mcp`,
+      resourceMetadataUrl: `${issuer}/.well-known/oauth-protected-resource`
+    };
+  }
+  rewriteUnauthorizedResponse(ctx) {
+    const metadata = this.getOauthMetadata(ctx);
+    if (metadata) {
+      ctx.set(
+        "WWW-Authenticate",
+        `Bearer resource_metadata="${metadata.resourceMetadataUrl}", scope="${this.mcpScopes.join(" ")}"`
+      );
+    }
+    ctx.withoutDataWrapping = true;
+    ctx.type = "application/json";
+    ctx.status = 401;
+    ctx.body = {
+      errors: [{ message: "Authentication required" }]
+    };
+  }
+  registerProtectedResourceMetadataRoute() {
+    const metadataPath = `${this.getApiBasePath()}/.well-known/oauth-protected-resource`;
+    this.app.use(
+      async (ctx, next) => {
+        if (ctx.path !== metadataPath || ctx.method !== "GET") {
+          await next();
+          return;
+        }
+        const metadata = this.getOauthMetadata(ctx);
+        if (!metadata) {
+          await next();
+          return;
+        }
+        ctx.withoutDataWrapping = true;
+        ctx.type = "application/json";
+        ctx.body = {
+          resource: metadata.resource,
+          authorization_servers: [metadata.issuer],
+          scopes_supported: [...this.mcpScopes]
+        };
+      },
+      {
+        tag: "mcp-oauth-protected-resource",
+        before: "dataWrapping"
+      }
+    );
+  }
+  registerIdpResource() {
+    var _a, _b;
+    (_b = (_a = this.getIdpOauthPlugin()) == null ? void 0 : _a.service) == null ? void 0 : _b.registerResourceServer("mcp", {
+      path: "/mcp",
+      scope: this.mcpScopes.join(" "),
+      accessTokenFormat: "jwt",
+      jwt: {
+        sign: { alg: "RS256" }
+      }
     });
-    this.ai.mcpToolsManager.registerTools([...apiTools, (0, import_crud_tool.createCrudTool)({ app: this.app })]);
-  };
+  }
+  unregisterIdpResource() {
+    var _a, _b, _c;
+    (_c = (_b = (_a = this.getIdpOauthPlugin()) == null ? void 0 : _a.service) == null ? void 0 : _b.unregisterResourceServer) == null ? void 0 : _c.call(_b, "mcp");
+  }
+  parsePackagePatterns(ctx) {
+    var _a, _b, _c;
+    const value = ((_a = ctx == null ? void 0 : ctx.headers) == null ? void 0 : _a[MCP_PACKAGES_HEADER]) ?? ((_c = (_b = ctx == null ? void 0 : ctx.request) == null ? void 0 : _b.headers) == null ? void 0 : _c[MCP_PACKAGES_HEADER]);
+    if (typeof value === "undefined") {
+      return void 0;
+    }
+    const rawValues = (Array.isArray(value) ? value : [value]).flatMap((item) => String(item).split(","));
+    return (0, import_mcp_tools.normalizePackagePatterns)(rawValues);
+  }
+  getMcpToolsCacheKey(packagePatterns) {
+    if (typeof packagePatterns === "undefined") {
+      return "__default__";
+    }
+    return packagePatterns.slice().sort().join(",");
+  }
+  async getMcpTools(ctx) {
+    const packagePatterns = this.parsePackagePatterns(ctx);
+    const cacheKey = this.getMcpToolsCacheKey(packagePatterns);
+    let toolsPromise = this.mcpToolsCache.get(cacheKey);
+    if (!toolsPromise) {
+      toolsPromise = (0, import_mcp_tools.collectMcpToolsFromSwagger)({
+        app: this.app,
+        packagePatterns
+      }).then((apiTools) => [
+        ...apiTools,
+        ...(0, import_crud_tool.createCrudTools)({ app: this.app, mcpToolsManager: this.ai.mcpToolsManager })
+      ]).catch((error) => {
+        this.mcpToolsCache.delete(cacheKey);
+        throw error;
+      });
+      this.mcpToolsCache.set(cacheKey, toolsPromise);
+    }
+    return toolsPromise;
+  }
   async afterAdd() {
   }
   async beforeLoad() {
   }
   async load() {
-    await this.registerMcpTools();
+    var _a;
+    if ((_a = this.getIdpOauthPlugin()) == null ? void 0 : _a.service) {
+      this.registerIdpResource();
+      this.registerProtectedResourceMetadataRoute();
+    }
     this.mcpServer = new import_mcp_server.McpServer({
       name: "nocobase-mcp-server",
       version: this.options.version || "0.0.0",
       toolsManager: this.ai.mcpToolsManager,
+      getTools: async (ctx) => this.getMcpTools(ctx),
       logger: this.log
     });
-    const mcpHandler = async (ctx, next) => {
+    this.app.use(
+      async (ctx, next) => {
+        if (ctx.path !== this.getMcpPath()) {
+          return next();
+        }
+        try {
+          await next();
+        } catch (error) {
+          if (ctx.status === 401 || (error == null ? void 0 : error.status) === 401 || (error == null ? void 0 : error.statusCode) === 401) {
+            this.rewriteUnauthorizedResponse(ctx);
+            return;
+          }
+          throw error;
+        }
+        if (ctx.status === 401) {
+          this.rewriteUnauthorizedResponse(ctx);
+        }
+      },
+      {
+        tag: "mcp-unauthorized-response",
+        before: "dataSource"
+      }
+    );
+    const mcpHandler = async (ctx) => {
       await this.mcpServer.handlePost(ctx);
-      await next();
     };
     this.app.resourceManager.define({
       name: "mcp",
@@ -75,8 +215,10 @@ class PluginMcpServerServer extends import_server.Plugin {
   async afterEnable() {
   }
   async afterDisable() {
+    this.unregisterIdpResource();
   }
   async remove() {
+    this.unregisterIdpResource();
   }
 }
 var plugin_default = PluginMcpServerServer;

package/dist/server/schema-utils.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 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 function sanitizeJsonSchemaForOpenAITools<T>(schema: T): T;

package/dist/server/schema-utils.js

@@ -0,0 +1,69 @@
+/**
+ * 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 __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 schema_utils_exports = {};
+__export(schema_utils_exports, {
+  sanitizeJsonSchemaForOpenAITools: () => sanitizeJsonSchemaForOpenAITools
+});
+module.exports = __toCommonJS(schema_utils_exports);
+function sanitizeSchemaNode(node) {
+  if (Array.isArray(node)) {
+    return node.map((item) => sanitizeSchemaNode(item)).filter((item) => typeof item !== "undefined");
+  }
+  if (!node || typeof node !== "object") {
+    return node;
+  }
+  const sanitizedEntries = Object.entries(node).filter(([, value]) => value !== null).map(([key, value]) => [key, sanitizeSchemaNode(value)]).filter(([, value]) => typeof value !== "undefined");
+  const sanitizedNode = Object.fromEntries(sanitizedEntries);
+  if (Array.isArray(sanitizedNode.type)) {
+    const nextTypes = sanitizedNode.type.filter((type) => type !== null && type !== "null");
+    if (nextTypes.length === 1) {
+      sanitizedNode.type = nextTypes[0];
+    } else if (nextTypes.length > 1) {
+      sanitizedNode.type = nextTypes;
+    } else {
+      delete sanitizedNode.type;
+    }
+  } else if (sanitizedNode.type === null || sanitizedNode.type === "null") {
+    delete sanitizedNode.type;
+  }
+  delete sanitizedNode.nullable;
+  if (typeof sanitizedNode.type === "undefined") {
+    if (sanitizedNode.properties || sanitizedNode.additionalProperties || Array.isArray(sanitizedNode.required) || sanitizedNode.patternProperties) {
+      sanitizedNode.type = "object";
+    } else if (sanitizedNode.items) {
+      sanitizedNode.type = "array";
+    }
+  }
+  return sanitizedNode;
+}
+function sanitizeJsonSchemaForOpenAITools(schema) {
+  return sanitizeSchemaNode(schema);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  sanitizeJsonSchemaForOpenAITools
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nocobase/plugin-mcp-server",
   "main": "dist/server/index.js",
-  "version": "2.1.0-alpha.9",
+  "version": "2.1.0-beta.17",
   "displayName": "AI: MCP server",
   "displayName.zh-CN": "AI: MCP 服务器",
   "description": "An MCP server for building NocoBase systems and supporting business workflows.",
@@ -16,11 +16,12 @@
     "@modelcontextprotocol/sdk": "^1.27.1",
     "@nocobase/ai": "2.x",
     "@nocobase/client": "2.x",
+    "@nocobase/plugin-idp-oauth": "2.x",
     "@nocobase/server": "2.x",
     "@nocobase/test": "2.x"
   },
   "keywords": [
     "AI"
   ],
-  "gitHead": "f9c6c53772bd5002fa419188d15ab227224f1962"
+  "gitHead": "227d625e47174ab7b3a90170e7c6c67bbdf36e23"
 }