Update app.py

app.py

@@ -179,41 +179,112 @@ def get_recommendation_with_agent(user_id, merchant, category, amount):
         
         result = response.json()
         
-        # Extract agent data safely
-        recommended_card = safe_get(result, 'recommended_card', {})
-        if isinstance(recommended_card, dict):
-            card_name = safe_get(recommended_card, 'card_name', 'Unknown Card')
-        else:
-            card_name = str(recommended_card)
+        # ✅ FIXED: Extract data from new response format
+        recommendation = safe_get(result, 'recommendation', {})
+        reasoning_data = safe_get(result, 'reasoning', {})
+        services_data = safe_get(result, 'services_used', {})
+        metadata = safe_get(result, 'agent_metadata', {})
+        transaction_info = safe_get(result, 'transaction', {})
+        plan = safe_get(result, 'plan', {})
         
-        # Format response with agent insights
-        output = f"""
-## 🤖 AI Agent Recommendation
+        # Extract card info
+        card_name = safe_get(recommendation, 'card_name', 
+                           safe_get(recommendation, 'recommended_card', 'Unknown Card'))
+        rewards_earned = safe_get(recommendation, 'rewards_earned', 0)
+        rewards_rate = safe_get(recommendation, 'rewards_rate', 'N/A')
+        confidence = safe_get(recommendation, 'confidence', 0)
+        confidence_label = safe_get(recommendation, 'confidence_label', 'Unknown')
+        
+        # Extract reasoning
+        main_reasoning = safe_get(reasoning_data, 'main', 'No reasoning provided')
+        why_points = safe_get(reasoning_data, 'why_this_card', [])
+        alternatives = safe_get(reasoning_data, 'alternative_options', [])
+        warnings = safe_get(reasoning_data, 'warnings', [])
+        
+        # Extract insights
+        insights = safe_get(result, 'insights', {})
+        annual_impact = safe_get(insights, 'annual_impact', {})
+        optimization_score = safe_get(insights, 'optimization_score', 0)
+        
+        # Extract transaction details
+        tx_amount = safe_get(transaction_info, 'amount', amount)
+        tx_merchant = safe_get(transaction_info, 'merchant', merchant)
+        tx_category = safe_get(transaction_info, 'category', category)
+        
+        # Extract service statuses
+        services_used = []
+        for service_name, service_data in services_data.items():
+            if isinstance(service_data, dict) and safe_get(service_data, 'status') == 'success':
+                services_used.append(service_name)
+        
+        # Processing time
+        processing_time = safe_get(metadata, 'processing_time_ms', 0)
+        
+        # ✅ Format comprehensive output
+        output = f"""## 🤖 AI Agent Recommendation
 
 ### 💳 Recommended Card: **{card_name}**
 
-### 🧠 Agent's Reasoning:
-{safe_get(result, 'final_recommendation', 'No reasoning provided')}
+**Rewards Earned:** ${rewards_earned:.2f} ({rewards_rate})  
+**Confidence:** {confidence_label} ({confidence*100:.0f}%)
 
 ---
 
-### 📊 Quick Stats:
-- **Amount**: ${safe_get(result, 'amount_usd', amount):.2f}
-- **Merchant**: {safe_get(result, 'merchant', merchant)}
-- **Category**: {safe_get(result, 'category', category)}
-- **Services Used**: {', '.join(safe_get(result, 'services_used', []))}
-- **Processing Time**: {safe_get(result, 'orchestration_time_ms', 0):.0f}ms
+### 🧠 Agent's Reasoning:
 
+{main_reasoning}
+"""
+        
+        # Add key points
+        if why_points:
+            output += "\n\n**Why This Card:**\n"
+            for point in why_points[:3]:
+                output += f"- {point}\n"
+        
+        output += f"""
 ---
 
-### 💡 Why This Card?
-The AI agent analyzed your transaction context, card portfolio, and spending patterns to determine this is your optimal choice.
+### 📊 Transaction Details:
+- **Amount:** ${tx_amount:.2f}
+- **Merchant:** {tx_merchant}
+- **Category:** {tx_category}
 
