Fix OptimizedResult handling: use result.prompt property, improvement_data, and reflection_history for real backend

app.py

@@ -74,8 +74,13 @@ def increment_iteration():
 try:
     from gepa_optimizer import quick_optimize_sync, OptimizedResult
     BACKEND_AVAILABLE = True
-except ImportError:
+    logger.info("✅ Successfully imported gepa_optimizer")
+except ImportError as e:
     BACKEND_AVAILABLE = False
+    logger.error(f"❌ Failed to import gepa_optimizer: {str(e)}")
+    logger.error(f"Python path: {sys.path}")
+    logger.error(f"Current directory: {os.getcwd()}")
+    logger.error(f"src directory exists: {os.path.exists(os.path.join(os.path.dirname(__file__), 'src'))}")
     from dataclasses import dataclass
 
     @dataclass
@@ -279,6 +284,11 @@ def validate_api_keys(model: str, api_keys: Dict[str, str]) -> Tuple[bool, str]:
 def safe_optimize(seed_prompt, dataset, model, custom_model="", max_iterations=5, max_metric_calls=50, batch_size=4, use_llego=True, api_keys=None):
     """Safely run optimization with comprehensive error handling."""
     try:
+        # Log backend status
+        if not BACKEND_AVAILABLE:
+            logger.warning("⚠️ Backend not available - using mock optimizer. Check gepa_optimizer installation.")
+        else:
+            logger.info("✅ Backend available - using real gepa_optimizer")
         # Validate seed prompt
         if not seed_prompt or not isinstance(seed_prompt, str):
             return False, "Seed prompt is required and must be a string.", None
@@ -352,23 +362,20 @@ def safe_optimize(seed_prompt, dataset, model, custom_model="", max_iterations=5
                 return False, "Optimization returned no result.", None
             
             # Check for both property-based (real backend) and attribute-based (mock backend)
-            # Try to access the prompt to see if it exists (works for both attributes and properties)
-            has_optimized_prompt = False
+            has_prompt = False
             try:
-                if hasattr(result, 'optimized_prompt'):
-                    # Mock backend - direct attribute
-                    has_optimized_prompt = True
-                elif hasattr(result, 'prompt'):
-                    # Real backend - property-based, try to access it
-                    _ = result.prompt
-                    has_optimized_prompt = True
-                elif hasattr(result, '_result') and hasattr(result._result, 'optimized_prompt'):
-                    has_optimized_prompt = True
-            except Exception:
-                pass
+                # Real backend uses .prompt property
+                if hasattr(result, 'prompt'):
+                    _ = result.prompt  # Try to access property
+                    has_prompt = True
+                # Mock backend uses .optimized_prompt attribute
+                elif hasattr(result, 'optimized_prompt'):
+                    has_prompt = True
+            except Exception as e:
+                logger.warning(f"Error checking result structure: {str(e)}")
             
-            if not has_optimized_prompt:
-                return False, "Optimization result is missing required fields.", None
+            if not has_prompt:
+                return False, "Optimization result is missing required prompt field.", None
             
             return True, "Success", result
             
@@ -695,21 +702,48 @@ def run_optimization_flow(seed, dataset, model, custom_model, iter_count, call_c
             # Show results
             try:
                 # Handle both property-based (real backend) and attribute-based (mock backend)
-                if hasattr(result, 'optimized_prompt'):
+                if hasattr(result, 'prompt'):
+                    # Real backend - use .prompt property
+                    try:
+                        optimized_prompt = result.prompt or ""
+                    except Exception as e:
+                        logger.error(f"Error accessing result.prompt: {str(e)}")
+                        optimized_prompt = ""
+                    
+                    # Get improvement_data (real backend)
+                    improvement_data = result.improvement_data if hasattr(result, 'improvement_data') else {}
+                    
+                    # Convert improvement_data to display format
+                    if isinstance(improvement_data, dict):
+                        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"),
+                            "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",
+                        }
+                    else:
+                        improvement_metrics = {}
+                    
+                    # Create iteration history from reflection_history if available
+                    iteration_history = []
+                    if hasattr(result, '_result') and hasattr(result._result, 'reflection_history'):
+                        reflection_history = result._result.reflection_history
+                        for i, reflection in enumerate(reflection_history, 1):
+                            summary = reflection.get('summary', f'Iteration {i}')
+                            iteration_history.append(f"Iter {i}: {summary}")
+                    elif isinstance(improvement_data, dict) and 'iteration_history' in improvement_data:
+                        iteration_history = improvement_data['iteration_history']
+                    else:
+                        # Fallback: create simple history
+                        iterations = result.total_iterations if hasattr(result, 'total_iterations') else 0
+                        iteration_history = [f"Iteration {i+1} completed" for i in range(iterations)]
+                
+                elif hasattr(result, 'optimized_prompt'):
                     # Mock backend - direct attribute
                     optimized_prompt = result.optimized_prompt or ""
                     improvement_metrics = getattr(result, 'improvement_metrics', {})
                     iteration_history = getattr(result, 'iteration_history', [])
-                elif hasattr(result, 'prompt'):
-                    # Real backend - property-based
-                    optimized_prompt = result.prompt or ""
-                    improvement_data = result.improvement_data if hasattr(result, 'improvement_data') else {}
-                    # improvement_metrics might be in improvement_data or as separate field
-                    improvement_metrics = improvement_data if isinstance(improvement_data, dict) else {}
-                    # For iteration_history, check if it exists in improvement_data or as separate attribute
-                    iteration_history = getattr(result, 'iteration_history', [])
-                    if not iteration_history and isinstance(improvement_data, dict):
-                        iteration_history = improvement_data.get('iteration_history', [])
                 else:
                     optimized_prompt = ""
                     improvement_metrics = {}