p

ai_intelligence_layer/services/strategy_analyzer.py

@@ -0,0 +1,132 @@
+"""
+Strategy analyzer service - Step 2: Analysis & Selection.
+"""
+import logging
+from typing import List
+from config import get_settings
+from models.input_models import EnrichedTelemetryWebhook, RaceContext, Strategy
+from models.output_models import (
+    AnalyzeResponse,
+    AnalyzedStrategy,
+    PredictedOutcome,
+    RiskAssessment,
+    TelemetryInsights,
+    EngineerBrief,
+    ECUCommands,
+    SituationalContext
+)
+from services.gemini_client import GeminiClient
+from prompts.analyze_prompt import build_analyze_prompt
+
+logger = logging.getLogger(__name__)
+
+
+class StrategyAnalyzer:
+    """Analyzes strategies and selects top 3 using Gemini AI."""
+    
+    def __init__(self):
+        """Initialize strategy analyzer."""
+        self.gemini_client = GeminiClient()
+        self.settings = get_settings()
+        logger.info("Strategy analyzer initialized")
+    
+    async def analyze(
+        self,
+        enriched_telemetry: List[EnrichedTelemetryWebhook],
+        race_context: RaceContext,
+        strategies: List[Strategy]
+    ) -> AnalyzeResponse:
+        """
+        Analyze strategies and select top 3.
+        
+        Args:
+            enriched_telemetry: Recent enriched telemetry data
+            race_context: Current race context
+            strategies: Strategies to analyze
+            
+        Returns:
+            AnalyzeResponse with top 3 strategies
+            
+        Raises:
+            Exception: If analysis fails
+        """
+        logger.info(f"Starting strategy analysis for {len(strategies)} strategies...")
+        
+        # Build prompt (use fast mode if enabled)
+        if self.settings.fast_mode:
+            from prompts.analyze_prompt import build_analyze_prompt_fast
+            prompt = build_analyze_prompt_fast(enriched_telemetry, race_context, strategies)
+            logger.info("Using FAST MODE prompt")
+        else:
+            prompt = build_analyze_prompt(enriched_telemetry, race_context, strategies)
+        logger.debug(f"Prompt length: {len(prompt)} chars")
+        
+        # Generate with Gemini (lower temperature for analytical consistency)
+        response_data = await self.gemini_client.generate_json(
+            prompt=prompt,
+            temperature=0.3,
+            timeout=self.settings.analyze_timeout
+        )
+        
+        # Log the response structure for debugging
+        logger.info(f"Gemini response keys: {list(response_data.keys())}")
+        
+        # Parse top strategies
+        if "top_strategies" not in response_data:
+            # Log first 500 chars of response for debugging
+            response_preview = str(response_data)[:500]
+            logger.error(f"Response preview: {response_preview}...")
+            raise Exception(f"Response missing 'top_strategies' field. Got keys: {list(response_data.keys())}. Check logs for details.")
+        
+        if "situational_context" not in response_data:
+            raise Exception("Response missing 'situational_context' field")
+        
+        top_strategies_data = response_data["top_strategies"]
+        situational_context_data = response_data["situational_context"]
+        
+        logger.info(f"Received {len(top_strategies_data)} top strategies from Gemini")
+        
+        # Parse top strategies
+        top_strategies = []
+        for ts_data in top_strategies_data:
+            try:
+                # Parse nested structures
+                predicted_outcome = PredictedOutcome(**ts_data["predicted_outcome"])
+                risk_assessment = RiskAssessment(**ts_data["risk_assessment"])
+                telemetry_insights = TelemetryInsights(**ts_data["telemetry_insights"])
+                engineer_brief = EngineerBrief(**ts_data["engineer_brief"])
+                ecu_commands = ECUCommands(**ts_data["ecu_commands"])
+                
+                # Create analyzed strategy
+                analyzed_strategy = AnalyzedStrategy(
+                    rank=ts_data["rank"],
+                    strategy_id=ts_data["strategy_id"],
+                    strategy_name=ts_data["strategy_name"],
+                    classification=ts_data["classification"],
+                    predicted_outcome=predicted_outcome,
+                    risk_assessment=risk_assessment,
+                    telemetry_insights=telemetry_insights,
+                    engineer_brief=engineer_brief,
+                    driver_audio_script=ts_data["driver_audio_script"],
+                    ecu_commands=ecu_commands
+                )
+                
+                top_strategies.append(analyzed_strategy)
+                
+            except Exception as e:
+                logger.warning(f"Failed to parse strategy rank {ts_data.get('rank', '?')}: {e}")
+        
+        # Parse situational context
+        situational_context = SituationalContext(**situational_context_data)
+        
+        # Validate we have 3 strategies
+        if len(top_strategies) != 3:
+            logger.warning(f"Expected 3 top strategies, got {len(top_strategies)}")
+        
+        logger.info(f"Successfully analyzed and selected {len(top_strategies)} strategies")
+        
+        # Return response
+        return AnalyzeResponse(
+            top_strategies=top_strategies,
+            situational_context=situational_context
+        )