Update tools.py

tools.py

@@ -1,18 +1,19 @@
 from langchain_core.tools import StructuredTool
-from schema import RouteInput,CostInput,TrafficInput
-from typing import Tuple,Dict
+from schema import RouteInput, CostInput, TrafficInput, WeatherInput
+from typing import Tuple, Dict
 from datetime import datetime
 import time
 import folium
 import os
 
-from api  import geocode_address_nominatim,get_route_osrm,get_alternative_routes_osrm, get_detailed_route_with_instructions,get_realtime_traffic
+from api import (
+    geocode_address_nominatim, get_route_osrm, get_alternative_routes_osrm,
+    get_detailed_route_with_instructions, get_realtime_traffic, get_weather_along_route
+)
+
 
 def estimate_traffic_from_time() -> float:
-    """
-    Estimate traffic based on time of day
-    Uses typical traffic patterns
-    """
+    """Estimate traffic based on time of day"""
     current_hour = datetime.now().hour
     
     if 7 <= current_hour <= 10:  
@@ -27,130 +28,51 @@ def estimate_traffic_from_time() -> float:
         return 1.0
 
 REAL_VEHICLES = [
-    {
-        "id": "BIKE-001",
-        "type": "Motorcycle",
-        "capacity_kg": 30,
-        "fuel_cost_per_km": 2.5,
-        "speed_kmph": 40,
-        "available": True
-    },
-    {
-        "id": "VAN-001",
-        "type": "Small Van",
-        "capacity_kg": 500,
-        "fuel_cost_per_km": 8.0,
-        "speed_kmph": 50,
-        "available": True
-    },
-    {
-        "id": "TRUCK-001",
-        "type": "Light Truck",
-        "capacity_kg": 2000,
-        "fuel_cost_per_km": 15.0,
-        "speed_kmph": 45,
-        "available": True
-    },
-    {
-        "id": "TRUCK-002",
-        "type": "Heavy Truck",
-        "capacity_kg": 5000,
-        "fuel_cost_per_km": 25.0,
-        "speed_kmph": 40,
-        "available": True
-    },
+    {"id": "BIKE-001", "type": "Motorcycle", "capacity_kg": 30, "fuel_cost_per_km": 2.5, "speed_kmph": 40, "available": True},
+    {"id": "VAN-001", "type": "Small Van", "capacity_kg": 500, "fuel_cost_per_km": 8.0, "speed_kmph": 50, "available": True},
+    {"id": "TRUCK-001", "type": "Light Truck", "capacity_kg": 2000, "fuel_cost_per_km": 15.0, "speed_kmph": 45, "available": True},
+    {"id": "TRUCK-002", "type": "Heavy Truck", "capacity_kg": 5000, "fuel_cost_per_km": 25.0, "speed_kmph": 40, "available": True},
 ]
 
 def calculate_traffic(origin_coords: Tuple[float, float], dest_coords: Tuple[float, float]):
-    """Analyze the traffic using the realtime data"""
+    """Analyze traffic using realtime data"""
     traffic_data = get_realtime_traffic(origin_coords, dest_coords)
-
+    
     if not traffic_data:
-        print("sing fallback: estimate_traffic_from_time()")
         return estimate_traffic_from_time()
-
+    
     try:
         base_time = traffic_data["noTrafficTravelTimeInSeconds"]
         current_time = traffic_data["travelTimeInSeconds"]
-        delay = traffic_data["trafficDelayInSeconds"]
-
+        
         if base_time == 0:
             return 1.0 
-
+        
         traffic_factor = current_time / base_time
-
         traffic_factor = max(0.8, min(traffic_factor, 2.0))
         return round(traffic_factor, 2)
-
     except KeyError:
-        print("Missing fields in traffic data, fallback to estimate_traffic_from_time()")
         return estimate_traffic_from_time()
 
