@lobehub/lobehub 2.0.0-next.311 → 2.0.0-next.313

package/packages/agent-runtime/src/agents/__tests__/GeneralChatAgent.test.ts

@@ -911,7 +911,12 @@ describe('GeneralChatAgent', () => {
 
       const context = createMockContext('task_result', {
         parentMessageId: 'task-parent-msg',
-        result: { success: true, taskMessageId: 'task-1', threadId: 'thread-1', result: 'Task result' },
+        result: {
+          success: true,
+          taskMessageId: 'task-1',
+          threadId: 'thread-1',
+          result: 'Task result',
+        },
       });
 
       const result = await agent.runner(context, state);
@@ -1519,4 +1524,273 @@ describe('GeneralChatAgent', () => {
       ]);
     });
   });
+
+  describe('headless mode (for async tasks)', () => {
+    it('should execute all tools directly in headless mode including those requiring approval', async () => {
+      const agent = new GeneralChatAgent({
+        agentConfig: { maxSteps: 100 },
+        operationId: 'test-session',
+        modelRuntimeConfig: mockModelRuntimeConfig,
+      });
+
+      const toolCall: ChatToolPayload = {
+        id: 'call-1',
+        identifier: 'dangerous-tool',
+        apiName: 'delete',
+        arguments: '{}',
+        type: 'default',
+      };
+
+      const state = createMockState({
+        toolManifestMap: {
+          'dangerous-tool': {
+            identifier: 'dangerous-tool',
+            humanIntervention: 'required', // Tool requires approval
+          },
+        },
+        userInterventionConfig: {
+          approvalMode: 'headless', // Headless mode for async tasks
+        },
+      });
+
+      const context = createMockContext('llm_result', {
+        hasToolsCalling: true,
+        toolsCalling: [toolCall],
+        parentMessageId: 'msg-1',
+      });
+
+      const result = await agent.runner(context, state);
+
+      // Should execute directly in headless mode
+      expect(result).toEqual([
+        {
+          type: 'call_tool',
+          payload: {
+            parentMessageId: 'msg-1',
+            toolCalling: toolCall,
+          },
+        },
+      ]);
+    });
+
+    it('should execute tools with "always" policy in headless mode', async () => {
+      const agent = new GeneralChatAgent({
+        agentConfig: { maxSteps: 100 },
+        operationId: 'test-session',
+        modelRuntimeConfig: mockModelRuntimeConfig,
+      });
+
+      const alwaysTool: ChatToolPayload = {
+        id: 'call-1',
+        identifier: 'agent-builder',
+        apiName: 'installPlugin',
+        arguments: '{"identifier":"some-plugin","source":"market"}',
+        type: 'builtin',
+      };
+
+      const state = createMockState({
+        toolManifestMap: {
+          'agent-builder': {
+            identifier: 'agent-builder',
+            api: [
+              {
+                name: 'installPlugin',
+                humanIntervention: 'always', // Always requires intervention normally
+              },
+            ],
+          },
+        },
+        userInterventionConfig: {
+          approvalMode: 'headless', // Headless mode bypasses even 'always'
+        },
+      });
+
+      const context = createMockContext('llm_result', {
+        hasToolsCalling: true,
+        toolsCalling: [alwaysTool],
+        parentMessageId: 'msg-1',
+      });
+
+      const result = await agent.runner(context, state);
+
+      // Should execute directly in headless mode, even for 'always' policy
+      expect(result).toEqual([
+        {
+          type: 'call_tool',
+          payload: {
+            parentMessageId: 'msg-1',
+            toolCalling: alwaysTool,
+          },
+        },
+      ]);
+    });
+
+    it('should skip security blacklisted tools in headless mode', async () => {
+      const agent = new GeneralChatAgent({
+        agentConfig: { maxSteps: 100 },
+        operationId: 'test-session',
+        modelRuntimeConfig: mockModelRuntimeConfig,
+      });
+
+      const blacklistedTool: ChatToolPayload = {
+        id: 'call-1',
+        identifier: 'bash',
+        apiName: 'bash',
+        arguments: '{"command":"rm -rf /"}', // Matches security blacklist
+        type: 'builtin',
+      };
+
+      const state = createMockState({
+        toolManifestMap: {
+          bash: {
+            identifier: 'bash',
+            humanIntervention: 'never',
+          },
+        },
+        userInterventionConfig: {
+          approvalMode: 'headless',
+        },
+        // Using default security blacklist which blocks "rm -rf /"
+      });
+
+      const context = createMockContext('llm_result', {
+        hasToolsCalling: true,
+        toolsCalling: [blacklistedTool],
+        parentMessageId: 'msg-1',
+      });
+
+      const result = await agent.runner(context, state);
+
+      // Should return empty array (tool is skipped, not executed or pending)
+      expect(result).toEqual([]);
+    });
+
+    it('should handle mixed tools in headless mode - execute safe ones, skip blacklisted', async () => {
+      const agent = new GeneralChatAgent({
+        agentConfig: { maxSteps: 100 },
+        operationId: 'test-session',
+        modelRuntimeConfig: mockModelRuntimeConfig,
+      });
+
+      const safeTool: ChatToolPayload = {
+        id: 'call-1',
+        identifier: 'web-search',
+        apiName: 'search',
+        arguments: '{"query":"hello"}',
+        type: 'default',
+      };
+
+      const blacklistedTool: ChatToolPayload = {
+        id: 'call-2',
+        identifier: 'bash',
+        apiName: 'bash',
+        arguments: '{"command":"rm -rf /"}', // Matches security blacklist
+        type: 'builtin',
+      };
+
+      const alwaysTool: ChatToolPayload = {
+        id: 'call-3',
+        identifier: 'agent-builder',
+        apiName: 'installPlugin',
+        arguments: '{}',
+        type: 'builtin',
+      };
+
+      const state = createMockState({
+        toolManifestMap: {
+          'web-search': {
+            identifier: 'web-search',
+            humanIntervention: 'required',
+          },
+          'bash': {
+            identifier: 'bash',
+          },
+          'agent-builder': {
+            identifier: 'agent-builder',
+            api: [
+              {
+                name: 'installPlugin',
+                humanIntervention: 'always',
+              },
+            ],
+          },
+        },
+        userInterventionConfig: {
+          approvalMode: 'headless',
+        },
+      });
+
+      const context = createMockContext('llm_result', {
+        hasToolsCalling: true,
+        toolsCalling: [safeTool, blacklistedTool, alwaysTool],
+        parentMessageId: 'msg-1',
+      });
+
+      const result = await agent.runner(context, state);
+
+      // Should execute safeTool and alwaysTool, skip blacklistedTool
+      expect(result).toEqual([
+        {
+          type: 'call_tools_batch',
+          payload: {
+            parentMessageId: 'msg-1',
+            toolsCalling: [safeTool, alwaysTool],
+          },
+        },
+      ]);
+    });
+
+    it('should execute multiple tools as batch in headless mode', async () => {
+      const agent = new GeneralChatAgent({
+        agentConfig: { maxSteps: 100 },
+        operationId: 'test-session',
+        modelRuntimeConfig: mockModelRuntimeConfig,
+      });
+
+      const tool1: ChatToolPayload = {
+        id: 'call-1',
+        identifier: 'search',
+        apiName: 'search',
+        arguments: '{}',
+        type: 'default',
+      };
+
+      const tool2: ChatToolPayload = {
+        id: 'call-2',
+        identifier: 'crawl',
+        apiName: 'crawl',
+        arguments: '{}',
+        type: 'default',
+      };
+
+      const state = createMockState({
+        toolManifestMap: {
+          search: { identifier: 'search', humanIntervention: 'required' },
+          crawl: { identifier: 'crawl', humanIntervention: 'always' },
+        },
+        userInterventionConfig: {
+          approvalMode: 'headless',
+        },
+      });
+
+      const context = createMockContext('llm_result', {
+        hasToolsCalling: true,
+        toolsCalling: [tool1, tool2],
+        parentMessageId: 'msg-1',
+      });
+
+      const result = await agent.runner(context, state);
+
+      // Should execute both tools as batch in headless mode
+      expect(result).toEqual([
+        {
+          type: 'call_tools_batch',
+          payload: {
+            parentMessageId: 'msg-1',
+            toolsCalling: [tool1, tool2],
+          },
+        },
+      ]);
+    });
+  });
 });

