Update app.py

argument descriptions for convert_currency.

app.py

@@ -5,28 +5,27 @@ import re
 import requests
 import datetime
 import pytz
-import json
-from typing import List, Dict, Optional
+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 (FIXED + ENHANCED)
+# CUSTOM TRAVEL TOOLS (FULLY COMPLIANT WITH SMOLAGENTS)
 # ======================
 
 @tool
 def get_weather_forecast(location: str, travel_dates: str) -> str:
     """
-    Get weather forecast for a destination during travel dates using wttr.in (no API key required).
+    Get weather forecast for a destination during travel dates using wttr.in.
     
     Args:
         location: Destination city name (e.g., "Paris", "Tokyo")
-        travel_dates: Travel date range in format "YYYY-MM-DD to YYYY-MM-DD" or month name
+        travel_dates: Travel date range (e.g., "October 15-19" or "June 2026")
     
     Returns:
-        Weather summary including temperature range, conditions, and packing recommendations
+        Weather summary with temperature, conditions, and packing recommendations
     """
     try:
         clean_location = re.sub(r'[^a-zA-Z0-9\s]', '', location).replace(' ', '+')
@@ -42,41 +41,40 @@ def get_weather_forecast(location: str, travel_dates: str) -> str:
         humidity = current['humidity']
         wind = current['windspeedKmph']
         
-        # Smart packing advice
         if temp_c > 25:
-            packing_advice = "Light clothing, sunscreen, hat, sunglasses, reusable water bottle"
+            packing = "Light clothing, sunscreen, hat, sunglasses"
         elif temp_c > 15:
-            packing_advice = "Light layers, light jacket, comfortable walking shoes"
+            packing = "Light layers, light jacket, comfortable walking shoes"
         elif temp_c > 5:
-            packing_advice = "Warm layers, medium jacket, scarf"
+            packing = "Warm layers, medium jacket, scarf"
         else:
-            packing_advice = "Heavy winter coat, thermal layers, hat, gloves, warm boots"
+            packing = "Heavy winter coat, thermal layers, hat, gloves"
         
         if "rain" in conditions.lower() or "shower" in conditions.lower():
-            packing_advice += ", waterproof jacket, umbrella"
-        elif "snow" in conditions.lower():
-            packing_advice += ", waterproof boots, snow gear"
+            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: {packing_advice}"
+            f"• Packing tip: {packing}"
         )
-        
     except Exception:
-        return (
-            f"Typical weather for {location} this season:\n"
-            f"• Mild temperatures (15-25°C)\n"
-            f"• Light layers + light jacket recommended\n"
-            f"• Pack compact umbrella for unexpected showers"
-        )
+        return f"Typical {location} weather: Mild (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).
+    
+    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")
+    
+    Returns:
+        Conversion result with exchange rate and formatted amounts
     """
     try:
         from_currency = from_currency.upper()
@@ -92,121 +90,137 @@ def convert_currency(amount: float, from_currency: str, to_currency: str) -> str
         
         return (
             f"💱 {amount:,.2f} {from_currency} = {converted:,.2f} {to_currency}\n"
-            f"   (1 {from_currency} = {rate:.4f} {to_currency})"
+            f"   (Rate: 1 {from_currency} = {rate:.4f} {to_currency})"
         )
-        
     except Exception:
-        fallback = {("USD","EUR"):0.93, ("EUR","USD"):1.07, ("USD","JPY"):150.0}.get((from_currency,to_currency), 1.0)
+        fallback = {("USD", "EUR"): 0.93, ("EUR", "USD"): 1.07}.get((from_currency, to_currency), 1.0)
         converted = amount * fallback
-        return f"⚠️ Estimated: {amount:,.2f} {from_currency} ≈ {converted:,.2f} {to_currency}"
+        return f"⚠️ Est: {amount:,.2f} {from_currency} ≈ {converted:,.2f} {to_currency}"
 
 
 @tool
-def generate_packing_list(destination: str, weather_summary: str, trip_duration_days: int, trip_type: str = "sightseeing") -> str:
+def generate_packing_list(destination: str, weather_summary: str, trip_duration_days: int, trip_type: str) -> str:
     """
