Update app.py

app.py

@@ -3,89 +3,62 @@
 import os
 import re
 import requests
-from datetime import datetime, timedelta
+from datetime import datetime
 from typing import Optional
 from smolagents import CodeAgent, DuckDuckGoSearchTool, HfApiModel, load_tool, tool
 from Gradio_UI import GradioUI
 
 # ======================
-# TRAVEL TOOLS (PRODUCTION-GRADE)
+# TRAVEL TOOLS (SMOLAGENTS-COMPLIANT DOCSTRINGS)
 # ======================
 
 @tool
 def get_weather_forecast(location: str, travel_dates: str) -> str:
     """
-    Get weather forecast using OpenWeatherMap (fallback to wttr.in).
+    Get weather forecast for destination using wttr.in API.
+
     Args:
-        location: Destination city (e.g., "Barcelona")
-        travel_dates: Date range (e.g., "2026-10-15 to 2026-10-19")
+        location: Destination city name (e.g., "Barcelona")
+        travel_dates: Travel date range string (e.g., "October 15-19")
+
     Returns:
-        Weather summary with packing advice
+        Weather summary string with temperature and packing recommendations
     """
-    api_key = os.environ.get("OPENWEATHER_API_KEY")
     try:
-        # Parse dates to get start date
-        start_date = re.search(r"(\d{4}-\d{2}-\d{2})", travel_dates)
-        if not start_date:
-            raise ValueError("Invalid date format")
-        
-        # Try OpenWeatherMap first (more reliable)
-        if api_key:
-            city = re.sub(r"[^a-zA-Z\s]", "", location).strip()
-            resp = requests.get(
-                f"https://api.openweathermap.org/data/2.5/forecast",
-                params={"q": city, "appid": api_key, "units": "metric"},
-                timeout=10
-            )
-            if resp.status_code == 200:
-                data = resp.json()
-                day1 = data["list"][0]
-                temp = day1["main"]["temp"]
-                cond = day1["weather"][0]["description"]
-                rain = "rain" in cond.lower() or day1.get("rain", {}).get("3h", 0) > 1
-                return _generate_packing_advice(location, temp, cond, rain)
-        
-        # Fallback to wttr.in
         clean = re.sub(r"[^a-zA-Z0-9\s]", "", location).replace(" ", "+")
         resp = requests.get(f"http://wttr.in/{clean}?format=j1", timeout=10)
-        if resp.status_code == 200:
-            data = resp.json()
-            cur = data["current_condition"][0]
-            temp = int(cur["temp_C"])
-            cond = cur["lang_en"][0]["value"]
-            rain = "rain" in cond.lower()
-            return _generate_packing_advice(location, temp, cond, rain)
-            
+        resp.raise_for_status()
+        data = resp.json()
+        cur = data["current_condition"][0]
+        temp = int(cur["temp_C"])
+        cond = cur["lang_en"][0]["value"].lower()
+        
+        if temp > 25:
+            pack = "Light clothing, shorts, breathable fabrics, sunscreen, hat"
+        elif temp > 15:
+            pack = "Light layers, long sleeves, light jacket"
+        else:
+            pack = "Warm layers, jacket, beanie recommended"
+        
+        if "rain" in cond or "shower" in cond:
+            pack += " + compact umbrella + waterproof jacket"
+        
+        return f"{location} forecast: {temp}°C, {cond}. Packing: {pack}"
     except Exception:
-        pass
-    
-    # Safe fallback
-    return f"{location} typical weather: 15-25°C. Pack light layers, light jacket, and compact umbrella."
-
-def _generate_packing_advice(location: str, temp: float, condition: str, rain: bool) -> str:
-    """Helper to generate weather-based packing advice"""
-    if temp > 25:
-        clothes = "Light clothing, shorts, breathable fabrics"
-    elif temp > 15:
-        clothes = "Light layers, long sleeves, light jacket"
-    else:
-        clothes = "Warm layers, jacket, beanie recommended"
-    
-    if rain:
-        clothes += " + waterproof jacket + compact umbrella"
-    
-    return f"{location} forecast: {temp:.0f}°C, {condition}. Packing: {clothes}"
+        return f"{location} typical weather: 15-25°C. Pack versatile layers, light jacket, and compact umbrella."
 
 @tool
 def convert_currency(amount: float, from_currency: str, to_currency: str) -> str:
     """
-    Convert currency using Frankfurter API (no key required).
+    Convert currency amount using Frankfurter API (no API key required).
+
     Args:
-        amount: Amount to convert
-        from_currency: Source currency (e.g., "USD")
-        to_currency: Target currency (e.g., "EUR")
+        amount: Numeric amount to convert (e.g., 1200.0)
+        from_currency: Source currency ISO code (e.g., "USD")
+        to_currency: Target currency ISO code (e.g., "EUR")
+
     Returns:
-        Formatted conversion result
+        Formatted string showing conversion result and exchange rate
     """
     try:
         from_curr = from_currency.upper()[:3]
