Final 7.11.3

src/agents/router.py

@@ -80,7 +80,7 @@ class RouterAgent:
             llm_classification = self._get_llm_classification(state.question)
             
             # Combine pattern-based and LLM-based classification
-            final_types, final_primary = self._combine_classifications(
+            final_types, final_primary = self._combine_classifications_legacy(
                 question_types, primary_type, llm_classification
             )
             
@@ -565,8 +565,8 @@ REASONING: [brief explanation]
         
         return parsed
     
-    def _combine_classifications(self, pattern_types: List[QuestionType], pattern_primary: QuestionType, 
-                               llm_classification: Dict[str, Any]) -> Tuple[List[QuestionType], QuestionType]:
+    def _combine_classifications_legacy(self, pattern_types: List[QuestionType], pattern_primary: QuestionType,
+                                       llm_classification: Dict[str, Any]) -> Tuple[List[QuestionType], QuestionType]:
         """Combine pattern-based and LLM-based classifications"""
         
         # Map LLM classification to our enum types
@@ -597,35 +597,36 @@ REASONING: [brief explanation]
         
         return combined_types, final_primary
     
-    def _select_agents(self, question_types: List[QuestionType], primary_type: QuestionType, question: str) -> List[AgentRole]:
-        """Select agents based on combined classification"""
-        
-        agents = []
+    def _select_agents_for_type(self, classification_result: Dict[str, Any]) -> List[AgentRole]:
+        """Select appropriate agents based on enhanced classification"""
         
-        # Primary agent based on primary type
-        primary_agent_map = {
-            QuestionType.MATHEMATICAL: AgentRole.REASONING_AGENT,
-            QuestionType.TEXT_MANIPULATION: AgentRole.REASONING_AGENT,
-            QuestionType.WEB_RESEARCH: AgentRole.WEB_RESEARCHER,
-            QuestionType.FILE_PROCESSING: AgentRole.FILE_PROCESSOR,
-            QuestionType.REASONING: AgentRole.REASONING_AGENT,
-            QuestionType.CODE_EXECUTION: AgentRole.CODE_EXECUTOR
-        }
+        question_type = classification_result['type']
+        confidence = classification_result['confidence']
         
-        primary_agent = primary_agent_map.get(primary_type, AgentRole.WEB_RESEARCHER)
-        if primary_agent not in agents:
-            agents.append(primary_agent)
+        # Agent selection based on question type
+        if question_type == 'mathematical':
+            agents = [AgentRole.WEB_RESEARCHER, AgentRole.REASONING_AGENT]
+        elif question_type == 'text_manipulation':
+            agents = [AgentRole.REASONING_AGENT]
+        elif question_type == 'file_processing':
+            agents = [AgentRole.FILE_PROCESSOR, AgentRole.REASONING_AGENT]
+        elif question_type == 'web_research':
+            agents = [AgentRole.WEB_RESEARCHER]
+        elif question_type == 'reasoning':
+            agents = [AgentRole.REASONING_AGENT, AgentRole.WEB_RESEARCHER]
+        elif question_type == 'factual_lookup':
+            agents = [AgentRole.WEB_RESEARCHER]
+        else:
+            # General questions - try multiple approaches
+            agents = [AgentRole.WEB_RESEARCHER, AgentRole.REASONING_AGENT]
         
-        # Add secondary agents based on all detected types
-        for qtype in question_types:
-            if qtype != primary_type:  # Don't duplicate primary
-                secondary_agent = primary_agent_map.get(qtype)
-                if secondary_agent and secondary_agent not in agents:
-                    agents.append(secondary_agent)
+        # Always add synthesizer
+        agents.append(AgentRole.SYNTHESIZER)
         
-        # Always add synthesizer at the end
-        if AgentRole.SYNTHESIZER not in agents:
-            agents.append(AgentRole.SYNTHESIZER)
+        # If confidence is low, add more agents for better coverage
+        if confidence < 0.6:
+            if AgentRole.WEB_RESEARCHER not in agents:
+                agents.insert(-1, AgentRole.WEB_RESEARCHER)  # Insert before synthesizer
         
         return agents 
 
@@ -1035,6 +1036,38 @@ REASONING: [brief explanation]
                 'reasoning': 'LLM classification error'
             }
     
+    def _select_agents(self, question_types: List[QuestionType], primary_type: QuestionType, question: str) -> List[AgentRole]:
+        """Select agents based on combined classification"""
+        
+        agents = []
+        
+        # Primary agent based on primary type
+        primary_agent_map = {
+            QuestionType.MATHEMATICAL: AgentRole.REASONING_AGENT,
+            QuestionType.TEXT_MANIPULATION: AgentRole.REASONING_AGENT,
+            QuestionType.WEB_RESEARCH: AgentRole.WEB_RESEARCHER,
+            QuestionType.FILE_PROCESSING: AgentRole.FILE_PROCESSOR,
+            QuestionType.REASONING: AgentRole.REASONING_AGENT,
+            QuestionType.CODE_EXECUTION: AgentRole.CODE_EXECUTOR
+        }
+        
+        primary_agent = primary_agent_map.get(primary_type, AgentRole.WEB_RESEARCHER)
+        if primary_agent not in agents:
+            agents.append(primary_agent)
+        
+        # Add secondary agents based on all detected types
+        for qtype in question_types:
+            if qtype != primary_type:  # Don't duplicate primary
+                secondary_agent = primary_agent_map.get(qtype)
+                if secondary_agent and secondary_agent not in agents:
+                    agents.append(secondary_agent)
+        
+        # Always add synthesizer at the end
+        if AgentRole.SYNTHESIZER not in agents:
+            agents.append(AgentRole.SYNTHESIZER)
+        
+        return agents 
+
     def _combine_classifications(self, pattern_result: Dict[str, Any], llm_result: Dict[str, Any], question: str) -> Dict[str, Any]:
         """Combine pattern and LLM classifications for final decision"""
         
@@ -1085,37 +1118,4 @@ REASONING: [brief explanation]
             'reasoning': reasoning,
             'pattern_result': pattern_result,
             'llm_result': llm_result
-        }
-    
-    def _select_agents_for_type(self, classification_result: Dict[str, Any]) -> List[AgentRole]:
-        """Select appropriate agents based on enhanced classification"""
-        
-        question_type = classification_result['type']
-        confidence = classification_result['confidence']
-        
-        # Agent selection based on question type
-        if question_type == 'mathematical':
-            agents = [AgentRole.WEB_RESEARCHER, AgentRole.REASONING_AGENT]
-        elif question_type == 'text_manipulation':
-            agents = [AgentRole.REASONING_AGENT]
-        elif question_type == 'file_processing':
-            agents = [AgentRole.FILE_PROCESSOR, AgentRole.REASONING_AGENT]
-        elif question_type == 'web_research':
-            agents = [AgentRole.WEB_RESEARCHER]
-        elif question_type == 'reasoning':
-            agents = [AgentRole.REASONING_AGENT, AgentRole.WEB_RESEARCHER]
-        elif question_type == 'factual_lookup':
-            agents = [AgentRole.WEB_RESEARCHER]
-        else:
-            # General questions - try multiple approaches
-            agents = [AgentRole.WEB_RESEARCHER, AgentRole.REASONING_AGENT]
-        
-        # Always add synthesizer
-        agents.append(AgentRole.SYNTHESIZER)
-        
-        # If confidence is low, add more agents for better coverage
-        if confidence < 0.6:
-            if AgentRole.WEB_RESEARCHER not in agents:
-                agents.insert(-1, AgentRole.WEB_RESEARCHER)  # Insert before synthesizer
-        
-        return agents 
+        }