-    Generate a customized packing list. FIXED: Proper f-string evaluation for quantities.
+    Generate a customized 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"
+    
+    Returns:
+        Formatted packing checklist with quantities
     """
     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()
-    has_hot = "hot" in weather_summary.lower() or "sunscreen" in weather_summary.lower()
     
-    # CRITICAL FIX: Evaluate expressions properly (was broken string interpolation)
+    # 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
-    base_layer_qty = trip_duration_days // 3 + 1
     
     essentials = [
-        "• Passport + photocopies (and visa if required)",
-        "• Travel insurance documents",
-        "• Credit/debit cards + small local currency",
-        "• Universal power adapter (Type F for Europe)",
+        "• Passport + copies",
+        "• Travel insurance",
+        "• Credit cards + small local cash",
+        "• Universal power adapter",
         "• Phone + charger + power bank",
-        "• Reusable water bottle",
     ]
     
     clothing = []
-    if has_hot:
-        clothing = [
-            f"• T-shirts/tanks ({tshirt_qty})",
-            "• Lightweight breathable pants/shorts",
-            "• Sun hat + sunglasses",
-            "• High-SPF sunscreen",
-        ]
-    elif has_cold:
+    if has_cold:
         clothing = [
-            f"• Warm base layers ({base_layer_qty})",
+            f"• Warm base layers ({trip_duration_days // 3 + 1})",
             "• Insulated jacket",
             f"• Warm socks ({socks_qty})",
             "• Beanie + gloves",
         ]
     else:
         clothing = [
-            f"• Versatile tops ({tshirt_qty})",
+            f"• T-shirts ({tshirt_qty})",
             f"• Comfortable pants ({pants_qty})",
-            "• Light jacket/sweater (essential for layering)",
+            "• Light jacket (essential for layering)",
         ]
     
     if has_rain:
-        clothing.extend(["• Compact travel umbrella", "• Light waterproof jacket"])
+        clothing.extend(["• Compact umbrella", "• Light waterproof jacket"])
     
     if trip_type == "beach":
         clothing.extend(["• Swimsuit", "• Beach towel", "• Flip-flops"])
     elif trip_type == "hiking":
-        clothing.extend(["• Sturdy hiking boots", "• Moisture-wicking socks", "• Daypack"])
+        clothing.extend(["• Hiking boots", "• Moisture-wicking socks", "• Daypack"])
     
     toiletries = [
-        "• Travel-sized toiletries",
+        "• Travel-sized shampoo/conditioner",
         "• Toothbrush + toothpaste",
         "• Deodorant",
-        "• Prescription medications",
+        "• Prescription meds",
         "• Basic first-aid kit",
     ]
     
-    if has_hot:
-        toiletries.append("• After-sun lotion")
-    
     return (
         f"🎒 PACKING LIST: {destination} ({trip_duration_days}-day {trip_type})\n"
-        f"{'─'*56}\n"
-        f"ESSENTIALS\n" + "\n".join(essentials) + "\n\n"
-        f"CLOTHING\n" + "\n".join(clothing) + "\n\n"
-        f"TOILETRIES\n" + "\n".join(toiletries) + "\n\n"
-        f"💡 Pro tip: Roll clothes to save space. Use packing cubes!"
+        f"{'─'*56}\nESSENTIALS\n" + "\n".join(essentials) + "\n\nCLOTHING\n" + "\n".join(clothing) + "\n\nTOILETRIES\n" + "\n".join(toiletries)
     )
 
 
 @tool
 def build_itinerary(destination: str, attractions: str, weather_summary: str, budget_local_currency: float, trip_duration_days: int) -> str:
     """
-    Create day-by-day itinerary with budget allocation.
+    Create a day-by-day travel itinerary with budget allocation.
+    
+    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)
+    
+    Returns:
+        Formatted day-by-day itinerary with time slots and cost estimates
     """
     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", "Local cuisine"]
+        attraction_list = ["Old Town", "Local museum", "Scenic viewpoint", "Cultural market"]
     
     daily_budget = budget_local_currency / max(trip_duration_days, 1)
-    activity_budget = daily_budget * 0.4
     food_budget = daily_budget * 0.35
     
-    itinerary = [f"🗓️ {trip_duration_days}-DAY ITINERARY: {destination}", "─"*56]
+    lines = [f"🗓️ {trip_duration_days}-DAY ITINERARY: {destination}", "─"*56]
     
     for day in range(1, trip_duration_days + 1):
-        focus = "Morning outdoor sights, afternoon indoor museums" if "cold" in weather_summary.lower() else "Outdoor exploration with indoor breaks"
         am_act = attraction_list[(day-1) % len(attraction_list)]
         pm_act = attraction_list[day % len(attraction_list)]
-        
-        itinerary.extend([
-            f"\nDAY {day}: {focus}",
+        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})",
-            f"  💡 Book attractions online to skip lines!",
         ])
     
-    itinerary.append(f"\n💰 DAILY BUDGET: {daily_budget:,.0f} ({activity_budget:,.0f} activities | {food_budget:,.0f} food | rest transport/buffer)")
-    return "\n".join(itinerary)
+    lines.append(f"\n💰 Daily budget: ~{daily_budget:,.0f} (activities + food + transport)")
+    return "\n".join(lines)
+
+
+@tool
+def generate_destination_images(destination: str, image_prompts: 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
@@ -214,41 +228,36 @@ def assemble_travel_catalogue(
     destination: str,
     origin: str,
     travel_dates: str,
-    budget: str,
+    budget_summary: str,
     weather_info: str,
     itinerary: str,
     packing_list: str,
-    image_prompts: str = "landmark, street scene, local food"
+    image_urls: str,
 ) -> str:
     """
