@nocobase/ai 2.2.0-alpha.1 → 2.2.0-alpha.10

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

package/package.json

@@ -1,31 +1,31 @@
 {
   "name": "@nocobase/ai",
-  "version": "2.2.0-alpha.1",
+  "version": "2.2.0-alpha.10",
   "description": "",
   "license": "Apache-2.0",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "dependencies": {
-    "@langchain/anthropic": "^1.3.17",
-    "@langchain/classic": "^1.0.21",
-    "@langchain/community": "~1.1.18",
-    "@langchain/core": "~1.1.27",
-    "@langchain/deepseek": "^1.0.11",
-    "@langchain/google-genai": "^2.1.18",
-    "@langchain/langgraph": "~1.1.4",
-    "@langchain/langgraph-checkpoint": "^1.0.0",
-    "@langchain/mcp-adapters": "^1.1.3",
-    "@langchain/ollama": "~1.2.7",
-    "@langchain/openai": "^1.2.7",
-    "@nocobase/data-source-manager": "2.2.0-alpha.1",
-    "@nocobase/logger": "2.2.0-alpha.1",
-    "@nocobase/resourcer": "2.2.0-alpha.1",
-    "@nocobase/utils": "2.2.0-alpha.1",
+    "@langchain/anthropic": "1.3.17",
+    "@langchain/classic": "1.0.34",
+    "@langchain/community": "1.1.29",
+    "@langchain/core": "1.1.49",
+    "@langchain/deepseek": "1.0.27",
+    "@langchain/google-genai": "2.1.18",
+    "@langchain/langgraph": "1.4.4",
+    "@langchain/langgraph-checkpoint": "1.1.2",
+    "@langchain/mcp-adapters": "1.1.3",
+    "@langchain/ollama": "1.2.7",
+    "@langchain/openai": "1.4.7",
+    "@nocobase/data-source-manager": "2.2.0-alpha.10",
+    "@nocobase/logger": "2.2.0-alpha.10",
+    "@nocobase/resourcer": "2.2.0-alpha.10",
+    "@nocobase/utils": "2.2.0-alpha.10",
     "d3-dsv": "2",
     "fast-glob": "^3.3.2",
     "flexsearch": "^0.8.2",
     "gray-matter": "^4.0.3",
-    "langchain": "~1.2.24",
+    "langchain": "1.2.39",
     "mammoth": "^1.10.0",
     "officeparser": "^5.2.0",
     "pdf-parse": "^1.1.1",
@@ -37,5 +37,5 @@
     "url": "git+https://github.com/nocobase/nocobase.git",
     "directory": "packages/ai"
   },
-  "gitHead": "303663aba6c6eefa27e6a6435b4c0352074ec40f"
+  "gitHead": "b5a3f131bb0a4a2fbfd96852896bccadc933d834"
 }

package/src/__tests__/document-loader.test.ts