-
-def format_route_instructions(route_data: Dict) -> str:
-    """
-    Format route instructions in readable format
-    """
-    if not route_data:
-        return "No route instructions available"
-    
-    output = f"\nRoute {route_data['route_number']}:\n"
-    output += f"Total Distance: {route_data['distance_km']:.1f} km\n"
-    output += f"Total Duration: {route_data['duration_min']:.0f} minutes\n"
-    output += "\nTurn-by-Turn Directions:\n"
-    output += "-" * 50 + "\n"
-    
-    cumulative_distance = 0
-    for idx, step in enumerate(route_data['instructions'], 1):
-        cumulative_distance += step['distance_km']
-        
-        instruction_type = step['instruction']
-        direction = step['direction']
-        
-        if instruction_type == "depart":
-            action = "Start"
-        elif instruction_type == "arrive":
-            action = "Arrive at destination"
-        elif instruction_type == "turn":
-            action = f"Turn {direction}" if direction else "Turn"
-        elif instruction_type == "new name":
-            action = "Continue onto"
-        elif instruction_type == "roundabout":
-            action = "Take roundabout"
-        elif instruction_type == "merge":
-            action = f"Merge {direction}" if direction else "Merge"
-        else:
-            action = instruction_type.replace("_", " ").capitalize()
-        
-        road_name = step['road_name']
-        distance = step['distance_km']
-        
-        if distance > 0.1: 
-            output += f"{idx}. {action}"
-            if road_name and road_name != "Unnamed road":
-                output += f" on {road_name}"
-            output += f" for {distance:.1f} km"
-            output += f" (Total: {cumulative_distance:.1f} km)\n"
-    
-    return output
-
-
 def find_optimal_route(origin_coords: Tuple[float, float], 
                        dest_coords: Tuple[float, float]) -> Dict:
-    """
-    Compare all available routes and find optimal with detailed instructions
-    """
-
+    """Compare all available routes and find optimal with detailed instructions"""
+    print(f"\n{'='*60}")
+    print("Checking for better route")
+    print(f"\n{'='*60}")
+    
     detailed_routes = get_detailed_route_with_instructions(origin_coords, dest_coords)
     
     if not detailed_routes:
         return None
     
-    traffic_factor = calculate_traffic(origin_coords,dest_coords)
+    traffic_factor = calculate_traffic(origin_coords, dest_coords)
+    weather_data = get_weather_along_route(origin_coords, dest_coords)
+    weather_factor = weather_data.get("weather_factor", 1.0)
     
     scored_routes = []
     for route_data in detailed_routes:
-        adjusted_time = route_data['duration_min'] * traffic_factor
+        adjusted_time = route_data['duration_min'] * traffic_factor * weather_factor
         
         fuel_cost_per_km = 8.0
         estimated_cost = route_data['distance_km'] * fuel_cost_per_km
@@ -164,19 +86,21 @@ def find_optimal_route(origin_coords: Tuple[float, float],
             'adjusted_duration': adjusted_time,
             'estimated_cost': estimated_cost,
             'score': score,
-            'instructions': route_data['instructions'] 
+            'instructions': route_data['instructions'],
+            'weather_warnings': weather_data.get('warnings', [])
         })
     
     scored_routes.sort(key=lambda x: x['score'])
     
     return {
         'optimal': scored_routes[0],
-        'all_routes': scored_routes
+        'all_routes': scored_routes,
+        'weather_data': weather_data,
+        'traffic_factor': traffic_factor
     }
 
