Update app.py

app.py

@@ -360,202 +360,83 @@ def get_recommendation_with_agent(user_id, merchant, category, amount):
         
         print(f"🔍 KEYS: {list(result.keys())}")
         
-        card_id = result.get('recommended_card', 'Unknown')
-        rewards_earned = float(result.get('rewards_earned', 0))
-        rewards_rate = result.get('rewards_rate', 'N/A')
-        confidence = float(result.get('confidence', 0))
-        reasoning = result.get('reasoning', 'No reasoning provided')
-        alternatives = result.get('alternative_options', [])
-        warnings = result.get('warnings', [])
+        recommendation = result.get('recommendation', {})
         
-        card_name_map = {
-            'c_citi_custom_cash': 'Citi Custom Cash',
-            'c_amex_gold': 'American Express Gold',
-            'c_chase_sapphire_reserve': 'Chase Sapphire Reserve',
-            'c_chase_freedom_unlimited': 'Chase Freedom Unlimited',
-            'c_chase_sapphire_preferred': 'Chase Sapphire Preferred',
-            'c_capital_one_venture': 'Capital One Venture',
-            'c_discover_it': 'Discover it',
-            'c_wells_fargo_active_cash': 'Wells Fargo Active Cash'
-        }
-        card_name = card_name_map.get(card_id, card_id.replace('c_', '').replace('_', ' ').title())
+        if not recommendation:
+            yield f"❌ Invalid response: No recommendation found", None
+            return
         
-        transaction_mcc = result.get('mcc', MCC_CATEGORIES.get(category, "5999"))
-        card_details_from_db = get_card_details(card_id, transaction_mcc)
-        card_details = result.get('card_details', {})
-        
-        if not card_details or not card_details.get('reward_rate'):
-            reward_structure = CARD_DATABASE.get(card_id, {}).get('reward_structure', {})
-            
-            if transaction_mcc in reward_structure:
-                reward_rate_value = reward_structure[transaction_mcc]
-            else:
-                reward_rate_value = reward_structure.get('default', 1.0)
-            
-            spending_caps_db = CARD_DATABASE.get(card_id, {}).get('spending_caps', {})
-            
-            card_details = {
-                'reward_rate': reward_rate_value,
-                'monthly_cap': spending_caps_db.get('monthly_bonus'),
-                'annual_cap': spending_caps_db.get('annual_bonus'),
-                'quarterly_cap': spending_caps_db.get('quarterly_bonus'),
-                'base_rate': reward_structure.get('default', 1.0),
-                'annual_fee': CARD_DATABASE.get(card_id, {}).get('annual_fee', 0),
-                'cap_type': 'monthly' if 'monthly_bonus' in spending_caps_db else
-                            'annual' if 'annual_bonus' in spending_caps_db else
-                            'quarterly' if 'quarterly_bonus' in spending_caps_db else 'none'
-            }
-            print(f"✅ Using cards.json details for {card_id}")
+        # ✅ Extract values correctly
+        card_id = recommendation.get('recommended_card', 'Unknown')
+        card_name = recommendation.get('card_name', card_id)
+        rewards_earned = float(recommendation.get('rewards_earned', 0))
+        rewards_rate = recommendation.get('rewards_rate', 'N/A')
+        confidence = float(recommendation.get('confidence', 0))
+        reasoning = recommendation.get('reasoning', 'No reasoning provided')
+        alternatives = recommendation.get('alternative_options', [])
+        warnings = recommendation.get('warnings', [])
+        
+        # ✅ CRITICAL FIX: Access nested annual_impact object
+        annual_impact = recommendation.get('annual_impact', {})
+        annual_potential = annual_impact.get('potential_savings', 0)
+        optimization_score = annual_impact.get('optimization_score', 0)
+        frequency = annual_impact.get('transaction_frequency', 12)
+        annual_spending = annual_impact.get('annual_spending', 0)
+        frequency_label = annual_impact.get('frequency_assumption', f'{frequency}x per year')
+        
+        # ✅ Get card details from database
+        transaction_mcc = transaction.get('mcc', MCC_CATEGORIES.get(category, "5999"))
+        card_details = get_card_details(card_id, transaction_mcc)
         
         reward_rate_value = card_details.get('reward_rate', 1.0)
-        monthly_cap = card_details.get('monthly_cap', None)
-        annual_cap = card_details.get('annual_cap', None)
-        base_rate = card_details.get('base_rate', 1.0)
         annual_fee = card_details.get('annual_fee', 0)