package/packages/builtin-tool-agent-builder/src/systemRole.ts

@@ -86,6 +86,7 @@ Always adapt to user's language. Use natural descriptions, not raw field names.
 5. **Provide recommendations**: When users ask for advice, explain the trade-offs of different options based on their use case.
 6. **Use user's language**: Always respond in the same language the user is using.
 7. **Keep it simple**: Focus on core settings. Don't overwhelm users with advanced options unless they ask.
+8. **Install plugins one by one**: When multiple plugins need to be installed, install them sequentially one at a time instead of batching. This ensures better error handling, allows users to understand each plugin's purpose, and makes it easier to troubleshoot if something goes wrong.
 </guidelines>
 
 <configuration_knowledge>
@@ -202,6 +203,14 @@ Action: Use updateConfig with { config: { params: { temperature: 0.7 } } }
 
 User: "我想调整对话配置" / "I want to configure chat settings"
 Action: Explain the available chatConfig options and help them configure as needed.
+
+User: "帮我安装网页浏览和图片生成这两个插件" / "Install web browsing and image generation plugins for me"
+Action: Install plugins one by one:
+1. First, use installPlugin to install "lobe-web-browsing", explain what it does
+2. Wait for confirmation of success
+3. Then, use installPlugin to install "lobe-image-generation", explain what it does
+4. Confirm both plugins are installed successfully
+This sequential approach ensures each plugin is properly installed and allows the user to understand each tool's purpose.
 </examples>
 
 <response_format>

