test

app.py

@@ -1,6 +1,6 @@
 from smolagents import CodeAgent, LiteLLMModel
-from tools.mood_to_need import MoodToNeedTool
-from tools.need_to_destination import NeedToDestinationTool
+from tools.mood_to_need import MoodToNeedTool, claude_mood_to_need_model
+from tools.need_to_destination import NeedToDestinationTool, claude_need_to_destination_model
 from tools.weather_tool import WeatherTool
 from tools.find_flight import FlightsFinderTool
 from tools.final_answer import FinalAnswerTool
@@ -19,7 +19,7 @@ model = LiteLLMModel(
 )
 
 # Load prompt templates
-with open("prompts.yaml", "r") as f:
+with open("prompts_new.yaml", "r") as f:
     prompt_templates = yaml.safe_load(f)
 
 # Define the agent with all tools
@@ -40,14 +40,14 @@ with open("prompts.yaml", "r") as f:
 agent = CodeAgent(
     model=model,
     tools=[
-        MoodToNeedTool(model=model),          # Step 1: Mood → Need
-        NeedToDestinationTool(model=model),   # Step 2: Need → Destination
+        MoodToNeedTool(model=claude_mood_to_need_model),          # Step 1: Mood → Need
+        NeedToDestinationTool(model=claude_need_to_destination_model),   # Step 2: Need → Destination
         WeatherTool(),             # Step 3: Weather for destination
         FlightsFinderTool(),       # Step 4: Destination → Flights           # Step 5: Claude wrap
         FinalAnswerTool(),      # Required final output
         CountryInfoTool()           # Step 6: Country info
     ],
-    max_steps=6,
+    max_steps=10,
     verbosity_level=1,
     prompt_templates=prompt_templates
 )

prompts.yaml

@@ -53,13 +53,14 @@ system_prompt: |-
 
 
   Your available tools are:
-  - mood_to_need(mood: str) → str: Extracts the emotional need behind a mood (e.g., "to reconnect").
-  - need_to_destination(need: str) → dict: Suggests a destination and activity for that need. Returns JSON with keys 'city', 'country', 'activity'.
-  - weather_forecast(location: str) → str: Gets current weather forecast.
-  - get_flights(origin: str, destination: str) → str: Lists flights between two cities.
-  - quote_from_mood(mood: str) → str: Provides a motivational quote based on mood.
-  - final_wrap(mood, need, destination, activity, weather, flights) → str: Composes final inspirational message.
-  - final_answer(output: Any): Ends the task and returns the final result.
+  - MoodToNeed(mood: str) → str: Extracts the emotional need behind a mood (e.g., "to reconnect").
+  - NeedToDestination(need: str) → list: Suggests destinations and flight info for that need. Returns list of destinations with flight details.
+  - weather_forecast(location: str, date: str, activity_type: str) → str: Gets weather forecast with intelligent recommendations.
+  - flights_finder(departure_airport: str, arrival_airport: str, outbound_date: str, return_date: str) → str: Lists flights between airports.
+  - country_info(country: str, info_type: str) → str: Gets security, events, holidays and travel info for a country.
+  - final_answer(answer: Any): Ends the task and returns the final result.
+
+  IMPORTANT: You MUST use these tools instead of writing Python code to simulate their functionality. Call the tools directly with their exact names.
 
   DO NOT use a tool unless needed. Plan your steps clearly. You can retry with different inputs if the weather is bad.
 
@@ -83,14 +84,14 @@ planning:
     - Final wrap-up message to user.
 
   initial_plan: |-
-    1. Extract emotional need from user mood using mood_to_need().
-    2. Suggest destination and activity using need_to_destination().
-    3. Get weather at destination with weather_forecast().
-    4. Assess if weather suits the need. If not, return to step 2.
-    5. Get flights using get_flights().
-    6. Generate quote using quote_from_mood().
-    7. Compose final message using final_wrap().
-    8. Call final_answer() with all outputs.
+    1. Check if user provided mood, origin, and travel dates. If missing, ask for them.
+    2. Extract emotional need from user mood using MoodToNeed().
+    3. Suggest destinations using NeedToDestination().
+    4. For each suggested destination, get weather forecast using weather_forecast().
+    5. Get country information using country_info() to check safety and context.
+    6. Assess if weather and country conditions suit the need. If not, try another destination.
+    7. Get flights using flights_finder() with proper airport codes.
+    8. Compose final inspirational message and call final_answer().
     <end_plan>
 
   update_facts_pre_messages: |-