+        spending_caps = card_details.get('spending_caps', {})
         
-        print(f"✅ CARD DETAILS: {reward_rate_value}%, cap={monthly_cap or annual_cap}, fee=${annual_fee}")
-        
-        amount_float = float(amount)
+        # ✅ Calculate baseline comparison
+        baseline_rewards = annual_spending * 0.01
+        net_rewards = annual_potential - annual_fee
+        net_benefit = net_rewards - baseline_rewards
         
-        frequency_map = {
-            'Groceries': 52,
-            'Restaurants': 52,
-            'Gas Stations': 52,
-            'Fast Food': 52,
-            'Airlines': 4,
-            'Hotels': 12,
-            'Online Shopping': 24,
-            'Entertainment': 24,
-        }
-        frequency = frequency_map.get(category, 26)
-        frequency_label = {
-            52: 'weekly',
-            26: 'bi-weekly',
-            24: 'bi-weekly',
-            12: 'monthly',
-            4: 'quarterly'
-        }.get(frequency, f'{frequency}x per year')
-        
-        annual_spend = amount_float * frequency
-        
-        if monthly_cap:
-            monthly_cap_annual = monthly_cap * 12
+        # ✅ Build calculation table
+        if spending_caps and spending_caps.get('limit'):
+            cap_limit = spending_caps['limit']
+            cap_type = spending_caps.get('type', 'monthly')
             
-            if annual_spend <= monthly_cap_annual:
-                high_rate_spend = annual_spend
-                low_rate_spend = 0
+            if cap_type == 'monthly':
+                cap_annual = cap_limit * 12
+            elif cap_type == 'quarterly':
+                cap_annual = cap_limit * 4
             else:
-                high_rate_spend = monthly_cap_annual
-                low_rate_spend = annual_spend - monthly_cap_annual
+                cap_annual = cap_limit
             
-            high_rate_rewards = high_rate_spend * (reward_rate_value / 100)
-            low_rate_rewards = low_rate_spend * (base_rate / 100)
-            total_rewards = high_rate_rewards + low_rate_rewards
-            
-            calc_table = f"""
-| Spending Tier | Annual Amount | Rate | Rewards |
-|---------------|---------------|------|---------|
-| First ${monthly_cap}/month | ${high_rate_spend:.2f} | {reward_rate_value}% | ${high_rate_rewards:.2f} |
-| Remaining spend | ${low_rate_spend:.2f} | {base_rate}% | ${low_rate_rewards:.2f} |
-| **Subtotal** | **${annual_spend:.2f}** | - | **${total_rewards:.2f}** |
-| Annual fee | - | - | -${annual_fee:.2f} |
-| **Net Rewards** | - | - | **${total_rewards - annual_fee:.2f}** |
-"""
-            
-        elif annual_cap:
-            if annual_spend <= annual_cap:
-                high_rate_spend = annual_spend
+            if annual_spending <= cap_annual:
+                high_rate_spend = annual_spending
                 low_rate_spend = 0
             else:
-                high_rate_spend = annual_cap
-                low_rate_spend = annual_spend - annual_cap
+                high_rate_spend = cap_annual
+                low_rate_spend = annual_spending - cap_annual
             
             high_rate_rewards = high_rate_spend * (reward_rate_value / 100)
-            low_rate_rewards = low_rate_spend * (base_rate / 100)
-            total_rewards = high_rate_rewards + low_rate_rewards
+            low_rate_rewards = low_rate_spend * (card_details.get('base_rate', 1.0) / 100)
             
-            calc_table = f"""
-| Spending Tier | Annual Amount | Rate | Rewards |
+            calc_table = f"""| Spending Tier | Annual Amount | Rate | Rewards |
 |---------------|---------------|------|---------|
-| Up to ${annual_cap:,.0f}/year | ${high_rate_spend:.2f} | {reward_rate_value}% | ${high_rate_rewards:.2f} |
-| Above cap | ${low_rate_spend:.2f} | {base_rate}% | ${low_rate_rewards:.2f} |
-| **Subtotal** | **${annual_spend:.2f}** | - | **${total_rewards:.2f}** |
+| First ${spending_caps['display']} | ${high_rate_spend:.2f} | {reward_rate_value}% | ${high_rate_rewards:.2f} |
+| Remaining spend | ${low_rate_spend:.2f} | {card_details.get('base_rate', 1.0)}% | ${low_rate_rewards:.2f} |
+| **Subtotal** | **${annual_spending:.2f}** | - | **${annual_potential:.2f}** |
 | Annual fee | - | - | -${annual_fee:.2f} |
