@nocobase/ai 2.1.0-beta.14 → 2.1.0-beta.16

package/src/mcp-tools-manager.ts

@@ -0,0 +1,90 @@
+/**
+ * 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 { Registry } from '@nocobase/utils';
+
+export type McpTool = {
+  name: string;
+  description: string;
+  inputSchema?: any;
+  resourceName?: string;
+  actionName?: string;
+  path?: string;
+  method?: string;
+  call: (args: Record<string, any>, context?: McpToolCallContext) => Promise<any>;
+};
+
+export type McpToolCallContext = {
+  token?: string;
+  headers?: Record<string, string | string[] | undefined>;
+};
+
+export type McpToolResultPostProcessorContext = {
+  tool: McpTool;
+  args: Record<string, any>;
+  callContext?: McpToolCallContext;
+  response?: {
+    statusCode?: number;
+    headers?: Record<string, any>;
+    body?: any;
+  };
+};
+
+export type McpToolResultPostProcessor = (
+  result: any,
+  context: McpToolResultPostProcessorContext,
+) => any | Promise<any>;
+
+export class McpToolsManager {
+  private tools = new Registry<McpTool>();
+  private resultPostProcessors = new Map<string, McpToolResultPostProcessor[]>();
+
+  private getActionKey(resourceName: string, actionName: string) {
+    return `${resourceName}:${actionName}`;
+  }
+
+  registerTools(tools: McpTool[]) {
+    for (const tool of tools) {
+      this.tools.register(tool.name, tool);
+    }
+  }
+
+  registerToolResultPostProcessor(resourceName: string, actionName: string, processor: McpToolResultPostProcessor) {
+    const key = this.getActionKey(resourceName, actionName);
+    const processors = this.resultPostProcessors.get(key) || [];
+    processors.push(processor);
+    this.resultPostProcessors.set(key, processors);
+  }
+
+  async postProcessToolResult(tool: McpTool, result: any, context: Omit<McpToolResultPostProcessorContext, 'tool'>) {
+    if (!tool.resourceName || !tool.actionName) {
+      return result;
+    }
+
+    const processors = this.resultPostProcessors.get(this.getActionKey(tool.resourceName, tool.actionName)) || [];
+    let current = result;
+
+    for (const processor of processors) {
+      current = await processor(current, {
+        ...context,
+        tool,
+      });
+    }
+
+    return current;
+  }
+
+  listTools() {
+    return [...this.tools.getValues()];
+  }
+
+  getTool(name: string) {
+    return this.tools.get(name);
+  }
+}

package/src/skills-manager/index.ts

@@ -0,0 +1,148 @@
+/**
+ * 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 { Op } from '@nocobase/database';
+import { SkillsEntry, SkillsManager, SkillsOptions, SkillsFilter } from './types';
+import { SequelizeCollectionManager } from '@nocobase/data-source-manager';
+import { Registry } from '@nocobase/utils';
+import _ from 'lodash';
+
+export class DefaultSkillsManager implements SkillsManager {
+  private readonly skills = new Registry<SkillsEntry>();
+  private readonly provideCollectionManager: () => { collectionManager: SequelizeCollectionManager };
+  private mode = 'memory';
+
+  constructor(private readonly app: any) {
+    this.provideCollectionManager = () => app.mainDataSource;
+  }
+
+  async init() {
+    if (this.mode === 'memory') {
+      await this.persistence();
+      this.mode = 'database';
+    }
+  }
+
+  getSkills(name: string[]): Promise<SkillsEntry[]>;
+  getSkills(name: string): Promise<SkillsEntry>;
+  async getSkills(name: string | string[]): Promise<SkillsEntry | SkillsEntry[]> {
+    if (_.isArray(name)) {
+      return (await this.aiSkillsModel.findAll({ where: { name: { [Op.in]: name } } }))
+        .map((it) => it.toJSON())
+        .map(converterSkillsEntry);
+    } else {
+      return converterSkillsEntry((await this.aiSkillsModel.findOne({ where: { name } }))?.toJSON()) as SkillsEntry;
+    }
+  }
+
+  async listSkills(filter: SkillsFilter): Promise<SkillsEntry[]> {
+    const where = {};
+    if (filter?.scope) {
+      where['scope'] = filter.scope;
+    }
+    if (filter?.name) {
+      where['name'] = {
+        [Op.substring]: filter.name,
+      };
+    }
+    return (await this.aiSkillsModel.findAll({ where })).map((it) => it.toJSON()).map(converterSkillsEntry);
+  }
+
+  async registerSkills(options: SkillsOptions): Promise<void> {
+    if (this.mode === 'memory') {
+      return this.registerSkillsInMemory(options);
+    }
+    return this.registerSkillsInDatabase(options);
+  }
+
+  async persistence(): Promise<void> {
+    const skillsList = [...this.skills.getValues()];
+    for (const skill of skillsList) {
+      await this.registerSkillsInDatabase(skill);
+    }
+  }
+
+  private registerSkillsInMemory(options: SkillsOptions): void {
+    const skillsEntry: SkillsEntry = { ...options };
+    this.skills.register(options.name, skillsEntry);
+  }
+
+  async registerSkillsInDatabase(options: SkillsOptions): Promise<void> {
+    const title = options.introduction?.title;
+    const about = options.introduction?.about;
+    const from = options.from || 'loader';
+
+    await this.sequelize.transaction(async (transaction) => {
+      const existed = await this.aiSkillsModel.findOne({ where: { name: options.name }, transaction });
+      if (existed) {
+        await this.aiSkillsModel.update(
+          {
+            scope: options.scope,
+            description: options.description,
+            content: options.content,
+            tools: options.tools,
+            title,
+            about,
+            from,
+          },
+          {
+            where: { name: options.name },
+            transaction,
+          },
+        );
+      } else {
+        await this.aiSkillsModel.create(
+          {
+            name: options.name,
+            scope: options.scope,
+            description: options.description,
+            content: options.content,
+            tools: options.tools,
+            title,
+            about,
+            from,
+          },
+          {
+            transaction,
+          },
+        );
+      }
+    });
+  }
+
+  private get aiSkillsCollection() {
+    return this.collectionManager.getCollection('aiSkills');
+  }
+
+  private get aiSkillsModel() {
+    return this.aiSkillsCollection?.model;
+  }
+
+  private get sequelize() {
+    return this.collectionManager.db.sequelize;
+  }
+
+  private get collectionManager() {
+    return this.provideCollectionManager().collectionManager;
+  }
+}
+
+const converterSkillsEntry = (model: any): SkillsEntry => {
+  return {
+    ...(model ?? {}),
+    introduction: model?.title
+      ? {
+          title: model.title,
+          about: model?.about,
+        }
+      : undefined,
+  };
+};
+
+export * from './types';

package/src/skills-manager/types.ts

@@ -0,0 +1,38 @@
+/**
+ * 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 interface SkillsManager {
+  init(): Promise<void>;
+  getSkills(name: string[]): Promise<SkillsEntry[]>;
+  getSkills(name: string): Promise<SkillsEntry>;
+  listSkills(filter?: SkillsFilter): Promise<SkillsEntry[]>;
+  registerSkills(options: SkillsOptions): Promise<void>;
+}
+
+export type SkillsOptions = {
+  scope: SkillsScope;
+  name: string;
+  description: string;
+  content: string;
+  tools?: string[];
+  introduction?: {
+    title: string;
+    about?: string;
+  };
+  from?: string;
+};
+
+export type SkillsEntry = SkillsOptions;
+
+export type SkillsFilter = {
+  scope?: SkillsScope;
+  name?: string;
+};
+
+export type SkillsScope = 'SPECIFIED' | 'GENERAL' | 'CUSTOM';

package/src/tools-manager/index.ts

@@ -17,17 +17,17 @@ export class DefaultToolsManager implements ToolsManager {
     private readonly dynamicTools: DynamicToolsProvider[] = [],
   ) {}
 
-  async getTools(toolName: string): Promise<ToolsEntry> {
+  async getTools(toolName: string, filter?: ToolsFilter): Promise<ToolsEntry> {
     const target = this.tools.get(toolName);
     if (target) {
       return target;
     }
-    const dynamicTools = await this.syncDynamicTools();
+    const dynamicTools = await this.syncDynamicTools(filter);
     return dynamicTools.find((x) => x.definition.name === toolName);
   }
 
   async listTools(filter?: ToolsFilter): Promise<ToolsEntry[]> {
-    const toolsList = await this.getToolsList();
+    const toolsList = await this.getToolsList(filter);
     return toolsList.filter((x) => {
       if (!filter) {
         return true;
@@ -50,10 +50,21 @@ export class DefaultToolsManager implements ToolsManager {
     });
   }
 
+  isToolsExisted(toolName: string): boolean {
+    const target = this.tools.get(toolName);
+    if (target) {
+      return true;
+    }
+    return false;
+  }
+
   registerTools(options: ToolsOptions | ToolsOptions[]): void {
     const list = _.isArray(options) ? options : [options];
     for (const item of list) {
       const toolsEntry = { ...item } as ToolsEntry;
+      if (!toolsEntry.from) {
+        toolsEntry.from = 'loader';
+      }
       if (!toolsEntry.execution) {
         toolsEntry.execution = 'backend';
       }
@@ -74,18 +85,18 @@ export class DefaultToolsManager implements ToolsManager {
     this.dynamicTools.push(provider);
   }
 
-  private async getToolsList(): Promise<ToolsEntry[]> {
-    const dynamicTools = await this.syncDynamicTools();
+  private async getToolsList(filter?: ToolsFilter): Promise<ToolsEntry[]> {
+    const dynamicTools = await this.syncDynamicTools(filter);
     return [...this.tools.getValues(), ...dynamicTools];
   }
 
-  private async syncDynamicTools(): Promise<ToolsEntry[]> {
+  private async syncDynamicTools(filter?: ToolsFilter): Promise<ToolsEntry[]> {
     if (this.dynamicTools.length === 0) {
       return [];
     }
     const registry = new Registry<ToolsEntry>();
     const ephemeral = new DefaultToolsManager(registry);
-    await Promise.all(this.dynamicTools.map((register) => register(ephemeral)));
+    await Promise.all(this.dynamicTools.map((register) => register(ephemeral, filter)));
     return [...registry.getValues()];
   }
 }

package/src/tools-manager/types.ts

@@ -10,17 +10,19 @@
 import type { Context } from '@nocobase/actions';
 
 export interface ToolsManager extends ToolsRegistration {
-  getTools(toolName: string): Promise<ToolsEntry>;
+  getTools(toolName: string, filter?: ToolsFilter): Promise<ToolsEntry>;
   listTools(filter?: ToolsFilter): Promise<ToolsEntry[]>;
+  isToolsExisted(toolName: string): boolean;
 }
 
 export interface ToolsRegistration {
   registerTools(options: ToolsOptions | ToolsOptions[]): void;
-  registerDynamicTools(provider: (register: ToolsRegistration) => Promise<void>): void;
+  registerDynamicTools(provider: DynamicToolsProvider): void;
 }
 
 export type ToolsOptions = {
   scope: Scope;
+  from?: From;
   execution?: 'frontend' | 'backend';
   defaultPermission?: Permission;
   silence?: boolean;
@@ -33,18 +35,25 @@ export type ToolsOptions = {
     description: string;
     schema?: any;
   };
-  invoke: (ctx: Context, args: any, id: string) => Promise<any>;
+  invoke: (ctx: Context, args: any, runtime: ToolsRuntime) => Promise<any>;
+};
+
+export type ToolsRuntime = {
+  toolCallId: string;
+  writer: (chunk: any) => void;
 };
 
 export type ToolsEntry = ToolsOptions;
 
 export type Scope = 'SPECIFIED' | 'GENERAL' | 'CUSTOM';
 export type Permission = 'ASK' | 'ALLOW';
+export type From = 'loader' | 'workflow' | 'mcp';
 
-export type DynamicToolsProvider = (register: ToolsRegistration) => Promise<void>;
+export type DynamicToolsProvider = (register: ToolsRegistration, filter?: ToolsFilter) => Promise<void>;
 
 export type ToolsFilter = {
   scope?: Scope;
   defaultPermission?: Permission;
   silence?: boolean;
+  sessionId?: string;
 };