@probelabs/probe 0.6.0-rc67 → 0.6.0-rc70

package/build/agent/ProbeAgent.js

@@ -115,9 +115,13 @@ export class ProbeAgent {
       search: wrappedTools.searchToolInstance,
       query: wrappedTools.queryToolInstance,
       extract: wrappedTools.extractToolInstance,
+      delegate: wrappedTools.delegateToolInstance,
       listFiles: listFilesToolInstance,
       searchFiles: searchFilesToolInstance,
     };
+    
+    // Store wrapped tools for ACP system
+    this.wrappedTools = wrappedTools;
   }
 
   /**
@@ -580,8 +584,15 @@ When troubleshooting:
           throw new Error(finalResult);
         }
 
-        // Parse tool call from response
-        const parsedTool = parseXmlToolCallWithThinking(assistantResponseContent);
+        // Parse tool call from response with valid tools list
+        const validTools = [
+          'search', 'query', 'extract', 'listFiles', 'searchFiles', 'attempt_completion'
+        ];
+        if (this.allowEdit) {
+          validTools.push('implement');
+        }
+        
+        const parsedTool = parseXmlToolCallWithThinking(assistantResponseContent, validTools);
         if (parsedTool) {
           const { toolName, params } = parsedTool;
           if (this.debug) console.log(`[DEBUG] Parsed tool call: ${toolName} with params:`, params);
@@ -614,6 +625,22 @@ When troubleshooting:
                 
                 // Execute tool with tracing if available
                 const executeToolCall = async () => {
+                  // For delegate tool, pass current iteration and max iterations
+                  if (toolName === 'delegate') {
+                    const enhancedParams = {
+                      ...toolParams,
+                      currentIteration,
+                      maxIterations,
+                      debug: this.debug
+                    };
+                    
+                    if (this.debug) {
+                      console.log(`[DEBUG] Executing delegate tool at iteration ${currentIteration}/${maxIterations}`);
+                      console.log(`[DEBUG] Delegate task: ${toolParams.task?.substring(0, 100)}...`);
+                    }
+                    
+                    return await this.toolImplementations[toolName].execute(enhancedParams);
+                  }
                   return await this.toolImplementations[toolName].execute(toolParams);
                 };
 
@@ -722,7 +749,8 @@ When troubleshooting:
       this.tokenCounter.updateHistory(this.history);
 
       // Schema handling - format response according to provided schema
-      if (options.schema && !options._schemaFormatted) {
+      // Skip schema processing if result came from attempt_completion tool
+      if (options.schema && !options._schemaFormatted && !completionAttempted) {
         if (this.debug) {
           console.log('[DEBUG] Schema provided, applying automatic formatting...');
         }
@@ -822,6 +850,38 @@ Convert your previous response content into this JSON format now. Return nothing
           console.error('[ERROR] Schema formatting failed:', error);
           // Return the original result if schema formatting fails
         }
+      } else if (completionAttempted && options.schema) {
+        // For attempt_completion results with schema, still clean markdown if needed
+        try {
+          finalResult = cleanSchemaResponse(finalResult);
+          
+          // Validate and fix Mermaid diagrams if present
+          const mermaidValidation = await validateAndFixMermaidResponse(finalResult, {
+            debug: this.debug,
+            path: this.allowedFolders[0],
+            provider: this.clientApiProvider,
+            model: this.model
+          });
+          
+          if (mermaidValidation.wasFixed) {
+            finalResult = mermaidValidation.fixedResponse;
+            if (this.debug) {
+              console.log(`[DEBUG] Mermaid diagrams fixed in attempt_completion result`);
+            }
+          }
+          
+          // Validate JSON if schema expects JSON
+          if (isJsonSchema(options.schema)) {
+            const validation = validateJsonResponse(finalResult);
+            if (!validation.isValid && this.debug) {
+              console.log(`[DEBUG] attempt_completion result JSON validation failed: ${validation.error}`);
+            }
+          }
+        } catch (error) {
+          if (this.debug) {
+            console.log(`[DEBUG] attempt_completion result cleanup failed: ${error.message}`);
+          }
+        }
       }
 
       return finalResult;

package/build/agent/acp/tools.js

@@ -160,6 +160,8 @@ export class ACPToolManager {
         return ToolCallKind.query;
       case 'extract':
         return ToolCallKind.extract;
+      case 'delegate':
+        return ToolCallKind.execute;
       case 'implement':
         return ToolCallKind.edit;
       default:
@@ -202,6 +204,15 @@ export class ACPToolManager {
           sessionId: this.probeAgent.sessionId
         });
         
+      case 'delegate':
+        if (!tools.delegateToolInstance) {
+          throw new Error('Delegate tool not available');
+        }
+        return await tools.delegateToolInstance.execute({
+          ...params,
+          sessionId: this.probeAgent.sessionId
+        });
+        
       default:
         throw new Error(`Unknown tool: ${toolName}`);
     }
@@ -336,6 +347,21 @@ export class ACPToolManager {
           },
           required: ['files']
         }
+      },
+      {
+        name: 'delegate',
+        description: 'Automatically delegate big distinct tasks to specialized probe subagents within the agentic loop. Use when complex requests can be broken into focused, parallel tasks.',
+        kind: ToolCallKind.execute,
+        parameters: {
+          type: 'object',
+          properties: {
+            task: {
+              type: 'string',
+              description: 'A complete, self-contained task that can be executed independently by a subagent. Should be specific and focused on one area of expertise.'
+            }
+          },
+          required: ['task']
+        }
       }
     ];
   }

package/build/agent/acp/tools.test.js

@@ -101,6 +101,9 @@ describe('ACPToolManager', () => {
         },
         extractToolInstance: {
           execute: jest.fn().mockResolvedValue('extract result')
+        },
+        delegateToolInstance: {
+          execute: jest.fn().mockResolvedValue('delegate result')
         }
       }
     };
@@ -113,6 +116,7 @@ describe('ACPToolManager', () => {
       expect(toolManager.getToolKind('search')).toBe(ToolCallKind.search);
       expect(toolManager.getToolKind('query')).toBe(ToolCallKind.query);
       expect(toolManager.getToolKind('extract')).toBe(ToolCallKind.extract);
+      expect(toolManager.getToolKind('delegate')).toBe(ToolCallKind.execute);
       expect(toolManager.getToolKind('implement')).toBe(ToolCallKind.edit);
       expect(toolManager.getToolKind('unknown')).toBe(ToolCallKind.execute);
     });
@@ -167,6 +171,18 @@ describe('ACPToolManager', () => {
       });
     });
     
+    test('should execute delegate tool successfully', async () => {
+      const params = { task: 'Analyze security vulnerabilities in authentication code' };
+      
+      const result = await toolManager.executeToolCall('session-123', 'delegate', params);
+      
+      expect(result).toBe('delegate result');
+      expect(mockProbeAgent.wrappedTools.delegateToolInstance.execute).toHaveBeenCalledWith({
+        ...params,
+        sessionId: 'test-session'
+      });
+    });
+    
     test('should handle tool execution errors', async () => {
       const error = new Error('Tool execution failed');
       mockProbeAgent.wrappedTools.searchToolInstance.execute.mockRejectedValue(error);
@@ -187,6 +203,10 @@ describe('ACPToolManager', () => {
       mockProbeAgent.wrappedTools.searchToolInstance = null;
       
       await expect(toolManager.executeToolCall('session-123', 'search', {})).rejects.toThrow('Search tool not available');
+      
+      mockProbeAgent.wrappedTools.delegateToolInstance = null;
+      
+      await expect(toolManager.executeToolCall('session-123', 'delegate', {})).rejects.toThrow('Delegate tool not available');
     });
   });
   
@@ -263,7 +283,7 @@ describe('ACPToolManager', () => {
     test('should provide correct tool definitions', () => {
       const definitions = ACPToolManager.getToolDefinitions();
       
-      expect(definitions).toHaveLength(3);
+      expect(definitions).toHaveLength(4);
       
       const searchTool = definitions.find(d => d.name === 'search');
       expect(searchTool).toBeDefined();
@@ -282,6 +302,12 @@ describe('ACPToolManager', () => {
       expect(extractTool.kind).toBe(ToolCallKind.extract);
       expect(extractTool.parameters.properties.files).toBeDefined();
       expect(extractTool.parameters.required).toContain('files');
+      
+      const delegateTool = definitions.find(d => d.name === 'delegate');
+      expect(delegateTool).toBeDefined();
+      expect(delegateTool.kind).toBe(ToolCallKind.execute);
+      expect(delegateTool.parameters.properties.task).toBeDefined();
+      expect(delegateTool.parameters.required).toContain('task');
     });
   });