Details enhancement V2

mobile_handlers.py

@@ -50,7 +50,7 @@ class MobileUXHandlers:
             # Format for mobile display
             formatted_response = self._format_for_mobile(
                 result['final_response'],
-                show_reasoning and result.get('reasoning_chain'),
+                show_reasoning and result.get('metadata', {}).get('reasoning_chain'),
                 show_agent_trace and result.get('agent_trace')
             )
             
@@ -60,7 +60,7 @@ class MobileUXHandlers:
             yield {
                 "chatbot": updated_history,
                 "message_input": "",
-                "reasoning_display": result.get('reasoning_chain', {}),
+                "reasoning_display": result.get('metadata', {}).get('reasoning_chain', {}),
                 "performance_display": result.get('performance_metrics', {})
             }
             
@@ -92,9 +92,23 @@ class MobileUXHandlers:
         
         # Add reasoning if requested
         if reasoning_chain:
+            # Handle both old and new reasoning chain formats
+            if isinstance(reasoning_chain, dict):
+                # New enhanced format - extract key information
+                chain_of_thought = reasoning_chain.get('chain_of_thought', {})
+                if chain_of_thought:
+                    first_step = list(chain_of_thought.values())[0] if chain_of_thought else {}
+                    hypothesis = first_step.get('hypothesis', 'Processing...')
+                    reasoning_text = f"Hypothesis: {hypothesis}"
+                else:
+                    reasoning_text = "Enhanced reasoning chain available"
+            else:
+                # Old format - direct string
+                reasoning_text = str(reasoning_chain)[:200]
+            
             formatted += f"""
 <div class="reasoning-mobile" style="margin-top: 15px; padding: 10px; background: #f5f5f5; border-radius: 8px; font-size: 14px;">
-<strong>Reasoning:</strong> {reasoning_chain[:200]}...
+<strong>Reasoning:</strong> {reasoning_text}...
 </div>
 """
         

orchestrator_engine.py

@@ -46,14 +46,15 @@ class MVPOrchestrator:
             
             # Add context analysis to reasoning chain
             reasoning_chain["chain_of_thought"]["step_1"] = {
-                "hypothesis": "Analyzing conversation context and user history",
+                "hypothesis": f"User is asking about: '{self._extract_main_topic(user_input)}'",
                 "evidence": [
                     f"Previous interactions: {len(context.get('interactions', []))}",
                     f"Session duration: {self._calculate_session_duration(context)}",
-                    f"Topic continuity: {self._analyze_topic_continuity(context, user_input)}"
+                    f"Topic continuity: {self._analyze_topic_continuity(context, user_input)}",
+                    f"Query keywords: {self._extract_keywords(user_input)}"
                 ],
                 "confidence": 0.85,
-                "reasoning": "Context analysis provides foundation for intent recognition and response personalization"
+                "reasoning": f"Context analysis shows user is focused on {self._extract_main_topic(user_input)} with {len(context.get('interactions', []))} previous interactions"
             }
             
             # Step 3: Intent recognition with enhanced CoT
@@ -75,14 +76,15 @@ class MVPOrchestrator:
             
             # Add intent reasoning to chain
             reasoning_chain["chain_of_thought"]["step_2"] = {
-                "hypothesis": f"User intent is '{intent_result.get('primary_intent', 'unknown')}'",
+                "hypothesis": f"User intent is '{intent_result.get('primary_intent', 'unknown')}' for topic '{self._extract_main_topic(user_input)}'",
                 "evidence": [
                     f"Pattern analysis: {self._extract_pattern_evidence(user_input)}",
                     f"Confidence scores: {intent_result.get('confidence_scores', {})}",
-                    f"Secondary intents: {intent_result.get('secondary_intents', [])}"
+                    f"Secondary intents: {intent_result.get('secondary_intents', [])}",
+                    f"Query complexity: {self._assess_query_complexity(user_input)}"
                 ],
                 "confidence": intent_result.get('confidence_scores', {}).get(intent_result.get('primary_intent', 'unknown'), 0.7),
-                "reasoning": f"Intent recognition based on linguistic patterns and context analysis"
+                "reasoning": f"Intent '{intent_result.get('primary_intent', 'unknown')}' detected for {self._extract_main_topic(user_input)} based on linguistic patterns and context"
             }
             
             # Step 4: Agent execution planning with reasoning
