@nocobase/ai 2.1.0-beta.2 → 2.1.0-beta.21

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