@@ -99,133 +72,156 @@ def convert_currency(amount: float, from_currency: str, to_currency: str) -> str
             params={"from": from_curr, "to": to_curr},
             timeout=10
         )
-        if resp.status_code == 200:
-            rate = resp.json()["rates"][to_curr]
-            converted = amount * rate
-            return f"{amount:,.0f} {from_curr} = {converted:,.0f} {to_curr} (1 {from_curr} = {rate:.2f} {to_curr})"
+        resp.raise_for_status()
+        rate = resp.json()["rates"][to_curr]
+        converted = amount * rate
+        return f"{amount:,.0f} {from_curr} = {converted:,.0f} {to_curr} (1 {from_curr} = {rate:.2f} {to_curr})"
     except Exception:
-        pass
-    
-    return f"{amount:,.0f} {from_currency} (conversion rate unavailable)"
+        return f"{amount:,.0f} {from_currency} (conversion rate unavailable)"
 
 @tool
-def get_time_difference(origin: str, destination: str) -> str:
+def get_time_difference(origin_city: str, destination_city: str) -> str:
     """
-    Get time difference between origin and destination cities.
+    Calculate time difference between origin and destination cities using heuristic mapping.
+
     Args:
-        origin: Home city
-        destination: Travel destination
+        origin_city: Traveler's home city name (e.g., "New York")
+        destination_city: Travel destination city name (e.g., "Paris")
+
     Returns:
-        Time difference description
+        Human-readable string describing time difference and jet lag advice
     """