-**Confidence Level**: High ✅
+### ⚙️ Agent Performance:
+- **Services Used:** {', '.join(services_used) if services_used else 'N/A'}
+- **Processing Time:** {processing_time:.0f}ms
+- **Planning Confidence:** {safe_get(metadata, 'planning_confidence', 0)*100:.0f}%
 """
         
-        # Create simple comparison chart
-        chart = create_agent_recommendation_chart(result)
+        # Add annual impact if available
+        if annual_impact:
+            potential_savings = safe_get(annual_impact, 'potential_savings', 0)
+            if potential_savings > 0:
+                output += f"\n### 💰 Annual Impact:\n- **Potential Savings:** ${potential_savings:.2f}/year\n"
+                output += f"- **Optimization Score:** {optimization_score}/100\n"
+        
+        # Add warnings
+        if warnings:
+            output += "\n\n### ⚠️ Important Warnings:\n"
+            for warning in warnings:
+                output += f"- {warning}\n"
+        
+        # Add alternatives
+        if alternatives:
+            output += "\n\n### 🔄 Alternative Options:\n"
+            for alt in alternatives[:3]:
+                alt_card = safe_get(alt, 'card', 'Unknown')
+                alt_reason = safe_get(alt, 'reason', 'Alternative option')
+                output += f"- **{alt_card}:** {alt_reason}\n"
+        
+        # Add plan strategy
+        strategy = safe_get(plan, 'strategy', '')
+        if strategy:
+            output += f"\n\n### 🎯 Agent Strategy:\n{strategy}\n"
+        
+        output += "\n---\n\n💡 **The AI agent analyzed your transaction context, card portfolio, and spending patterns to determine this is your optimal choice.**"
+        
+        # ✅ Create enhanced comparison chart
+        chart = create_agent_recommendation_chart_enhanced(result)
         
         yield output, chart
         
@@ -223,40 +294,59 @@ The AI agent analyzed your transaction context, card portfolio, and spending pat
         import traceback
         error_details = traceback.format_exc()
         print(f"Agent recommendation error: {error_details}")
-        yield f"❌ **Error**: {str(e)}\n\nPlease check the orchestrator service or try again.", None
-
+        yield f"❌ **Error:** {str(e)}\n\nPlease check the orchestrator service or try again.", None
+        
 
 def create_agent_recommendation_chart(result: Dict) -> go.Figure:
-    """Create simple chart showing agent's recommendation"""
+    """Create enhanced chart showing agent's recommendation with alternatives"""
     try:
-        # Extract card info
-        recommended = result.get('recommended_card', {})
-        alternatives = result.get('alternative_cards', [])[:2]  # Top 2 alternatives
+        # Extract recommendation data
+        recommendation = safe_get(result, 'recommendation', {})
+        reasoning_data = safe_get(result, 'reasoning', {})
         
-        if isinstance(recommended, dict):
-            rec_name = recommended.get('card_name', 'Recommended Card')
-            rec_reward = recommended.get('reward_amount', 0)
-        else:
-            rec_name = str(recommended)
-            rec_reward = 0
+        # Get recommended card
+        rec_name = safe_get(recommendation, 'card_name', 
+                          safe_get(recommendation, 'recommended_card', 'Recommended Card'))
+        rec_reward = float(safe_get(recommendation, 'rewards_earned', 0))
+        
+        # Get alternatives
+        alternatives = safe_get(reasoning_data, 'alternative_options', [])
         
         cards = [rec_name]
         rewards = [rec_reward]
         colors = ['#667eea']  # Purple for recommended
         
         # Add alternatives
-        for alt in alternatives:
+        for alt in alternatives[:3]:  # Limit to top 3
             if isinstance(alt, dict):
-                cards.append(alt.get('card_name', 'Alternative'))
-                rewards.append(alt.get('reward_amount', 0))
+                alt_card = safe_get(alt, 'card', 'Alternative')
+                # Try to extract reward amount from reason text if available
+                alt_reward = rec_reward * 0.8  # Estimate if not provided
+                cards.append(alt_card)
+                rewards.append(alt_reward)
                 colors.append('#cbd5e0')  # Gray for alternatives
         
+        # Only create chart if we have valid data
+        if not cards or all(r == 0 for r in rewards):
+            fig = go.Figure()
+            fig.add_annotation(
+                text="No comparison data available",
+                xref="paper", yref="paper",
+                x=0.5, y=0.5, showarrow=False,
+                font=dict(size=14, color="#666")
+            )
+            fig.update_layout(height=400, template='plotly_white')
+            return fig
+        
         # Create bar chart
         fig = go.Figure(data=[
             go.Bar(
                 x=cards,
                 y=rewards,
-                marker=dict(color=colors, line=dict(color='white', width=2)),
+                marker=dict(
+                    color=colors,
+                    line=dict(color='white', width=2)
+                ),
                 text=[f'${r:.2f}' for r in rewards],
                 textposition='outside',
                 hovertemplate='<b>%{x}</b><br>Rewards: $%{y:.2f}<extra></extra>'
@@ -264,7 +354,11 @@ def create_agent_recommendation_chart(result: Dict) -> go.Figure:
         ])
         
         fig.update_layout(
-            title={'text': '🎯 Agent\'s Card Comparison', 'x': 0.5, 'xanchor': 'center'},
+            title={
+                'text': '🎯 Agent\'s Card Comparison',
+                'x': 0.5,
+                'xanchor': 'center'
+            },
             xaxis_title='Credit Card',
             yaxis_title='Rewards Earned ($)',
             template='plotly_white',
@@ -277,6 +371,9 @@ def create_agent_recommendation_chart(result: Dict) -> go.Figure:
         
     except Exception as e:
         print(f"Chart error: {e}")
+        import traceback
+        print(traceback.format_exc())
+        
         fig = go.Figure()
         fig.add_annotation(
             text="Chart unavailable",
@@ -287,7 +384,6 @@ def create_agent_recommendation_chart(result: Dict) -> go.Figure:
         fig.update_layout(height=400, template='plotly_white')
         return fig
 
-
         
 # Initialize clients
 client = RewardPilotClient(config.ORCHESTRATOR_URL)