-def create_route_map_html(origin_coords, dest_coords, route_data, filename="static/route_map.html"):
-    """Generate interactive map with YOUR exact turn-by-turn directions"""
-    
+def create_enhanced_map(origin_coords, dest_coords, route_data, weather_data, filename="static/route_map.html", map_type="route"):
+    """Generate interactive map with route visualization (supports route/traffic/weather modes)"""
     os.makedirs("static", exist_ok=True)
     
     m = folium.Map(
@@ -184,68 +108,113 @@ def create_route_map_html(origin_coords, dest_coords, route_data, filename="stat
         zoom_start=8
     )
     
+    if map_type == "traffic":
+        origin_icon = folium.Icon(color='orange', icon='exclamation-triangle', prefix='fa')
+        dest_icon = folium.Icon(color='red', icon='flag-checkered', prefix='fa')
+        route_color = '#ff6b6b' 
+    elif map_type == "weather":
+        origin_icon = folium.Icon(color='blue', icon='cloud', prefix='fa')
+        dest_icon = folium.Icon(color='lightblue', icon='cloud-sun', prefix='fa')
+        route_color = '#4dabf7'  
+    else: 
+        origin_icon = folium.Icon(color='green', icon='play')
+        dest_icon = folium.Icon(color='red', icon='stop')
+        route_color = '#4C763B'  
+    
     folium.Marker(
         origin_coords, 
         popup="<b>START</b>", 
-        icon=folium.Icon(color='green', icon='play')
+        icon=origin_icon
     ).add_to(m)
     
     folium.Marker(
         dest_coords, 
         popup="<b>DESTINATION</b>", 
-        icon=folium.Icon(color='red', icon='stop')
+        icon=dest_icon
     ).add_to(m)
     
+
     if 'geometry' in route_data and route_data['geometry']:
         coords = [[c[1], c[0]] for c in route_data['geometry']['coordinates']]
-        folium.PolyLine(coords, color='blue', weight=5, opacity=0.7).add_to(m)
-    
-    directions_html = "<div style='position:fixed;top:10px;right:10px;width:300px;background:white;padding:10px;border:2px solid blue;max-height:80vh;overflow-y:auto;z-index:1000'>"
-    directions_html += f"<h3>Route Directions</h3>"
-    directions_html += f"<b>Distance:</b> {route_data.get('distance_km', 0):.1f} km<br>"
-    directions_html += f"<b>Duration:</b> {route_data.get('duration_min', 0):.0f} min<br><hr>"
-    
-    for idx, step in enumerate(route_data.get('instructions', []), 1):
-        if step['distance_km'] > 0.1:
-            directions_html += f"<b>{idx}.</b> {step['instruction'].title()}"
-            if step['road_name'] != "Unnamed road":
-                directions_html += f" on <b>{step['road_name']}</b>"
-            directions_html += f"<br><small>{step['distance_km']:.1f} km</small><hr>"
-    
-    directions_html += "</div>"
-    
-    m.get_root().html.add_child(folium.Element(directions_html))
+        folium.PolyLine(
+            coords, 
+            color=route_color, 
+            weight=5, 
+            opacity=0.7,
+            tooltip=f"{map_type.title()} Route"
+        ).add_to(m)
+    
+    if map_type == "weather" and weather_data:
+        if weather_data.get('origin'):
+            origin_w = weather_data['origin']
+            folium.CircleMarker(
+                origin_coords,
+                radius=15,
+                popup=f"<b>Origin Weather</b><br>{origin_w.get('temperature')}°C<br>{origin_w.get('description', 'N/A')}",
+                color='blue',
+                fill=True,
+                fillColor='lightblue',
+                fillOpacity=0.3
+            ).add_to(m)
+        
+        if weather_data.get('destination'):
+            dest_w = weather_data['destination']
+            folium.CircleMarker(
+                dest_coords,
+                radius=15,
+                popup=f"<b>Destination Weather</b><br>{dest_w.get('temperature')}°C<br>{dest_w.get('description', 'N/A')}",
+                color='blue',
+                fill=True,
+                fillColor='lightblue',
+                fillOpacity=0.3
+            ).add_to(m)
+        
+        if weather_data.get('warnings'):
+            mid_lat = (origin_coords[0] + dest_coords[0]) / 2
+            mid_lon = (origin_coords[1] + dest_coords[1]) / 2
+            folium.Marker(
+                [mid_lat, mid_lon],
+                popup=f"<b>⚠️ Weather Alert</b><br>{'<br>'.join(weather_data['warnings'])}",
+                icon=folium.Icon(color='orange', icon='exclamation-triangle', prefix='fa')
+            ).add_to(m)
+    
+    if map_type == "traffic":
+        mid_lat = (origin_coords[0] + dest_coords[0]) / 2
+        mid_lon = (origin_coords[1] + dest_coords[1]) / 2
+        folium.Marker(
+            [mid_lat, mid_lon],
+            popup=f"<b>🚦 Traffic Analysis</b><br>Check route details for conditions",
+            icon=folium.Icon(color='orange', icon='car', prefix='fa')
+        ).add_to(m)
     
     m.save(filename)
     return filename
 
+
 def real_route_planner(origin: str, destination: str) -> str:
-    """
-    Plan route using FREE OSRM with real OpenStreetMap data
-    """
+    """Plan route with weather and memory integration"""
+    
     print(f"\n{'='*60}")
-    print(f"Planning route: {origin} → {destination}")
+    print(f"Planning route: {origin} -> {destination}")
     print(f"{'='*60}")
     
     origin_coords = geocode_address_nominatim(origin)
     if not origin_coords:
-        return f"Could not find location: {origin}. Try being more specific (e.g., 'Mumbai, Maharashtra, India')"
-    print(f"✓ Origin found: {origin_coords}")
+        return f"Could not find location: {origin}"
     
     dest_coords = geocode_address_nominatim(destination)
     if not dest_coords:
-        return f"Could not find location: {destination}. Try being more specific."
-    print(f"✓ Destination found: {dest_coords}")
+        return f"Could not find location: {destination}"
     
     route = get_route_osrm(origin_coords, dest_coords)
     if not route:
-        return f"No route found between {origin} and {destination}"
-    print(f"✓ Route found: {route['distance_km']:.1f} km, {route['duration_min']:.0f} min")
+        return f"No route found"
     
     optimization = find_optimal_route(origin_coords, dest_coords)
     if not optimization:
         return f"Could not optimize route"
     
+    # Create map filename
     safe_origin = origin.replace(' ', '_').replace(',', '')[:30]
     safe_dest = destination.replace(' ', '_').replace(',', '')[:30]
     map_filename = f"route_{safe_origin}_to_{safe_dest}.html"
@@ -253,121 +222,182 @@ def real_route_planner(origin: str, destination: str) -> str:
     
     optimal_route_data = {
         'distance_km': optimization['optimal']['distance_km'],
-        'duration_min': optimization['optimal']['duration_min'],
+        'duration_min': optimization['optimal']['adjusted_duration'],
         'instructions': optimization['optimal']['instructions'],
         'geometry': route.get('geometry')
     }
     
+    weather_data = optimization.get('weather_data', {})
+    
     try:
-        map_file = create_route_map_html(origin_coords, dest_coords, optimal_route_data, map_path)
-        print("Map saved to", map_file)
+        create_enhanced_map(origin_coords, dest_coords, optimal_route_data, weather_data, map_path,map_type="route")
         map_url = f"/view-map/{map_filename}"
     except Exception as e:
         print("Map creation failed:", e)
         map_url = None
-
-
-    result = f"Route Analysis (OpenStreetMap Data):\n"
-    result += f"From: {origin}\n"
-    result += f"To: {destination}\n\n"
+    
+    result = f"ROUTE SUMMARY\n"
+    result += f"Origin: {origin}\n"
+    result += f"Destination: {destination}\n"
+    result += f"Distance: {route['distance_km']:.1f} km\n"
+    result += f"Base Duration: {route['duration_min']:.0f} min\n"
+    result += f"Adjusted ETA: {optimization['optimal']['adjusted_duration']:.0f} min\n\n"
     
     if map_url:
-        result += f"INTERACTIVE MAP: {map_url}\n"
-        result += f"(Open this link in your browser to view the map)\n\n"
+        result += f"INTERACTIVE MAP: {map_url}\n\n"
     
-    result += f"PRIMARY ROUTE:\n"
-    result += f"Distance: {route['distance_km']:.1f} km\n"
-    result += f"Duration: {route['duration_min']:.0f} minutes\n"
-
-    if optimization and len(optimization['all_routes']) >= 1:
-        result += "\n\nROUTE COMPARISON:\n"
-        for i, r in enumerate(optimization['all_routes']):
-            marker = " [OPTIMAL]" if i == 0 else ""
-            result += (f"\nRoute {r['route_num']}:{marker}\n"
-                      f"  Distance: {r['distance_km']:.1f} km\n"
-                      f"  Base Time: {r['duration_min']:.0f} min\n"
-                      f"  With Traffic: {r['adjusted_duration']:.0f} min\n"
-                      f"  Est. Cost: Rs {r['estimated_cost']:.2f}\n"
-                      f"  Score: {r['score']:.1f}")
-        
-        if optimization['optimal']['route_num'] != 1:
-            result += f"\n\nRECOMMENDATION: Route {optimization['optimal']['route_num']} is optimal based on time and cost factors"
-        
-        optimal_route = optimization['optimal']
-        result += "\n\n" + "=" * 50
-        result += format_route_instructions({
-            'route_number': optimal_route['route_num'],
-            'distance_km': optimal_route['distance_km'],
-            'duration_min': optimal_route['duration_min'],
-            'instructions': optimal_route['instructions']
-        })
+    result += f"TRAFFIC ANALYSIS\n"
+    traffic_factor = optimization.get('traffic_factor', 1.0)
+    if traffic_factor >= 1.5:
+        traffic_level = "Heavy"
+        advice = "Consider delaying by 1-2 hours or use alternative route"
+    elif traffic_factor >= 1.2:
+        traffic_level = "Moderate"
+        advice = "Expect minor delays, monitor conditions"
+    else:
+        traffic_level = "Light"
+        advice = "Good time to depart"
+    
+    result += f"Current Traffic: {traffic_level}\n"
+    result += f"Traffic Factor: {traffic_factor:.2f}x\n"
+    
+    base_duration = route['duration_min']
+    adjusted = optimization['optimal']['adjusted_duration']
+    delay = adjusted - base_duration
+    result += f"Expected Delay: {delay:.0f} min\n"
+    result += f"Advice: {advice}\n\n"
+    
+    result += f"WEATHER CONDITIONS\n"
+    origin_w = weather_data.get('origin', {})
+    dest_w = weather_data.get('destination', {})
+    if origin_w:
+        result += f"Origin: {origin_w.get('temperature', 'N/A')}°C, {origin_w.get('condition', 'N/A')}\n"
+    if dest_w:
+        result += f"Destination: {dest_w.get('temperature', 'N/A')}°C, {dest_w.get('condition', 'N/A')}\n"
+    
+    if optimization['optimal'].get('weather_warnings'):
+        result += f"\nWeather Alerts:\n"
+        for warning in optimization['optimal']['weather_warnings']:
+            result += f"  • {warning}\n"
 
-    return result
+    return result 
 
-def real_cost_optimizer(origin: str, destination: str,distance_km: float, weight_kg: float, duration_min: float) -> str:
-    """
-    Calculate real-world delivery costs
-    """
-    print(f"\nCalculating costs: {distance_km:.1f}km, {weight_kg}kg, {duration_min/60:.0f}hr")
 
+def real_cost_optimizer(origin: str, destination: str, distance_km: float, weight_kg: float, duration_min: float) -> str:
+    """Calculate costs with weather impact"""
     origin_coords = geocode_address_nominatim(origin)
     dest_coords = geocode_address_nominatim(destination)
     
+    print(f"\n{'='*60}")
+    print("Inside the cost optimizer")
+    print(f"\n{'='*60}")
+
     suitable = [v for v in REAL_VEHICLES if v["capacity_kg"] >= weight_kg and v["available"]]
     
     if not suitable:
-        return f"No vehicle available for {weight_kg}kg (max capacity: {max(v['capacity_kg'] for v in REAL_VEHICLES)}kg)"
+        return f"No vehicle available for {weight_kg}kg"
+    
+    traffic_multiplier = calculate_traffic(origin_coords, dest_coords)
+    weather_data = get_weather_along_route(origin_coords, dest_coords)
+    weather_multiplier = weather_data.get("weather_factor", 1.0)
     
     options = []
     for vehicle in suitable:
-    
         fuel_cost = distance_km * vehicle["fuel_cost_per_km"]
-        
         driver_cost = (duration_min / 60) * 200
-        
         base_fee = 150
         
-        traffic_multiplier = calculate_traffic(origin_coords,dest_coords)
-        
         capacity_usage = weight_kg / vehicle["capacity_kg"]
         capacity_multiplier = 1.15 if capacity_usage > 0.8 else 1.0
         
-        total_cost = (base_fee + fuel_cost + driver_cost) * traffic_multiplier * capacity_multiplier
+        total_cost = (base_fee + fuel_cost + driver_cost) * traffic_multiplier * weather_multiplier * capacity_multiplier
         
         options.append({
             "vehicle": vehicle,
             "total_cost": total_cost,
             "fuel_cost": fuel_cost,
             "driver_cost": driver_cost,
-            "traffic_factor": traffic_multiplier
+            "traffic_factor": traffic_multiplier,
+            "weather_factor": weather_multiplier
         })
     
     options.sort(key=lambda x: x["total_cost"])
     best = options[0]
     
-    result = (
-        f"Cost Estimate (Real-world pricing):\n"
-        f"Recommended: {best['vehicle']['type']} ({best['vehicle']['id']})\n"
-        f"Total Cost: ₹{best['total_cost']:.2f}\n"
-        f"• Base Fee: ₹150\n"
-        f"• Fuel: ₹{best['fuel_cost']:.2f}\n"
-        f"• Driver: ₹{best['driver_cost']:.2f}\n"
-        f"• Traffic Factor: {best['traffic_factor']:.2f}x\n"
-        f"Capacity: {best['vehicle']['capacity_kg']}kg (using {(weight_kg/best['vehicle']['capacity_kg'])*100:.1f}%)"
-    )
-    
-    if len(options) > 1:
-        alt = options[1]
-        result += f"\n Alternative: {alt['vehicle']['type']} at ₹{alt['total_cost']:.2f}"
+    result = f"\nCOST ESTIMATE\n"
+    result += f"Recommended Vehicle: {best['vehicle']['type']} ({best['vehicle']['id']})\n"
+    result += f"Total Cost: Rs {best['total_cost']:.2f}\n\n"
+    result += f"Cost Breakdown:\n"
+    result += f"  • Base Fee: Rs 150\n"
+    result += f"  • Fuel Cost: Rs {best['fuel_cost']:.2f}\n"
+    result += f"  • Driver Cost: Rs {best['driver_cost']:.2f}\n"
+    result += f"  • Traffic Multiplier: {best['traffic_factor']:.2f}x\n"
+    result += f"  • Weather Multiplier: {best['weather_factor']:.2f}x\n"
     
     return result
 
+def real_weather_analyzer(origin: str, destination: str) -> str:
+    """Analyze weather conditions along route"""
+
+    print(f"\n{'='*60}")
+    print("Inside the weather analyzer")
+    print(f"\n{'='*60}")
+
+    origin_coords = geocode_address_nominatim(origin)
+    dest_coords = geocode_address_nominatim(destination)
+    
+    if not origin_coords or not dest_coords:
+        return "Could not analyze weather - invalid locations"
+    
+    weather_data = get_weather_along_route(origin_coords, dest_coords)
+    
+    result = f"WEATHER ANALYSIS\n\n"
+    
+    if weather_data.get('origin'):
+        origin_weather = weather_data['origin']
+        result += f"Origin Weather:\n"
+        result += f"  Temperature: {origin_weather.get('temperature', 'N/A')}°C (feels like {origin_weather.get('feels_like', 'N/A')}°C)\n"
+        result += f"  Condition: {origin_weather.get('description', 'N/A').title()}\n"
+        result += f"  Humidity: {origin_weather.get('humidity', 'N/A')}%\n"
+        result += f"  Wind Speed: {origin_weather.get('wind_speed', 'N/A')} m/s\n"
+        if origin_weather.get('rain', 0) > 0:
+            result += f"  Rain: {origin_weather['rain']:.1f} mm/h\n"
+        result += "\n"
+    
+    if weather_data.get('destination'):
+        dest_weather = weather_data['destination']
+        result += f"Destination Weather:\n"
+        result += f"  Temperature: {dest_weather.get('temperature', 'N/A')}°C\n"
+        result += f"  Condition: {dest_weather.get('description', 'N/A').title()}\n\n"
+    
+    if weather_data.get('warnings'):
+        result += f"Weather Alerts:\n"
+        for warning in weather_data['warnings']:
+            result += f"  • {warning}\n"
+        result += f"\nWeather Impact Factor: {weather_data.get('weather_factor', 1.0):.2f}x\n"
+        result += f"Recommendation: Exercise caution. Delivery time may increase by {(weather_data.get('weather_factor', 1.0) - 1) * 100:.0f}%\n"
+    else:
+        result += f"Good weather conditions for delivery.\n"
+    
+    safe_origin = origin.replace(' ', '_').replace(',', '')[:30]
+    safe_dest = destination.replace(' ', '_').replace(',', '')[:30]
+    map_filename = f"weather_{safe_origin}_to_{safe_dest}.html"
+    map_path = f"static/{map_filename}"
+
+    route = get_route_osrm(origin_coords, dest_coords)
+    if route:
+        route_data = {
+            'geometry': route.get('geometry')
+        }
+        create_enhanced_map(origin_coords, dest_coords, route_data, weather_data, map_path, map_type="weather")
+
+    result += f"\nINTERACTIVE MAP: /view-map/{map_filename}\n"
+
+    return result
 
 def real_traffic_analyzer(origin: str, destination: str) -> str:
-    """
-    Analyze traffic conditions using real data and patterns
-    """
-    print(f"\nAnalyzing traffic: {origin} → {destination}")
+    """Analyze traffic conditions using real data and patterns"""
+    print(f"\nAnalyzing traffic: {origin} -> {destination}")
     
     origin_coords = geocode_address_nominatim(origin)
     dest_coords = geocode_address_nominatim(destination)
@@ -380,7 +410,7 @@ def real_traffic_analyzer(origin: str, destination: str) -> str:
         return "No route found for traffic analysis"
     
     current_hour = datetime.now().hour
-    traffic_factor = calculate_traffic(origin_coords,dest_coords)
+    traffic_factor = calculate_traffic(origin_coords, dest_coords)
     
     if traffic_factor >= 1.5:
         traffic_level = "Heavy"
@@ -390,43 +420,61 @@ def real_traffic_analyzer(origin: str, destination: str) -> str:
         advice = "Expect minor delays, monitor conditions"
     else:
         traffic_level = "Light"
-        advice = "Good time to depart!"
-    
+        advice = "Good time to depart"
     
     base_duration = route["duration_min"]
     adjusted_duration = base_duration * traffic_factor
     total_delay = adjusted_duration - base_duration
     
     result = (
-        f"Traffic Analysis (Real-time patterns):\n"
+        f"TRAFFIC ANALYSIS\n"
         f"Current Traffic: {traffic_level}\n"
         f"Time: {datetime.now().strftime('%H:%M')} (Factor: {traffic_factor:.2f}x)\n"
         f"Base ETA: {base_duration:.0f} min\n"
-        f"Adjusted ETA: {adjusted_duration:.0f} min (+{total_delay:.0f} min delay)\n"
+        f"Adjusted ETA: {adjusted_duration:.0f} min\n"
+        f"Expected Delay: {total_delay:.0f} min\n\n"
+        f"Advice: {advice}\n"
     )
-    
-    result += f"\nAdvice: {advice}"
-    
-    return result
+ 
+    safe_origin = origin.replace(' ', '_').replace(',', '')[:30]
+    safe_dest = destination.replace(' ', '_').replace(',', '')[:30]
+    map_filename = f"traffic_{safe_origin}_to_{safe_dest}.html"
+    map_path = f"static/{map_filename}"
 
+    if route:
+        route_data = {
+            'geometry': route.get('geometry')
+        }
+        create_enhanced_map(origin_coords, dest_coords, route_data, {}, map_path, map_type="traffic")
+
+    result += f"\nINTERACTIVE MAP: /view-map/{map_filename}\n"
+
+    return result
 
 route_tool = StructuredTool.from_function(
     func=real_route_planner,
     name="real_route_planner",
-    description="Find optimal route using FREE OpenStreetMap data. Provide city names or addresses and the detailed routes.",
+    description="Plan route with weather and traffic integration. Returns distance and duration from API.",
     args_schema=RouteInput
 )
 
 cost_tool = StructuredTool.from_function(
     func=real_cost_optimizer,
     name="real_cost_optimizer",
-    description="Calculate delivery costs with real-world pricing. Pass distance_km, weight_kg, duration_min as numbers.",
+    description="Calculate delivery costs with weather and traffic factors. ONLY use when user provides weight.",
     args_schema=CostInput
 )
 
 traffic_tool = StructuredTool.from_function(
     func=real_traffic_analyzer,
     name="real_traffic_analyzer",
-    description="Analyze traffic conditions using real patterns.",
+    description="Analyze traffic conditions using real patterns",
     args_schema=TrafficInput
+)
+
+weather_tool = StructuredTool.from_function(
+    func=real_weather_analyzer,
+    name="real_weather_analyzer",
+    description="Analyze weather conditions along route",
+    args_schema=WeatherInput
 )