Added StrategyResult class and enhanced base ReasoningStrategy

reasoning/base.py

@@ -1,17 +1,90 @@
-"""Base class for all reasoning strategies."""
+"""Base classes and types for reasoning strategies."""
 
-from typing import Dict, Any
+from abc import ABC, abstractmethod
+from typing import Dict, Any, List, Optional
+from dataclasses import dataclass, field
+from datetime import datetime
 
-class ReasoningStrategy:
-    """Base class for reasoning strategies."""
-    async def reason(self, query: str, context: Dict[str, Any]) -> Dict[str, Any]:
-        """Apply reasoning strategy to query with context.
+@dataclass
+class StrategyResult:
+    """Result from a reasoning strategy."""
+    
+    strategy_type: str
+    success: bool
+    answer: Optional[str]
+    confidence: float
+    reasoning_trace: List[Dict[str, Any]]
+    metadata: Dict[str, Any]
+    performance_metrics: Dict[str, Any]
+    timestamp: str = field(default_factory=lambda: datetime.now().isoformat())
+
+class ReasoningStrategy(ABC):
+    """Base class for all reasoning strategies."""
+    
+    @abstractmethod
+    async def reason(
+        self,
+        query: str,
+        context: Dict[str, Any],
+        **kwargs
+    ) -> StrategyResult:
+        """
+        Reason about a query using this strategy.
         
         Args:
             query: The query to reason about
             context: Additional context for reasoning
+            **kwargs: Additional strategy-specific parameters
+            
+        Returns:
+            StrategyResult containing the reasoning output and metadata
+        """
+        pass
+    
+    def _prepare_messages(
+        self,
+        query: str,
+        context: Dict[str, Any]
+    ) -> List[Dict[str, str]]:
+        """
+        Prepare messages for the model.
+        
+        Args:
+            query: The query to reason about
+            context: Additional context
+            
+        Returns:
+            List of message dictionaries
+        """
+        messages = []
+        
+        # Add system message if provided
+        if "system_message" in context:
+            messages.append({
+                "role": "system",
+                "content": context["system_message"]
+            })
+        
+        # Add chat history if provided
+        if "chat_history" in context:
+            messages.extend(context["chat_history"])
+        
+        # Add the current query
+        messages.append({
+            "role": "user",
+            "content": query
+        })
+        
+        return messages
+    
+    def _calculate_confidence(self, response: Any) -> float:
+        """
+        Calculate confidence score for a response.
+        
+        Args:
+            response: Response from the model
             
         Returns:
-            Dictionary containing reasoning results
+            Confidence score between 0 and 1
         """
-        raise NotImplementedError
+        return 0.8  # Default confidence