-    FINAL STEP: Generate images AND compile a beautiful Markdown catalogue.
-    This tool MUST be called last to produce the formatted output with images.
+    Compile all travel information into a beautifully formatted Markdown catalogue.
     
     Args:
-        destination: e.g., "Barcelona"
-        origin: e.g., "New York"
-        travel_dates: e.g., "October 15-19, 2026"
-        budget: e.g., "$1,200 USD"
-        weather_info: Output from get_weather_forecast
-        itinerary: Output from build_itinerary
-        packing_list: Output from generate_packing_list
-        image_prompts: Comma-separated prompts for image generation (e.g., "Sagrada Familia, La Rambla street food, Park Guell mosaic")
+        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
     
     Returns:
-        Fully formatted travel catalogue with embedded image placeholders
+        Complete travel catalogue in Markdown format with embedded images
     """
-    # Generate 3 destination images using the image generation tool
-    # (Agent will observe these image URLs and include them in final answer)
-    prompts = [p.strip() for p in image_prompts.split(",")][:3]
-    
+    image_list = [url.strip() for url in image_urls.split(",") if url.strip()]
     image_section = "\n".join([
-        f"![{prompt}]({{'image_url_placeholder_{i+1}'}})  \n*{prompt.title()}*"
-        for i, prompt in enumerate(prompts)
-    ])
+        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*"
     
-    # Beautiful Markdown catalogue
     catalogue = f"""# 🌍 {destination} Travel Catalogue
-*From {origin} • {travel_dates} • Budget: {budget}*
+*From {origin} • {travel_dates} • {budget_summary}*
 
 ---
 
@@ -257,12 +266,12 @@ def assemble_travel_catalogue(
 
 ---
 
-## 🗓️ Itinerary Highlights
+## 🗓️ Itinerary
 {itinerary}
 
 ---
 
-## 🎒 Packing Essentials
+## 🎒 Packing List
 {packing_list}
 
 ---
@@ -272,8 +281,7 @@ def assemble_travel_catalogue(
 
 ---
 
-> ✈️ *Tip: Book flights/accommodation 6-8 weeks in advance for best prices.  
-> 💳 Use no-foreign-transaction-fee cards to avoid extra charges.*
+> 💡 Pro Tips: Book attractions online to skip lines. Use public transport passes for savings.
 """
     return catalogue
 
@@ -295,32 +303,34 @@ model = HfApiModel(
 with open("prompts.yaml", 'r') as stream:
     prompt_templates = yaml.safe_load(stream)
 
-# CRITICAL: Add assemble_travel_catalogue as the FINAL tool to force image generation + formatting
 agent = CodeAgent(
     model=model,
     tools=[
         final_answer,
         web_search,
-        image_generation_tool,  # Must be available BEFORE assembler tool
+        image_generation_tool,
         get_weather_forecast,
         convert_currency,
         generate_packing_list,
         build_itinerary,
-        assemble_travel_catalogue,  # This triggers final formatted output WITH images
+        generate_destination_images,
+        assemble_travel_catalogue,
     ],
-    max_steps=15,  # Allow extra steps for image generation
+    max_steps=18,  # Extra steps for image generation
     verbosity_level=1,
     grammar=None,
     planning_interval=None,
     name="TravelCatalogueCreator",
     description=(
-        "Creates beautiful travel catalogues. ALWAYS use assemble_travel_catalogue as the FINAL step "
-        "to generate images and format the output as a visually appealing Markdown catalogue."
+        "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."
     ),
     prompt_templates=prompt_templates,
 )
 
 if __name__ == "__main__":
     print("🚀 Travel Catalogue Creator Agent starting...")
-    print("💡 Example query: 'Create a 4-day Barcelona travel catalogue from New York with $1200 budget for October 15-19'")
+    print("💡 Example: 'Create a 4-day Barcelona travel catalogue from New York with $1200 budget for October 15-19'")
     GradioUI(agent, file_upload_folder="./uploads").launch()