@@ -91,14 +93,15 @@ class MVPOrchestrator:
             
             # Add execution planning reasoning
             reasoning_chain["chain_of_thought"]["step_3"] = {
-                "hypothesis": f"Optimal agent sequence for '{intent_result.get('primary_intent', 'unknown')}' intent",
+                "hypothesis": f"Optimal approach for '{intent_result.get('primary_intent', 'unknown')}' intent on '{self._extract_main_topic(user_input)}'",
                 "evidence": [
                     f"Intent complexity: {self._assess_intent_complexity(intent_result)}",
                     f"Required agents: {execution_plan.get('agents_to_execute', [])}",
-                    f"Execution strategy: {execution_plan.get('execution_order', 'sequential')}"
+                    f"Execution strategy: {execution_plan.get('execution_order', 'sequential')}",
+                    f"Response scope: {self._determine_response_scope(user_input)}"
                 ],
                 "confidence": 0.80,
-                "reasoning": "Agent selection based on intent requirements and system capabilities"
+                "reasoning": f"Agent selection optimized for {intent_result.get('primary_intent', 'unknown')} intent regarding {self._extract_main_topic(user_input)}"
             }
             
             # Step 5: Parallel agent execution
@@ -125,14 +128,15 @@ class MVPOrchestrator:
             
             # Add synthesis reasoning
             reasoning_chain["chain_of_thought"]["step_4"] = {
-                "hypothesis": f"Response synthesis using '{final_response.get('synthesis_method', 'unknown')}' method",
+                "hypothesis": f"Response synthesis for '{self._extract_main_topic(user_input)}' using '{final_response.get('synthesis_method', 'unknown')}' method",
                 "evidence": [
                     f"Synthesis quality: {final_response.get('coherence_score', 0.7)}",
                     f"Source integration: {len(final_response.get('source_references', []))} sources",
-                    f"Response length: {len(str(final_response.get('final_response', '')))} characters"
+                    f"Response length: {len(str(final_response.get('final_response', '')))} characters",
+                    f"Content relevance: {self._assess_content_relevance(user_input, final_response)}"
                 ],
                 "confidence": final_response.get('coherence_score', 0.7),
-                "reasoning": "Multi-source information integration with quality optimization"
+                "reasoning": f"Multi-source synthesis for {self._extract_main_topic(user_input)} using {final_response.get('synthesis_method', 'unknown')} approach"
             }
             
             # Step 7: Safety and bias check with reasoning
@@ -153,14 +157,15 @@ class MVPOrchestrator:
             
             # Add safety reasoning
             reasoning_chain["chain_of_thought"]["step_5"] = {
-                "hypothesis": "Response passes safety and bias checks",
+                "hypothesis": f"Safety validation for response about '{self._extract_main_topic(user_input)}'",
                 "evidence": [
                     f"Safety score: {safety_checked.get('safety_analysis', {}).get('overall_safety_score', 0.8)}",
                     f"Warnings generated: {len(safety_checked.get('warnings', []))}",
-                    f"Analysis method: {safety_checked.get('safety_analysis', {}).get('analysis_method', 'unknown')}"
+                    f"Analysis method: {safety_checked.get('safety_analysis', {}).get('analysis_method', 'unknown')}",
+                    f"Content appropriateness: {self._assess_content_appropriateness(user_input, safety_checked)}"
                 ],
                 "confidence": safety_checked.get('safety_analysis', {}).get('overall_safety_score', 0.8),
-                "reasoning": "Comprehensive safety analysis with non-blocking warning system"
+                "reasoning": f"Safety analysis for {self._extract_main_topic(user_input)} content with non-blocking warning system"
             }
             
             # Generate alternative paths and uncertainty analysis
