Update app.py

app.py

@@ -188,7 +188,7 @@ def get_recommendation_with_agent(user_id, merchant, category, amount):
         
         print(f"🔍 KEYS: {list(result.keys())}")
         
-        # Extract data
+        # ========== EXTRACT BASIC DATA ==========
         card_id = result.get('recommended_card', 'Unknown')
         rewards_earned = float(result.get('rewards_earned', 0))
         rewards_rate = result.get('rewards_rate', 'N/A')
@@ -196,48 +196,98 @@ def get_recommendation_with_agent(user_id, merchant, category, amount):
         reasoning = result.get('reasoning', 'No reasoning provided')
         alternatives = result.get('alternative_options', [])
         warnings = result.get('warnings', [])
-        annual_impact = result.get('annual_impact', {})
         
         # Map card_id to card_name
         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_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())
         
-        # Extract card-specific details from API
+        # ========== CARD DATABASE (FALLBACK) ==========
+        # If API doesn't provide card_details, use this database
+        CARD_DATABASE = {
+            'c_citi_custom_cash': {
+                'reward_rate': 5.0,
+                'monthly_cap': 500,
+                'base_rate': 1.0,
+                'annual_fee': 0,
+                'cap_type': 'monthly'
+            },
+            'c_amex_gold': {
+                'reward_rate': 4.0,
+                'annual_cap': 25000,
+                'base_rate': 1.0,
+                'annual_fee': 250,
+                'cap_type': 'annual'
+            },
+            'c_chase_sapphire_reserve': {
+                'reward_rate': 3.0,
+                'monthly_cap': None,
+                'base_rate': 3.0,
+                'annual_fee': 550,
+                'cap_type': 'none'
+            },
+            'c_chase_freedom_unlimited': {
+                'reward_rate': 1.5,
+                'monthly_cap': None,
+                'base_rate': 1.5,
+                'annual_fee': 0,
+                'cap_type': 'none'
+            },
+            'c_chase_sapphire_preferred': {
+                'reward_rate': 2.0,
+                'monthly_cap': None,
+                'base_rate': 2.0,
+                'annual_fee': 95,
+                'cap_type': 'none'
+            }
+        }
+        
+        # ========== GET CARD DETAILS (API OR FALLBACK) ==========
         card_details = result.get('card_details', {})
-        reward_rate_value = card_details.get('reward_rate', 0)  # e.g., 5 for 5%
-        monthly_cap = card_details.get('monthly_cap', None)  # e.g., 500
-        annual_cap = card_details.get('annual_cap', None)
-        base_rate = card_details.get('base_rate', 1)  # Fallback rate after cap
-        annual_fee = card_details.get('annual_fee', 0)
         
-        print(f"✅ PARSED: {card_name}, ${rewards_earned}, {rewards_rate}, {confidence}")
+        if not card_details or not card_details.get('reward_rate'):
+            # Use fallback database
+            card_details = CARD_DATABASE.get(card_id, {
+                'reward_rate': 1.0,
+                'monthly_cap': None,
+                'annual_cap': None,
+                'base_rate': 1.0,
+                'annual_fee': 0,
+                'cap_type': 'none'
+            })
+            print(f"⚠️ Using fallback card details for {card_id}")
         
-        # ========== DYNAMIC CALCULATION ==========
+        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)
         
-        # Get actual potential savings and score from API
-        potential_savings = annual_impact.get('potential_savings', 0)
-        optimization_score = annual_impact.get('optimization_score', 0)
+        print(f"✅ CARD DETAILS: {reward_rate_value}%, cap={monthly_cap or annual_cap}, fee=${annual_fee}")
         
-        # Calculate annual projection dynamically
+        # ========== CALCULATE ANNUAL PROJECTION ==========
         amount_float = float(amount)
         
-        # Determine frequency assumption (you can make this smarter based on category)
+        # Frequency assumptions by category
         frequency_map = {
             'Groceries': 52,  # Weekly
-            'Restaurants': 52,  # Weekly
-            'Gas Stations': 52,  # Weekly
-            'Fast Food': 52,  # Weekly
+            'Restaurants': 52,
+            'Gas Stations': 52,
+            'Fast Food': 52,
             'Airlines': 4,  # Quarterly
             'Hotels': 12,  # Monthly
-            'Online Shopping': 24,  # Bi-weekly
-            'Entertainment': 24,  # Bi-weekly
+            'Online Shopping': 24,
+            'Entertainment': 24,
         }