package/packages/builtin-tool-cloud-sandbox/package.json

@@ -5,6 +5,7 @@
   "exports": {
     ".": "./src/index.ts",
     "./client": "./src/client/index.ts",
+    "./executor": "./src/executor/index.ts",
     "./executionRuntime": "./src/ExecutionRuntime/index.ts"
   },
   "main": "./src/index.ts",

package/packages/builtin-tool-cloud-sandbox/src/ExecutionRuntime/index.ts

@@ -1,125 +1,62 @@
+import {
+  formatEditResult,
+  formatFileContent,
+  formatFileList,
+  formatFileSearchResults,
+  formatGlobResults,
+  formatMoveResults,
+  formatRenameResult,
+  formatWriteResult,
+} from '@lobechat/prompts';
 import { type BuiltinServerRuntimeOutput } from '@lobechat/types';
 
-import { codeInterpreterService } from '@/services/codeInterpreter';
-
 import {
+  type EditLocalFileParams,
   type EditLocalFileState,
+  type ExecuteCodeParams,
   type ExecuteCodeState,
+  type ExportFileParams,
   type ExportFileState,
+  type GetCommandOutputParams,
   type GetCommandOutputState,
   type GlobFilesState,
+  type GlobLocalFilesParams,
+  type GrepContentParams,
   type GrepContentState,
+  type ISandboxService,
+  type KillCommandParams,
   type KillCommandState,
+  type ListLocalFilesParams,
   type ListLocalFilesState,
+  type MoveLocalFilesParams,
   type MoveLocalFilesState,
+  type ReadLocalFileParams,
   type ReadLocalFileState,
+  type RenameLocalFileParams,
   type RenameLocalFileState,
+  type RunCommandParams,
   type RunCommandState,
+  type SearchLocalFilesParams,
   type SearchLocalFilesState,
+  type WriteLocalFileParams,
   type WriteLocalFileState,
 } from '../types';
 
 /**
  * Cloud Sandbox Execution Runtime
  *
- * This runtime executes tools via the LobeHub Market SDK's runBuildInTool API,
- * which connects to AWS Bedrock AgentCore sandbox.
+ * This runtime executes tools via the injected ISandboxService.
+ * The service handles context (topicId, userId) internally - Runtime doesn't need to know about it.
  *
- * Session Management:
- * - Sessions are automatically created per userId + topicId combination
- * - Sessions are recreated automatically if expired
- * - The sessionExpiredAndRecreated flag indicates if recreation occurred
+ * Dependency Injection:
+ * - Client: Inject codeInterpreterService (uses tRPC client)
+ * - Server: Inject ServerSandboxService (uses MarketSDK directly)
  */
