Update app.py

updated tools: generate_destination_images, assemble_travel_catalogue

app.py

@@ -1,268 +1,160 @@
 #!/usr/bin/env python
 # coding=utf-8
-import os
 import re
 import requests
-import datetime
-import pytz
-from typing import List
 from smolagents import CodeAgent, DuckDuckGoSearchTool, HfApiModel, load_tool, tool
 from tools.final_answer import FinalAnswerTool
 from Gradio_UI import GradioUI
 import yaml
 
 # ======================
-# CUSTOM TRAVEL TOOLS (FULLY COMPLIANT WITH SMOLAGENTS)
+# MINIMAL TRAVEL TOOLS (SMOLAGENTS-COMPLIANT)
 # ======================
 
 @tool
 def get_weather_forecast(location: str, travel_dates: str) -> str:
     """
-    Get weather forecast for a destination during travel dates using wttr.in.
+    Get weather forecast for destination using wttr.in.
     
     Args:
-        location: Destination city name (e.g., "Paris", "Tokyo")
-        travel_dates: Travel date range (e.g., "October 15-19" or "June 2026")
+        location: Destination city name (e.g., "Barcelona")
+        travel_dates: Travel date range (e.g., "October 15-19")
     
     Returns:
-        Weather summary with temperature, conditions, and packing recommendations
+        Weather summary with temperature and packing advice
     """
     try:
-        clean_location = re.sub(r'[^a-zA-Z0-9\s]', '', location).replace(' ', '+')
-        url = f"http://wttr.in/{clean_location}?format=j1"
-        response = requests.get(url, timeout=10)
-        response.raise_for_status()
-        data = response.json()
-        
-        current = data['current_condition'][0]
-        temp_c = int(current['temp_C'])
-        feels_like = int(current['FeelsLikeC'])
-        conditions = current['lang_en'][0]['value']
-        humidity = current['humidity']
-        wind = current['windspeedKmph']
-        
-        if temp_c > 25:
-            packing = "Light clothing, sunscreen, hat, sunglasses"
-        elif temp_c > 15:
-            packing = "Light layers, light jacket, comfortable walking shoes"
-        elif temp_c > 5:
-            packing = "Warm layers, medium jacket, scarf"
+        clean = re.sub(r'[^a-zA-Z0-9\s]', '', location).replace(' ', '+')
+        data = requests.get(f"http://wttr.in/{clean}?format=j1", timeout=10).json()
+        cur = data['current_condition'][0]
+        temp = int(cur['temp_C'])
+        cond = cur['lang_en'][0]['value']
+        if temp > 20:
+            pack = "Light layers, sunscreen, hat"
         else:
-            packing = "Heavy winter coat, thermal layers, hat, gloves"
-        
-        if "rain" in conditions.lower() or "shower" in conditions.lower():
-            packing += ", waterproof jacket, umbrella"
-        
-        return (
-            f"Weather in {location}:\n"
-            f"• {temp_c}°C (feels like {feels_like}°C) | {conditions}\n"
-            f"• Humidity: {humidity}% | Wind: {wind} km/h\n"
-            f"• Packing tip: {packing}"
-        )
-    except Exception:
-        return f"Typical {location} weather: Mild (15-25°C). Pack light layers + light jacket + umbrella."
+            pack = "Warm layers, light jacket"
+        if "rain" in cond.lower():
+            pack += " + umbrella"
+        return f"{location} weather: {temp}°C, {cond}. Packing: {pack}"
+    except:
+        return f"{location} typical weather: 15-25°C. Pack light layers + light jacket + umbrella."
 
 
 @tool
 def convert_currency(amount: float, from_currency: str, to_currency: str) -> str:
     """
-    Convert currency using Frankfurter API (free ECB data).
+    Convert currency using Frankfurter API.
     
     Args:
-        amount: Amount to convert (e.g., 1000.0)
-        from_currency: Source currency code (e.g., "USD", "EUR")
-        to_currency: Target currency code (e.g., "JPY", "EUR")
+        amount: Amount to convert (e.g., 1200.0)
+        from_currency: Source currency code (e.g., "USD")
+        to_currency: Target currency code (e.g., "EUR")
     
     Returns:
-        Conversion result with exchange rate and formatted amounts
+        Formatted conversion result
     """
     try:
         from_currency = from_currency.upper()
         to_currency = to_currency.upper()
         if from_currency == to_currency:
-            return f"{amount:,.2f} {from_currency} = {amount:,.2f} {to_currency}"
-        
-        url = f"https://api.frankfurter.app/latest?from={from_currency}&to={to_currency}"
-        response = requests.get(url, timeout=10)
-        response.raise_for_status()
-        rate = response.json()['rates'][to_currency]
-        converted = amount * rate
-        
-        return (
-            f"💱 {amount:,.2f} {from_currency} = {converted:,.2f} {to_currency}\n"
-            f"   (Rate: 1 {from_currency} = {rate:.4f} {to_currency})"
-        )
-    except Exception:
-        fallback = {("USD", "EUR"): 0.93, ("EUR", "USD"): 1.07}.get((from_currency, to_currency), 1.0)
-        converted = amount * fallback
-        return f"⚠️ Est: {amount:,.2f} {from_currency} ≈ {converted:,.2f} {to_currency}"
+            return f"{amount:,.0f} {from_currency}"
+        rate = requests.get(
+            f"https://api.frankfurter.app/latest?from={from_currency}&to={to_currency}", 
+            timeout=10
+        ).json()['rates'][to_currency]
+        return f"{amount:,.0f} {from_currency} = {amount*rate:,.0f} {to_currency} (1 {from_currency} = {rate:.2f} {to_currency})"
+    except:
+        return f"{amount:,.0f} {from_currency} (conversion unavailable)"
 
 
 @tool
-def generate_packing_list(destination: str, weather_summary: str, trip_duration_days: int, trip_type: str) -> str:
+def generate_packing_list(destination: str, weather_summary: str, trip_days: int, trip_type: str) -> str:
     """
-    Generate a customized packing list based on weather and trip type.
+    Generate packing list based on weather and trip type.
     
     Args:
-        destination: Travel destination name (e.g., "Barcelona")
-        weather_summary: Weather conditions from get_weather_forecast tool
-        trip_duration_days: Length of trip in days (e.g., 4)
-        trip_type: Type of trip: "sightseeing", "beach", "hiking", or "business"
+        destination: Destination name (e.g., "Barcelona")
+        weather_summary: Weather conditions summary
+        trip_days: Number of travel days (e.g., 4)
+        trip_type: Trip type: "sightseeing", "beach", or "hiking"
     
     Returns:
-        Formatted packing checklist with quantities
+        Formatted packing checklist
     """
-    has_rain = "rain" in weather_summary.lower() or "umbrella" in weather_summary.lower()
-    has_cold = "cold" in weather_summary.lower() or "jacket" in weather_summary.lower()
-    
-    # FIXED: Proper quantity calculation (was broken string interpolation)
-    tshirt_qty = trip_duration_days // 2 + 1
-    pants_qty = trip_duration_days // 3 + 1
-    socks_qty = trip_duration_days // 2 + 1
+    cold = "cold" in weather_summary.lower() or "jacket" in weather_summary.lower()
+    rain = "rain" in weather_summary.lower() or "umbrella" in weather_summary.lower()
     
-    essentials = [
-        "• Passport + copies",
-        "• Travel insurance",
-        "• Credit cards + small local cash",
-        "• Universal power adapter",
-        "• Phone + charger + power bank",
-    ]
+    tops = trip_days // 2 + 1
+    bottoms = trip_days // 3 + 1
     