@@ -0,0 +1,63 @@
+/**
+ * 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 { loadByWorker } from '../document-loader';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import * as XLSX from 'xlsx';
+
+describe('Document loader worker', () => {
+  const tempDirs: string[] = [];
+
+  const createTempFile = async (filename: string, content: string | Buffer) => {
+    const tempDir = await mkdtemp(path.join(os.tmpdir(), 'nocobase-document-loader-test-'));
+    tempDirs.push(tempDir);
+    const filePath = path.join(tempDir, filename);
+    await writeFile(filePath, content);
+    return filePath;
+  };
+
+  afterEach(async () => {
+    await Promise.all(tempDirs.splice(0).map((tempDir) => rm(tempDir, { recursive: true, force: true })));
+  });
+
+  it('loads text files by path', async () => {
+    const filePath = await createTempFile('source.txt', 'hello knowledge base\nsecond line\n');
+
+    const documents = await loadByWorker('.txt', {
+      filePath,
+      mimeType: 'text/plain',
+    });
+
+    expect(documents).toHaveLength(1);
+    expect(documents[0].pageContent).toBe('hello knowledge base\nsecond line\n');
+    expect(documents[0].metadata.source).toBe(filePath);
+  });
+
+  it('loads xlsx files by path', async () => {
+    const worksheet = XLSX.utils.aoa_to_sheet([
+      ['name', 'value'],
+      ['alpha', 1],
+    ]);
+    const workbook = XLSX.utils.book_new();
+    XLSX.utils.book_append_sheet(workbook, worksheet, 'Sheet1');
+    const buffer = XLSX.write(workbook, { type: 'buffer', bookType: 'xlsx' });
+    const filePath = await createTempFile('source.xlsx', buffer);
+
+    const documents = await loadByWorker('.xlsx', {
+      filePath,
+      mimeType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    });
+
+    expect(documents).toHaveLength(1);
+    expect(documents[0].pageContent).toBe('Sheet: Sheet1\nname\tvalue\nalpha\t1');
+    expect(documents[0].metadata.source).toBe(filePath);
+  });
+});

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

@@ -0,0 +1,339 @@
+/**
+ * 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.
+ */
+
+const mcpClientMock = vi.hoisted(() => {
+  const instances: any[] = [];
+
+  class MultiServerMCPClient {
+    connections: Record<string, any>;
+    close = vi.fn();
+
+    constructor(connections: Record<string, any>) {
+      this.connections = connections;
+      instances.push(this);
+    }
+
+    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,
+          [
+            {
+              name: 'getProfile',
+              description: `Get profile from ${serverName}`,
+              schema: {},
+              invoke: vi.fn(async (args) => ({ serverName, args })),
+            },
+          ],
+        ]),
+      );
+    }
+  }
+
+  return {
+    instances,
+    MultiServerMCPClient,
+  };
+});
+
+vi.mock('@langchain/mcp-adapters', () => ({
+  MultiServerMCPClient: mcpClientMock.MultiServerMCPClient,
+}));
+
+import { DefaultMCPManager } from '../mcp-manager';
+import { normalizeMCPOptions, renderMCPOptions } from '../mcp-manager/options-renderer';
+import { UserContextMCPClientManager } from '../mcp-manager/user-context-client-manager';
+
+describe('user-bound MCP clients', () => {
+  const createApp = () => ({
+    environment: {
+      getVariables: () => ({
+        MCP_HOST: 'mcp.example.test',
+        API_TOKEN: 'env-token',
+      }),
+    },
+    log: {
+      warn: vi.fn(),
+    },
+  });
+
+  const createCtx = (id: number, extraUser: Record<string, unknown> = {}) =>
+    ({
+      state: {
+        currentUser: {
+          id,
+          name: `user-${id}`,
+          ...extraUser,
+        },
+      },
+      auth: {
+        user: {
+          id,
+          name: `user-${id}`,
+          ...extraUser,
+        },
+      },
+      db: {
+        getRepository: () => ({
+          findOne: vi.fn(),
+        }),
+      },
+      request: {
+        headers: {
+          authorization: 'Bearer request-token',
+          'x-role': 'admin',
+        },
+      },
+      getBearerToken: () => 'request-token',
+    }) as any;
+
+  beforeEach(() => {
+    mcpClientMock.instances.length = 0;
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('normalizes stdio records as not user-bound', () => {
+    expect(
+      normalizeMCPOptions({
+        transport: 'stdio',
+        command: 'node',
+        args: ['server.js'],
+        env: { TOKEN: '{{ $env.API_TOKEN }}' },
+        useUserContext: true,
+      }),
+    ).toMatchObject({
+      transport: 'stdio',
+      command: 'node',
+      args: ['server.js'],
+      env: { TOKEN: '{{ $env.API_TOKEN }}' },
+      useUserContext: false,
+      headers: {},
+    });
+  });
+
+  it('renders environment and current user variables in MCP options', async () => {
+    const rendered = await renderMCPOptions(
+      {
+        transport: 'http',
+        url: 'https://{{ $env.MCP_HOST }}/users/{{ currentUser.id }}',
+        headers: {
+          Authorization: 'Bearer {{ $env.API_TOKEN }}',
+          'X-User': '{{ $user.name }}',
+        },
+        useUserContext: true,
+      },
+      createApp(),
+      createCtx(7),
+    );
+
+    expect(rendered).toMatchObject({
+      transport: 'http',
+      url: 'https://mcp.example.test/users/7',
+      headers: {
+        Authorization: 'Bearer env-token',
+        'X-User': 'user-7',
+      },
+      useUserContext: true,
+    });
+  });
+
+  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([]);
+
+    await manager.rebuildClient();
+
+    expect(manager.listMCP).toHaveBeenCalledWith({ enabled: true, useUserContext: false });
+    expect(mcpClientMock.instances).toHaveLength(0);
+  });
+
+  it('registers user-bound tools from filter ctx', async () => {
+    const manager = new DefaultMCPManager(createApp() as any) as any;
+    manager.listMCP = vi.fn().mockResolvedValue([
+      {
+        name: 'profile',
+        enabled: true,
+        transport: 'http',
+        url: 'https://{{ $env.MCP_HOST }}/{{ currentUser.id }}',
+        headers: {},
+        useUserContext: true,
+      },
+    ]);
+    const registered: any[] = [];
+
+    await manager.getMCPToolsProvider()(
+      {
+        registerTools: (tool) => registered.push(tool),
+        registerDynamicTools: vi.fn(),
+      },
+      { ctx: createCtx(9) },
+    );
+
+    expect(registered).toHaveLength(1);
+    expect(registered[0].definition.name).toBe('mcp-profile-getProfile');
+    expect(mcpClientMock.instances[0].connections.profile.url).toBe('https://mcp.example.test/9');
+  });
+
+  it('lists user-bound tools from ctx', async () => {
+    const manager = new DefaultMCPManager(createApp() as any) as any;
+    manager.listMCP = vi.fn().mockResolvedValue([
+      {
+        name: 'profile',
+        enabled: true,
+        transport: 'http',
+        url: 'https://{{ $env.MCP_HOST }}/{{ currentUser.id }}',
+        headers: {},
+        useUserContext: true,
+      },
+    ]);
+
+    const tools = await manager.listMCPTools(createCtx(11));
+
+    expect(tools.profile).toEqual([
+      {
+        name: 'mcp-profile-getProfile',
+        title: 'getProfile',
+        description: 'Get profile from profile',
+        serverName: 'profile',
+        permission: 'ALLOW',
+      },
+    ]);
+    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);
+
+    const manager = new UserContextMCPClientManager({
+      app: createApp(),
+      ttlMs: 10,
+      maxSize: 10,
+      listEntries: async () => [
+        {
+          name: 'profile',
+          enabled: true,
+          transport: 'http',
+          url: 'https://{{ $env.MCP_HOST }}/{{ currentUser.id }}',
+          headers: {},
+          useUserContext: true,
+        },
+      ],
+      buildConnection: (options) => options as any,
+    });
+
+    await manager.getToolsMap(createCtx(1));
+    await manager.getToolsMap(createCtx(1));
+    expect(mcpClientMock.instances).toHaveLength(1);
+
+    vi.setSystemTime(11);
+    await manager.getToolsMap(createCtx(1));
+
+    expect(mcpClientMock.instances).toHaveLength(2);
+    expect(mcpClientMock.instances[0].close).toHaveBeenCalledTimes(1);
+  });
+
+  it('evicts the oldest user-bound cache entry when max size is exceeded', async () => {
+    const manager = new UserContextMCPClientManager({
+      app: createApp(),
+      ttlMs: 1000,
+      maxSize: 1,
+      listEntries: async () => [
+        {
+          name: 'profile',
+          enabled: true,
+          transport: 'http',
+          url: 'https://{{ $env.MCP_HOST }}/{{ currentUser.id }}',
+          headers: {},
+          useUserContext: true,
+        },
+      ],
+      buildConnection: (options) => options as any,
+    });
+
+    await manager.getToolsMap(createCtx(1));
+    await manager.getToolsMap(createCtx(2));
+
+    expect(mcpClientMock.instances).toHaveLength(2);
+    expect(mcpClientMock.instances[0].close).toHaveBeenCalledTimes(1);
+
+    await manager.clear();
+    expect(mcpClientMock.instances[1].close).toHaveBeenCalledTimes(1);
+  });
+});

package/src/__tests__/mcp.test.ts

@@ -85,7 +85,7 @@ describe('MCP loader test cases', () => {
         title: 'getForecast',
         description: 'Get weather forecast',
         serverName: 'weather',
-        permission: 'ASK',
+        permission: 'ALLOW',
       },
       {
         name: 'mcp-weather-setDefaultCity',