-    try:
-        # Simple heuristic-based approach (no external API required)
-        major_cities = {
-            "new york": -5, "london": 0, "paris": 1, "tokyo": 9, "sydney": 10,
-            "los angeles": -8, "chicago": -6, "mumbai": 5.5, "dubai": 4,
-            "singapore": 8, "berlin": 1, "rome": 1, "barcelona": 1, "madrid": 1
-        }
-        
-        origin_tz = major_cities.get(origin.lower(), 0)
-        dest_tz = major_cities.get(destination.lower(), 0)
-        diff = dest_tz - origin_tz
-        
-        if diff == 0:
-            return f"No time difference between {origin} and {destination}"
-        elif diff > 0:
-            return f"{destination} is {diff} hours ahead of {origin} (adjust sleep schedule accordingly)"
-        else:
-            return f"{destination} is {abs(diff)} hours behind {origin} (prepare for jet lag)"
-    except:
-        return f"Time difference information unavailable. Check world clock apps before travel."
+    city_tz = {
+        "new york": -5, "london": 0, "paris": 1, "tokyo": 9, "sydney": 10,
+        "los angeles": -8, "chicago": -6, "mumbai": 5.5, "dubai": 4,
+        "singapore": 8, "berlin": 1, "rome": 1, "barcelona": 1, "madrid": 1,
+        "amsterdam": 1, "vienna": 1, "prague": 1, "budapest": 1, "warsaw": 1,
+        "stockholm": 1, "oslo": 1, "copenhagen": 1, "helsinki": 2, "athens": 2,
+        "istanbul": 3, "cairo": 2, "bangkok": 7, "seoul": 9, "beijing": 8,
+        "shanghai": 8, "hong kong": 8, "manila": 8, "kuala lumpur": 8,
+        "jakarta": 7, "delhi": 5.5, "rio de janeiro": -3, "sao paulo": -3,
+        "buenos aires": -3, "mexico city": -6, "toronto": -5, "vancouver": -8,
+        "montreal": -5, "miami": -5, "las vegas": -8, "san francisco": -8,
+        "seattle": -8, "denver": -7, "dallas": -6, "houston": -6, "atlanta": -5,
+        "boston": -5, "philadelphia": -5, "washington dc": -5, "orlando": -5,
+        "phoenix": -7, "minneapolis": -6, "detroit": -5, "pittsburgh": -5,
+        "cleveland": -5, "cincinnati": -5, "st louis": -6, "kansas city": -6,
+        "new orleans": -6, "memphis": -6, "nashville": -6, "charlotte": -5,
+        "raleigh": -5, "baltimore": -5, "milwaukee": -6, "indianapolis": -5,
+        "louisville": -5, "portland": -8, "salt lake city": -7, "albuquerque": -7,
+        "tucson": -7, "fresno": -8, "sacramento": -8, "oakland": -8, "san jose": -8,
+        "las palmas": 0, "tenerife": 0, "lisbon": 0, "madrid": 1, "barcelona": 1,
+        "valencia": 1, "seville": 1, "malaga": 1, "bilbao": 1, "zaragoza": 1,
+        "granada": 1, "alicante": 1, "murcia": 1, "palma": 1, "ibiza": 1,
+        "menorca": 1, "fuerteventura": 0, "lanzarote": 0, "tenerife": 0,
+        "gran canaria": 0, "la palma": 0, "el hierro": 0, "la gomera": 0,
+        "santa cruz de tenerife": 0, "las palmas de gran canaria": 0,
+    }
+    
+    origin_key = origin_city.lower().strip()
+    dest_key = destination_city.lower().strip()
+    
+    origin_tz = city_tz.get(origin_key, 0)
+    dest_tz = city_tz.get(dest_key, 0)
+    diff = dest_tz - origin_tz
+    
+    if diff == 0:
+        return f"No time difference between {origin_city} and {destination_city}."
+    elif diff > 0:
+        return f"{destination_city} is {diff} hours ahead of {origin_city}. Prepare for eastward jet lag (may cause fatigue)."
+    else:
+        return f"{destination_city} is {abs(diff)} hours behind {origin_city}. Prepare for westward jet lag (may cause insomnia)."
 
 @tool
 def generate_packing_list(destination: str, weather_summary: str, trip_days: int, trip_type: str) -> str:
     """
-    Generate customized packing list.
+    Generate customized packing checklist based on destination, weather, duration and trip type.
+
     Args:
-        destination: Destination name
-        weather_summary: Weather conditions
-        trip_days: Duration in days
-        trip_type: "city", "beach", "mountain", or "mixed"
+        destination: Destination city or region name (e.g., "Barcelona")
+        weather_summary: Weather forecast string containing temperature and conditions
+        trip_days: Total number of travel days (integer >= 1)
+        trip_type: Type of trip: "city", "beach", "mountain", or "mixed"
+
     Returns:
-        Formatted packing checklist
+        Formatted multi-section packing checklist as string
     """
-    cold = any(w in weather_summary.lower() for w in ["cold", "cool", "jacket", "10°c", "11°c", "12°c", "13°c", "14°c"])
-    rain = any(w in weather_summary.lower() for w in ["rain", "shower", "umbrella", "drizzle"])
-    hot = any(w in weather_summary.lower() for w in ["hot", "warm", "25°c", "26°c", "27°c", "28°c", "29°c", "30°c"])
+    weather_lower = weather_summary.lower()
+    cold = any(w in weather_lower for w in ["cold", "cool", "10°c", "11°c", "12°c", "13°c", "14°c", "jacket", "below 15"])
+    rain = any(w in weather_lower for w in ["rain", "shower", "drizzle", "umbrella", "precipitation"])
+    hot = any(w in weather_lower for w in ["hot", "warm", "25°c", "26°c", "27°c", "28°c", "29°c", "30°c", "above 25"])
     