@@ -384,34 +389,43 @@ class MVPOrchestrator:
             return "Complex, multi-faceted intent"
     
     def _generate_alternative_paths(self, intent_result: dict, user_input: str) -> list:
-        """Generate alternative reasoning paths"""
+        """Generate alternative reasoning paths based on actual content"""
         primary_intent = intent_result.get('primary_intent', 'unknown')
         secondary_intents = intent_result.get('secondary_intents', [])
+        main_topic = self._extract_main_topic(user_input)
         
         alternative_paths = []
         
         # Add secondary intents as alternative paths
         for secondary_intent in secondary_intents:
             alternative_paths.append({
-                "path": f"Alternative intent: {secondary_intent}",
-                "reasoning": f"Could interpret as {secondary_intent} based on linguistic patterns",
+                "path": f"Alternative intent: {secondary_intent} for {main_topic}",
+                "reasoning": f"Could interpret as {secondary_intent} based on linguistic patterns in the query about {main_topic}",
                 "confidence": intent_result.get('confidence_scores', {}).get(secondary_intent, 0.3),
-                "rejected_reason": f"Primary intent '{primary_intent}' has higher confidence"
+                "rejected_reason": f"Primary intent '{primary_intent}' has higher confidence for {main_topic} topic"
             })
         
-        # Add method-based alternatives
-        if primary_intent == "information_request":
+        # Add method-based alternatives based on content
+        if 'curriculum' in user_input.lower() or 'course' in user_input.lower():
             alternative_paths.append({
-                "path": "Technical deep-dive approach",
-                "reasoning": "Could provide mathematical foundations and technical details",
+                "path": "Structured educational framework approach",
+                "reasoning": f"Could provide a more structured educational framework for {main_topic}",
                 "confidence": 0.6,
-                "rejected_reason": "User level suggests conceptual approach"
+                "rejected_reason": f"Current approach better matches user's specific request for {main_topic}"
+            })
+        
+        if 'detailed' in user_input.lower() or 'comprehensive' in user_input.lower():
+            alternative_paths.append({
+                "path": "High-level overview approach",
+                "reasoning": f"Could provide a high-level overview instead of detailed content for {main_topic}",
+                "confidence": 0.4,
+                "rejected_reason": f"User specifically requested detailed information about {main_topic}"
             })
         
         return alternative_paths
     
     def _identify_uncertainty_areas(self, intent_result: dict, final_response: dict, safety_checked: dict) -> list:
-        """Identify areas of uncertainty in the reasoning"""
+        """Identify areas of uncertainty in the reasoning based on actual content"""
         uncertainty_areas = []
         
         # Intent uncertainty
@@ -419,33 +433,42 @@ class MVPOrchestrator:
         confidence = intent_result.get('confidence_scores', {}).get(primary_intent, 0.5)
         if confidence < 0.8:
             uncertainty_areas.append({
-                "aspect": f"Intent classification ({primary_intent})",
+                "aspect": f"Intent classification ({primary_intent}) for user's specific request",
                 "confidence": confidence,
-                "mitigation": "Provided multiple interpretation options"
+                "mitigation": "Provided multiple interpretation options and context-aware analysis"
             })
         
         # Response quality uncertainty
         coherence_score = final_response.get('coherence_score', 0.7)
         if coherence_score < 0.8:
             uncertainty_areas.append({
-                "aspect": "Response coherence and structure",
+                "aspect": "Response coherence and structure for the specific topic",
                 "confidence": coherence_score,
-                "mitigation": "Applied quality enhancement techniques"
+                "mitigation": "Applied quality enhancement techniques and content relevance checks"
             })
         
         # Safety uncertainty
         safety_score = safety_checked.get('safety_analysis', {}).get('overall_safety_score', 0.8)
         if safety_score < 0.9:
             uncertainty_areas.append({
-                "aspect": "Content safety and bias assessment",
+                "aspect": "Content safety and bias assessment for educational content",
                 "confidence": safety_score,
-                "mitigation": "Generated advisory warnings for user awareness"
+                "mitigation": "Generated advisory warnings for user awareness and content appropriateness"
+            })
+        
+        # Content relevance uncertainty
+        response_text = str(final_response.get('final_response', ''))
+        if len(response_text) < 100:  # Very short response
+            uncertainty_areas.append({
+                "aspect": "Response completeness for user's detailed request",
+                "confidence": 0.6,
+                "mitigation": "Enhanced response generation with topic-specific content"
             })
         
         return uncertainty_areas
     
     def _extract_evidence_sources(self, intent_result: dict, final_response: dict, context: dict) -> list:
