@nocobase/ai 2.1.9 → 2.1.11

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

@@ -9,6 +9,7 @@
 import { MultiServerMCPClient } from '@langchain/mcp-adapters';
 import { MCPEntry, MCPFilter, MCPManager, MCPOptions, MCPTestResult, MCPToolEntry } from './types';
 import type { DynamicToolsProvider, Permission } from '../tools-manager/types';
+import type { Context } from '@nocobase/actions';
 export declare class DefaultMCPManager implements MCPManager {
     private readonly app;
     private readonly mcpRegistry;
@@ -17,6 +18,7 @@ export declare class DefaultMCPManager implements MCPManager {
     private client;
     private toolsMap;
     private toolsPermissionMap;
+    private readonly userContextClientManager;
     constructor(app: any);
     init(): Promise<void>;
     registerMCP(registration: {
@@ -27,9 +29,13 @@ export declare class DefaultMCPManager implements MCPManager {
     rebuildClient(): Promise<void>;
     getClient(): MultiServerMCPClient | null;
     getMCPToolsProvider(): DynamicToolsProvider;
-    listMCPTools(): Promise<Record<string, MCPToolEntry[]>>;
+    private registerToolsFromMap;
+    private ensureToolPermission;
+    listMCPTools(ctx?: Context): Promise<Record<string, MCPToolEntry[]>>;
+    private formatMCPTools;
     updateMCPToolPermission(toolName: string, permission: Permission): Promise<void>;
-    testConnection(options: MCPOptions): Promise<MCPTestResult>;
+    clearUserContextCache(): Promise<void>;
+    testConnection(options: MCPOptions, ctx?: Context): Promise<MCPTestResult>;
     private buildMCPConnection;
     persistence(): Promise<void>;
     private persistenceEntry;

package/lib/mcp-manager/index.js

@@ -35,11 +35,18 @@ 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");
+var import_options_renderer = require("./options-renderer");
+var import_user_context_client_manager = require("./user-context-client-manager");
 __reExport(mcp_manager_exports, require("./types"), module.exports);
 const _DefaultMCPManager = class _DefaultMCPManager {
   constructor(app) {
     this.app = app;
     this.provideCollectionManager = () => app.mainDataSource;
+    this.userContextClientManager = new import_user_context_client_manager.UserContextMCPClientManager({
+      app,
+      listEntries: /* @__PURE__ */ __name(() => this.listMCP({ enabled: true, useUserContext: true }), "listEntries"),
+      buildConnection: /* @__PURE__ */ __name((options) => this.buildMCPConnection(options), "buildConnection")
+    });
   }
   mcpRegistry = new import_utils.Registry();
   provideCollectionManager;
@@ -47,6 +54,7 @@ const _DefaultMCPManager = class _DefaultMCPManager {
   client = null;
   toolsMap = {};
   toolsPermissionMap = {};
+  userContextClientManager;
   async init() {
     if (this.mode === "memory") {
       await this.persistence();
@@ -90,6 +98,11 @@ const _DefaultMCPManager = class _DefaultMCPManager {
     if (filter.transport) {
       where["transport"] = filter.transport;
     }
+    if (filter.useUserContext != null) {
+      where["useUserContext"] = filter.useUserContext === true ? true : {
+        [import_database.Op.or]: [false, null]
+      };
+    }
     return ((_b = await ((_a = this.aiMcpClientsModel) == null ? void 0 : _a.findAll({ where }))) == null ? void 0 : _b.map((item) => item.toJSON())) ?? [];
   }
   async rebuildClient() {
@@ -101,13 +114,13 @@ const _DefaultMCPManager = class _DefaultMCPManager {
       this.client = null;
       this.toolsMap = {};
     }
-    const entries = await this.listMCP({ enabled: true });
+    const entries = await this.listMCP({ enabled: true, useUserContext: false });
     if (entries.length === 0) {
       return;
     }
     const connections = {};
     for (const entry of entries) {
-      connections[entry.name] = this.buildMCPConnection(entry);
+      connections[entry.name] = this.buildMCPConnection(await (0, import_options_renderer.renderMCPOptions)(entry, this.app));
     }
     this.client = new import_mcp_adapters.MultiServerMCPClient(connections);
     const toolsMap = await this.client.initializeConnections();
@@ -125,46 +138,70 @@ const _DefaultMCPManager = class _DefaultMCPManager {
     return this.client;
   }
   getMCPToolsProvider() {
-    return async (register) => {
+    return async (register, filter) => {
       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);
-        }
+        this.registerToolsFromMap(register, serverName, tools);
+      }
+      if (!(filter == null ? void 0 : filter.ctx)) {
+        return;
+      }
+      const userToolsMap = await this.userContextClientManager.getToolsMap(filter.ctx);
+      for (const [serverName, tools] of Object.entries(userToolsMap)) {
+        this.registerToolsFromMap(register, serverName, tools);
       }
     };
   }
-  async listMCPTools() {
+  registerToolsFromMap(register, serverName, tools) {
+    for (const tool of tools) {
+      const toolName = `mcp-${serverName}-${tool.name}`;
+      this.ensureToolPermission(toolName, 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);
+    }
+  }
+  ensureToolPermission(toolName, rawToolName) {
+    if (!(toolName in this.toolsPermissionMap)) {
+      this.toolsPermissionMap[toolName] = rawToolName.startsWith("get") ? "ALLOW" : "ASK";
+    }
+  }
+  async listMCPTools(ctx) {
+    const toolsMap = {
+      ...this.toolsMap,
+      ...ctx ? await this.userContextClientManager.getToolsMap(ctx) : {}
+    };
+    return this.formatMCPTools(toolsMap);
+  }
+  formatMCPTools(toolsMap) {
     return Object.fromEntries(
-      Object.entries(this.toolsMap).map(([serverName, tools]) => [
+      Object.entries(toolsMap).map(([serverName, tools]) => [
         serverName,
         tools.map((tool) => {
           const toolName = `mcp-${serverName}-${tool.name}`;
+          this.ensureToolPermission(toolName, tool.name);
           return {
             name: toolName,
             title: tool.name,
@@ -179,21 +216,25 @@ const _DefaultMCPManager = class _DefaultMCPManager {
   async updateMCPToolPermission(toolName, permission) {
     this.toolsPermissionMap[toolName] = permission;
   }
-  async testConnection(options) {
-    const { transport } = options;
+  async clearUserContextCache() {
+    await this.userContextClientManager.clear();
+  }
+  async testConnection(options, ctx) {
+    const renderedOptions = await (0, import_options_renderer.renderMCPOptions)((0, import_options_renderer.normalizeMCPOptions)(options), this.app, ctx);
+    const { transport } = renderedOptions;
     if (!transport) {
       return {
         success: false,
         error: "Transport type is required"
       };
     }
-    if (transport === "stdio" && !options.command) {
+    if (transport === "stdio" && !renderedOptions.command) {
       return {
         success: false,
         error: "Command is required for stdio transport"
       };
     }
-    if ((transport === "http" || transport === "sse") && !options.url) {
+    if ((transport === "http" || transport === "sse") && !renderedOptions.url) {
       return {
         success: false,
         error: "URL is required for HTTP/SSE transport"
@@ -201,7 +242,7 @@ const _DefaultMCPManager = class _DefaultMCPManager {
     }
     let client = null;
     try {
-      const connection = this.buildMCPConnection(options);
+      const connection = this.buildMCPConnection(renderedOptions);
       const serverName = "test-server";
       client = new import_mcp_adapters.MultiServerMCPClient({
         [serverName]: connection
@@ -279,18 +320,20 @@ ${(error == null ? void 0 : error.stack) || ""}` : (error == null ? void 0 : err
     }
   }
   async persistenceEntry(entry) {
+    const normalizedEntry = (0, import_options_renderer.normalizeMCPOptions)(entry);
     await this.sequelize.transaction(async (transaction) => {
-      const existed = await this.aiMcpClientsModel.findOne({ where: { name: entry.name }, transaction });
+      const existed = await this.aiMcpClientsModel.findOne({ where: { name: normalizedEntry.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
+            transport: normalizedEntry.transport,
+            command: normalizedEntry.command,
+            args: normalizedEntry.args,
+            env: normalizedEntry.env,
+            url: normalizedEntry.url,
+            headers: normalizedEntry.headers,
+            restart: normalizedEntry.restart,
+            useUserContext: normalizedEntry.useUserContext
           },
           { transaction }
         );
@@ -298,20 +341,22 @@ ${(error == null ? void 0 : error.stack) || ""}` : (error == null ? void 0 : err
       }
       await this.aiMcpClientsModel.create(
         {
-          ...entry
+          ...normalizedEntry
         },
         { transaction }
       );
     });
   }
   normalizeEntry(name, options) {
-    return {
+    const entry = {
       name,
       enabled: true,
       ...options,
       args: options.args ?? [],
-      env: options.env ?? {}
+      env: options.env ?? {},
+      useUserContext: options.useUserContext === true
     };
+    return (0, import_options_renderer.normalizeMCPOptions)(entry);
   }
   get aiMcpClientsCollection() {
     return this.collectionManager.getCollection("aiMcpClients");

package/lib/mcp-manager/options-renderer.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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 { Context } from '@nocobase/actions';
+import type { MCPOptions } from './types';
+export declare const normalizeMCPOptions: (options: MCPOptions) => MCPOptions;
+export declare function renderMCPOptions(options: MCPOptions, app: {
+    environment?: {
+        getVariables?: () => Record<string, unknown>;
+    };
+}, ctx?: Context): Promise<MCPOptions>;

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

@@ -0,0 +1,144 @@
+/**
+ * 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 options_renderer_exports = {};
+__export(options_renderer_exports, {
+  normalizeMCPOptions: () => normalizeMCPOptions,
+  renderMCPOptions: () => renderMCPOptions
+});
+module.exports = __toCommonJS(options_renderer_exports);
+var import_utils = require("@nocobase/utils");
+const unsafePathSegments = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+const currentUserVariableRegExp = /{{\s*(?:(ctx)\.)?(currentUser|\$user)(?:\.([^}]+))?\s*}}/g;
+const hasUnsafePathSegment = /* @__PURE__ */ __name((path) => {
+  return path.split(/[.[\]]+/).filter(Boolean).some((segment) => unsafePathSegments.has(segment));
+}, "hasUnsafePathSegment");
+const toPlainObject = /* @__PURE__ */ __name((value) => {
+  if (!value) {
+    return value;
+  }
+  if (typeof value.toJSON === "function") {
+    return value.toJSON();
+  }
+  return value;
+}, "toPlainObject");
+const getCurrentUserReferencePaths = /* @__PURE__ */ __name((value) => {
+  const text = typeof value === "string" ? value : JSON.stringify(value ?? {});
+  return Array.from(text.matchAll(currentUserVariableRegExp)).map((match) => {
+    var _a;
+    return (_a = match[3]) == null ? void 0 : _a.trim();
+  }).filter((path) => !!path && !hasUnsafePathSegment(path));
+}, "getCurrentUserReferencePaths");
+const getCurrentUserAppends = /* @__PURE__ */ __name((paths, currentUser) => {
+  return Array.from(
+    new Set(
+      paths.map((path) => path.split(".")[0]).filter((append) => append && !Reflect.has(currentUser || {}, append))
+    )
+  );
+}, "getCurrentUserAppends");
+async function getCurrentUser(ctx, template) {
+  var _a, _b;
+  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 (!ctx || !currentUser) {
+    return toPlainObject(currentUser);
+  }
+  const appends = getCurrentUserAppends(getCurrentUserReferencePaths(template), currentUser);
+  if (!appends.length) {
+    return toPlainObject(currentUser);
+  }
+  const user = await ctx.db.getRepository("users").findOne({
+    filterByTk: currentUser.id,
+    appends
+  });
+  return toPlainObject(user) || toPlainObject(currentUser);
+}
+__name(getCurrentUser, "getCurrentUser");
+const stringifyRecord = /* @__PURE__ */ __name((value) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+  return Object.entries(value).reduce((result, [key, item]) => {
+    if (!key || item == null) {
+      return result;
+    }
+    result[key] = String(item);
+    return result;
+  }, {});
+}, "stringifyRecord");
+const stringifyArray = /* @__PURE__ */ __name((value) => {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  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,
+    args: stringifyArray(options.args),
+    env: stringifyRecord(options.env),
+    headers: stringifyRecord(options.headers),
+    useUserContext: options.transport === "stdio" ? false : options.useUserContext === true
+  };
+  if (normalized.transport === "stdio") {
+    normalized.url = void 0;
+    normalized.headers = {};
+  }
+  return normalized;
+}, "normalizeMCPOptions");
+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,
+      request
+    }
+  };
+  return normalizeMCPOptions((0, import_utils.parse)(options)(variables));
+}
+__name(renderMCPOptions, "renderMCPOptions");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  normalizeMCPOptions,
+  renderMCPOptions
+});

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

@@ -7,17 +7,19 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import type { MultiServerMCPClient } from '@langchain/mcp-adapters';
+import type { Context } from '@nocobase/actions';
 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>;
+    testConnection(options: MCPOptions, ctx?: Context): Promise<MCPTestResult>;
     rebuildClient(): Promise<void>;
     getClient(): MultiServerMCPClient | null;
     getMCPToolsProvider(): DynamicToolsProvider;
-    listMCPTools(): Promise<Record<string, MCPToolEntry[]>>;
+    listMCPTools(ctx?: Context): Promise<Record<string, MCPToolEntry[]>>;
     updateMCPToolPermission(toolName: string, permission: Permission): Promise<void>;
+    clearUserContextCache(): Promise<void>;
 }
 export interface MCPRegistration {
     registerMCP(registration: {
@@ -32,6 +34,7 @@ export type MCPOptions = {
     url?: string;
     headers?: Record<string, string>;
     restart?: Record<string, any>;
+    useUserContext?: boolean;
 };
 export type MCPEntry = MCPOptions & {
     name: string;
@@ -41,6 +44,7 @@ export type MCPFilter = {
     name?: string;
     enabled?: boolean;
     transport?: MCPTransport;
+    useUserContext?: boolean;
 };
 export type MCPTransport = 'stdio' | 'sse' | 'http';
 export type MCPTestResult = {

package/lib/mcp-manager/user-context-client-manager.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 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 { Context } from '@nocobase/actions';
+import { StdioConnection, StreamableHTTPConnection } from '@langchain/mcp-adapters';
+import { StructuredToolInterface } from '@langchain/core/tools';
+import type { MCPEntry, MCPOptions } from './types';
+type MCPConnection = StdioConnection | StreamableHTTPConnection;
+export type UserContextMCPClientManagerOptions = {
+    app: any;
+    listEntries: () => Promise<MCPEntry[]>;
+    buildConnection: (options: MCPOptions) => MCPConnection;
+    ttlMs?: number;
+    maxSize?: number;
+};
+export declare class UserContextMCPClientManager {
+    private readonly options;
+    private readonly cache;
+    private readonly ttlMs;
+    private readonly maxSize;
+    constructor(options: UserContextMCPClientManagerOptions);
+    getToolsMap(ctx: Context): Promise<Record<string, StructuredToolInterface[]>>;
+    clear(): Promise<void>;
+    private evictExpired;
+    private evictOversized;
+    private closeEntry;
+}
+export {};

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

@@ -0,0 +1,146 @@
+/**
+ * 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 user_context_client_manager_exports = {};
+__export(user_context_client_manager_exports, {
+  UserContextMCPClientManager: () => UserContextMCPClientManager
+});
+module.exports = __toCommonJS(user_context_client_manager_exports);
+var import_mcp_adapters = require("@langchain/mcp-adapters");
+var import_options_renderer = require("./options-renderer");
+const _UserContextMCPClientManager = class _UserContextMCPClientManager {
+  constructor(options) {
+    this.options = options;
+    this.ttlMs = options.ttlMs ?? 5 * 60 * 1e3;
+    this.maxSize = options.maxSize ?? 100;
+  }
+  cache = /* @__PURE__ */ new Map();
+  ttlMs;
+  maxSize;
+  async getToolsMap(ctx) {
+    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 {};
+    }
+    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 {};
+    }
+  }
+  async clear() {
+    const entries = [...this.cache.values()];
+    this.cache.clear();
+    await Promise.all(entries.map((entry) => this.closeEntry(entry)));
+  }
+  evictExpired() {
+    const now = Date.now();
+    for (const [key, entry] of this.cache.entries()) {
+      if (entry.expiresAt <= now) {
+        this.cache.delete(key);
+        this.closeEntry(entry).catch((error) => {
+          var _a, _b, _c;
+          (_c = (_b = (_a = this.options.app) == null ? void 0 : _a.log) == null ? void 0 : _b.warn) == null ? void 0 : _c.call(_b, "fail to close expired user-bound mcp client", error);
+        });
+      }
+    }
+  }
+  async evictOversized() {
+    while (this.cache.size > this.maxSize) {
+      const oldest = [...this.cache.entries()].sort(
+        ([, left], [, right]) => left.lastAccessedAt - right.lastAccessedAt
+      )[0];
+      if (!oldest) {
+        return;
+      }
+      this.cache.delete(oldest[0]);
+      await this.closeEntry(oldest[1]);
+    }
+  }
+  async closeEntry(entry) {
+    var _a, _b, _c;
+    try {
+      await entry.client.close();
+    } catch (error) {
+      (_c = (_b = (_a = this.options.app) == null ? void 0 : _a.log) == null ? void 0 : _b.warn) == null ? void 0 : _c.call(_b, "fail to close user-bound mcp client", error);
+    }
+  }
+};
+__name(_UserContextMCPClientManager, "UserContextMCPClientManager");
+let UserContextMCPClientManager = _UserContextMCPClientManager;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  UserContextMCPClientManager
+});

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

@@ -47,4 +47,5 @@ export type ToolsFilter = {
     defaultPermission?: Permission;
     silence?: boolean;
     sessionId?: string;
+    ctx?: Context;
 };