prompts_new.yaml

@@ -0,0 +1,59 @@
+system_prompt: |-
+  You are WanderMind, a world-class travel assistant that helps users find perfect destinations based on their mood.
+
+  🎯 YOUR MISSION:
+  1. Get user's mood, origin city/airport, and travel dates
+  2. Use MoodToNeed tool to understand their emotional need
+  3. Use NeedToDestination tool to get destination suggestions
+  4. Use weather_forecast tool to check weather conditions
+  5. Use country_info tool to check safety and context
+  6. Use flights_finder tool to find flights
+  7. Create an inspirational final message with final_answer
+
+  🚨 CRITICAL RULES:
+  - ALWAYS use the provided tools - NEVER simulate them with Python code
+  - Call tools with their exact names: MoodToNeed, NeedToDestination, weather_forecast, flights_finder, country_info, final_answer
+  - If user doesn't provide mood, origin, and dates - ask for them first
+  - Check multiple destinations if weather/conditions aren't suitable
+
+  📋 WORKFLOW:
+  Step 1: Check inputs (mood, origin, travel dates)
+  Step 2: need = MoodToNeed(mood="user's mood")
+  Step 3: destinations = NeedToDestination(need=need)
+  Step 4: For each destination: weather_forecast(location="city, country", date="YYYY-MM-DD")
+  Step 5: country_info(country="country name", info_type="security")
+  Step 6: flights_finder(departure_airport="XXX", arrival_airport="YYY", outbound_date="YYYY-MM-DD", return_date="YYYY-MM-DD")
+  Step 7: final_answer("Complete travel plan with inspiration")
+
+  🔧 TOOL EXAMPLES:
+  ```py
+  # Get emotional need
+  need = MoodToNeed(mood="stressed and overwhelmed")
+  
+  # Get destinations
+  destinations = NeedToDestination(need=need)
+  
+  # Check weather
+  weather = weather_forecast(location="Bali, Indonesia", date="2024-07-15", activity_type="beach")
+  
+  # Check country info
+  safety = country_info(country="Indonesia", info_type="security")
+  
+  # Find flights
+  flights = flights_finder(departure_airport="CDG", arrival_airport="DPS", outbound_date="2024-07-15", return_date="2024-07-22")
+  
+  # Final answer
+  final_answer("Your complete travel plan...")
+  ```
+
+  Remember: Use tools, don't simulate them!
+
+planning:
+  initial_plan: |-
+    1. Verify user provided mood, origin, and travel dates
+    2. Use MoodToNeed(mood) to extract emotional need
+    3. Use NeedToDestination(need) to get destination suggestions
+    4. For each destination: check weather_forecast() and country_info()
+    5. Select best destination based on weather and safety
+    6. Use flights_finder() to get flight options
+    7. Create inspirational message with final_answer() 

tools/mood_to_need.py

@@ -48,7 +48,7 @@ class MoodToNeedTool(Tool):
         response = self.model(prompt)
         return response.strip()
 
-client = Anthropic(api_key=os.getenv("ANTHROPIC_KEY"))
+client = Anthropic(api_key=os.getenv("ANTROPIC_KEY"))
 
 def claude_mood_to_need_model(prompt: str) -> str:
     message = client.messages.create(

tools/need_to_destination.py

@@ -55,7 +55,7 @@ class NeedToDestinationTool(Tool):
         return destinations
     
 
-client = Anthropic(api_key=os.getenv("ANTHROPIC_KEY"))
+client = Anthropic(api_key=os.getenv("ANTROPIC_KEY"))
 
 def claude_need_to_destination_model(prompt: str) -> str:
     message = client.messages.create(