Update src/utils/response_verifier.py

src/utils/response_verifier.py

@@ -1,6 +1,173 @@
+File: src\utils\response_verifier.py
+````````python
 from typing import Dict, Any, List, Optional
 from ..knowledge_base.grounding_truth import GroundingTruth
-from .response_templates import get_response_templates
+from ..components.response_templates import get_response_templates
+import logging
+
+logger = logging.getLogger(__name__)
+
+class ResponseVerifier:
+    """Verifies responses using grounding truth while preserving multi-perspective analysis"""
+    
+    def __init__(self):
+        self.grounding_truth = GroundingTruth()
+        self.response_templates = get_response_templates()
+        self.mode_confidence_thresholds = {
+            "scientific": 0.9,
+            "creative": 0.7,
+            "emotional": 0.6,
+            "quantum": 0.8,
+            "philosophical": 0.7
+        }
+        
+    def verify_insight(
+        self, 
+        insight: str, 
+        mode: str,
+        context: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """
+        Verify a single insight from a specific perspective mode
+        
+        Args:
+            insight: The insight to verify
+            mode: The perspective mode that generated it
+            context: Optional additional context
+            
+        Returns:
+            Dict containing verification results and confidence
+        """
+        verification = self.grounding_truth.verify_statement(insight, context)
+        confidence_threshold = self.mode_confidence_thresholds.get(mode, 0.7)
+        
+        # Adjust verification based on mode characteristics
+        if mode == "creative":
+            # Allow more speculative statements in creative mode
+            verification["confidence"] *= 1.2
+        elif mode == "quantum":
+            # Account for quantum uncertainty
+            verification["confidence"] = max(
+                verification["confidence"],
+                0.5  # Quantum superposition baseline
+            )
+            
+        return {
+            "verified": verification["verified"] or verification["confidence"] >= confidence_threshold,
+            "confidence": verification["confidence"],
+            "mode": mode,
+            "original_insight": insight,
+            "requires_qualifier": verification["confidence"] < confidence_threshold
+        }
+        
+    def process_multi_perspective_response(
+        self,
+        insights: List[str],
+        modes: List[str],
+        consciousness_state: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """
+        Process and verify a multi-perspective response
+        
+        Args:
+            insights: List of insights from different perspectives
+            modes: List of perspective modes that generated the insights
+            consciousness_state: Optional consciousness state info
+            
+        Returns:
+            Processed response with verification metadata
+        """
+        verified_insights = []
+        uncertain_insights = []
+        
+        for insight, mode in zip(insights, modes):
+            result = self.verify_insight(
+                insight, 
+                mode, 
+                {"consciousness": consciousness_state} if consciousness_state else None
+            )
+            
+            if result["verified"]:
+                verified_insights.append({
+                    "text": result["original_insight"],
+                    "mode": mode,
+                    "confidence": result["confidence"]
+                })
+            else:
+                qualified_insight = self._add_qualifier(
+                    result["original_insight"],
+                    result["confidence"],
+                    mode
+                )
+                uncertain_insights.append({
+                    "text": qualified_insight,
+                    "mode": mode,
+                    "confidence": result["confidence"]
+                })
+                
+        return {
+            "verified_insights": verified_insights,
+            "uncertain_insights": uncertain_insights,
+            "overall_confidence": self._calculate_overall_confidence(
+                verified_insights, uncertain_insights
+            )
+        }
+        
+    def _add_qualifier(self, insight: str, confidence: float, mode: str) -> str:
+        """Add appropriate qualifier based on confidence and mode"""
+        base_qualifier = self._get_base_qualifier(confidence)
+        mode_specific = self._get_mode_qualifier(mode)
+        
+        if mode_specific:
+            return f"{base_qualifier} {insight} ({mode_specific})"
+        return f"{base_qualifier} {insight}"
+        
+    def _get_base_qualifier(self, confidence: float) -> str:
+        """Get base confidence qualifier"""
+        if confidence >= 0.8:
+            return "Evidence suggests that"
+        elif confidence >= 0.6:
+            return "It appears that"
+        elif confidence >= 0.4:
+            uncertain = self.response_templates.get_uncertain_prefix()
+            return uncertain.rstrip(',')  # Remove trailing comma if present
+        elif confidence >= 0.2:
+            return "There is a speculation that"
+        else:
+            return "There is an unverified hypothesis that"
+            
+    def _get_mode_qualifier(self, mode: str) -> Optional[str]:
+        """Get mode-specific qualifier"""
+        qualifiers = {
+            "scientific": "based on available data",
+            "creative": "from a creative perspective",
+            "emotional": "from an emotional standpoint",
+            "quantum": "considering quantum possibilities",
+            "philosophical": "from a philosophical view"
+        }
+        return qualifiers.get(mode)
+        
+    def _calculate_overall_confidence(
+        self,
+        verified: List[Dict[str, Any]],
+        uncertain: List[Dict[str, Any]]
+    ) -> float:
+        """Calculate overall response confidence"""
+        if not verified and not uncertain:
+            return 0.0
+            
+        total_insights = len(verified) + len(uncertain)
+        confidence_sum = sum(v["confidence"] for v in verified)
+        confidence_sum += sum(u["confidence"] for u in uncertain)
+        
+        return confidence_sum / total_insights
+````````
+
+# Response
+````````python
+from typing import Dict, Any, List, Optional
+from ..knowledge_base.grounding_truth import GroundingTruth
+from ..components.response_templates import get_response_templates
 import logging
 
 logger = logging.getLogger(__name__)
@@ -127,7 +294,6 @@ class ResponseVerifier:
         elif confidence >= 0.6:
             return "It appears that"
         elif confidence >= 0.4:
-            return "It seems possible that"
             uncertain = self.response_templates.get_uncertain_prefix()
             return uncertain.rstrip(',')  # Remove trailing comma if present
         elif confidence >= 0.2: