test

.env

@@ -1,3 +0,0 @@
-SERPAPI_API_KEY="5f1ba2f2179fafad997e2514ccaa634be88cc9d7c5d0382e9e5b528ba0e434c0O"
-OPENWEATHER_API_KEY="e6945bba120fdad7ef7421c5cdbe731c"
-NEWSAPI_KEY="c104341b18f34979b0b117549f5a76c2"

Gradio_UI.py

@@ -1,121 +0,0 @@
-# gradio_UI.py
-
-import os
-import re
-import mimetypes
-import shutil
-from typing import Optional
-
-import gradio as gr
-
-from smolagents.agent_types import AgentText, AgentImage, AgentAudio, handle_agent_output_types
-from smolagents.agents import ActionStep, MultiStepAgent
-from smolagents.memory import MemoryStep
-from smolagents.utils import _is_package_available
-
-def pull_messages_from_step(step_log: MemoryStep):
-    if isinstance(step_log, ActionStep):
-        step_number = f"Step {step_log.step_number}" if step_log.step_number is not None else ""
-        yield gr.ChatMessage(role="assistant", content=f"**{step_number}**")
-
-        if hasattr(step_log, "model_output") and step_log.model_output is not None:
-            model_output = re.sub(r"```.?\s*<end_code>", "```", step_log.model_output.strip())
-            yield gr.ChatMessage(role="assistant", content=model_output)
-
-        if hasattr(step_log, "tool_calls") and step_log.tool_calls:
-            tool_call = step_log.tool_calls[0]
-            content = str(tool_call.arguments.get("answer", tool_call.arguments)) if isinstance(tool_call.arguments, dict) else str(tool_call.arguments)
-            if tool_call.name == "python_interpreter":
-                content = f"```python\n{re.sub(r'<end_code>', '', content).strip()}\n```"
-            tool_msg = gr.ChatMessage(
-                role="assistant",
-                content=content,
-                metadata={"title": f"🛠️ Used tool {tool_call.name}", "id": "tool_call", "status": "pending"},
-            )
-            yield tool_msg
-            if step_log.observations:
-                yield gr.ChatMessage(role="assistant", content=step_log.observations.strip(), metadata={"title": "📝 Execution Logs", "parent_id": "tool_call", "status": "done"})
-            if step_log.error:
-                yield gr.ChatMessage(role="assistant", content=str(step_log.error), metadata={"title": "💥 Error", "parent_id": "tool_call", "status": "done"})
-            tool_msg.metadata["status"] = "done"
-
-        elif step_log.error:
-            yield gr.ChatMessage(role="assistant", content=str(step_log.error), metadata={"title": "💥 Error"})
-
-        meta = f"<span style='color:#bbb;font-size:12px;'>Input tokens: {getattr(step_log, 'input_token_count', 0)} | Output tokens: {getattr(step_log, 'output_token_count', 0)} | Duration: {round(getattr(step_log, 'duration', 0), 2)}</span>"
-        yield gr.ChatMessage(role="assistant", content=meta)
-        yield gr.ChatMessage(role="assistant", content="-----")
-
-def stream_to_gradio(agent, task: str, reset_agent_memory: bool = False, additional_args: Optional[dict] = None):
-    total_input_tokens = 0
-    total_output_tokens = 0
-    for step_log in agent.run(task, stream=True, reset=reset_agent_memory, additional_args=additional_args):
-        if hasattr(agent.model, "last_input_token_count"):
-            total_input_tokens += agent.model.last_input_token_count
-            total_output_tokens += agent.model.last_output_token_count
-            if isinstance(step_log, ActionStep):
-                step_log.input_token_count = agent.model.last_input_token_count
-                step_log.output_token_count = agent.model.last_output_token_count
-        for message in pull_messages_from_step(step_log):
-            yield message
-    final_answer = handle_agent_output_types(step_log)
-    if isinstance(final_answer, AgentText):
-        yield gr.ChatMessage(role="assistant", content=f"**Final answer:**\n{final_answer.to_string()}")
-    elif isinstance(final_answer, AgentImage):
-        yield gr.ChatMessage(role="assistant", content={"path": final_answer.to_string(), "mime_type": "image/png"})
-    elif isinstance(final_answer, AgentAudio):
-        yield gr.ChatMessage(role="assistant", content={"path": final_answer.to_string(), "mime_type": "audio/wav"})
-    else:
-        yield gr.ChatMessage(role="assistant", content=f"**Final answer:** {str(final_answer)}")
-
-class GradioUI:
-    def __init__(self, agent: MultiStepAgent):
-        if not _is_package_available("gradio"):
-            raise ModuleNotFoundError("Please install 'gradio' with: pip install 'smolagents[gradio]'")
-        self.agent = agent
-
-    def interact_with_agent(self, prompt, messages):
-        messages.append(gr.ChatMessage(role="user", content=prompt))
-        yield messages
-        for msg in stream_to_gradio(self.agent, task=prompt):
-            messages.append(msg)
-            yield messages
-        yield messages
-
-    # def launch(self):
-    #     with gr.Blocks(fill_height=True) as demo:
-    #         stored_messages = gr.State([])
-    #         chatbot = gr.Chatbot(label="🌍 Mood-Based Travel Agent", type="messages")
-    #         user_input = gr.Textbox(lines=1, label="Describe your mood")
-    #         user_input.submit(
-    #             lambda text, hist: (hist + [gr.ChatMessage(role="user", content=text)], ""),
-    #             [user_input, stored_messages],
-    #             [stored_messages, user_input],
-    #         ).then(self.interact_with_agent, [user_input, stored_messages], [chatbot])
-    #     demo.launch(debug=True, share=True)
-
-    def launch(self):
-        def run_agent_interface(prompt):
-            messages = []
-            for msg in stream_to_gradio(self.agent, task=prompt):
-                messages.append(msg)
-            return "\n".join([m.content if isinstance(m.content, str) else str(m.content) for m in messages])
-
-
-        demo = gr.Interface(
-            fn=run_agent_interface,
-            inputs=gr.Textbox(
-                label="Describe your mood",
-                placeholder="e.g., I need a lemon-scented reset by the sea...",
-                lines=1
-            ),
-            outputs=gr.Textbox(label="Response"),
-            title="Mood-Based Travel Agent",
-            description="Plan your perfect Mediterranean escape, one mood at a time.",
-            theme="default",
-            api_name="predict"
-        )
-
-        demo.launch(debug=True, share=True)
-
-__all__ = ["GradioUI", "stream_to_gradio"]

app.py

@@ -1,18 +1,15 @@
-from smolagents import CodeAgent, LiteLLMModel
-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 smolagents import CodeAgent, HfApiModel
+from tools.mood_to_need import mood_to_need
+from tools.need_to_destination import need_to_destination
+from tools.get_weather import get_weather
+from tools.get_flights import get_flights
+from tools.final_wrap import final_wrap
 from tools.final_answer import FinalAnswerTool
-from tools.country_info_tool import CountryInfoTool
-from smolagents import CodeAgent,DuckDuckGoSearchTool, HfApiModel,load_tool,tool
-from smolagents import MultiStepAgent, ActionStep, AgentText, AgentImage, AgentAudio, handle_agent_output_types
 from Gradio_UI import GradioUI
 import yaml
-# from tools.mock_tools import MoodToNeedTool, NeedToDestinationTool, WeatherTool, FlightsFinderTool, FinalAnswerTool
 
 # Initialize Claude model via Hugging Face