-        frequency = frequency_map.get(category, 26)  # Default: bi-weekly
+        frequency = frequency_map.get(category, 26)
         frequency_label = {
             52: 'weekly',
             26: 'bi-weekly',
@@ -248,17 +298,15 @@ def get_recommendation_with_agent(user_id, merchant, category, amount):
         
         annual_spend = amount_float * frequency
         
-        # Calculate rewards based on card structure
+        # ========== TIERED CALCULATION ==========
         if monthly_cap:
-            # Card has monthly cap (e.g., Citi Custom Cash: $500/month at 5%)
+            # Monthly cap logic (e.g., Citi Custom Cash)
             monthly_cap_annual = monthly_cap * 12
             
             if annual_spend <= monthly_cap_annual:
-                # All spending is within cap
                 high_rate_spend = annual_spend
                 low_rate_spend = 0
             else:
-                # Some spending exceeds cap
                 high_rate_spend = monthly_cap_annual
                 low_rate_spend = annual_spend - monthly_cap_annual
             
@@ -266,36 +314,16 @@ def get_recommendation_with_agent(user_id, merchant, category, amount):
             low_rate_rewards = low_rate_spend * (base_rate / 100)
             total_rewards = high_rate_rewards + low_rate_rewards
             
-            # Baseline comparison (1% card)
-            baseline_rewards = annual_spend * 0.01
-            net_benefit = total_rewards - baseline_rewards - annual_fee
-            
-            # Build calculation table
-            calc_table = f"""
-| Spending Tier | Annual Amount | 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}** |
-"""
+| **Net Rewards** | - | - | **${total_rewards - annual_fee:.2f}** |"""
             
-            comparison_text = f"""
-**With {card_name}:**
-- High rate earnings: ${high_rate_rewards:.2f}
-- Base rate earnings: ${low_rate_rewards:.2f}
-- Annual fee: -${annual_fee:.2f}
-- **Net total: ${total_rewards - annual_fee:.2f}/year**
-
-**With Baseline 1% Card:**
-- All spending at 1%: ${baseline_rewards:.2f}/year
-
-**Net Benefit: ${net_benefit:.2f}/year**
-"""
-        
         elif annual_cap:
-            # Card has annual cap (e.g., Amex Gold: $25,000/year at 4x)
+            # Annual cap logic (e.g., Amex Gold)
             if annual_spend <= annual_cap:
                 high_rate_spend = annual_spend
                 low_rate_spend = 0
@@ -307,83 +335,83 @@ def get_recommendation_with_agent(user_id, merchant, category, amount):
             low_rate_rewards = low_rate_spend * (base_rate / 100)
             total_rewards = high_rate_rewards + low_rate_rewards
             
-            baseline_rewards = annual_spend * 0.01
-            net_benefit = total_rewards - baseline_rewards - annual_fee
-            
-            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}** |
 | Annual fee | - | - | -${annual_fee:.2f} |
-| **Net Rewards** | - | - | **${total_rewards - annual_fee:.2f}** |
-"""
+| **Net Rewards** | - | - | **${total_rewards - annual_fee:.2f}** |"""
             
-            comparison_text = f"""
-**With {card_name}:**
-- High rate earnings: ${high_rate_rewards:.2f}
-- Base rate earnings: ${low_rate_rewards:.2f}
-- Annual fee: -${annual_fee:.2f}
-- **Net total: ${total_rewards - annual_fee:.2f}/year**
-
-**With Baseline 1% Card:**
-- All spending at 1%: ${baseline_rewards:.2f}/year
-
-**Net Benefit: ${net_benefit:.2f}/year**
-"""
-        
         else:
-            # No cap - flat rate on all spending
+            # No cap - flat rate
             total_rewards = annual_spend * (reward_rate_value / 100)
-            baseline_rewards = annual_spend * 0.01
-            net_benefit = total_rewards - baseline_rewards - annual_fee
             
-            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} |
 | Annual fee | - | - | -${annual_fee:.2f} |
-| **Net Rewards** | - | - | **${total_rewards - annual_fee:.2f}** |
-"""
-            
-            comparison_text = f"""
-**With {card_name}:**
-- Earnings at {reward_rate_value}%: ${total_rewards:.2f}
+| **Net Rewards** | - | - | **${total_rewards - annual_fee:.2f}** |"""
+        
+        # ========== BASELINE COMPARISON ==========
+        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: ${total_rewards - annual_fee:.2f}/year**
+- **Net total: ${net_rewards:.2f}/year**
 
 **With Baseline 1% Card:**
 - All spending at 1%: ${baseline_rewards:.2f}/year
 
-**Net Benefit: ${net_benefit:.2f}/year**
-"""
+**Net Benefit: ${net_benefit:+.2f}/year** {"🎉" if net_benefit > 0 else "⚠️"}"""
         
-        # Dynamic optimization score breakdown
-        score_breakdown = annual_impact.get('score_breakdown', {})
-        if not score_breakdown:
-            # Generate based on optimization_score
-            score_breakdown = {
-                'reward_rate': min(30, int(optimization_score * 0.3)),
-                'cap_availability': min(25, int(optimization_score * 0.25)),
-                'annual_fee': min(20, int(optimization_score * 0.2)),
-                'category_match': min(20, int(optimization_score * 0.2)),
-                'penalties': max(-5, int((optimization_score - 100) * 0.05))
-            }
+        # ========== OPTIMIZATION SCORE ==========
+        # Calculate score based on performance
+        max_possible_rewards = annual_spend * 0.06  # Theoretical max (6%)
         
-        score_details = f"""
-**Score Components:**
-- {"✅" if score_breakdown.get('reward_rate', 0) > 20 else "⚠️"} Reward rate: **+{score_breakdown.get('reward_rate', 0)} points**
-- {"✅" if score_breakdown.get('cap_availability', 0) > 15 else "⚠️"} Cap availability: **+{score_breakdown.get('cap_availability', 0)} points**
-- {"✅" if score_breakdown.get('annual_fee', 0) > 15 else "⚠️"} Annual fee value: **+{score_breakdown.get('annual_fee', 0)} points**
-- {"✅" if score_breakdown.get('category_match', 0) > 15 else "⚠️"} Category match: **+{score_breakdown.get('category_match', 0)} points**
-- {"⚠️" if score_breakdown.get('penalties', 0) < 0 else "✅"} Limitations: **{score_breakdown.get('penalties', 0)} points**
+        if max_possible_rewards > 0:
+            performance_ratio = (net_rewards / max_possible_rewards) * 100
+            
+            # Bonus for beating baseline
+            if net_rewards > baseline_rewards:
+                improvement = (net_rewards - baseline_rewards) / baseline_rewards
+                baseline_bonus = min(improvement * 20, 20)
+            else:
+                baseline_bonus = -10  # Penalty for underperforming
+            
+            optimization_score = int(min(performance_ratio + baseline_bonus, 100))
+        else:
+            optimization_score = 0
+        
+        # Score breakdown
+        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 OUTPUT ==========
-        
         output = f"""## 🤖 AI Agent Recommendation
 
 ### 💳 Recommended Card: **{card_name}**
@@ -397,8 +425,7 @@ def get_recommendation_with_agent(user_id, merchant, category, amount):
 
 {reasoning}
 
----
-"""
+---"""
         
         # Add alternatives
         if alternatives:
@@ -415,12 +442,11 @@ def get_recommendation_with_agent(user_id, merchant, category, amount):
             for warning in warnings:
                 output += f"- {warning}\n"
         
-        # Add dynamic annual impact
-        if annual_impact:
-            output += f"""
+        # Add annual impact with expandable details
+        output += f"""
 ### 💰 Annual Impact
 
-- **Potential Savings:** ${potential_savings:.2f}/year
+- **Potential Savings:** ${net_benefit:.2f}/year
 - **Optimization Score:** {optimization_score}/100
 
 <details>
@@ -430,10 +456,11 @@ def get_recommendation_with_agent(user_id, merchant, category, amount):
 
 **Step 1: Estimate Annual Spending**
 
-Current transaction: amountfloat:.2fatmerchantCategory:categoryFrequencyassumption:frequencylabel.capitalize()Annualestimate:{amount_float:.2f} at {merchant}
-Category: {category}
-Frequency assumption: {frequency_label.capitalize()}
-Annual estimate: amountf​loat:.2fatmerchantCategory:categoryFrequencyassumption:frequencyl​abel.capitalize()Annualestimate:{amount_float:.2f} × {frequency} = ${annual_spend:.2f}
+Current transaction: ${amount_float:.2f} at {merchant}  
+Category: {category}  
+Frequency assumption: {frequency_label.capitalize()}  
+Annual estimate: ${amount_float:.2f} × {frequency} = **${annual_spend:.2f}**
+
 **Step 2: Calculate Rewards with {card_name}**
 
 {calc_table}
@@ -448,13 +475,6 @@ Annual estimate: amountf​loat:.2fatmerchantCategory:categoryFrequencyassumptio
 
 {score_details}
 
-**Score Ranges:**
-- 90-100: Optimal choice ✅
-- 80-89: Great choice 👍
-- 70-79: Good choice 👌
-- 60-69: Acceptable ⚠️
-- <60: Suboptimal ❌
-
 ---
 
 #### 🔍 Card Details:
@@ -466,27 +486,22 @@ Annual estimate: amountf​loat:.2fatmerchantCategory:categoryFrequencyassumptio
 
 </details>
 
----
-"""
+---"""
         
         # Add transaction details
-        output += f"""
-### 📊 Transaction Details:
-
+        output += f"""### 📊 Transaction Details:
 - **Amount:** ${amount_float:.2f}
 - **Merchant:** {merchant}
 - **Category:** {category}
-- **MCC Code:** {transaction['mcc']}
-"""
+- **MCC Code:** {transaction['mcc']}"""
         
         chart = create_agent_recommendation_chart_enhanced(result)
         yield output, chart
-        
+    
     except Exception as e:
         import traceback
         print(f"❌ ERROR: {traceback.format_exc()}")
-        yield f"❌ **Error:** {str(e)}", None
-        
+        yield f"❌ **Error:** {str(e)}", None        
         
 def create_agent_recommendation_chart_enhanced(result: Dict) -> go.Figure:
     try: