@nocobase/ai 2.1.10 → 2.1.11

package/lib/mcp-manager/options-renderer.js

@@ -95,6 +95,17 @@ const stringifyArray = /* @__PURE__ */ __name((value) => {
   }
   return value.filter((item) => item != null).map((item) => String(item));
 }, "stringifyArray");
+const getRequestVariables = /* @__PURE__ */ __name((ctx) => {
+  var _a, _b;
+  return {
+    headers: ((_a = ctx == null ? void 0 : ctx.request) == null ? void 0 : _a.headers) ?? {},
+    token: ((_b = ctx == null ? void 0 : ctx.getBearerToken) == null ? void 0 : _b.call(ctx)) ?? ""
+  };
+}, "getRequestVariables");
+const emptyRequestVariables = {
+  headers: {},
+  token: ""
+};
 const normalizeMCPOptions = /* @__PURE__ */ __name((options) => {
   const normalized = {
     ...options,
@@ -112,12 +123,15 @@ const normalizeMCPOptions = /* @__PURE__ */ __name((options) => {
 async function renderMCPOptions(options, app, ctx) {
   var _a, _b;
   const currentUser = options.useUserContext ? await getCurrentUser(ctx, options) : void 0;
+  const request = options.useUserContext ? getRequestVariables(ctx) : emptyRequestVariables;
   const variables = {
     $env: ((_b = (_a = app.environment) == null ? void 0 : _a.getVariables) == null ? void 0 : _b.call(_a)) ?? {},
     currentUser,
     $user: currentUser,
+    request,
     ctx: {
-      currentUser
+      currentUser,
+      request
     }
   };
   return normalizeMCPOptions((0, import_utils.parse)(options)(variables));

package/lib/mcp-manager/user-context-client-manager.js

@@ -42,48 +42,63 @@ const _UserContextMCPClientManager = class _UserContextMCPClientManager {
   ttlMs;
   maxSize;
   async getToolsMap(ctx) {
-    var _a, _b;
+    var _a, _b, _c, _d, _e;
     const currentUser = ((_a = ctx == null ? void 0 : ctx.state) == null ? void 0 : _a.currentUser) ?? ((_b = ctx == null ? void 0 : ctx.auth) == null ? void 0 : _b.user);
     if (!(currentUser == null ? void 0 : currentUser.id)) {
       return {};
     }
-    this.evictExpired();
-    const entries = (await this.options.listEntries()).filter((entry) => entry.enabled !== false && entry.useUserContext === true && entry.transport !== "stdio").sort((left, right) => left.name.localeCompare(right.name));
-    if (!entries.length) {
+    let client = null;
+    try {
+      this.evictExpired();
+      const entries = (await this.options.listEntries()).filter((entry) => entry.enabled !== false && entry.useUserContext === true && entry.transport !== "stdio").sort((left, right) => left.name.localeCompare(right.name));
+      if (!entries.length) {
+        return {};
+      }
+      const cacheKey = String(currentUser.id);
+      const cached = this.cache.get(cacheKey);
+      const now = Date.now();
+      if (cached && cached.expiresAt > now) {
+        cached.lastAccessedAt = now;
+        return cached.toolsMap;
+      }
+      if (cached) {
+        await this.closeEntry(cached);
+        this.cache.delete(cacheKey);
+      }
+      const connections = {};
+      for (const entry of entries) {
+        const rendered = await (0, import_options_renderer.renderMCPOptions)(entry, this.options.app, ctx);
+        connections[entry.name] = this.options.buildConnection(rendered);
+      }
+      client = new import_mcp_adapters.MultiServerMCPClient(connections);
+      const initializedToolsMap = await client.initializeConnections();
+      const toolsMap = Object.fromEntries(
+        Object.entries(initializedToolsMap).map(([serverName, tools]) => [
+          serverName,
+          tools
+        ])
+      );
+      this.cache.set(cacheKey, {
+        client,
+        toolsMap,
+        expiresAt: now + this.ttlMs,
+        lastAccessedAt: now
+      });
+      client = null;
+      await this.evictOversized();
+      return toolsMap;
+    } catch (error) {
+      if (client) {
+        await this.closeEntry({
+          client,
+          toolsMap: {},
+          expiresAt: 0,
+          lastAccessedAt: 0
+        });
+      }
+      (_e = (_d = (_c = this.options.app) == null ? void 0 : _c.log) == null ? void 0 : _d.warn) == null ? void 0 : _e.call(_d, "fail to get user-bound mcp tools", error);
       return {};
     }
-    const cacheKey = String(currentUser.id);
-    const cached = this.cache.get(cacheKey);
-    const now = Date.now();
-    if (cached && cached.expiresAt > now) {
-      cached.lastAccessedAt = now;
-      return cached.toolsMap;
-    }
-    if (cached) {
-      await this.closeEntry(cached);
-      this.cache.delete(cacheKey);
-    }
-    const connections = {};
-    for (const entry of entries) {
-      const rendered = await (0, import_options_renderer.renderMCPOptions)(entry, this.options.app, ctx);
-      connections[entry.name] = this.options.buildConnection(rendered);
-    }
-    const client = new import_mcp_adapters.MultiServerMCPClient(connections);
-    const initializedToolsMap = await client.initializeConnections();
-    const toolsMap = Object.fromEntries(
-      Object.entries(initializedToolsMap).map(([serverName, tools]) => [
-        serverName,
-        tools
-      ])
-    );
-    this.cache.set(cacheKey, {
-      client,
-      toolsMap,
-      expiresAt: now + this.ttlMs,
-      lastAccessedAt: now
-    });
-    await this.evictOversized();
-    return toolsMap;
   }
   async clear() {
     const entries = [...this.cache.values()];

package/package.json

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

package/src/__tests__/mcp-user-context.test.ts

@@ -20,6 +20,9 @@ const mcpClientMock = vi.hoisted(() => {
     }
 
     async initializeConnections() {
+      if (Object.values(this.connections).some((connection) => connection?.failInitialize)) {
+        throw new Error('initialize failed');
+      }
       return Object.fromEntries(
         Object.keys(this.connections).map((serverName) => [
           serverName,
@@ -84,6 +87,13 @@ describe('user-bound MCP clients', () => {
           findOne: vi.fn(),
         }),
       },
+      request: {
+        headers: {
+          authorization: 'Bearer request-token',
+          'x-role': 'admin',
+        },
+      },
+      getBearerToken: () => 'request-token',
     }) as any;
 
   beforeEach(() => {
@@ -139,6 +149,48 @@ describe('user-bound MCP clients', () => {
     });
   });
 
+  it('renders NocoBase request in MCP options', async () => {
+    const rendered = await renderMCPOptions(
+      {
+        transport: 'http',
+        url: 'https://{{ $env.MCP_HOST }}/mcp',
+        headers: {
+          Authorization: 'Bearer {{ request.token }}',
+          'X-Role': '{{ request.headers.x-role }}',
+        },
+        useUserContext: true,
+      },
+      createApp(),
+      createCtx(7),
+    );
+
+    expect(rendered).toMatchObject({
+      headers: {
+        Authorization: 'Bearer request-token',
+        'X-Role': 'admin',
+      },
+    });
+  });
+
+  it('does not render NocoBase request for shared MCP options', async () => {
+    const rendered = await renderMCPOptions(
+      {
+        transport: 'http',
+        url: 'https://{{ $env.MCP_HOST }}/mcp',
+        headers: {
+          Authorization: 'Bearer {{ request.token }}',
+        },
+        useUserContext: false,
+      },
+      createApp(),
+      createCtx(7),
+    );
+
+    expect(rendered.headers).toMatchObject({
+      Authorization: 'Bearer ',
+    });
+  });
+
   it('excludes user-bound records when rebuilding the shared client', async () => {
     const manager = new DefaultMCPManager(createApp() as any) as any;
     manager.listMCP = vi.fn().mockResolvedValue([]);
@@ -203,6 +255,28 @@ describe('user-bound MCP clients', () => {
     expect(mcpClientMock.instances[0].connections.profile.url).toBe('https://mcp.example.test/11');
   });
 
+  it('returns empty tools and logs warning when user-bound MCP initialization fails', async () => {
+    const app = createApp();
+    const manager = new UserContextMCPClientManager({
+      app,
+      listEntries: async () => [
+        {
+          name: 'profile',
+          enabled: true,
+          transport: 'http',
+          url: 'https://{{ $env.MCP_HOST }}/{{ currentUser.id }}',
+          headers: {},
+          useUserContext: true,
+        },
+      ],
+      buildConnection: () => ({ failInitialize: true }) as any,
+    });
+
+    await expect(manager.getToolsMap(createCtx(1))).resolves.toEqual({});
+    expect(app.log.warn).toHaveBeenCalledWith('fail to get user-bound mcp tools', expect.any(Error));
+    expect(mcpClientMock.instances[0].close).toHaveBeenCalledTimes(1);
+  });
+
   it('reuses cached user-bound tools and refreshes them after TTL', async () => {
     vi.useFakeTimers();
     vi.setSystemTime(0);

package/src/mcp-manager/options-renderer.ts

@@ -84,6 +84,16 @@ const stringifyArray = (value: unknown): string[] => {
   return value.filter((item) => item != null).map((item) => String(item));
 };
 
+const getRequestVariables = (ctx?: Context) => ({
+  headers: ctx?.request?.headers ?? {},
+  token: ctx?.getBearerToken?.() ?? '',
+});
+
+const emptyRequestVariables = {
+  headers: {},
+  token: '',
+};
+
 export const normalizeMCPOptions = (options: MCPOptions): MCPOptions => {
   const normalized: MCPOptions = {
     ...options,
@@ -106,12 +116,15 @@ export async function renderMCPOptions(
   ctx?: Context,
 ): Promise<MCPOptions> {
   const currentUser = options.useUserContext ? await getCurrentUser(ctx, options) : undefined;
+  const request = options.useUserContext ? getRequestVariables(ctx) : emptyRequestVariables;
   const variables = {
     $env: app.environment?.getVariables?.() ?? {},
     currentUser,
     $user: currentUser,
+    request,
     ctx: {
       currentUser,
+      request,
     },
   };
 

package/src/mcp-manager/user-context-client-manager.ts

@@ -46,52 +46,67 @@ export class UserContextMCPClientManager {
       return {};
     }
 
-    this.evictExpired();
+    let client: MultiServerMCPClient | null = null;
+    try {
+      this.evictExpired();
 
-    const entries = (await this.options.listEntries())
-      .filter((entry) => entry.enabled !== false && entry.useUserContext === true && entry.transport !== 'stdio')
-      .sort((left, right) => left.name.localeCompare(right.name));
-    if (!entries.length) {
-      return {};
-    }
+      const entries = (await this.options.listEntries())
+        .filter((entry) => entry.enabled !== false && entry.useUserContext === true && entry.transport !== 'stdio')
+        .sort((left, right) => left.name.localeCompare(right.name));
+      if (!entries.length) {
+        return {};
+      }
 
-    const cacheKey = String(currentUser.id);
-    const cached = this.cache.get(cacheKey);
-    const now = Date.now();
-    if (cached && cached.expiresAt > now) {
-      cached.lastAccessedAt = now;
-      return cached.toolsMap;
-    }
+      const cacheKey = String(currentUser.id);
+      const cached = this.cache.get(cacheKey);
+      const now = Date.now();
+      if (cached && cached.expiresAt > now) {
+        cached.lastAccessedAt = now;
+        return cached.toolsMap;
+      }
 
-    if (cached) {
-      await this.closeEntry(cached);
-      this.cache.delete(cacheKey);
-    }
+      if (cached) {
+        await this.closeEntry(cached);
+        this.cache.delete(cacheKey);
+      }
 
-    const connections: Record<string, MCPConnection> = {};
-    for (const entry of entries) {
-      const rendered = await renderMCPOptions(entry, this.options.app, ctx);
-      connections[entry.name] = this.options.buildConnection(rendered);
-    }
+      const connections: Record<string, MCPConnection> = {};
+      for (const entry of entries) {
+        const rendered = await renderMCPOptions(entry, this.options.app, ctx);
+        connections[entry.name] = this.options.buildConnection(rendered);
+      }
 
-    const client = new MultiServerMCPClient(connections);
-    const initializedToolsMap = await client.initializeConnections();
-    const toolsMap = Object.fromEntries(
-      Object.entries(initializedToolsMap).map(([serverName, tools]) => [
-        serverName,
-        tools as StructuredToolInterface[],
-      ]),
-    );
-
-    this.cache.set(cacheKey, {
-      client,
-      toolsMap,
-      expiresAt: now + this.ttlMs,
-      lastAccessedAt: now,
-    });
-    await this.evictOversized();
-
-    return toolsMap;
+      client = new MultiServerMCPClient(connections);
+      const initializedToolsMap = await client.initializeConnections();
+      const toolsMap = Object.fromEntries(
+        Object.entries(initializedToolsMap).map(([serverName, tools]) => [
+          serverName,
+          tools as StructuredToolInterface[],
+        ]),
+      );
+
+      this.cache.set(cacheKey, {
+        client,
+        toolsMap,
+        expiresAt: now + this.ttlMs,
+        lastAccessedAt: now,
+      });
+      client = null;
+      await this.evictOversized();
+
+      return toolsMap;
+    } catch (error) {
+      if (client) {
+        await this.closeEntry({
+          client,
+          toolsMap: {},
+          expiresAt: 0,
+          lastAccessedAt: 0,
+        });
+      }
+      this.options.app?.log?.warn?.('fail to get user-bound mcp tools', error);
+      return {};
+    }
   }
 
   async clear() {