-
-interface ExecutionContext {
-  topicId: string;
-  userId: string;
-}
-
-// Types for tool parameters matching market-sdk
-interface ListLocalFilesParams {
-  directoryPath: string;
-}
-
-interface ReadLocalFileParams {
-  endLine?: number;
-  path: string;
-  startLine?: number;
-}
-
-interface WriteLocalFileParams {
-  content: string;
-  createDirectories?: boolean;
-  path: string;
-}
-
-interface EditLocalFileParams {
-  all?: boolean;
-  path: string;
-  replace: string;
-  search: string;
-}
-
-interface SearchLocalFilesParams {
-  directory: string;
-  fileType?: string;
-  keyword?: string;
-  modifiedAfter?: string;
-  modifiedBefore?: string;
-}
-
-interface MoveLocalFilesParams {
-  operations: Array<{
-    destination: string;
-    source: string;
-  }>;
-}
-
-interface RenameLocalFileParams {
-  newName: string;
-  oldPath: string;
-}
-
-interface RunCommandParams {
-  background?: boolean;
-  command: string;
-  timeout?: number;
-}
-
-interface GetCommandOutputParams {
-  commandId: string;
-}
-
-interface KillCommandParams {
-  commandId: string;
-}
-
-interface GrepContentParams {
-  directory: string;
-  filePattern?: string;
-  pattern: string;
-  recursive?: boolean;
-}
-
-interface GlobLocalFilesParams {
-  directory?: string;
-  pattern: string;
-}
-
-interface ExportFileParams {
-  path: string;
-}
-
-interface ExecuteCodeParams {
-  code: string;
-  language?: 'javascript' | 'python' | 'typescript';
-}
-
 export class CloudSandboxExecutionRuntime {
-  private context: ExecutionContext;
+  private sandboxService: ISandboxService;
 
-  constructor(context: ExecutionContext) {
-    this.context = context;
+  constructor(sandboxService: ISandboxService) {
+    this.sandboxService = sandboxService;
   }
 
   // ==================== File Operations ====================
@@ -128,12 +65,19 @@ export class CloudSandboxExecutionRuntime {
     try {
       const result = await this.callTool('listLocalFiles', args);
 
-      const state: ListLocalFilesState = {
-        files: result.result?.files || [],
-      };
+      const files = result.result?.files || [];
+      const state: ListLocalFilesState = { files };
+
+      const content = formatFileList(
+        files.map((f: { isDirectory: boolean; name: string }) => ({
+          isDirectory: f.isDirectory,
+          name: f.name,
+        })),
+        args.directoryPath,
+      );
 
       return {
-        content: JSON.stringify(result.result),
+        content,
         state,
         success: true,
       };
@@ -154,8 +98,19 @@ export class CloudSandboxExecutionRuntime {
         totalLines: result.result?.totalLines,
       };
 
+      const lineRange: [number, number] | undefined =
+        args.startLine !== undefined && args.endLine !== undefined
+          ? [args.startLine, args.endLine]
+          : undefined;
+
+      const content = formatFileContent({
+        content: result.result?.content || '',
+        lineRange,
+        path: args.path,
+      });
+
       return {
-        content: JSON.stringify(result.result),
+        content,
         state,
         success: true,
       };
@@ -174,11 +129,13 @@ export class CloudSandboxExecutionRuntime {
         success: result.success,
       };
 
+      const content = formatWriteResult({
+        path: args.path,
+        success: true,
+      });
+
       return {
-        content: JSON.stringify({
-          message: `Successfully wrote to ${args.path}`,
-          success: true,
-        }),
+        content,
         state,
         success: true,
       };
@@ -199,13 +156,15 @@ export class CloudSandboxExecutionRuntime {
         replacements: result.result?.replacements || 0,
       };
 
-      const statsText =
-        state.linesAdded || state.linesDeleted
-          ? ` (+${state.linesAdded || 0} -${state.linesDeleted || 0})`
-          : '';
+      const content = formatEditResult({
+        filePath: args.path,
+        linesAdded: state.linesAdded,
+        linesDeleted: state.linesDeleted,
+        replacements: state.replacements,
+      });
 
       return {
-        content: `Successfully replaced ${state.replacements} occurrence(s) in ${args.path}${statsText}`,
+        content,
         state,
         success: true,
       };
@@ -218,13 +177,18 @@ export class CloudSandboxExecutionRuntime {
     try {
       const result = await this.callTool('searchLocalFiles', args);
 
+      const results = result.result?.results || [];
       const state: SearchLocalFilesState = {
-        results: result.result?.results || [],
+        results,
         totalCount: result.result?.totalCount || 0,
       };
 
+      const content = formatFileSearchResults(
+        results.map((r: { path: string }) => ({ path: r.path })),
+      );
+
       return {
-        content: JSON.stringify(result.result),
+        content,
         state,
         success: true,
       };
@@ -237,17 +201,17 @@ export class CloudSandboxExecutionRuntime {
     try {
       const result = await this.callTool('moveLocalFiles', args);
 
+      const results = result.result?.results || [];
       const state: MoveLocalFilesState = {
-        results: result.result?.results || [],
+        results,
         successCount: result.result?.successCount || 0,
         totalCount: args.operations.length,
       };
 
+      const content = formatMoveResults(results);
+
       return {
-        content: JSON.stringify({
-          message: `Moved ${state.successCount}/${state.totalCount} items`,
-          results: state.results,
-        }),
+        content,
         state,
         success: true,
       };
@@ -267,11 +231,15 @@ export class CloudSandboxExecutionRuntime {
         success: result.success,
       };
 
+      const content = formatRenameResult({
+        error: result.result?.error,
+        newName: args.newName,
+        oldPath: args.oldPath,
+        success: result.success,
+      });
+
       return {
-        content: JSON.stringify({
-          message: `Successfully renamed ${args.oldPath} to ${args.newName}`,
-          success: true,
-        }),
+        content,
         state,
         success: result.success,
       };
@@ -405,14 +373,22 @@ export class CloudSandboxExecutionRuntime {
     try {
       const result = await this.callTool('globLocalFiles', args);
 
+      const files = result.result?.files || [];
+      const totalCount = result.result?.totalCount || 0;
+
       const state: GlobFilesState = {
-        files: result.result?.files || [],
+        files,
         pattern: args.pattern,
-        totalCount: result.result?.totalCount || 0,
+        totalCount,
       };
 
+      const content = formatGlobResults({
+        files,
+        totalFiles: totalCount,
+      });
+
       return {
-        content: JSON.stringify(result.result),
+        content,
         state,
         success: true,
       };
@@ -425,7 +401,7 @@ export class CloudSandboxExecutionRuntime {
 
   /**
    * Export a file from the sandbox to cloud storage
-   * Uses a single tRPC call that handles:
+   * Uses a single call that handles:
    * 1. Generate pre-signed upload URL
    * 2. Call sandbox to upload file
    * 3. Create persistent file record
@@ -437,11 +413,7 @@ export class CloudSandboxExecutionRuntime {
       const filename = args.path.split('/').pop() || 'exported_file';
 
       // Single call that handles everything: upload URL generation, sandbox upload, and file record creation
-      const result = await codeInterpreterService.exportAndUploadFile(
-        args.path,
-        filename,
-        this.context.topicId,
-      );
+      const result = await this.sandboxService.exportAndUploadFile(args.path, filename);
 
       const state: ExportFileState = {
         downloadUrl: result.success && result.url ? result.url : '',
@@ -478,17 +450,16 @@ export class CloudSandboxExecutionRuntime {
   // ==================== Helper Methods ====================
 
   /**
-   * Call a tool via the market SDK through tRPC
-   * Routes through: ExecutionRuntime -> codeInterpreterService -> tRPC -> codeInterpreterRouter -> MarketSDK
+   * Call a tool via the injected sandbox service
    */
   private async callTool(
     toolName: string,
     params: Record<string, any>,
   ): Promise<{ result: any; sessionExpiredAndRecreated?: boolean; success: boolean }> {
-    const result = await codeInterpreterService.callTool(toolName, params, this.context);
+    const result = await this.sandboxService.callTool(toolName, params);
 
     if (!result.success) {
-      throw new Error((result as any).error?.message || `Cloud Sandbox tool ${toolName} failed`);
+      throw new Error(result.error?.message || `Cloud Sandbox tool ${toolName} failed`);
     }
 
     return result;