-    clothing = []
-    if has_cold:
-        clothing = [
-            f"• Warm base layers ({trip_duration_days // 3 + 1})",
-            "• Insulated jacket",
-            f"• Warm socks ({socks_qty})",
-            "• Beanie + gloves",
-        ]
+    clothes = [f"• Tops ({tops})", f"• Bottoms ({bottoms})"]
+    if cold:
+        clothes += ["• Warm jacket", "• Beanie + gloves"]
     else:
-        clothing = [
-            f"• T-shirts ({tshirt_qty})",
-            f"• Comfortable pants ({pants_qty})",
-            "• Light jacket (essential for layering)",
-        ]
-    
-    if has_rain:
-        clothing.extend(["• Compact umbrella", "• Light waterproof jacket"])
-    
+        clothes += ["• Light jacket (essential)"]
+    if rain:
+        clothes += ["• Compact umbrella", "• Waterproof jacket"]
     if trip_type == "beach":
-        clothing.extend(["• Swimsuit", "• Beach towel", "• Flip-flops"])
-    elif trip_type == "hiking":
-        clothing.extend(["• Hiking boots", "• Moisture-wicking socks", "• Daypack"])
-    
-    toiletries = [
-        "• Travel-sized shampoo/conditioner",
-        "• Toothbrush + toothpaste",
-        "• Deodorant",
-        "• Prescription meds",
-        "• Basic first-aid kit",
-    ]
+        clothes += ["• Swimsuit", "• Flip-flops"]
     
     return (
-        f"🎒 PACKING LIST: {destination} ({trip_duration_days}-day {trip_type})\n"
-        f"{'─'*56}\nESSENTIALS\n" + "\n".join(essentials) + "\n\nCLOTHING\n" + "\n".join(clothing) + "\n\nTOILETRIES\n" + "\n".join(toiletries)
+        f"🎒 PACKING LIST ({trip_days}-day {trip_type})\n"
+        "ESSENTIALS\n• Passport + copies\n• Cards + small cash\n• Power adapter\n• Phone + charger\n\n"
+        "CLOTHING\n" + "\n".join(clothes) + "\n\n"
+        "TOILETRIES\n• Travel toiletries\n• Medications\n• First-aid kit"
     )
 
 
 @tool
-def build_itinerary(destination: str, attractions: str, weather_summary: str, budget_local_currency: float, trip_duration_days: int) -> str:
+def build_itinerary(destination: str, attractions: str, budget: float, days: int) -> str:
     """
-    Create a day-by-day travel itinerary with budget allocation.
+    Create day-by-day itinerary.
     
     Args:
-        destination: Destination city name (e.g., "Barcelona")
-        attractions: Comma-separated list of attractions (e.g., "Sagrada Familia, Park Guell")
-        weather_summary: Weather conditions to optimize daily activities
-        budget_local_currency: Total budget in destination currency (e.g., 1200.0)
-        trip_duration_days: Length of trip in days (e.g., 4)
+        destination: Destination city (e.g., "Barcelona")
+        attractions: Comma-separated attractions list
+        budget: Total budget in local currency
+        days: Number of travel days
     
     Returns:
-        Formatted day-by-day itinerary with time slots and cost estimates
+        Formatted itinerary with daily schedule
     """
