snow-flow 2.6.0 → 2.6.2

package/dist/utils/agent-detector.d.ts

@@ -47,6 +47,14 @@ export declare class AgentDetector {
      * Analyze task using MCP dynamic categorization or fallback to static patterns
      */
     static analyzeTaskDynamic(objective: string, userMaxAgents?: number): Promise<TaskAnalysis>;
+    /**
+     * Discover dynamic agents using MCP agent_discover
+     */
+    private static discoverDynamicAgents;
+    /**
+     * Extract required capabilities from intent analysis
+     */
+    private static extractCapabilitiesFromIntent;
     private static readonly AGENT_PATTERNS;
     private static readonly SERVICENOW_ARTIFACTS;
     static analyzeTask(objective: string, userMaxAgents?: number): TaskAnalysis;

package/dist/utils/agent-detector.js

@@ -35,12 +35,14 @@ class AgentDetector {
                 });
                 if (response && response.content && response.content[0]) {
                     const result = JSON.parse(response.content[0].text);
-                    // Map MCP response to TaskAnalysis interface
+                    // Now discover dynamic agents based on the task analysis
+                    const agentDiscoveryResponse = await this.discoverDynamicAgents(result.categorization, result.intent_analysis);
+                    // Map MCP response to TaskAnalysis interface with dynamic agents
                     return {
-                        primaryAgent: result.categorization.primary_agent,
-                        supportingAgents: result.categorization.supporting_agents,
+                        primaryAgent: agentDiscoveryResponse.primaryAgent || result.categorization.primary_agent,
+                        supportingAgents: agentDiscoveryResponse.supportingAgents || result.categorization.supporting_agents,
                         complexity: result.categorization.complexity,
-                        estimatedAgentCount: result.categorization.estimated_agent_count,
+                        estimatedAgentCount: agentDiscoveryResponse.agentCount || result.categorization.estimated_agent_count,
                         requiresUpdateSet: result.categorization.requires_update_set,
                         requiresApplication: result.categorization.requires_application,
                         taskType: result.categorization.task_type,
@@ -65,6 +67,102 @@ class AgentDetector {
         // Fallback to static analysis
         return this.analyzeTask(objective, userMaxAgents);
     }
+    /**
+     * Discover dynamic agents using MCP agent_discover
+     */
+    static async discoverDynamicAgents(categorization, intentAnalysis) {
+        if (!this.mcpClient) {
+            return {
+                primaryAgent: categorization.primary_agent,
+                supportingAgents: categorization.supporting_agents,
+                agentCount: categorization.estimated_agent_count,
+            };
+        }
+        try {
+            const response = await this.mcpClient.callTool({
+                name: 'agent_discover',
+                arguments: {
+                    task_analysis: {
+                        task_type: categorization.task_type,
+                        complexity: categorization.complexity,
+                        service_now_artifacts: categorization.service_now_artifacts,
+                    },
+                    required_capabilities: this.extractCapabilitiesFromIntent(intentAnalysis),
+                    context: {
+                        max_agents: categorization.estimated_agent_count || 8,
+                        include_new_types: true,
+                        learn_from_history: true,
+                    },
+                },
+            });
+            if (response && response.content && response.content[0]) {
+                const result = JSON.parse(response.content[0].text);
+                // Map discovered agents to our format
+                const discoveredAgents = result.discovered_agents || [];
+                const primaryAgent = result.recommendations.primary_coordinator || categorization.primary_agent;
+                const supportingAgents = discoveredAgents
+                    .filter((a) => a.type !== primaryAgent)
+                    .map((a) => a.type);
+                return {
+                    primaryAgent,
+                    supportingAgents,
+                    agentCount: discoveredAgents.length,
+                    discoveredAgents,
+                    executionBatches: result.execution_batches,
+                    newAgentTypes: result.new_agent_types,
+                };
+            }
+        }
+        catch (error) {
+            console.warn('MCP agent_discover failed, using static agents:', error);
+        }
+        // Fallback to original agents
+        return {
+            primaryAgent: categorization.primary_agent,
+            supportingAgents: categorization.supporting_agents,
+            agentCount: categorization.estimated_agent_count,
+        };
+    }
+    /**
+     * Extract required capabilities from intent analysis
+     */
+    static extractCapabilitiesFromIntent(intentAnalysis) {
+        const capabilities = [];
+        // Extract from action verbs
+        const verbCapabilityMap = {
+            'integrate': 'integration',
+            'optimize': 'performance',
+            'secure': 'security',
+            'analyze': 'analytics',
+            'visualize': 'visualization',
+            'automate': 'automation',
+            'deploy': 'devops',
+            'test': 'testing',
+            'document': 'documentation',
+        };
+        for (const verb of intentAnalysis.action_verbs || []) {
+            if (verbCapabilityMap[verb]) {
+                capabilities.push(verbCapabilityMap[verb]);
+            }
+        }
+        // Extract from target objects
+        const objectCapabilityMap = {
+            'mobile': 'mobile',
+            'chatbot': 'chatbot',
+            'ml': 'ml',
+            'ai': 'ml',
+            'blockchain': 'blockchain',
+            'iot': 'iot',
+            'compliance': 'compliance',
+            'accessibility': 'accessibility',
+        };
+        for (const obj of intentAnalysis.target_objects || []) {
+            if (objectCapabilityMap[obj]) {
+                capabilities.push(objectCapabilityMap[obj]);
+            }
+        }
+        return [...new Set(capabilities)]; // Remove duplicates
+    }
     static analyzeTask(objective, userMaxAgents) {
         const lowerObjective = objective.toLowerCase();
         const words = lowerObjective.split(/\s+/);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "snow-flow",
-  "version": "2.6.0",
+  "version": "2.6.2",
   "description": "Snow-Flow: ServiceNow Advanced Intelligence Platform - 100+ real MCP tools with AI-powered swarm orchestration and neural networks. Dynamic task categorization using AI. Machine learning for incident classification, change risk prediction, and anomaly detection. Zero Mock Data, 100% Real API Integration.",
   "main": "dist/index.js",
   "type": "commonjs",