-model = LiteLLMModel(
+model = HfApiModel(
     model_id="claude-3-opus-20240229",
     temperature=0.7,
     max_tokens=2048
@@ -23,31 +20,17 @@ with open("prompts.yaml", "r") as f:
     prompt_templates = yaml.safe_load(f)
 
 # Define the agent with all tools
-# agent = CodeAgent(
-#     model=model,
-#     tools=[
-#         MoodToNeedTool(),          # Step 1: Mood → Need
-#         NeedToDestinationTool(),   # Step 2: Need → Destination
-#         WeatherTool(),             # Step 3: Weather for destination
-#         FlightsFinderTool(),       # Step 4: Destination → Flights           # Step 5: Claude wrap
-#         FinalAnswerTool()       # Required final output
-#     ],
-#     max_steps=6,
-#     verbosity_level=1,
-#     prompt_templates=prompt_templates
-# )
-
 agent = CodeAgent(
     model=model,
     tools=[
-        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
+        mood_to_need,          # Step 1: Mood → Need
+        need_to_destination,   # Step 2: Need → Destination
+        get_weather,           # Step 3: Weather for destination
+        get_flights,           # Step 4: Destination → Flights
+        final_wrap,            # Step 5: Claude wrap
+        FinalAnswerTool()      # Required final output
     ],
-    max_steps=10,
+    max_steps=6,
     verbosity_level=1,
     prompt_templates=prompt_templates
 )

prompts.yaml

@@ -1,137 +0,0 @@
-system_prompt: |-
-  You are a world-class travel assistant agent named WanderMind, built to help users find the perfect destination based on their mood.
-  You operate in an autonomous, multi-step thinking loop using Thought → Code → Observation.
-
-  Your job is to:
-    - Reflect on the user’s mood
-    - Infer their emotional need
-    - Suggest a travel destination with a matching activity
-    - Check the weather
-    - Retrieve relevant country information
-    - Decide whether the weather and country conditions suit the emotional need
-    - If not, suggest another destination
-    - Once happy, find flights from the origin
-    - Wrap everything into an inspirational message
-    - Optionally, add a quote based on the mood
-
-  You must solve the full task by reasoning, calling tools or managed agents if needed, and writing Python code in the Code block.
-
-  Each step should follow this format:
-
-  Thought: explain what you will do and why.
-  Code:
-  ⁠ py
-  # your code here
-   ⁠<end_code>
-  Observation: result of previous code
-
-  You must output a final result using ⁠ final_answer() ⁠. 
-
-  
-  🛫 Your very first job is to ensure the user has provided the following inputs:
-  - `mood`: how the user is feeling (e.g., "stressed", "adventurous")
-  - `origin`: the city or airport they’re departing from
-  - `week`: approximate travel week or date range (e.g., "mid July" or "2025-07-15")
-
-  ❗If one or more are missing, ask for them clearly and stop the plan until you receive all of them.
-  
-  Example check code:
-  ```py
-  if not mood or not origin or not week:
-      missing = []
-      if not mood:
-          missing.append("your mood")
-      if not origin:
-          missing.append("your departure city or airport")
-      if not week:
-          missing.append("your travel week or dates")
-
-      print(f"Before we start planning, could you tell me {', '.join(missing)}? 😊")
-  else:
-      print("All required inputs provided. Let's begin planning.")
-  ```<end_code>
-
-
-  Your available tools are:
-  - 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.
-
-  Now begin!
-  
-planning:
-  initial_facts: |-
-    ### 1. Facts given in the task
-    - The user provides their mood.
-    
-    ### 2. Facts to look up
-    - Emotional need based on mood.
-    - Destination and activity based on need.
-    - Current weather at destination.
-    - Flights from user origin to destination.
-    - Quote for mood.
-
-    ### 3. Facts to derive
-    - Whether the weather fits the emotional need.
-    - If not, re-iterate destination choice.
-    - Final wrap-up message to user.
-
-  initial_plan: |-
-    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: |-
-    ### 1. Facts given in the task
-    ### 2. Facts that we have learned
-    ### 3. Facts still to look up
-    ### 4. Facts still to derive
-
-  update_facts_post_messages: |-
-    Please update your facts:
-    ### 1. Facts given in the task
-    ### 2. Facts that we have learned
-    ### 3. Facts still to look up
-    ### 4. Facts still to derive
-
-  update_plan_pre_messages: |-
-    Below is your current task and history. Please write a new plan based on the updated facts.
-
-  update_plan_post_messages: |-
-    Write a clean new plan with the latest facts. You must respect tool usage rules.
-
-managed_agent:
-  task: |-
-    You are a helpful sub-agent named '{{name}}'.
-    Your manager gives you this task:
-    {{task}}
-
-    You MUST return:
-    ### 1. Task outcome (short version):
-    ### 2. Task outcome (extremely detailed version):
-    ### 3. Additional context (if any)
-
-    Wrap everything in a final_answer().
-
-  report: |-
-    Final answer from agent '{{name}}':
-    {{final_answer}}
-
-final_answer:
-  pre_messages: |-
-    Let's summarize everything before presenting the final answer:
-  post_messages: |-
-    Here's your final result. Enjoy your journey!

requirements.txt

@@ -1,8 +1 @@
-huggingface_hub==0.31.2
-requests>=2.25.0
-smolagents>=1.18.0
-python-dotenv>=0.19.0
-markdownify>=0.11.0
-serpapi==0.1.5
-anthropic>=0.24.0
-smolagents[litellm]
+huggingface_hub==0.25.2

test_tools.py

@@ -1,59 +0,0 @@
-#!/usr/bin/env python3
-
-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.country_info_tool import CountryInfoTool
-from tools.find_flight import FlightsFinderTool
-
-def test_tools():
-    print("🧪 Testing individual tools...\n")
-    
-    # Test 1: MoodToNeed
-    print("1️⃣ Testing MoodToNeed...")
-    mood_tool = MoodToNeedTool(model=claude_mood_to_need_model)
-    need = mood_tool.forward(mood="happy")
-    print(f"   Input: 'happy' → Output: '{need}'\n")
-    
-    # Test 2: NeedToDestination
-    print("2️⃣ Testing NeedToDestination...")
-    destination_tool = NeedToDestinationTool(model=claude_need_to_destination_model)
-    destinations = destination_tool.forward(need=need)
-    print(f"   Input: '{need}' → Output: {destinations}\n")
-    
-    # Test 3: WeatherTool
-    print("3️⃣ Testing WeatherTool...")
-    weather_tool = WeatherTool()
-    if destinations and len(destinations) > 0:
-        first_dest = destinations[0]["destination"]
-        weather = weather_tool.forward(location=first_dest)
-        print(f"   Input: '{first_dest}' → Output: {weather[:200]}...\n")
-    
-    # Test 4: CountryInfoTool
-    print("4️⃣ Testing CountryInfoTool...")
-    country_tool = CountryInfoTool()
-    if destinations and len(destinations) > 0:
-        # Extract country from destination
-        dest_parts = destinations[0]["destination"].split(", ")
-        if len(dest_parts) > 1:
-            country = dest_parts[1]
-            safety = country_tool.forward(country=country, info_type="security")
-            print(f"   Input: '{country}' → Output: {safety[:200]}...\n")
-    
-    # Test 5: FlightsFinderTool
-    print("5️⃣ Testing FlightsFinderTool...")
-    flights_tool = FlightsFinderTool()
-    if destinations and len(destinations) > 0:
-        dest_airport = destinations[0]["departure"]["to_airport"]
-        flights = flights_tool.forward(
-            departure_airport="CDG",
-            arrival_airport=dest_airport,
-            outbound_date="2025-06-15",
-            return_date="2025-06-22"
-        )
-        print(f"   Input: CDG → {dest_airport} → Output: {flights[:200]}...\n")
-    
-    print("✅ All tools tested!")
-
-if __name__ == "__main__":
-    test_tools() 

tools/country_info_tool.py

@@ -1,729 +0,0 @@
-from typing import Any
-from smolagents.tools import Tool
-import requests
-from datetime import datetime, timedelta
-import json
-import os
-from dotenv import load_dotenv
-import re
-import anthropic
-
-class CountryInfoTool(Tool):
-    name = "country_info"
-    description = "Retrieves important contextual information about a country in real-time: security, current events, national holidays, political climate, travel advice."
-    inputs = {
-        'country': {'type': 'string', 'description': 'Country name in French or English (e.g., "France", "United States", "Japan")'},
-        'info_type': {'type': 'string', 'description': 'Type of information requested: "all" (recommended), "security", "events", "holidays", "travel", "politics"', 'nullable': True}
-    }
-    output_type = "string"
-
-    def __init__(self):
-        super().__init__()
-        load_dotenv()
-        
-        # Initialiser le client Claude (Anthropic)
-        self.claude_client = anthropic.Anthropic(api_key=os.getenv('ANTROPIC_KEY'))
-        
-        # Mapping étendu des pays français vers anglais pour les APIs
-        self.country_mapping = {
-            # Europe
-            'france': 'France', 'allemagne': 'Germany', 'italie': 'Italy', 'espagne': 'Spain',
-            'royaume-uni': 'United Kingdom', 'angleterre': 'United Kingdom', 'écosse': 'United Kingdom',
-            'pays-bas': 'Netherlands', 'hollande': 'Netherlands', 'belgique': 'Belgium', 
-            'suisse': 'Switzerland', 'autriche': 'Austria', 'portugal': 'Portugal',
-            'suède': 'Sweden', 'norvège': 'Norway', 'danemark': 'Denmark', 'finlande': 'Finland',
-            'pologne': 'Poland', 'république tchèque': 'Czech Republic', 'tchéquie': 'Czech Republic',
-            'hongrie': 'Hungary', 'roumanie': 'Romania', 'bulgarie': 'Bulgaria',
-            'grèce': 'Greece', 'croatie': 'Croatia', 'slovénie': 'Slovenia', 'slovaquie': 'Slovakia',
-            'estonie': 'Estonia', 'lettonie': 'Latvia', 'lituanie': 'Lithuania',
-            'irlande': 'Ireland', 'islande': 'Iceland', 'malte': 'Malta', 'chypre': 'Cyprus',
-            'serbie': 'Serbia', 'bosnie': 'Bosnia and Herzegovina', 'monténégro': 'Montenegro',
-            'macédoine': 'North Macedonia', 'albanie': 'Albania', 'moldavie': 'Moldova',
-            'ukraine': 'Ukraine', 'biélorussie': 'Belarus', 'russie': 'Russia',
-            
-            # Amériques
-            'états-unis': 'United States', 'usa': 'United States', 'amérique': 'United States',
-            'canada': 'Canada', 'mexique': 'Mexico',
-            'brésil': 'Brazil', 'argentine': 'Argentina', 'chili': 'Chile', 'pérou': 'Peru',
-            'colombie': 'Colombia', 'venezuela': 'Venezuela', 'équateur': 'Ecuador',
-            'bolivie': 'Bolivia', 'paraguay': 'Paraguay', 'uruguay': 'Uruguay',
-            'guatemala': 'Guatemala', 'costa rica': 'Costa Rica', 'panama': 'Panama',
-            'cuba': 'Cuba', 'jamaïque': 'Jamaica', 'haïti': 'Haiti', 'république dominicaine': 'Dominican Republic',
-            
-            # Asie
-            'chine': 'China', 'japon': 'Japan', 'corée du sud': 'South Korea', 'corée du nord': 'North Korea',
-            'inde': 'India', 'pakistan': 'Pakistan', 'bangladesh': 'Bangladesh', 'sri lanka': 'Sri Lanka',
-            'thaïlande': 'Thailand', 'vietnam': 'Vietnam', 'cambodge': 'Cambodia', 'laos': 'Laos',
-            'myanmar': 'Myanmar', 'birmanie': 'Myanmar', 'malaisie': 'Malaysia', 'singapour': 'Singapore',
-            'indonésie': 'Indonesia', 'philippines': 'Philippines', 'brunei': 'Brunei',
-            'mongolie': 'Mongolia', 'kazakhstan': 'Kazakhstan', 'ouzbékistan': 'Uzbekistan',
-            'kirghizistan': 'Kyrgyzstan', 'tadjikistan': 'Tajikistan', 'turkménistan': 'Turkmenistan',
-            'afghanistan': 'Afghanistan', 'iran': 'Iran', 'irak': 'Iraq', 'syrie': 'Syria',
-            'turquie': 'Turkey', 'israël': 'Israel', 'palestine': 'Palestine', 'liban': 'Lebanon',
-            'jordanie': 'Jordan', 'arabie saoudite': 'Saudi Arabia', 'émirats arabes unis': 'United Arab Emirates',
-            'qatar': 'Qatar', 'koweït': 'Kuwait', 'bahreïn': 'Bahrain', 'oman': 'Oman', 'yémen': 'Yemen',
-            
-            # Afrique
-            'maroc': 'Morocco', 'algérie': 'Algeria', 'tunisie': 'Tunisia', 'libye': 'Libya', 'égypte': 'Egypt',
-            'soudan': 'Sudan', 'éthiopie': 'Ethiopia', 'kenya': 'Kenya', 'tanzanie': 'Tanzania',
-            'ouganda': 'Uganda', 'rwanda': 'Rwanda', 'burundi': 'Burundi', 'congo': 'Democratic Republic of the Congo',
-            'république démocratique du congo': 'Democratic Republic of the Congo', 'rdc': 'Democratic Republic of the Congo',
-            'république du congo': 'Republic of the Congo', 'cameroun': 'Cameroon', 'nigeria': 'Nigeria',
-            'ghana': 'Ghana', 'côte d\'ivoire': 'Ivory Coast', 'sénégal': 'Senegal', 'mali': 'Mali',
-            'burkina faso': 'Burkina Faso', 'niger': 'Niger', 'tchad': 'Chad', 'centrafrique': 'Central African Republic',
-            'gabon': 'Gabon', 'guinée équatoriale': 'Equatorial Guinea', 'sao tomé': 'Sao Tome and Principe',
-            'cap-vert': 'Cape Verde', 'guinée-bissau': 'Guinea-Bissau', 'guinée': 'Guinea',
-            'sierra leone': 'Sierra Leone', 'liberia': 'Liberia', 'togo': 'Togo', 'bénin': 'Benin',
-            'mauritanie': 'Mauritania', 'gambie': 'Gambia', 'afrique du sud': 'South Africa',
-            'namibie': 'Namibia', 'botswana': 'Botswana', 'zimbabwe': 'Zimbabwe', 'zambie': 'Zambia',
-            'malawi': 'Malawi', 'mozambique': 'Mozambique', 'madagascar': 'Madagascar', 'maurice': 'Mauritius',
-            'seychelles': 'Seychelles', 'comores': 'Comoros', 'djibouti': 'Djibouti', 'érythrée': 'Eritrea',
-            'somalie': 'Somalia', 'lesotho': 'Lesotho', 'eswatini': 'Eswatini', 'swaziland': 'Eswatini',
-            
-            # Océanie
-            'australie': 'Australia', 'nouvelle-zélande': 'New Zealand', 'fidji': 'Fiji',
-            'papouasie-nouvelle-guinée': 'Papua New Guinea', 'vanuatu': 'Vanuatu', 'samoa': 'Samoa',
-            'tonga': 'Tonga', 'îles salomon': 'Solomon Islands', 'micronésie': 'Micronesia',
-            'palau': 'Palau', 'nauru': 'Nauru', 'kiribati': 'Kiribati', 'tuvalu': 'Tuvalu'
-        }
-        
-        # Codes ISO pour certaines APIs
-        self.country_codes = {
-            'France': 'FR', 'United States': 'US', 'United Kingdom': 'GB',
-            'Germany': 'DE', 'Italy': 'IT', 'Spain': 'ES', 'Japan': 'JP',
-            'China': 'CN', 'India': 'IN', 'Brazil': 'BR', 'Canada': 'CA',
-            'Australia': 'AU', 'Russia': 'RU', 'Mexico': 'MX', 'South Korea': 'KR',
-            'Netherlands': 'NL', 'Belgium': 'BE', 'Switzerland': 'CH',
-            'Sweden': 'SE', 'Norway': 'NO', 'Denmark': 'DK', 'Turkey': 'TR',
-            'Egypt': 'EG', 'Thailand': 'TH', 'Iran': 'IR'
-        }
-
-    def forward(self, country: str, info_type: str = "all") -> str:
-        try:
-            # Normaliser le nom du pays
-            country_normalized = self._normalize_country_name(country)
-            
-            if not country_normalized:
-                return f"❌ Country not recognized: '{country}'. Try with the full name (e.g., 'France', 'United States', 'United Kingdom')"
-            
-            # Collecter les informations selon le type demandé
-            info_sections = []
-            
-            if info_type in ["all", "security"]:
-                security_info = self._get_security_info(country_normalized)
-                if security_info:
-                    info_sections.append(security_info)
-            
-            if info_type in ["all", "events"]:
-                events_info = self._get_current_events_info(country_normalized)
-                if events_info:
-                    info_sections.append(events_info)
-            
-            if info_type in ["all", "holidays"]:
-                holidays_info = self._get_holidays_info(country_normalized)
-                if holidays_info:
-                    info_sections.append(holidays_info)
-            
-            if info_type in ["all", "travel"]:
-                travel_info = self._get_travel_info(country_normalized)
-                if travel_info:
-                    info_sections.append(travel_info)
-            
-            if info_type in ["all", "politics"]:
-                politics_info = self._get_political_info(country_normalized)
-                if politics_info:
-                    info_sections.append(politics_info)
-            
-            if not info_sections:
-                return f"❌ No information available for {country_normalized} currently."
-            
-            # Assembler le rapport final
-            result = f"🌍 **Contextual Information for {country_normalized}**\n"
-            result += f"*Updated: {datetime.now().strftime('%m/%d/%Y %H:%M')}*\n\n"
-            result += "\n\n".join(info_sections)
-            
-            # Ajouter une recommandation finale intelligente si Claude est disponible et qu'on demande toutes les infos
-            if info_type == "all" and self.claude_client:
-                final_recommendation = self._get_llm_final_recommendation(country_normalized, "\n\n".join(info_sections))
-                if final_recommendation:
-                    result += f"\n\n{final_recommendation}"
-            
-            return result
-            
-        except Exception as e:
-            return f"❌ Error retrieving information: {str(e)}"
-
-    def _normalize_country_name(self, country: str):
-        """Normalise le nom du pays"""
-        country_lower = country.lower().strip()
-        
-        # Vérifier dans le mapping français -> anglais
-        if country_lower in self.country_mapping:
-            return self.country_mapping[country_lower]
-        
-        # Vérifier si c'est déjà un nom anglais valide
-        for french, english in self.country_mapping.items():
-            if country_lower == english.lower():
-                return english
-        
-        # Essayer une correspondance partielle
-        for french, english in self.country_mapping.items():
-            if country_lower in french or french in country_lower:
-                return english
-        
-        # Si pas trouvé dans le mapping, essayer de valider via l'API REST Countries
-        validated_country = self._validate_country_via_api(country)
-        if validated_country:
-            return validated_country
-        
-        return None
-
-    def _validate_country_via_api(self, country: str):
-        """Valide et normalise le nom du pays via l'API REST Countries"""
-        try:
-            # Essayer d'abord avec le nom exact
-            url = f"https://restcountries.com/v3.1/name/{country}"
-            response = requests.get(url, timeout=5)
-            
-            if response.status_code == 200:
-                data = response.json()
-                if data:
-                    # Retourner le nom officiel en anglais
-                    return data[0].get('name', {}).get('common', country.title())
-            
-            # Si échec, essayer avec une recherche partielle
-            url = f"https://restcountries.com/v3.1/name/{country}?fullText=false"
-            response = requests.get(url, timeout=5)
-            
-            if response.status_code == 200:
-                data = response.json()
-                if data:
-                    # Prendre le premier résultat
-                    return data[0].get('name', {}).get('common', country.title())
-            
-            return None
-            
-        except Exception:
-            # En cas d'erreur, retourner le nom avec la première lettre en majuscule
-            return country.title() if len(country) > 2 else None
-
-    def _get_country_code_from_api(self, country: str):
-        """Récupère le code ISO du pays via l'API REST Countries"""
-        try:
-            url = f"https://restcountries.com/v3.1/name/{country}"
-            response = requests.get(url, timeout=5)
-            
-            if response.status_code == 200:
-                data = response.json()
-                if data:
-                    # Retourner le code ISO alpha-2
-                    return data[0].get('cca2', '')
-            
-            return None
-            
-        except Exception:
-            return None
-
-    def _get_security_info(self, country: str) -> str:
-        """Récupère les informations de sécurité avec recherche exhaustive"""
-        try:
-            # Vérifier d'abord si c'est un pays à risque connu
-            risk_level = self._check_known_risk_countries(country)
-            
-            # Recherches multiples avec différents mots-clés
-            all_news_data = []
-            
-            # Recherche 1: Sécurité générale
-            security_keywords = f"{country} travel advisory security warning conflict war"
-            news_data1 = self._search_security_news(security_keywords)
-            all_news_data.extend(news_data1)
-            
-            # Recherche 2: Conflits spécifiques
-            conflict_keywords = f"{country} war conflict violence terrorism attack bombing"
-            news_data2 = self._search_security_news(conflict_keywords)
-            all_news_data.extend(news_data2)
-            
-            # Recherche 3: Instabilité politique
-            political_keywords = f"{country} coup government crisis instability sanctions"
-            news_data3 = self._search_security_news(political_keywords)
-            all_news_data.extend(news_data3)
-            
-            # Recherche 4: Alertes de voyage
-            travel_keywords = f"{country} 'travel ban' 'do not travel' 'avoid travel' embassy"
-            news_data4 = self._search_security_news(travel_keywords)
-            all_news_data.extend(news_data4)
-            
-            # Supprimer les doublons
-            unique_news = []
-            seen_titles = set()
-            for article in all_news_data:
-                title = article.get('title', '')
-                if title and title not in seen_titles:
-                    unique_news.append(article)
-                    seen_titles.add(title)
-            
-            # Analyser les résultats pour déterminer le niveau de sécurité
-            security_level, description, recommendation = self._analyze_security_data(country, unique_news, risk_level)
-            
-            result = f"🛡️ **Security and Travel Advice**\n"
-            result += f"{security_level} **Level determined by real-time analysis**\n"
-            result += f"📋 {description}\n"
-            result += f"🎯 **Recommendation: {recommendation}**"
-            
-            return result
-            
-        except Exception as e:
-            return f"🛡️ **Security**: Error during retrieval - {str(e)}"
-
-    def _check_known_risk_countries(self, country: str) -> str:
-        """Vérifie si le pays est dans la liste des pays à risque connus"""
-        
-        # Pays à très haut risque (guerre active, conflit majeur)
-        high_risk_countries = [
-            'Ukraine', 'Afghanistan', 'Syria', 'Yemen', 'Somalia', 'South Sudan',
-            'Central African Republic', 'Mali', 'Burkina Faso', 'Niger',
-            'Democratic Republic of the Congo', 'Myanmar', 'Palestine', 'Gaza',
-            'West Bank', 'Iraq', 'Libya', 'Sudan'
-        ]
-        
-        # Pays à risque modéré (instabilité, tensions)
-        moderate_risk_countries = [
-            'Iran', 'North Korea', 'Venezuela', 'Belarus', 'Ethiopia',
-            'Chad', 'Cameroon', 'Nigeria', 'Pakistan', 'Bangladesh',
-            'Haiti', 'Lebanon', 'Turkey', 'Egypt', 'Algeria'
-        ]
-        
-        # Pays avec tensions spécifiques
-        tension_countries = [
-            'Russia', 'China', 'Israel', 'India', 'Kashmir', 'Taiwan',
-            'Hong Kong', 'Thailand', 'Philippines', 'Colombia'
-        ]
-        
-        country_lower = country.lower()
-        
-        for risk_country in high_risk_countries:
-            if risk_country.lower() in country_lower or country_lower in risk_country.lower():
-                return "HIGH_RISK"
-        
-        for risk_country in moderate_risk_countries:
-            if risk_country.lower() in country_lower or country_lower in risk_country.lower():
-                return "MODERATE_RISK"
-                
-        for risk_country in tension_countries:
-            if risk_country.lower() in country_lower or country_lower in risk_country.lower():
-                return "TENSION"
-        
-        return "UNKNOWN"
-
-    def _search_security_news(self, keywords: str) -> list:
-        """Recherche d'actualités de sécurité avec période étendue"""
-        try:
-            # Utiliser NewsAPI si disponible
-            api_key = os.getenv('NEWSAPI_KEY')
-            if api_key:
-                url = "https://newsapi.org/v2/everything"
-                params = {
-                    'q': keywords,
-                    'sortBy': 'publishedAt',
-                    'pageSize': 20,  # Plus d'articles
-                    'language': 'en',
-                    'from': (datetime.now() - timedelta(days=30)).strftime('%Y-%m-%d'),  # 30 jours au lieu de 7
-                    'apiKey': api_key
-                }
-                
-                response = requests.get(url, params=params, timeout=10)
-                if response.status_code == 200:
-                    data = response.json()
-                    articles = data.get('articles', [])
-                    
-                    # Filtrer les articles pertinents
-                    relevant_articles = []
-                    for article in articles:
-                        title = article.get('title', '').lower()
-                        description = article.get('description', '').lower()
-                        
-                        # Mots-clés critiques pour filtrer
-                        critical_keywords = ['war', 'conflict', 'attack', 'bombing', 'terrorism', 
-                                           'violence', 'crisis', 'coup', 'sanctions', 'advisory',
-                                           'warning', 'danger', 'risk', 'threat', 'security']
-                        
-                        if any(keyword in title or keyword in description for keyword in critical_keywords):
-                            relevant_articles.append(article)
-                    
-                    return relevant_articles
-            
-            # Fallback: recherche via une API publique alternative
-            return self._search_alternative_news(keywords)
-            
-        except Exception:
-            return []
-
-    def _search_alternative_news(self, keywords: str) -> list:
-        """Recherche alternative sans API key"""
-        try:
-            # Utiliser une API publique comme Guardian ou BBC
-            # Pour l'exemple, on simule une recherche basique
-            dangerous_keywords = ['war', 'conflict', 'terrorism', 'violence', 'crisis', 'coup', 'sanctions']
-            warning_keywords = ['protest', 'unrest', 'advisory', 'caution', 'alert']
-            
-            # Simulation basée sur les mots-clés (à remplacer par vraie API)
-            if any(word in keywords.lower() for word in dangerous_keywords):
-                return [{'title': f'Security concerns in {keywords.split()[0]}', 'description': 'Recent security developments'}]
-            elif any(word in keywords.lower() for word in warning_keywords):
-                return [{'title': f'Travel advisory for {keywords.split()[0]}', 'description': 'Caution advised'}]
-            
-            return []
-            
-        except Exception:
-            return []
-
-    def _analyze_security_data(self, country: str, news_data: list, risk_level: str = "UNKNOWN") -> tuple:
-        """Analyse les données de sécurité avec Claude uniquement"""
-        try:
-            if not self.claude_client:
-                return ("⚪", 
-                       "Claude not available", 
-                       "❓ Anthropic API key required for security analysis")
-            
-            # Préparer le contenu des actualités pour l'analyse
-            news_content = ""
-            for i, article in enumerate(news_data[:10], 1):  # Limiter à 10 articles
-                title = article.get('title', '')
-                description = article.get('description', '')
-                if title or description:
-                    news_content += f"{i}. {title}\n{description}\n\n"
-            
-            # Si pas d'actualités mais pays à haut risque connu, forcer l'analyse
-            if not news_content.strip():
-                if risk_level == "HIGH_RISK":
-                    return ("🔴", 
-                           f"Very high risk country - active conflict or war",
-                           "🚫 CHANGE DESTINATION - Active conflict zone")
-                elif risk_level == "MODERATE_RISK":
-                    return ("🟡", 
-                           f"Moderate risk country - political instability",
-                           "⚠️ Travel possible with enhanced precautions")
-                else:
-                    return ("🟢", 
-                           f"No recent security news found",
-                           "✅ Destination considered safe")
-            
-            # Utiliser Claude pour analyser
-            analysis = self._llm_security_analysis(country, news_content, risk_level)
-            
-            if analysis:
-                return analysis
-            else:
-                return ("⚪", 
-                       "Claude analysis error", 
-                       "❓ Unable to analyze security currently")
-                       
-        except Exception:
-            return ("⚪", "Analysis impossible", "❓ Consult official sources")
-
-    def _llm_security_analysis(self, country: str, news_content: str, risk_level: str = "UNKNOWN"):
-        """Utilise Claude pour analyser la sécurité du pays"""
-        try:
-            if not self.claude_client:
-                return None
-                
-            prompt = f"""Analyze the following recent news about {country} and determine the security level for a traveler:
-
-KNOWN RISK LEVEL: {risk_level}
-- HIGH_RISK = Country in active war or major conflict
-- MODERATE_RISK = Country with significant political instability  
-- TENSION = Country with geopolitical tensions
-- UNKNOWN = No special classification
-
-RECENT NEWS:
-{news_content}
-
-CRITICAL INSTRUCTIONS:
-1. If RISK LEVEL = HIGH_RISK, you MUST recommend CHANGE_DESTINATION unless clear evidence of improvement
-2. For Ukraine, Palestine, Afghanistan, Syria, Yemen: ALWAYS RED/CHANGE_DESTINATION
-3. Analyze risk level for a civilian tourist/traveler
-4. Be VERY STRICT - traveler safety is priority
-
-Respond ONLY in the following JSON format:
-
-{{
-    "level": "RED|YELLOW|GREEN",
-    "description": "Short situation description (max 100 characters)",
-    "recommendation": "CHANGE_DESTINATION|ENHANCED_PRECAUTIONS|SAFE_DESTINATION",
-    "justification": "Explanation of your decision (max 200 characters)"
-}}
-
-STRICT Criteria:
-- RED/CHANGE_DESTINATION: active war, armed conflict, active terrorism, coup, widespread violence, combat zones
-- YELLOW/ENHANCED_PRECAUTIONS: violent protests, very high crime, political instability, ethnic tensions
-- GREEN/SAFE_DESTINATION: no major risks for civilians
-
-ABSOLUTE PRIORITY: Protect travelers - when in doubt, choose the strictest security level."""
-
-            response = self.claude_client.messages.create(
-                model="claude-3-opus-20240229",
-                max_tokens=300,
-                temperature=0.1,
-                system="Vous êtes un expert en sécurité des voyages. Analysez objectivement les risques.",
-                messages=[
-                    {"role": "user", "content": prompt}
-                ]
-            )
-            
-            result_text = response.content[0].text.strip()
-            # Parser la réponse JSON
-            try:
-                result = json.loads(result_text)
-                level = result.get('level', 'GREEN')
-                description = result.get('description', 'Analysis completed')
-                recommendation = result.get('recommendation', 'SAFE_DESTINATION')
-                justification = result.get('justification', '')
-                
-                # Convertir en format attendu
-                if level == 'RED':
-                    emoji = "🔴"
-                    advice = "🚫 CHANGE DESTINATION - " + justification
-                elif level == 'YELLOW':
-                    emoji = "🟡"
-                    advice = "⚠️ Travel possible with enhanced precautions - " + justification
-                else:
-                    emoji = "🟢"
-                    advice = "✅ Destination considered safe - " + justification
-                
-                return (emoji, description, advice)
-                
-            except json.JSONDecodeError:
-                return None
-                
-        except Exception:
-            return None
-
-
-
-    def _get_current_events_info(self, country: str) -> str:
-        """Retrieves current events via web search"""
-        try:
-            # Search for recent events
-            events_keywords = f"{country} current events news today recent"
-            events_data = self._search_current_events(events_keywords)
-            
-            if not events_data:
-                return f"📅 **Events**: No major events detected for {country}"
-            
-            result = f"📅 **Current Events and Context**\n"
-            for i, event in enumerate(events_data[:5], 1):
-                title = event.get('title', 'Event not specified')
-                result += f"• {title}\n"
-            
-            return result.rstrip()
-            
-        except Exception:
-            return "📅 **Events**: Error during retrieval"
-
-    def _search_current_events(self, keywords: str) -> list:
-        """Recherche d'événements actuels"""
-        try:
-            # Utiliser NewsAPI si disponible
-            api_key = os.getenv('NEWSAPI_KEY')
-            if api_key:
-                url = "https://newsapi.org/v2/everything"
-                params = {
-                    'q': keywords,
-                    'sortBy': 'publishedAt',
-                    'pageSize': 5,
-                    'from': (datetime.now() - timedelta(days=7)).strftime('%Y-%m-%d'),
-                    'language': 'en',
-                    'apiKey': api_key
-                }
-                
-                response = requests.get(url, params=params, timeout=10)
-                if response.status_code == 200:
-                    data = response.json()
-                    return data.get('articles', [])
-            
-            return []
-            
-        except Exception:
-            return []
-
-    def _get_holidays_info(self, country: str) -> str:
-        """Retrieves national holidays via API"""
-        try:
-            country_code = self.country_codes.get(country, '')
-            
-            # If no code in our mapping, try to get it via API
-            if not country_code:
-                country_code = self._get_country_code_from_api(country)
-            
-            if not country_code:
-                return f"🎉 **Holidays**: Country code not found for {country}"
-            
-            # Use Calendarific API or similar
-            holidays_data = self._fetch_holidays_api(country_code)
-            
-            if not holidays_data:
-                return f"🎉 **Holidays**: Information not available for {country}"
-            
-            current_month = datetime.now().month
-            current_year = datetime.now().year
-            
-            result = f"🎉 **Holidays and Seasonal Events**\n"
-            
-            # Filter holidays from current month and upcoming months
-            upcoming_holidays = []
-            for holiday in holidays_data:
-                try:
-                    holiday_date = datetime.strptime(holiday.get('date', ''), '%Y-%m-%d')
-                    if holiday_date.month >= current_month and holiday_date.year == current_year:
-                        upcoming_holidays.append(holiday)
-                except:
-                    continue
-            
-            if upcoming_holidays:
-                result += f"**Upcoming holidays:**\n"
-                for holiday in upcoming_holidays[:5]:
-                    name = holiday.get('name', 'Unknown holiday')
-                    date = holiday.get('date', '')
-                    result += f"• {name} ({date})\n"
-            else:
-                result += f"**No major holidays scheduled in the coming months**\n"
-            
-            return result.rstrip()
-            
-        except Exception:
-            return "🎉 **Holidays**: Error during retrieval"
-
-    def _fetch_holidays_api(self, country_code: str) -> list:
-        """Récupère les fêtes via API publique"""
-        try:
-            # Utiliser une API publique de fêtes (exemple: Calendarific, Nager.Date)
-            year = datetime.now().year
-            url = f"https://date.nager.at/api/v3/PublicHolidays/{year}/{country_code}"
-            
-            response = requests.get(url, timeout=10)
-            if response.status_code == 200:
-                return response.json()
-            
-            return []
-            
-        except Exception:
-            return []
-
-    def _get_travel_info(self, country: str) -> str:
-        """Retrieves travel information via REST Countries API"""
-        try:
-            # Use REST Countries API
-            url = f"https://restcountries.com/v3.1/name/{country}"
-            response = requests.get(url, timeout=10)
-            
-            if response.status_code == 200:
-                data = response.json()
-                if data:
-                    country_data = data[0]
-                    
-                    # Extract information
-                    currencies = country_data.get('currencies', {})
-                    languages = country_data.get('languages', {})
-                    region = country_data.get('region', 'Unknown')
-                    
-                    currency_name = list(currencies.keys())[0] if currencies else 'Unknown'
-                    language_list = list(languages.values()) if languages else ['Unknown']
-                    
-                    result = f"✈️ **Practical Travel Information**\n"
-                    result += f"💰 Currency: {currency_name}\n"
-                    result += f"🗣️ Languages: {', '.join(language_list[:3])}\n"
-                    result += f"🌍 Region: {region}\n"
-                    result += f"📋 Check visa requirements on the country's official website"
-                    
-                    return result
-            
-            return f"✈️ **Travel**: Information not available for {country}"
-            
-        except Exception:
-            return "✈️ **Travel**: Error during retrieval"
-
-    def _get_political_info(self, country: str) -> str:
-        """Retrieves political context via news search"""
-        try:
-            # Search for recent political news
-            political_keywords = f"{country} politics government election democracy"
-            political_data = self._search_political_news(political_keywords)
-            
-            if not political_data:
-                return f"🏛️ **Politics**: Stable situation for {country}"
-            
-            result = f"🏛️ **Political Context**\n"
-            
-            # Analyze political news
-            for article in political_data[:3]:
-                title = article.get('title', '')
-                if title:
-                    result += f"• {title}\n"
-            
-            return result.rstrip()
-            
-        except Exception:
-            return "🏛️ **Politics**: Error during retrieval"
-
-    def _search_political_news(self, keywords: str) -> list:
-        """Recherche d'actualités politiques"""
-        try:
-            api_key = os.getenv('NEWSAPI_KEY')
-            if api_key:
-                url = "https://newsapi.org/v2/everything"
-                params = {
-                    'q': keywords,
-                    'sortBy': 'publishedAt',
-                    'pageSize': 5,
-                    'from': (datetime.now() - timedelta(days=30)).strftime('%Y-%m-%d'),
-                    'language': 'en',
-                    'apiKey': api_key
-                }
-                
-                response = requests.get(url, params=params, timeout=10)
-                if response.status_code == 200:
-                    data = response.json()
-                    return data.get('articles', [])
-            
-            return []
-            
-        except Exception:
-            return []
-
-    def _get_llm_final_recommendation(self, country: str, full_report: str):
-        """Uses Claude to generate an intelligent final recommendation"""
-        try:
-            if not self.claude_client:
-                return None
-                
-            prompt = f"""Analyze this complete report about {country} and provide a concise final recommendation for a traveler:
-
-COMPLETE REPORT:
-{full_report}
-
-Your task:
-1. Synthesize the most important information
-2. Give a clear and actionable recommendation
-3. Respond in English, maximum 200 words
-4. Use a professional but accessible tone
-5. If risks exist, be explicit about precautions
-
-Desired response format:
-🎯 **FINAL RECOMMENDATION**
-[Your synthetic analysis and recommendation]
-
-If the destination is dangerous, clearly use "CHANGE DESTINATION" in your response."""
-
-            response = self.claude_client.messages.create(
-                model="claude-3-opus-20240229",
-                max_tokens=250,
-                temperature=0.2,
-                system="You are an expert travel advisor. Provide clear and practical recommendations.",
-                messages=[
-                    {"role": "user", "content": prompt}
-                ]
-            )
-            return response.content[0].text.strip()
-            
-        except Exception:
-            return None 

tools/find_flight.py

@@ -1,123 +0,0 @@
-import os
-from typing import Optional
-from smolagents.tools import Tool
-import serpapi
-from dotenv import load_dotenv
-load_dotenv()  # Loads variables from .env into environment
-
-
-
-class FlightsFinderTool(Tool):
-    name = "flights_finder"
-    description = "Find flights using the Google Flights engine."
-    inputs = {
-        'departure_airport': {'type': 'string', 'description': 'Departure airport code (IATA)'},
-        'arrival_airport': {'type': 'string', 'description': 'Arrival airport code (IATA)'},
-        'outbound_date': {'type': 'string', 'description': 'Outbound date in YYYY-MM-DD format'},
-        'return_date': {'type': 'string', 'description': 'Return date in YYYY-MM-DD format'},
-        'adults': {'type': 'integer', 'default': 1, 'nullable': True, 'description': 'Number of adults'},
-        'children': {'type': 'integer', 'default': 0, 'nullable': True, 'description': 'Number of children'},
-    }
-    output_type = "string"
-
-    @staticmethod
-    def find_flight(
-        departure_airport: Optional[str] = None,
-        arrival_airport: Optional[str] = None,
-        date: Optional[str] = None,
-        adults: Optional[int] = 1,
-        children: Optional[int] = 0,
-    ) -> str:
-        """
-        Finds the cheapest one-way flight for a given route and date.
-
-        Args:
-            departure_airport (str): Departure airport code (IATA)
-            arrival_airport (str): Arrival airport code (IATA)
-            date (str): Flight date in YYYY-MM-DD format
-            adults (int): Number of adults
-            children (int): Number of children
-            infants_in_seat (int): Number of infants in seat
-            infants_on_lap (int): Number of lap infants
-
-        Returns:
-            str: Formatted string with cheapest flight details
-        """
-        params = {
-            'api_key': os.getenv("SERPAPI_API_KEY"),
-            'engine': 'google_flights',
-            'hl': 'en',
-            'gl': 'us',
-            'departure_id': departure_airport,
-            'arrival_id': arrival_airport,
-            'outbound_date': date,
-            'currency': 'USD',
-            'adults': adults,
-            'children': children,
-            'type': 2,
-        }
-
-        try:
-            search = serpapi.search(params)
-            flights = search.data.get("best_flights", [])
-            if not flights:
-                return "No flights found."
-
-            # Find the flight with the lowest price
-            cheapest = min(flights, key=lambda f: f.get("price", float("inf")))
-
-            if not cheapest.get("flights"):
-                return "No flight segments found."
-
-            flight = cheapest["flights"][0]
-            dep = flight["departure_airport"]
-            arr = flight["arrival_airport"]
-            dep_time = dep["time"]
-            arr_time = arr["time"]
-            duration = flight["duration"]
-            airline = flight.get("airline", "Unknown")
-            price = cheapest["price"]
-
-            hours = duration // 60
-            minutes = duration % 60
-            duration_str = f"{hours}h {minutes}m"
-
-            return (
-                f"From {dep['id']} at {dep_time} → {arr['id']} at {arr_time} | "
-                f"Duration: {duration_str}\nAirline: {airline} | Price: ${price}"
-            )
-
-        except Exception as e:
-            return f"Error occurred: {e}"
-        
-    def forward(
-        self,
-        departure_airport: str,
-        arrival_airport: str,
-        outbound_date: str,
-        return_date: str,
-        adults: int = 1,
-        children: int = 0,
-    ) -> str:
-        outbound = self.find_flight(
-            departure_airport=departure_airport,
-            arrival_airport=arrival_airport,
-            date=outbound_date,
-            adults=adults,
-            children=children,
-        )
-
-        inbound = self.find_flight(
-            departure_airport=arrival_airport,
-            arrival_airport=departure_airport,
-            date=return_date,
-            adults=adults,
-            children=children,
-        )
-
-        return f"✈️ Outbound Flight:\n{outbound}\n\n🛬 Inbound Flight:\n{inbound}"
-
-        
-    def __init__(self, *args, **kwargs):
-        self.is_initialized = False
-

tools/mock_tools.py

@@ -1,81 +0,0 @@
-from smolagents.tools import tool
-
-@tool
-def mood_to_need(mood: str) -> str:
-    """
-    Map a mood to a need.
-
-    Args:
-        mood (str): The current emotional state of the user.
-
-    Returns:
-        str: A description of what the user needs based on the mood.
-    """
-    return "You need relaxation and nature."
-
-@tool
-def need_to_destination(need: str) -> str:
-    """
-    Map a need to a destination.
-
-    Args:
-        need (str): The user's identified need (e.g., relaxation, adventure).
-
-    Returns:
-        str: A suggested destination that fulfills the need.
-    """
-    return "Bali, Indonesia"
-
-@tool
-def get_weather(dest: str) -> str:
-    """
-    Get weather forecast for a destination.
-
-    Args:
-        dest (str): The destination location.
-
-    Returns:
-        str: A weather forecast for the given destination.
-    """
-    return "Sunny and 28°C"
-
-@tool
-def get_flights(dest: str) -> str:
-    """
-    Get flight options for a destination.
-
-    Args:
-        dest (str): The destination location.
-
-    Returns:
-        str: A list of flight options for the destination.
-    """
-    return "Flight from Paris to Bali: €600 roundtrip"
-
-@tool
-def final_wrap(info: str) -> str:
-    """
-    Create a final wrap-up message.
-
-    Args:
-        info (str): Summary information about the destination and travel.
-
-    Returns:
-        str: A personalized wrap-up message.
-    """
-    return f"Bali sounds like a perfect place for relaxation with great weather and affordable flights!"
-
-@tool
-def final_answer_tool(answer: str) -> str:
-    """
-    Provides a final answer to the user.
-
-    Args:
-        answer (str): The final recommendation or conclusion.
-
-    Returns:
-        str: The same final answer.
-    """
-    return answer
-    
-    

tools/mood_to_need.py

@@ -1,62 +0,0 @@
-from smolagents.tools import Tool
-from anthropic import Anthropic, HUMAN_PROMPT, AI_PROMPT
-import os
-from dotenv import load_dotenv
-load_dotenv()  # Loads variables from .env into environment
-class MoodToNeedTool(Tool):
-    """
-    A tool that converts user mood descriptions into vacation needs using an LLM.
-
-    Attributes:
-        model: A callable language model used to generate the output.
-    """
-    name = "MoodToNeed"
-    inputs = {
-    "mood": {"type": "string", "description": "User's mood as text"},
-}
-    output_type = "string"
-
-    description = "Converts user mood into a travel-related need."
-
-    def __init__(self, model: callable) -> None:
-        """
-        Args:
-            model: A callable language model with a __call__(str) -> str interface.
-        """
-        super().__init__()
-        self.model = model
-
-    def forward(self, mood: str) -> str:
-        """
-        Generates a vacation need from a user mood string.
-
-        Args:
-            mood: A string describing the user's emotional state.
-
-        Returns:
-            A short string describing the travel-related need.
-        """
-        prompt = (
-            f"Given the user's mood, suggest a travel need.\n"
-            f'Mood: "{mood}"\n'
-            f'Return only the need, no explanation.\n'
-            f'Example:\n'
-            f'Mood: "I am exhausted" → Need: "A calm wellness retreat"\n'
-            f'Mood: "{mood}"\n'
-            f'Need:'
-        )
-        response = self.model(prompt)
-        return response.strip()
-
-client = Anthropic(api_key=os.getenv("ANTROPIC_KEY"))
-
-def claude_mood_to_need_model(prompt: str) -> str:
-    message = client.messages.create(
-        model="claude-3-opus-20240229",
-        max_tokens=1024,
-        temperature=0.7,
-        messages=[
-            {"role": "user", "content": prompt}
-        ]
-    )
-    return message.content[0].text

tools/need_to_destination.py

@@ -1,69 +0,0 @@
-from smolagents.tools import Tool
-from anthropic import Anthropic
-import os
-import json
-from dotenv import load_dotenv
-load_dotenv()  # Loads variables from .env into environment
-
-class NeedToDestinationTool(Tool):
-    name = "NeedToDestination"
-    inputs = {
-        "need": {"type": "string", "description": "User's travel need as text"},
-    }
-    output_type = "array"
-    description = "Suggests destinations and flight info based on user need."
-
-    def __init__(self, model: callable, departure_airport: str = "CDG") -> None:
-        super().__init__()
-        self.model = model
-        self.departure_airport = departure_airport
-
-    def forward(self, need: str) -> list[dict]:
-        prompt = f"""
-            You are a travel agent AI.
-
-            Based on the user's need: "{need}",
-            suggest 2-3 travel destinations with round-trip flight information.
-
-            Return the output as valid JSON in the following format:
-
-            [
-            {{
-                "destination": "DestinationName",
-                "departure": {{
-                "date": "YYYY-MM-DD",
-                "from_airport": "{self.departure_airport}",
-                "to_airport": "XXX"
-                }},
-                "return": {{
-                "date": "YYYY-MM-DD",
-                "from_airport": "XXX",
-                "to_airport": "{self.departure_airport}"
-                }}
-            }},
-            ...
-            ]
-
-            DO NOT add explanations, only return raw JSON.
-            """
-        result = self.model(prompt)
-        try:
-            destinations = json.loads(result.strip())
-        except json.JSONDecodeError:
-            raise ValueError("Could not parse LLM output to JSON.")
-
-        return destinations
-    
-
-client = Anthropic(api_key=os.getenv("ANTROPIC_KEY"))
-
-def claude_need_to_destination_model(prompt: str) -> str:
-    message = client.messages.create(
-        model="claude-3-opus-20240229",
-        max_tokens=1024,
-        temperature=0.7,
-        messages=[
-            {"role": "user", "content": prompt}
-        ]
-    )
-    return message.content[0].text

tools/test_mood_to_destination.py

@@ -1,21 +0,0 @@
-from tools.mood_to_need import MoodToNeedTool, claude_mood_to_need_model
-from tools.need_to_destination import NeedToDestinationTool, claude_need_to_destination_model
-import json
-
-mood_tool = MoodToNeedTool(model=claude_mood_to_need_model)
-mood = "I'm feeling stuck in a routine and need change"
-# mood = "I feel overwhelmed and burned out."
-# mood = "I just got out of a break up"
-
-need = mood_tool(mood=mood)
-print(f"Mood: {mood}")
-print("Need:", need)
-
-destination_tool = NeedToDestinationTool(model=claude_need_to_destination_model, departure_airport="CDG")
-try:
-    destinations = destination_tool(need=need)
-    print("\n→ Suggested Destinations:")
-    for dest in destinations:
-        print(json.dumps(dest, indent=2))
-except ValueError as e:
-    print(f"Error parsing Claude output: {e}")

tools/visit_webpage.py

@@ -3,7 +3,6 @@ from smolagents.tools import Tool
 import requests
 import markdownify
 import smolagents
-import re
 
 class VisitWebpageTool(Tool):
     name = "visit_webpage"

tools/weather_tool.py

@@ -1,285 +0,0 @@
-from typing import Any, Optional
-from smolagents.tools import Tool
-import requests
-from datetime import datetime, timedelta
-import json
-import os
-from dotenv import load_dotenv
-import anthropic
-
-class WeatherTool(Tool):
-    name = "weather_forecast"
-    description = "Obtient les prévisions météorologiques intelligentes pour un pays/ville avec recommandations basées sur le type de destination et les activités prévues."
-    inputs = {
-        'location': {'type': 'string', 'description': 'Le nom de la ville ou du pays pour lequel obtenir la météo (ex: "Paris", "London", "Tokyo")'},
-        'date': {'type': 'string', 'description': 'La date pour laquelle obtenir la météo au format YYYY-MM-DD (optionnel, par défaut aujourd\'hui)', 'nullable': True},
-        'activity_type': {'type': 'string', 'description': 'Type d\'activité/destination: "plage", "ski", "ville", "randonnee", "camping", "festival" (optionnel)', 'nullable': True},
-        'api_key': {'type': 'string', 'description': 'Clé API OpenWeatherMap (optionnel si définie dans les variables d\'environnement)', 'nullable': True}
-    }
-    output_type = "string"
-
-    def __init__(self, api_key: Optional[str] = None):
-        super().__init__()
-        # Charger les variables d'environnement depuis le fichier .env
-        load_dotenv()
-        
-        # Utiliser la clé API fournie, sinon celle du .env
-        self.api_key = api_key or os.getenv('OPENWEATHER_API_KEY')
-        self.base_url = "http://api.openweathermap.org/data/2.5"
-        
-        # Initialiser le client Claude pour les recommandations intelligentes
-        try:
-            self.claude_client = anthropic.Anthropic(api_key=os.getenv('ANTROPIC_KEY'))
-        except:
-            self.claude_client = None
-
-    def forward(self, location: str, date: Optional[str] = None, activity_type: Optional[str] = None, api_key: Optional[str] = None) -> str:
-        try:
-            # Utiliser la clé API fournie ou celle par défaut
-            used_api_key = api_key or self.api_key
-            
-            if not used_api_key:
-                return "Erreur: Clé API OpenWeatherMap requise. Ajoutez OPENWEATHER_API_KEY dans votre fichier .env ou obtenez une clé gratuite sur https://openweathermap.org/api"
-
-            # Parser la date si fournie
-            target_date = None
-            if date:
-                try:
-                    target_date = datetime.strptime(date, "%Y-%m-%d")
-                except ValueError:
-                    return f"Erreur: Format de date invalide. Utilisez YYYY-MM-DD (ex: 2024-01-15)"
-
-            # Obtenir les coordonnées de la localisation
-            geo_url = f"http://api.openweathermap.org/geo/1.0/direct"
-            geo_params = {
-                'q': location,
-                'limit': 1,
-                'appid': used_api_key
-            }
-            
-            geo_response = requests.get(geo_url, params=geo_params, timeout=10)
-            geo_response.raise_for_status()
-            geo_data = geo_response.json()
-            
-            if not geo_data:
-                return f"Erreur: Localisation '{location}' non trouvée. Essayez avec le nom d'une ville ou d'un pays plus précis."
-            
-            lat = geo_data[0]['lat']
-            lon = geo_data[0]['lon']
-            country = geo_data[0].get('country', '')
-            city_name = geo_data[0]['name']
-
-            # Utiliser l'API gratuite
-            weather_data = self._get_weather(lat, lon, city_name, country, target_date, used_api_key)
-            
-            # Ajouter des recommandations intelligentes si Claude est disponible
-            if self.claude_client:
-                # Utiliser le type d'activité fourni ou essayer de le détecter automatiquement
-                detected_activity = activity_type or self._detect_activity_from_location(location)
-                
-                if detected_activity:
-                    recommendation = self._get_intelligent_recommendation(weather_data, detected_activity, location, target_date)
-                    if recommendation:
-                        if not activity_type:  # Si détecté automatiquement, l'indiquer
-                            weather_data += f"\n\n💡 *Activité détectée: {detected_activity}*"
-                        weather_data += f"\n\n{recommendation}"
-            
-            return weather_data
-
-        except requests.exceptions.Timeout:
-            return "Erreur: Délai d'attente dépassé. Veuillez réessayer."
-        except requests.exceptions.HTTPError as e:
-            if e.response.status_code == 401:
-                return "Erreur 401: Clé API invalide ou non activée. Vérifiez votre clé API OpenWeatherMap et assurez-vous qu'elle est activée (peut prendre quelques heures après création)."
-            elif e.response.status_code == 429:
-                return "Erreur 429: Limite de requêtes dépassée. Attendez avant de refaire une requête."
-            else:
-                return f"Erreur HTTP {e.response.status_code}: {str(e)}"
-        except requests.exceptions.RequestException as e:
-            return f"Erreur de requête: {str(e)}"
-        except Exception as e:
-            return f"Erreur inattendue: {str(e)}"
-
-    def _get_weather(self, lat: float, lon: float, city_name: str, country: str, target_date: Optional[datetime], api_key: str) -> str:
-        """Utilise l'API gratuite 2.5"""
-        
-        if not target_date or target_date.date() == datetime.now().date():
-            # Météo actuelle
-            weather_url = f"{self.base_url}/weather"
-            params = {
-                'lat': lat,
-                'lon': lon,
-                'appid': api_key,
-                'units': 'metric',
-                'lang': 'fr'
-            }
-            
-            response = requests.get(weather_url, params=params, timeout=10)
-            response.raise_for_status()
-            data = response.json()
-            
-            return self._format_current_weather(data, city_name, country)
-            
-        elif target_date and target_date <= datetime.now() + timedelta(days=5):
-            # Prévisions sur 5 jours
-            forecast_url = f"{self.base_url}/forecast"
-            params = {
-                'lat': lat,
-                'lon': lon,
-                'appid': api_key,
-                'units': 'metric',
-                'lang': 'fr'
-            }
-            
-            response = requests.get(forecast_url, params=params, timeout=10)
-            response.raise_for_status()
-            data = response.json()
-            
-            return self._format_forecast_weather(data, city_name, country, target_date)
-        else:
-            return "Erreur: Les prévisions ne sont disponibles que pour les 5 prochains jours maximum."
-
-    def _format_current_weather(self, data: dict, city_name: str, country: str) -> str:
-        """Formate les données météo actuelles"""
-        try:
-            weather = data['weather'][0]
-            main = data['main']
-            wind = data.get('wind', {})
-            
-            result = f"🌤️ **Météo actuelle pour {city_name}, {country}**\n\n"
-            result += f"**Conditions:** {weather['description'].title()}\n"
-            result += f"**Température:** {main['temp']:.1f}°C (ressenti: {main['feels_like']:.1f}°C)\n"
-            result += f"**Humidité:** {main['humidity']}%\n"
-            result += f"**Pression:** {main['pressure']} hPa\n"
-            
-            if 'speed' in wind:
-                result += f"**Vent:** {wind['speed']} m/s"
-                if 'deg' in wind:
-                    result += f" ({self._wind_direction(wind['deg'])})"
-                result += "\n"
-            
-            if 'visibility' in data:
-                result += f"**Visibilité:** {data['visibility']/1000:.1f} km\n"
-                
-            return result
-            
-        except KeyError as e:
-            return f"Erreur lors du formatage des données météo: {str(e)}"
-
-    def _format_forecast_weather(self, data: dict, city_name: str, country: str, target_date: datetime) -> str:
-        """Formate les prévisions météo pour une date spécifique"""
-        try:
-            target_date_str = target_date.strftime("%Y-%m-%d")
-            
-            # Trouver les prévisions pour la date cible
-            forecasts_for_date = []
-            for forecast in data['list']:
-                forecast_date = datetime.fromtimestamp(forecast['dt']).strftime("%Y-%m-%d")
-                if forecast_date == target_date_str:
-                    forecasts_for_date.append(forecast)
-            
-            if not forecasts_for_date:
-                return f"Aucune prévision disponible pour le {target_date_str}"
-            
-            result = f"🌤️ **Prévisions météo pour {city_name}, {country} - {target_date.strftime('%d/%m/%Y')}**\n\n"
-            
-            for i, forecast in enumerate(forecasts_for_date):
-                time = datetime.fromtimestamp(forecast['dt']).strftime("%H:%M")
-                weather = forecast['weather'][0]
-                main = forecast['main']
-                wind = forecast.get('wind', {})
-                
-                result += f"**{time}:**\n"
-                result += f"  • Conditions: {weather['description'].title()}\n"
-                result += f"  • Température: {main['temp']:.1f}°C (ressenti: {main['feels_like']:.1f}°C)\n"
-                result += f"  • Humidité: {main['humidity']}%\n"
-                
-                if 'speed' in wind:
-                    result += f"  • Vent: {wind['speed']} m/s"
-                    if 'deg' in wind:
-                        result += f" ({self._wind_direction(wind['deg'])})"
-                    result += "\n"
-                
-                if i < len(forecasts_for_date) - 1:
-                    result += "\n"
-            
-            return result
-            
-        except KeyError as e:
-            return f"Erreur lors du formatage des prévisions: {str(e)}"
-
-    def _wind_direction(self, degrees: float) -> str:
-        """Convertit les degrés en direction du vent"""
-        directions = ["N", "NNE", "NE", "ENE", "E", "ESE", "SE", "SSE",
-                     "S", "SSO", "SO", "OSO", "O", "ONO", "NO", "NNO"]
-        index = round(degrees / 22.5) % 16
-        return directions[index]
-
-    def _get_intelligent_recommendation(self, weather_data: str, activity_type: str, location: str, target_date: Optional[datetime]) -> Optional[str]:
-        """Utilise Claude pour générer des recommandations intelligentes basées sur la météo et l'activité"""
-        try:
-            if not self.claude_client:
-                return None
-            
-            date_str = target_date.strftime('%d/%m/%Y') if target_date else "aujourd'hui"
-            
-            prompt = f"""Analysez ces données météorologiques pour {location} le {date_str} et donnez une recommandation pour une activité de type "{activity_type}" :
-
-DONNÉES MÉTÉO :
-{weather_data}
-
-TYPE D'ACTIVITÉ : {activity_type}
-
-Votre tâche :
-1. Analysez si les conditions météo sont adaptées à cette activité
-2. Donnez une recommandation claire : IDÉAL / ACCEPTABLE / DÉCONSEILLÉ / CHANGEZ DE DESTINATION
-3. Proposez des alternatives si nécessaire
-4. Répondez en français, maximum 150 mots
-5. Utilisez un ton pratique et bienveillant
-
-Exemples de logique :
-- Plage + pluie = CHANGEZ DE DESTINATION ou reportez
-- Ski + température > 5°C = DÉCONSEILLÉ
-- Randonnée + orage = CHANGEZ DE DESTINATION
-- Ville + pluie légère = ACCEPTABLE avec parapluie
-- Festival en extérieur + pluie forte = DÉCONSEILLÉ
-
-Format de réponse :
-🎯 **RECOMMANDATION VOYAGE**
-[Votre analyse et conseil]"""
-
-            response = self.claude_client.messages.create(
-                model="claude-3-opus-20240229",
-                max_tokens=200,
-                temperature=0.2,
-                system="Vous êtes un conseiller météo expert. Donnez des recommandations pratiques et claires pour les activités de voyage.",
-                messages=[
-                    {"role": "user", "content": prompt}
-                ]
-            )
-            
-            return response.content[0].text.strip()
-            
-        except Exception:
-            return None
-
-    def _detect_activity_from_location(self, location: str) -> Optional[str]:
-        """Détecte automatiquement le type d'activité probable basé sur la localisation"""
-        location_lower = location.lower()
-        
-        # Stations balnéaires et plages
-        beach_keywords = ['nice', 'cannes', 'saint-tropez', 'biarritz', 'deauville', 'miami', 'maldives', 'ibiza', 'mykonos', 'cancun', 'phuket', 'bali']
-        if any(keyword in location_lower for keyword in beach_keywords):
-            return "plage"
-        
-        # Stations de ski
-        ski_keywords = ['chamonix', 'val d\'isère', 'courchevel', 'méribel', 'aspen', 'zermatt', 'st moritz', 'verbier']
-        if any(keyword in location_lower for keyword in ski_keywords):
-            return "ski"
-        
-        # Destinations de randonnée
-        hiking_keywords = ['mont blanc', 'everest', 'kilimanjaro', 'patagonie', 'himalaya', 'alpes', 'pyrénées']
-        if any(keyword in location_lower for keyword in hiking_keywords):
-            return "randonnee"
-        
-        return None