-| **Net Rewards** | - | - | **${total_rewards - annual_fee:.2f}** |
-"""
-            
+| **Net Rewards** | - | - | **${net_rewards:.2f}** |"""
         else:
-            total_rewards = annual_spend * (reward_rate_value / 100)
-            
-            calc_table = f"""
-| Spending Tier | Annual Amount | Rate | Rewards |
+            calc_table = f"""| Spending Tier | Annual Amount | Rate | Rewards |
 |---------------|---------------|------|---------|
-| All spending | ${annual_spend:.2f} | {reward_rate_value}% | ${total_rewards:.2f} |
+| All spending | ${annual_spending:.2f} | {reward_rate_value}% | ${annual_potential:.2f} |
 | Annual fee | - | - | -${annual_fee:.2f} |
-| **Net Rewards** | - | - | **${total_rewards - annual_fee:.2f}** |
-"""
-        
-        baseline_rewards = annual_spend * 0.01
-        net_rewards = total_rewards - annual_fee
-        net_benefit = net_rewards - baseline_rewards
-        
-        comparison_text = f"""
-**With {card_name}:**
-- Earnings: ${total_rewards:.2f}
-- Annual fee: -${annual_fee:.2f}
-- **Net total: ${net_rewards:.2f}/year**
-
-**With Baseline 1% Card:**
-- All spending at 1%: ${baseline_rewards:.2f}/year
-
-**Net Benefit: ${net_benefit:+.2f}/year** {"🎉" if net_benefit > 0 else "⚠️"}
-"""
-        
-        max_possible_rewards = annual_spend * 0.06
+| **Net Rewards** | - | - | **${net_rewards:.2f}** |"""
         
-        if max_possible_rewards > 0:
-            performance_ratio = (net_rewards / max_possible_rewards) * 100
-            
-            if net_rewards > baseline_rewards:
-                improvement = (net_rewards - baseline_rewards) / baseline_rewards
-                baseline_bonus = min(improvement * 20, 20)
-            else:
-                baseline_bonus = -10
-            
-            optimization_score = int(min(performance_ratio + baseline_bonus, 100))
-        else:
-            optimization_score = 0
-        
-        score_breakdown = {
-            'reward_rate': min(30, int(optimization_score * 0.30)),
-            'cap_availability': min(25, int(optimization_score * 0.25)),
-            'annual_fee': min(20, int(optimization_score * 0.20)),
-            'category_match': min(20, int(optimization_score * 0.20)),
-            'penalties': max(-5, int((optimization_score - 100) * 0.05))
-        }
-        
-        score_details = f"""
-**Score Components:**
-- {"✅" if score_breakdown['reward_rate'] > 20 else "⚠️"} Reward rate: **+{score_breakdown['reward_rate']} points**
-- {"✅" if score_breakdown['cap_availability'] > 15 else "⚠️"} Cap availability: **+{score_breakdown['cap_availability']} points**
-- {"✅" if score_breakdown['annual_fee'] > 15 else "⚠️"} Annual fee value: **+{score_breakdown['annual_fee']} points**
-- {"✅" if score_breakdown['category_match'] > 15 else "⚠️"} Category match: **+{score_breakdown['category_match']} points**
-- {"⚠️" if score_breakdown['penalties'] < 0 else "✅"} Limitations: **{score_breakdown['penalties']} points**
-
-**Total: {optimization_score}/100**
-
-**Score Ranges:**
-- 90-100: Optimal choice ✅
-- 80-89: Great choice 👍
-- 70-79: Good choice 👌
-- 60-69: Acceptable ⚠️
-- <60: Suboptimal ❌
-"""
+        # ✅ Format reasoning
         def format_reasoning(text):
-            """Format reasoning text into clean bullet points"""
             if text.strip().startswith(('-', '•', '*', '1.', '2.')):
                 return text
-            
             sentences = text.replace('\n', ' ').split('. ')
             bullets = []
             for sentence in sentences[:4]:
@@ -564,19 +445,18 @@ def get_recommendation_with_agent(user_id, merchant, category, amount):
                     if not sentence.endswith('.'):
                         sentence += '.'
                     bullets.append(f"- {sentence}")