-    attraction_list = [a.strip() for a in attractions.split(",") if a.strip()]
-    if not attraction_list:
-        attraction_list = ["Old Town", "Local museum", "Scenic viewpoint", "Cultural market"]
-    
-    daily_budget = budget_local_currency / max(trip_duration_days, 1)
-    food_budget = daily_budget * 0.35
-    
-    lines = [f"🗓️ {trip_duration_days}-DAY ITINERARY: {destination}", "─"*56]
-    
-    for day in range(1, trip_duration_days + 1):
-        am_act = attraction_list[(day-1) % len(attraction_list)]
-        pm_act = attraction_list[day % len(attraction_list)]
-        lines.extend([
-            f"\nDAY {day}",
-            f"  09:00  {am_act}",
-            f"  12:30  Lunch (~{food_budget * 0.4:,.0f})",
-            f"  14:00  {pm_act}",
-            f"  19:00  Dinner (~{food_budget * 0.6:,.0f})",
-        ])
-    
-    lines.append(f"\n💰 Daily budget: ~{daily_budget:,.0f} (activities + food + transport)")
+    atts = [a.strip() for a in attractions.split(",") if a.strip()] or ["Old Town", "Museum", "Viewpoint", "Market"]
+    daily = budget / max(days, 1)
+    lines = [f"🗓️ {days}-DAY ITINERARY: {destination}"]
+    for d in range(1, days+1):
+        am = atts[(d-1) % len(atts)]
+        pm = atts[d % len(atts)]
+        lines += [f"DAY {d}", f"  09:00 {am}", f"  14:00 {pm}", f"  💰 Daily budget: ~{daily:,.0f}"]
     return "\n".join(lines)
 
 
 @tool
-def generate_destination_images(destination: str, image_prompts: str) -> str:
+def assemble_catalogue(destination: str, origin: str, dates: str, budget_str: str, weather: str, itinerary: str, packing: str, image_url_1: str, image_url_2: str) -> str:
     """
-    Generate 3 representative images for the destination using text-to-image tool.
-    
-    Args:
-        destination: Destination name (e.g., "Barcelona")
-        image_prompts: Comma-separated prompts for images (e.g., "Sagrada Familia exterior, La Rambla street scene, Park Guell mosaic art")
-    
-    Returns:
-        Instructions for the agent to call image_generation_tool 3 times with these prompts
-    """
-    prompts = [p.strip() for p in image_prompts.split(",")][:3]
-    return (
-        f"Generate 3 images for {destination} using image_generation_tool with these prompts:\n"
-        + "\n".join([f"{i+1}. '{prompt}'" for i, prompt in enumerate(prompts)])
-    )
-
-
-@tool
-def assemble_travel_catalogue(
-    destination: str,
-    origin: str,
-    travel_dates: str,
-    budget_summary: str,
-    weather_info: str,
-    itinerary: str,
-    packing_list: str,
-    image_urls: str,
-) -> str:
-    """
-    Compile all travel information into a beautifully formatted Markdown catalogue.
+    Compile final travel catalogue with embedded images.
     
     Args:
         destination: Destination city (e.g., "Barcelona")
-        origin: Traveler's home city (e.g., "New York")
-        travel_dates: Travel date range (e.g., "October 15-19, 2026")
-        budget_summary: Budget conversion result (e.g., "$1,200 USD = €1,116 EUR")
-        weather_info: Weather forecast summary
-        itinerary: Day-by-day itinerary plan
-        packing_list: Customized packing checklist
-        image_urls: Comma-separated URLs of generated images
+        origin: Home city (e.g., "New York")
+        dates: Travel dates (e.g., "Oct 15-19")
+        budget_str: Budget conversion result
+        weather: Weather forecast summary
+        itinerary: Day-by-day plan
+        packing: Packing list
+        image_url_1: First generated image URL from image_generation_tool
+        image_url_2: Second generated image URL from image_generation_tool
     
     Returns:
-        Complete travel catalogue in Markdown format with embedded images
+        Beautiful Markdown travel catalogue with embedded images
     """
-    image_list = [url.strip() for url in image_urls.split(",") if url.strip()]
-    image_section = "\n".join([
-        f"![{destination} view]({url})  \n*Generated image {i+1}*"
-        for i, url in enumerate(image_list[:3])
-    ]) if image_list else "*Images will appear here after generation*"
-    
-    catalogue = f"""# 🌍 {destination} Travel Catalogue
-*From {origin} • {travel_dates} • {budget_summary}*
+    return f"""# 🌍 {destination} Travel Catalogue
+*From {origin} • {dates} • Budget: {budget_str}*
 
 ---
 