-        """Extract evidence sources for reasoning"""
+        """Extract evidence sources for reasoning based on actual content"""
         evidence_sources = []
         
         # Intent evidence
@@ -453,7 +476,7 @@ class MVPOrchestrator:
             "type": "linguistic_analysis",
             "source": "Pattern matching and NLP analysis",
             "relevance": 0.9,
-            "description": "Intent classification based on linguistic patterns"
+            "description": f"Intent classification based on linguistic patterns for '{intent_result.get('primary_intent', 'unknown')}' intent"
         })
         
         # Context evidence
@@ -463,7 +486,7 @@ class MVPOrchestrator:
                 "type": "conversation_history",
                 "source": f"Previous {len(interactions)} interactions",
                 "relevance": 0.7,
-                "description": "Conversation context and topic continuity"
+                "description": f"Conversation context and topic continuity analysis"
             })
         
         # Synthesis evidence
@@ -472,9 +495,19 @@ class MVPOrchestrator:
             "type": "synthesis_method",
             "source": f"{synthesis_method} approach",
             "relevance": 0.8,
-            "description": f"Response generated using {synthesis_method} methodology"
+            "description": f"Response generated using {synthesis_method} methodology with quality optimization"
         })
         
+        # Content-specific evidence
+        response_text = str(final_response.get('final_response', ''))
+        if len(response_text) > 1000:
+            evidence_sources.append({
+                "type": "content_analysis",
+                "source": "Comprehensive content generation",
+                "relevance": 0.85,
+                "description": "Detailed response generation based on user's specific requirements"
+            })
+        
         return evidence_sources
     
     def _calibrate_confidence_scores(self, reasoning_chain: dict) -> dict:
@@ -499,4 +532,111 @@ class MVPOrchestrator:
             },
             "calibration_method": "Weighted average of step confidences"
         }