-            
             return '\n'.join(bullets) if bullets else f"- {text}"
         
         reasoning_bullets = format_reasoning(reasoning)
         
-        # Format the output - CRITICAL: No indentation on f-string!
+        # ✅ Build output with CORRECT values from annual_impact
         output = f"""## 🎯 Recommended: **{card_name}**
-        
+
 | Metric | Value |
 |--------|-------|
 | 💰 **Rewards Earned** | ${rewards_earned:.2f} ({rewards_rate}) |
 | 📊 **Confidence** | {confidence*100:.0f}% |
-| 📈 **Annual Potential** | ${net_benefit:.2f}/year |
+| 📈 **Annual Potential** | ${annual_potential:.2f}/year |
 | ⭐ **Optimization Score** | {optimization_score}/100 |
 
 ---
@@ -588,42 +468,38 @@ def get_recommendation_with_agent(user_id, merchant, category, amount):
 ---
 """
         
-        # Alternatives
+        # ✅ Alternatives
         if alternatives:
             output += "\n### 🔄 Alternative Options\n\n"
-            output += "| Card | Rewards | Why? |\n"
-            output += "|------|---------|------|\n"
+            output += "| Card | Rewards | Rate | Why? |\n"
+            output += "|------|---------|------|------|\n"
             for alt in alternatives[:3]:
-                alt_card_id = alt.get('card', '')
-                alt_card_name = card_name_map.get(alt_card_id, alt_card_id.replace('c_', '').replace('_', ' ').title())
+                alt_card_name = alt.get('card_name', alt.get('card', 'Unknown'))
+                alt_rewards = alt.get('rewards_earned', 0)
+                alt_rate = alt.get('rewards_rate', 'N/A')
                 alt_reason = alt.get('reason', 'Good alternative')
-                alt_reward = alt.get('reward_amount', rewards_earned * 0.8)
-                
                 alt_reason_short = alt_reason.split('.')[0].strip()
                 if not alt_reason_short.endswith('.'):
                     alt_reason_short += '.'
-                
-                output += f"| {alt_card_name} | ${alt_reward:.2f} | {alt_reason_short} |\n"
+                output += f"| {alt_card_name} | ${alt_rewards:.2f} | {alt_rate} | {alt_reason_short} |\n"
             output += "\n---\n"
         
-        # Warnings
+        # ✅ Warnings
         if warnings:
             output += "\n### ⚠️ Alerts\n\n"
             for warning in warnings:
                 output += f"- {warning}\n"
             output += "\n---\n"
         
-        # Calculation details (collapsible)
-        output += f"""
-<details>
+        # ✅ Calculation details
+        output += f"""<details>
 <summary>📊 <b>Annual Impact Calculation</b> (Click to expand)</summary>
 
 <br>
 
 **Assumptions:**
-
-- Transaction: ${amount_float:.2f} at {merchant} ({category})
-- Frequency: {frequency_label} → ${annual_spend:.2f}/year
+- Transaction: ${float(amount):.2f} at {merchant} ({category})
+- Frequency: {frequency_label} → ${annual_spending:.2f}/year
 
 **Rewards Breakdown:**
 
@@ -633,26 +509,20 @@ def get_recommendation_with_agent(user_id, merchant, category, amount):
 
 **Net Benefit:** ${net_benefit:+.2f}/year {"🎉" if net_benefit > 0 else "⚠️"}
 
-**Card Details:** {reward_rate_value}% on {category} | Cap: {"$" + str(monthly_cap or annual_cap) if (monthly_cap or annual_cap) else "None"} | Fee: ${annual_fee}
+**Card Details:** {reward_rate_value}% on {category} | Cap: {"$" + str(spending_caps.get('limit', 'None')) if spending_caps else "None"} | Fee: ${annual_fee}
 
 <br>
-
 </details>
 """
-
         
-        chart = create_agent_recommendation_chart_enhanced(result)
+        # ✅ Create chart
+        chart = create_agent_recommendation_chart_enhanced(recommendation)
+        
         yield output, chart
         
-        print("=" * 80)
-        print("📤 FINAL OUTPUT (first 500 chars):")
-        print(output[:500])
-        print("=" * 80)
-    
     except Exception as e:
         print(f"❌ ERROR: {traceback.format_exc()}")
         yield f"❌ **Error:** {str(e)}", None
-
 def create_agent_recommendation_chart_enhanced(result: Dict) -> go.Figure:
     try:
         rec_name_map = {