-## 🌤️ Weather Forecast
-{weather_info}
+## 🌤️ Weather
+{weather}
 
 ---
 
@@ -272,65 +164,74 @@ def assemble_travel_catalogue(
 ---
 
 ## 🎒 Packing List
-{packing_list}
+{packing}
 
 ---
 
-## 📸 Destination Gallery
-{image_section}
+## 📸 Destination Views
+![{destination} landmark]({image_url_1})
+*Generated view #1*
+
+![{destination} street scene]({image_url_2})
+*Generated view #2*
 
 ---
 
-> 💡 Pro Tips: Book attractions online to skip lines. Use public transport passes for savings.
+> 💡 Book attractions online to skip lines. Use public transport passes for savings.
 """
-    return catalogue
 
 
 # ======================
-# AGENT SETUP
+# AGENT SETUP (IMAGE GENERATION FORCED)
 # ======================
 
 final_answer = FinalAnswerTool()
 web_search = DuckDuckGoSearchTool()
-image_generation_tool = load_tool("agents-course/text-to-image", trust_remote_code=True)
+image_gen = load_tool("agents-course/text-to-image", trust_remote_code=True)
 
 model = HfApiModel(
     max_tokens=2096,
-    temperature=0.5,
+    temperature=0.3,  # Lower temp for more reliable tool usage
     model_id="Qwen/Qwen2.5-Coder-32B-Instruct",
 )
 
-with open("prompts.yaml", 'r') as stream:
-    prompt_templates = yaml.safe_load(stream)
+# CRITICAL: System prompt that FORCES image generation steps
+prompt_templates = {
+    "system_prompt": (
+        "You are TravelCatalogueCreator. ALWAYS follow this EXACT workflow:\n"
+        "1. Use DuckDuckGoSearchTool to research destination attractions\n"
+        "2. Use get_weather_forecast for weather during travel dates\n"
+        "3. Use convert_currency to show budget in local currency\n"
+        "4. Use build_itinerary to create day-by-day plan\n"
+        "5. Use generate_packing_list for packing advice\n"
+        "6. CALL image_generation_tool EXACTLY TWICE with prompts:\n"
+        "   - First call: '{destination} landmark photorealistic travel photo'\n"
+        "   - Second call: '{destination} street scene vibrant travel photo'\n"
+        "7. Use assemble_catalogue with BOTH image URLs from step 6\n\n"
+        "NEVER skip image generation. NEVER call FinalAnswerTool directly. "
+        "You MUST complete all 7 steps before finishing."
+    )
+}
 
 agent = CodeAgent(
     model=model,
     tools=[
         final_answer,
         web_search,
-        image_generation_tool,
+        image_gen,  # Must be available for step 6
         get_weather_forecast,
         convert_currency,
         generate_packing_list,
         build_itinerary,
-        generate_destination_images,
-        assemble_travel_catalogue,
+        assemble_catalogue,  # Requires real image URLs as inputs
     ],
-    max_steps=18,  # Extra steps for image generation
+    max_steps=20,  # Allow room for 2 image generation steps
     verbosity_level=1,
-    grammar=None,
-    planning_interval=None,
     name="TravelCatalogueCreator",
-    description=(
-        "Expert travel planner that creates beautiful catalogues. "
-        "ALWAYS follow this sequence: 1) research 2) weather 3) currency 4) itinerary "
-        "5) packing list 6) generate_destination_images 7) assemble_travel_catalogue. "
-        "NEVER skip image generation."
-    ),
+    description="Creates beautiful travel catalogues with mandatory image generation",
     prompt_templates=prompt_templates,
 )
 
 if __name__ == "__main__":
-    print("🚀 Travel Catalogue Creator Agent starting...")
-    print("💡 Example: 'Create a 4-day Barcelona travel catalogue from New York with $1200 budget for October 15-19'")
+    print("🚀 Travel Catalogue Creator with guaranteed image generation")
     GradioUI(agent, file_upload_folder="./uploads").launch()