Fix improvement_data field mapping for real backend - use baseline_val_score, optimized_val_score, relative_improvement_percent

app.py

@@ -351,6 +351,10 @@ def safe_optimize(seed_prompt, dataset, model, custom_model="", max_iterations=5
 
         # Run optimization
         try:
+            logger.info(f"🚀 Starting optimization with model: {final_model}")
+            logger.info(f"   Parameters: iterations={max_iterations}, metric_calls={max_metric_calls}, batch={batch_size}, llego={use_llego}")
+            logger.info(f"   Dataset size: {len(dataset)} examples")
+            
             result = quick_optimize_sync(
                 seed_prompt=seed_prompt,
                 dataset=dataset,
@@ -362,6 +366,22 @@ def safe_optimize(seed_prompt, dataset, model, custom_model="", max_iterations=5
                 verbose=True,
             )
             
+            # Log result details for debugging
+            logger.info(f"📊 Optimization result received:")
+            logger.info(f"   Type: {type(result)}")
+            logger.info(f"   Has prompt: {hasattr(result, 'prompt')}")
+            logger.info(f"   Has optimized_prompt: {hasattr(result, 'optimized_prompt')}")
+            if hasattr(result, 'improvement_data'):
+                logger.info(f"   improvement_data: {result.improvement_data}")
+            if hasattr(result, 'total_iterations'):
+                logger.info(f"   total_iterations: {result.total_iterations}")
+            if hasattr(result, 'optimization_time'):
+                logger.info(f"   optimization_time: {result.optimization_time}")
+            if hasattr(result, 'status'):
+                logger.info(f"   status: {result.status}")
+            if hasattr(result, 'error_message') and result.error_message:
+                logger.error(f"   error_message: {result.error_message}")
+            
             # Validate result structure
             if not result:
                 return False, "Optimization returned no result.", None
@@ -719,16 +739,43 @@ def run_optimization_flow(seed, dataset, model, custom_model, iter_count, call_c
                     improvement_data = result.improvement_data if hasattr(result, 'improvement_data') else {}
                     
                     # Convert improvement_data to display format
+                    # Real backend uses: baseline_val_score, optimized_val_score, relative_improvement_percent
                     if isinstance(improvement_data, dict):
+                        # Try real backend field names first, then fall back to alternatives
+                        baseline_score = (
+                            improvement_data.get("baseline_val_score") or 
+                            improvement_data.get("baseline_score") or 
+                            improvement_data.get("baseline_metrics", {}).get("composite_score", 0.0)
+                        )
+                        final_score = (
+                            improvement_data.get("optimized_val_score") or 
+                            improvement_data.get("final_score") or 
+                            improvement_data.get("final_metrics", {}).get("composite_score", 0.0)
+                        )
+                        improvement_percent = (
+                            improvement_data.get("relative_improvement_percent") or 
+                            improvement_data.get("improvement_percent") or 
+                            "N/A"
+                        )
+                        
+                        # Format improvement percent
+                        if isinstance(improvement_percent, (int, float)):
+                            improvement_percent = f"+{improvement_percent:.1f}%" if improvement_percent > 0 else f"{improvement_percent:.1f}%"
+                        
                         improvement_metrics = {
-                            "baseline_score": improvement_data.get("baseline_score", improvement_data.get("baseline_metrics", {}).get("composite_score", 0.0)),
-                            "final_score": improvement_data.get("final_score", improvement_data.get("final_metrics", {}).get("composite_score", 0.0)),
-                            "improvement": improvement_data.get("improvement_percent", "N/A"),
+                            "baseline_score": round(baseline_score, 4) if isinstance(baseline_score, (int, float)) else baseline_score,
+                            "final_score": round(final_score, 4) if isinstance(final_score, (int, float)) else final_score,
+                            "improvement": improvement_percent,
                             "iterations_run": result.total_iterations if hasattr(result, 'total_iterations') else improvement_data.get("iterations", 0),
                             "optimization_time": f"{result.optimization_time:.2f}s" if hasattr(result, 'optimization_time') else "N/A",
                         }
+                        
+                        # Log the improvement data for debugging
+                        logger.info(f"📊 Improvement data received: {improvement_data}")
+                        logger.info(f"📊 Formatted metrics: {improvement_metrics}")
                     else:
                         improvement_metrics = {}
+                        logger.warning(f"⚠️ improvement_data is not a dict: {type(improvement_data)}")
                     
                     # Create iteration history from reflection_history if available
                     iteration_history = []