-    # Clothing calculations
     tops = min(trip_days, trip_days // 2 + 2)
     bottoms = min(trip_days // 2 + 1, 4)
     
     clothes = [f"• Tops ({tops})", f"• Bottoms ({bottoms})"]
     if cold:
-        clothes.extend(["• Warm jacket", "• Long underwear (if very cold)"])
+        clothes.extend(["• Warm jacket/coat", "• Long underwear (if very cold)", "• Warm socks (x3)"])
     elif hot:
-        clothes.extend(["• Light breathable fabrics", "• Sun hat"])
+        clothes.extend(["• Light breathable fabrics", "• Sun hat", "• Sunglasses", "• Reef-safe sunscreen (SPF 50+)"])
     else:
-        clothes.append("• Light jacket (essential)")
+        clothes.append("• Light jacket or sweater (essential)")
     
     if rain:
-        clothes.extend(["• Compact umbrella", "• Quick-dry clothing"])
+        clothes.extend(["• Compact travel umbrella", "• Quick-dry clothing", "• Waterproof shoes or sandals"])
     
     if trip_type == "beach":
-        clothes.extend(["• Swimsuit (x2)", "• Flip-flops", "• Reef-safe sunscreen"])
+        clothes.extend(["• Swimsuit (x2)", "• Beach towel", "• Flip-flops/sandals", "• Beach bag"])
     elif trip_type == "mountain":
-        clothes.extend(["• Sturdy hiking shoes", "• Moisture-wicking layers", "• Trekking poles (optional)"])
+        clothes.extend(["• Sturdy hiking shoes", "• Moisture-wicking base layers", "• Trekking socks (x3)", "• Daypack"])
     
     return (
         f"🎒 SMART PACKING LIST ({trip_days}-day {trip_type} trip to {destination})\n"
         "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
         "ESSENTIALS\n"
-        "• Passport + photocopies + digital scans\n"
-        "• Credit/debit cards + local currency (small amount)\n"
+        "• Passport + photocopies + digital scans in cloud\n"
+        "• Credit/debit cards + small amount of local currency\n"
         "• Universal power adapter\n"
-        "• Phone + portable charger + cables\n"
-        "• Travel insurance documents\n"
+        "• Phone + portable charger (10,000mAh+) + cables\n"
+        "• Travel insurance documents (digital + physical)\n"
         "\nCLOTHING\n" + "\n".join(clothes) + "\n"
         "\nHEALTH & HYGIENE\n"
-        "• Prescription medications (in original packaging)\n"
-        "• Basic first-aid kit\n"
-        "• Hand sanitizer + tissues\n"
-        "• Travel-sized toiletries\n"
-        "\n💡 Pro tip: Roll clothes to save space. Pack one versatile outfit per day + 1 extra."
+        "• Prescription medications (in original packaging + doctor's note)\n"
+        "• Basic first-aid kit (bandages, antiseptic, pain relievers)\n"
+        "• Hand sanitizer (60ml travel size)\n"
+        "• Travel-sized toiletries (toothbrush, toothpaste, deodorant)\n"
+        "\n💡 Pro tip: Roll clothes to save space. Pack one versatile outfit per day + 1 extra day buffer."
     )
 
 @tool
 def build_itinerary(destination: str, attractions: str, budget_local: float, days: int) -> str:
     """
-    Create realistic day-by-day itinerary.
+    Create realistic day-by-day travel itinerary with time allocations and budget guidance.
+
     Args:
-        destination: City name
-        attractions: Comma-separated attractions
-        budget_local: Daily budget in local currency
-        days: Trip duration
+        destination: Destination city name (e.g., "Barcelona")
+        attractions: Comma-separated list of attraction names (e.g., "Sagrada Familia, Park Guell")
+        budget_local: Total budget converted to local currency (float)
+        days: Number of full travel days (integer >= 1)
+
     Returns:
-        Formatted itinerary
+        Formatted multi-day itinerary with time slots and daily budget allocation
     """
-    atts = [a.strip() for a in attractions.split(",") if a.strip()]
-    if not atts:
-        atts = ["Old Town exploration", "Local museum", "Scenic viewpoint", "Local market"]
+    att_list = [a.strip() for a in attractions.split(",") if a.strip()]
+    if not att_list:
+        att_list = ["Old Town exploration", "Local museum", "Scenic viewpoint", "Local market"]
     
     daily_budget = budget_local / max(days, 1)
     lines = [f"🗓️ {days}-DAY REALISTIC ITINERARY: {destination}", "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"]
     
     for d in range(1, days + 1):
-        # Alternate between major and minor attractions
-        primary = atts[(d - 1) % len(atts)]
-        secondary = atts[d % len(atts)] if len(atts) > 1 else "Leisurely café break"
+        primary = att_list[(d - 1) % len(att_list)]
+        secondary = att_list[d % len(att_list)] if len(att_list) > 1 else "Leisurely café break"
         
         lines.extend([
             f"\nDAY {d} | Budget: ~{daily_budget:,.0f} local currency",
-            f"  09:00 - 12:00  {primary}",
-            f"  12:30 - 14:00  Lunch at local spot",
+            f"  09:00 - 12:00  {primary} (arrive early to avoid crowds)",
+            f"  12:30 - 14:00  Lunch at local spot (budget: ~{daily_budget * 0.25:,.0f})",
             f"  14:30 - 17:00  {secondary}",
-            f"  19:00+         Dinner + evening stroll"
+            f"  19:00+         Dinner + evening stroll (budget: ~{daily_budget * 0.35:,.0f})"
         ])
     
-    lines.append("\n💡 Book major attractions online in advance to skip lines!")
+    lines.append("\n💡 Pro tips: Book major attractions online in advance. Use public transport day passes for 30%+ savings.")
     return "\n".join(lines)
 
 @tool
@@ -237,15 +233,30 @@ def assemble_catalogue(
     weather: str,
     timezone_info: str,
     itinerary: str,
-    packing: str,
+    packing_list: str,
     image_url_1: str,
     image_url_2: str
 ) -> str:
     """
-    Compile final travel catalogue with embedded images.
+    Compile all travel research into a beautiful, structured Markdown travel catalogue.
+
+    Args:
+        destination: Destination city name (e.g., "Barcelona")
+        origin: Traveler's home city (e.g., "New York")
+        dates: Travel date range (e.g., "Oct 15-19, 2026")
+        budget_summary: Formatted budget conversion string
+        weather: Weather forecast with packing advice
+        timezone_info: Time difference and jet lag guidance
+        itinerary: Day-by-day schedule with time allocations
+        packing_list: Complete customized packing checklist
+        image_url_1: URL of first generated destination image (landmark)
+        image_url_2: URL of second generated destination image (street scene)
+
+    Returns:
+        Complete Markdown-formatted travel catalogue with embedded images
     """
     return f"""# 🌍 {destination} Travel Catalogue
-*From {origin} • {dates} • {budget_summary}*
+*Planned from {origin} • {dates} • {budget_summary}*
 
 ---
 
@@ -254,22 +265,23 @@ def assemble_catalogue(
 
 ---
 
-## 🌤️ Weather & Packing Guidance
+## 🌤️ Weather Forecast & Packing Guidance
 {weather}
 
 ---
 
-## 🗓️ Your Personalized Itinerary
+## 🗓️ Your Personalized {len([d for d in itinerary.split('DAY ') if d.strip() and d[0].isdigit()])}-Day Itinerary
 {itinerary}
 
 ---
 
-## 🎒 Packing Checklist
-{packing}
+## 🎒 Complete Packing Checklist
+{packing_list}
 
 ---
 
 ## 📸 Visual Inspiration
+
 <div style="display: flex; gap: 20px; margin: 20px 0;">
   <div style="flex: 1; text-align: center;">
     <img src="{image_url_1}" alt="{destination} landmark" style="max-width: 100%; border-radius: 8px; box-shadow: 0 4px 8px rgba(0,0,0,0.1);">
@@ -277,18 +289,19 @@ def assemble_catalogue(
   </div>
   <div style="flex: 1; text-align: center;">
     <img src="{image_url_2}" alt="{destination} street scene" style="max-width: 100%; border-radius: 8px; box-shadow: 0 4px 8px rgba(0,0,0,0.1);">
-    <p><em>Vibrant street life</em></p>
+    <p><em>Vibrant local atmosphere</em></p>
   </div>
 </div>
 
 ---
 
 > 💡 **Travel Pro Tips**  
-> • Download offline maps before departure  
-> • Learn 5 basic phrases in the local language  
-> • Keep digital copies of important documents in cloud storage  
-> • Budget 10-15% extra for unexpected experiences  
-> • Public transport passes often save 30%+ vs single tickets
+> • Download offline Google Maps before departure  
+> • Learn 5 basic phrases in the local language (hello, thank you, please, excuse me, bill please)  
+> • Keep digital copies of passport/insurance in cloud storage + email to yourself  
+> • Budget 10-15% extra for spontaneous experiences  
+> • Public transport passes often save 30%+ vs single tickets  
+> • Always carry small local currency for markets/tips
 """
 
 # ======================
@@ -298,24 +311,69 @@ if __name__ == "__main__":
     print("🚀 Initializing Travel Catalogue Creator...")
     
     # Load tools
+    web_search = DuckDuckGoSearchTool()
+    
+    # Try to load image generation tool (fallback if unavailable)
     try:
         image_gen = load_tool("black-forest-labs/FLUX.1-schnell", trust_remote_code=True)
-    except:
-        # Fallback to stable tool
-        image_gen = load_tool("stabilityai/stable-diffusion-3-medium", trust_remote_code=True)
+    except Exception:
+        try:
+            image_gen = load_tool("stabilityai/stable-diffusion-3-medium", trust_remote_code=True)
+        except Exception as e:
+            raise RuntimeError(f"Failed to load image generation tool: {e}")
     
-    web_search = DuckDuckGoSearchTool()
     model = HfApiModel(
         max_tokens=2048,
-        temperature=0.3,  # Lower for reliable tool usage
+        temperature=0.3,
         model_id="Qwen/Qwen2.5-Coder-32B-Instruct",
     )
     
-    # System prompt enforces strict workflow
-    with open("prompts.yaml", "r") as f:
-        import yaml
-        prompt_templates = yaml.safe_load(f)
-    
+    # System prompt enforcing strict 8-step workflow with mandatory image generation
+    system_prompt = """
+You are TravelCatalogueCreator, an expert travel planner. ALWAYS follow this EXACT 8-step workflow:
+
+1. RESEARCH: Use DuckDuckGoSearchTool to find:
+   - Top 4-5 attractions in {destination}
+   - Local customs and etiquette tips
+   - Safety considerations
+   - Typical food/transport prices
+
+2. WEATHER: Use get_weather_forecast with {destination} and {travel_dates}
+   → Capture temperature range and precipitation likelihood
+
+3. CURRENCY: Use convert_currency to convert {budget_amount} {home_currency} to {local_currency}
+   → Note the exchange rate for daily budgeting
+
+4. TIMEZONE: Use get_time_difference with {origin_city} and {destination}
+   → Calculate jet lag impact
+
+5. ITINERARY: Use build_itinerary with:
+   - destination={destination}
+   - attractions=[top attractions from Step 1]
+   - budget_local=[daily budget from Step 3]
+   - days=[trip duration]
+
+6. PACKING: Use generate_packing_list with:
+   - destination={destination}
+   - weather_summary=[output from Step 2]
+   - trip_days=[duration]
+   - trip_type="city" (default unless beach/mountain specified)
+
+7. IMAGES: CALL image_generation_tool EXACTLY TWICE:
+   First call: "{destination} iconic landmark photorealistic travel photo, golden hour, 4k"
+   Second call: "{destination} vibrant street scene with locals, authentic atmosphere, travel photography"
+
+8. ASSEMBLE: Use assemble_catalogue with ALL previous outputs including BOTH image URLs
+
+CRITICAL RULES:
+• NEVER skip image generation (Step 7 is mandatory - 2 calls required)
+• NEVER call final_answer directly – always use assemble_catalogue first
+• If a tool fails, retry ONCE with simplified parameters before proceeding
+• Always extract concrete values (temps, rates, times) from tool outputs
+• Budget must be converted to local currency before itinerary planning
+• You MUST complete all 8 steps before finishing
+"""
+
     agent = CodeAgent(
         model=model,
         tools=[
@@ -328,11 +386,11 @@ if __name__ == "__main__":
             build_itinerary,
             assemble_catalogue,
         ],
-        max_steps=25,  # Allow room for image generation + retries
+        max_steps=25,
         verbosity_level=1,
         name="TravelCatalogueCreator",
         description="Creates comprehensive, personalized travel catalogues with images",
-        prompt_templates=prompt_templates,
+        prompt_templates={"system_prompt": system_prompt},
     )
     
     # Launch UI