+    
+    def _extract_main_topic(self, user_input: str) -> str:
+        """Extract the main topic from user input for context-aware reasoning"""
+        input_lower = user_input.lower()
+        
+        # Topic extraction based on keywords
+        if any(word in input_lower for word in ['curriculum', 'course', 'teach', 'learning', 'education']):
+            if 'ai' in input_lower or 'chatbot' in input_lower or 'assistant' in input_lower:
+                return "AI chatbot course curriculum"
+            elif 'programming' in input_lower or 'python' in input_lower:
+                return "Programming course curriculum"
+            else:
+                return "Educational course design"
+        
+        elif any(word in input_lower for word in ['machine learning', 'ml', 'neural network', 'deep learning']):
+            return "Machine learning concepts"
+        
+        elif any(word in input_lower for word in ['ai', 'artificial intelligence', 'chatbot', 'assistant']):
+            return "Artificial intelligence and chatbots"
+        
+        elif any(word in input_lower for word in ['data science', 'data analysis', 'analytics']):
+            return "Data science and analysis"
+        
+        elif any(word in input_lower for word in ['programming', 'coding', 'development', 'software']):
+            return "Software development and programming"
+        
+        else:
+            # Extract first few words as topic
+            words = user_input.split()[:4]
+            return " ".join(words) if words else "General inquiry"
+    
+    def _extract_keywords(self, user_input: str) -> str:
+        """Extract key terms from user input"""
+        input_lower = user_input.lower()
+        keywords = []
+        
+        # Extract important terms
+        important_terms = [
+            'curriculum', 'course', 'teach', 'learning', 'education',
+            'ai', 'artificial intelligence', 'chatbot', 'assistant',
+            'machine learning', 'ml', 'neural network', 'deep learning',
+            'programming', 'python', 'development', 'software',
+            'data science', 'analytics', 'analysis'
+        ]
+        
+        for term in important_terms:
+            if term in input_lower:
+                keywords.append(term)
+        
+        return ", ".join(keywords[:5]) if keywords else "General terms"
+    
+    def _assess_query_complexity(self, user_input: str) -> str:
+        """Assess the complexity of the user query"""
+        word_count = len(user_input.split())
+        question_count = user_input.count('?')
+        
+        if word_count > 50 and question_count > 2:
+            return "Highly complex multi-part query"
+        elif word_count > 30 and question_count > 1:
+            return "Moderately complex query"
+        elif word_count > 15:
+            return "Standard complexity query"
+        else:
+            return "Simple query"
+    
+    def _determine_response_scope(self, user_input: str) -> str:
+        """Determine the scope of response needed"""
+        input_lower = user_input.lower()
+        
+        if any(word in input_lower for word in ['detailed', 'comprehensive', 'complete', 'full']):
+            return "Comprehensive detailed response"
+        elif any(word in input_lower for word in ['brief', 'short', 'summary', 'overview']):
+            return "Brief summary response"
+        elif any(word in input_lower for word in ['step by step', 'tutorial', 'guide', 'how to']):
+            return "Step-by-step instructional response"
+        else:
+            return "Standard informative response"
+    
+    def _assess_content_relevance(self, user_input: str, final_response: dict) -> str:
+        """Assess how relevant the response content is to the user input"""
+        response_text = str(final_response.get('final_response', ''))
+        
+        # Simple relevance check based on keyword overlap
+        input_words = set(user_input.lower().split())
+        response_words = set(response_text.lower().split())
+        
+        overlap = len(input_words.intersection(response_words))
+        total_input_words = len(input_words)
+        
+        if overlap / total_input_words > 0.3:
+            return "High relevance to user query"
+        elif overlap / total_input_words > 0.15:
+            return "Moderate relevance to user query"
+        else:
+            return "Low relevance to user query"
+    
+    def _assess_content_appropriateness(self, user_input: str, safety_checked: dict) -> str:
+        """Assess content appropriateness for the topic"""
+        warnings = safety_checked.get('warnings', [])
+        safety_score = safety_checked.get('safety_analysis', {}).get('overall_safety_score', 0.8)
+        
+        if safety_score > 0.9 and len(warnings) == 0:
+            return "Highly appropriate content"
+        elif safety_score > 0.8 and len(warnings) <= 1:
+            return "Appropriate content with minor notes"
+        else:
+            return "Content requires review"
 

src/event_handlers.py

@@ -43,7 +43,26 @@ class EventHandlers:
             performance_data = {}
             
             if show_reasoning:
-                reasoning_data = {"reasoning": "Mock reasoning chain for demonstration"}
+                reasoning_data = {
+                    "chain_of_thought": {
+                        "step_1": {
+                            "hypothesis": "Mock reasoning for demonstration",
+                            "evidence": ["Mock mode active", f"User input: {message[:50]}..."],
+                            "confidence": 0.5,
+                            "reasoning": "Demonstration mode - enhanced reasoning chain not available"
+                        }
+                    },
+                    "alternative_paths": [],
+                    "uncertainty_areas": [
+                        {
+                            "aspect": "System mode",
+                            "confidence": 0.5,
+                            "mitigation": "Mock mode - full reasoning chain not available"
+                        }
+                    ],
+                    "evidence_sources": [],
+                    "confidence_calibration": {"overall_confidence": 0.5, "mock_mode": True}
+                }
             
             if show_agent_trace:
                 performance_data = {"agents_used": ["intent", "synthesis", "safety"]}