update app.py and route_planner_tool.py

app.py

@@ -114,67 +114,139 @@ writer_agent = Agent(
 )
 
 # Core logic
-def generate_itinerary(location, start_date, end_date, preferences, transport_modes ):
+def generate_itinerary(location, start_date, end_date, preferences, transport_modes):
     t0 = time.time()
     print("✅ Button clicked:", location, start_date, end_date, transport_modes, preferences)
-    
-    try: 
+
+    try:
+        # -------------------- normalize dates --------------------
         if isinstance(start_date, str):
             start_date = start_date.replace("/", "-")
             start_date = datetime.fromisoformat(start_date).date().isoformat()
         elif hasattr(start_date, "date"):
             start_date = start_date.date().isoformat()
-    
+
         if isinstance(end_date, str):
             end_date = end_date.replace("/", "-")
             end_date = datetime.fromisoformat(end_date).date().isoformat()
         elif hasattr(end_date, "date"):
             end_date = end_date.date().isoformat()
+
         days, date_list = expand_dates(start_date, end_date)
         trip_duration_days = days
-    
+
         if isinstance(transport_modes, str):
             transport_modes = [transport_modes]
-    
+
         transport_modes_str = ", ".join(transport_modes)
         modes_json = json.dumps(transport_modes)
 
-        #Define the tasks
-
+        # -------------------- tasks (phase 1: retrieve + weather) --------------------
         retrieval_task = Task(
             description=f"Gather restaurants, landmarks, and activities for the trip in {location}.",
             expected_output="A JSON containing categorized lists of places.",
-            agent=retriever_agent
+            agent=retriever_agent,
         )
 
         weather_task = Task(
-            description=(f"Use the Weather Forecast Tool **once** to fetch a 7-day weather forecast covering the full period from {start_date} to {end_date} for {location}."
-            "Do not call the tool multiple times. Instead, request all days in one forecast."
-            "Return a single JSON mapping each date → weather summary (max/min temperature, precipitation, and general condition)."),
+            description=(
+                f"Use the Weather Forecast Tool **once** to fetch a 7-day weather forecast covering the full period "
+                f"from {start_date} to {end_date} for {location}. "
+                "Do not call the tool multiple times. Instead, request all days in one forecast. "
+                "Return a single JSON mapping each date → weather summary (max/min temperature, precipitation, and general condition)."
+            ),
             expected_output="A JSON object mapping each date to temperature, precipitation, and condition summaries.",
             agent=weather_agent,
         )
 
-        route_task = Task(
-            description=(
-                f"From the RetrieverTask output, build a destinations list (strings) using the "
-                f"top 10 places across categories (prefer formatted address if present, else name + city). "
-                f"Use origin='{location}'. Then call Route Planner Tool exactly once with:\n"
-                f"- origin: '{location}'\n"
-                f"- destinations: <that list>\n"
-                f"- modes: {transport_modes}\n"
-                f"- return_matrix: true\n"
-                f"Return ONLY the tool output as valid JSON (no extra commentary)."
-            ),
-            expected_output=(
-                "A single JSON object with keys: "
-                "'stops' (list), 'modes_requested' (list), 'origin_routes' (list of routes), "
-                "and 'matrix' (per-mode NxN distance_km/duration_min matrices)."
-            ),
-            agent=route_agent,
-            context=[retrieval_task]
+        prefetch_crew = Crew(
+            agents=[retriever_agent, weather_agent],
+            tasks=[retrieval_task, weather_task],
+            verbose=True,
+        )
+
+        _ = prefetch_crew.kickoff(inputs={
+            "location": location,
+            "start_date": start_date,
+            "end_date": end_date,
+        })
+
+        # -------------------- extract retrieval output --------------------
+        def _get_task_raw(task: Task) -> Any:
+            out = getattr(task, "output", None)
+            if out is None:
+                return None
+            raw = getattr(out, "raw", out)
+            # Some versions store a dict already; others store JSON string
+            if isinstance(raw, str):
+                try:
+                    return json.loads(raw)
+                except Exception:
+                    return raw
+            return raw
+
+        retrieval_data = _get_task_raw(retrieval_task)
+        weather_data = _get_task_raw(weather_task)
+
+        if retrieval_data is None:
+            raise RuntimeError("RetrieverTask produced no output; cannot build route destinations.")
+
+        # -------------------- build top-10 destinations across categories --------------------
+        # expected shape from your log:
+        # {
+        #   "restaurants": {"breakfast":[...], "lunch":[...], "dinner":[...]},
+        #   "landmarks":[...], "museums":[...], "parks":[...]
+        # }
+        destinations: List[str] = []
+
+        def _pick_addr(item: Any) -> Optional[str]:
+            if not isinstance(item, dict):
+                s = str(item).strip()
+                return s if s else None
+            addr = (item.get("formatted_address") or item.get("address") or "").strip()
+            if addr:
+                return addr
+            name = (item.get("name") or "").strip()
+            return f"{name}, {location}".strip(", ") if name else None
+
+        # pull in a balanced sample: breakfast/lunch/dinner + landmarks/museums/parks
+        restaurants = (retrieval_data.get("restaurants") or {}) if isinstance(retrieval_data, dict) else {}
+        for meal in ("breakfast", "lunch", "dinner"):
+            for x in (restaurants.get(meal) or [])[:2]:  # 2 each = 6
+                addr = _pick_addr(x)
+                if addr:
+                    destinations.append(addr)
+
+        for cat in ("landmarks", "museums", "parks"):
+            for x in (retrieval_data.get(cat) or [])[:2]:  # 2 each = 6 (we'll trim to 10)
+                addr = _pick_addr(x)
+                if addr:
+                    destinations.append(addr)
+
+        # de-dup while preserving order
+        seen = set()
+        destinations = [d for d in destinations if not (d in seen or seen.add(d))]
+
+        # cap to 10
+        destinations = destinations[:10]
+
+        if not destinations:
+            raise RuntimeError("No usable destinations built from RetrieverTask output.")
+
+        # -------------------- call Route Planner Tool ONCE in Python (guaranteed) --------------------
+        print("🧭 Calling Route Planner Tool once (return_matrix=True)...")
+        route_data_dict = route_tool.run(
+            origin=location,
+            destinations=destinations,
+            modes=transport_modes,
+            max_results=10,
+            return_matrix=True,
         )
 
+        # Make sure it's JSON-serializable string for injection into planner prompt
+        route_data_json = json.dumps(route_data_dict, ensure_ascii=False)
+
+        # -------------------- tasks (phase 2: plan + write) --------------------
         planning_task = Task(
             description=(
                 "You are the itinerary planning agent responsible for creating an optimized, personalized multi-day trip plan.\n\n"
@@ -185,96 +257,47 @@ def generate_itinerary(location, start_date, end_date, preferences, transport_mo
                 "2️⃣ Review the weather forecast (from WeatherTask) to determine which days are best for outdoor vs indoor activities. "
                 "If heavy rain or extreme temperatures are forecast, prioritize indoor attractions or museums.\n"
                 "3️⃣ For each category (breakfast, lunch, dinner, activities), call the Semantic Ranking Tool to identify the best matches "
-                "from the places retrieved by the RetrieverTask. Use the user's preferences to compute semantic similarity and select top results.\n"
-
-                "4️⃣ Use the route and distance data (from RouteTask) to minimize total travel time.\n"
-                "   IMPORTANT: RouteTask returns BOTH:\n"
-                "   - origin_routes: origin → each stop (useful for first hop)\n"
-                "   - stops + matrix: an NxN matrix for true inter-stop travel times\n\n"
-                "   How to use the matrix correctly:\n"
-                "   A) Read RouteTask JSON:\n"
-                "      - stops = RouteTask.stops (list of stop strings)\n"
-                "      - matrix = RouteTask.matrix (dict keyed by mode)\n"
-                "   B) Build an index map once: idx = { stops[i]: i for i in range(len(stops)) }\n"
-                "   C) Matching rule (critical): Each activity 'location' MUST be exactly one of the strings in RouteTask.stops "
-                "(verbatim), so the index lookup works. Do NOT invent combined locations. "
-                "If you want to mention two nearby landmarks, create two separate activities with their own stop locations.\n"
-                "   D) For each pair of consecutive itinerary activities A -> B:\n"
-                "      - Find i = idx[A.location] and j = idx[B.location]\n"
-                "      - Choose travel mode as follows:\n"
-                "         • If walking is allowed AND matrix['walking'].distance_km[i][j] <= 2.0 → use walking\n"
-                "         • Else if public_transport is allowed → use public_transport\n"
-                "         • Else if cycling is allowed → use cycling\n"
-                "         • Else use driving\n"
-                "      - Then set travel metadata using the matrix (NOT guesses):\n"
-                "         • distance_from_prev = matrix[chosen_mode].distance_km[i][j]\n"
-                "         • duration_minutes  = matrix[chosen_mode].duration_min[i][j]\n"
-                "         • travel_mode       = chosen_mode\n"
-                "   E) For the first activity of the day:\n"
-                "      - Use origin_routes if provided, OR treat the origin as the previous stop only if it is included in stops.\n"
-                "   Always use the matrix for inter-stop travel times (not origin_routes).\n"
+                "from the places retrieved by the RetrieverTask. Use the user's preferences to compute semantic similarity and select top results.\n\n"
+
+                "4️⃣ Use the route and distance data provided below (this is REAL tool output, not a suggestion):\n"
+                f"ROUTE_DATA_JSON = {route_data_json}\n\n"
+                "   IMPORTANT: ROUTE_DATA_JSON contains:\n"
+                "   - stops: list[str] (indexable; includes origin at index 0)\n"
+                "   - matrix: dict keyed by mode, each containing distance_km[i][j] and duration_min[i][j]\n\n"
+                "   How to use it correctly:\n"
+                "   A) stops = ROUTE_DATA_JSON['stops']\n"
+                "   B) matrix = ROUTE_DATA_JSON['matrix']\n"
+                "   C) Build idx once: idx = { stops[i]: i for i in range(len(stops)) }\n"
+                "   D) Matching rule (critical): Each activity 'location' MUST be exactly one of the strings in stops (verbatim).\n"
+                "   E) For each consecutive activity A -> B:\n"
+                "      - i = idx[A.location], j = idx[B.location]\n"
+                "      - choose mode:\n"
+                "        • if walking allowed and matrix['walking'].distance_km[i][j] <= 2.0 -> walking\n"
+                "        • else if public_transport allowed -> public_transport\n"
+                "        • else if cycling allowed -> cycling\n"
+                "        • else -> driving\n"
+                "      - set:\n"
+                "        • distance_from_prev = matrix[chosen_mode].distance_km[i][j]\n"
+                "        • duration_minutes  = matrix[chosen_mode].duration_min[i][j]\n"
+                "        • travel_mode       = chosen_mode\n\n"
 
                 "5️⃣ **Adjust activity timestamps dynamically based on route durations.**\n"
-                "   - After computing routes, calculate cumulative travel time between activities using:\n"
-                "     matrix[travel_mode].duration_min[i][j] between consecutive selected stops.\n"
+                "   - Use matrix[travel_mode].duration_min[i][j] between consecutive selected stops.\n"
                 "   - If travel between two events exceeds 20 minutes, delay the next event’s start time accordingly.\n"
-                "   - Ensure total daily schedule remains within 08:00–22:00. If an activity exceeds this range, reschedule or drop the lowest-ranked one.\n"
-                "6️⃣ Assign realistic timestamps to each event (e.g., breakfast 8:00–9:00, lunch 13:00–14:00, "
-                "activities between meals, dinner after 19:00) and dynamically adjust based on travel time.\n"
+                "   - Keep the day within 08:00–22:00; reschedule or drop the lowest-ranked activity if needed.\n"
+                "6️⃣ Assign realistic timestamps (breakfast 08:00–09:00, lunch 13:00–14:00, dinner after 19:00) and adjust based on travel time.\n"
                 "7️⃣ Ensure variety across days (don’t repeat the same activities).\n"
                 "8️⃣ Include timestamps and travel metadata in the JSON output for each event.\n"
-                "9️⃣ For each selected item (breakfast, activity, lunch, dinner), include:\n"
-                "   - name\n"
-                "   - category\n"
-                "   - start_time, end_time\n"
-                "   - location (address) (MUST be verbatim from RouteTask.stops)\n"
-                "   - rating (if available)\n"
-                "   - reasoning (why chosen)\n"
-                "   - weather_forecast (if applicable)\n"
-                "   - distance_from_prev (km)\n"
-                "   - duration_minutes (from matrix)\n"
-                "   - travel_mode (optional)\n\n"
-                "🔟 Output format (MUST match ItineraryModel exactly):\n"
-                "{\n"
-                '  "destination": "<city/region>",\n'
-                '  "trip_duration_days": <int>,\n'
-                f'  "transport_modes": {modes_json},\n'
-                '  "start_date": "YYYY-MM-DD",\n'
-                '  "end_date": "YYYY-MM-DD",\n'
-                '  "traveler_profile": "<short preference summary>",\n'
-                '  "days": [\n'
-                "    {\n"
-                '      "date": "YYYY-MM-DD",\n'
-                '      "weather_summary": "<string>",\n'
-                '      "summary": "<string>",\n'
-                '      "activities": [\n'
-                "        {\n"
-                '          "name": "<place name>",\n'
-                '          "category": "<breakfast|lunch|dinner|museum|park|landmark|...>",\n'
-                '          "start_time": "HH:MM",\n'
-                '          "end_time": "HH:MM",\n'
-                '          "location": "<address>",\n'
-                '          "map_url": "<optional>",\n'
-                '          "rating": <optional float>,\n'
-                '          "reasoning": "<optional>",\n'
-                '          "weather_forecast": "<optional>",\n'
-                '          "travel_mode": "<optional walking|public_transport|driving|cycling>",\n'
-                '          "distance_from_prev": <optional float>,\n'
-                '          "duration_minutes": <optional int>\n'
-                "        }\n"
-                "      ]\n"
-                "    }\n"
-                "  ],\n"
-                '  "total_distance_km": <optional float>,\n'
-                '  "notes": "<optional>"\n'
-                "}\n"
-                " Use field name 'activities' (NOT events). Use 'duration_minutes' (NOT travel_duration_min). Use 'transport_modes' (NOT transport_mode)."
+                "9️⃣ For each selected item include: name, category, start/end time, location, rating (if any), reasoning, weather_forecast, "
+                "distance_from_prev, duration_minutes, travel_mode.\n\n"
+                "🔟 Output MUST match ItineraryModel exactly (activities field, duration_minutes field, transport_modes list).\n"
+                f"transport_modes must equal: {modes_json}\n"
             ),
             expected_output="A structured JSON itinerary with complete metadata and travel-aware timestamps for each activity.",
-            context=[retrieval_task, weather_task, route_task],
+            context=[retrieval_task, weather_task],
             agent=planner_agent,
             output_pydantic=ItineraryModel,
-            reasoning=False
+            reasoning=False,
         )
 
         writing_task = Task(
@@ -282,45 +305,36 @@ def generate_itinerary(location, start_date, end_date, preferences, transport_mo
                 "You are a professional travel writer. Given a structured itinerary JSON with detailed fields "
                 "(rating, reasoning, distance_from_prev, weather_forecast), write an engaging Markdown itinerary.\n\n"
                 f"Make sure the itinerary is covering the period {start_date} to {end_date}.\n\n"
-                "At the top of the Markdown output, include a summary line like:\n"
-                f"'**Trip Dates:** {start_date} → {end_date} \n"
+                "At the top include:\n"
+                f"**Trip Dates:** {start_date} → {end_date}\n\n"
                 "Each day must include:\n"
                 "- The date and weather summary from the JSON.\n"
-                "- Chronological itinerary entries with start and end times.\n"
-                "Follow the timestamps, preserve logical sequencing, and describe only the actual restaurants, landmarks, "
-                "and activities from the structured itinerary. "
-                "For each activity, place or meal, include these details when present:\n"
-                "- Rating: '⭐ 4.7' inline with restaurant or activity name\n"
-                "- Distance/Travel time between items (e.g., '*Travel to next: 22-minute walk, 1.1 km*')\n"
-                "- Reasoning when relevant ('Chosen for excellent reviews or unique view of the lake')\n\n"
-                "Ensure each event lists time, name (with Google Maps link if available), address, and category."
-                "Do not invent fictional places or events. "
-                "If weather indicates rain, mention it contextually (e.g., 'Since the afternoon may rain, head indoors.').\n\n"
-                "⚠️ Important: The itinerary must remain consistent with the city and locations in the JSON (e.g., Florence, Italy). "
-                "Do not add generic beach or island content unless explicitly present in the JSON.\n\n"
-                "Return your final output in **Markdown** format with headers for each day and bold timestamps."
+                "- Chronological itinerary entries with start/end times.\n"
+                "- Only describe places present in the JSON. No invention.\n"
+                "- Include rating inline (⭐ 4.7) when present.\n"
+                "- Include travel line when present (e.g. '*Travel to next: 22-minute walk, 1.1 km*').\n"
+                "Return Markdown with headers per day and bold timestamps."
             ),
             expected_output="A richly detailed Markdown itinerary with times, ratings, and reasoning per event.",
             context=[planning_task],
-            agent=writer_agent
+            agent=writer_agent,
         )
 
-        trip_crew = Crew(
-            agents=[retriever_agent, weather_agent, route_agent, planner_agent, writer_agent],
-            tasks=[retrieval_task, weather_task, route_task, planning_task, writing_task],
-            verbose=True
+        planning_crew = Crew(
+            agents=[planner_agent, writer_agent],
+            tasks=[planning_task, writing_task],
+            verbose=True,
         )
 
-        result = trip_crew.kickoff(inputs = {
+        result = planning_crew.kickoff(inputs={
             "location": location,
             "start_date": start_date,
             "end_date": end_date,
             "transport_modes": transport_modes,
             "transport_modes_str": transport_modes_str,
-            "trip_duration_days": trip_duration_days
+            "trip_duration_days": trip_duration_days,
         })
 
-        # Safely extract the result
         markdown_itinerary = (
             result if isinstance(result, str)
             else getattr(result, "raw", None) or str(result)
@@ -328,7 +342,7 @@ def generate_itinerary(location, start_date, end_date, preferences, transport_mo
 
         print(f"✅ Done in {time.time() - t0:.1f}s")
         return markdown_itinerary
-    
+
     except Exception:
         tb = traceback.format_exc()
         print(tb)

tools/route_planner_tool.py

@@ -20,7 +20,7 @@ class RoutePlannerToolSchema(BaseModel):
     # Optional NxN matrix output
     return_matrix: bool = Field(
         default=False,
-        description="If true, also return an NxN distance/duration matrix over [origin] + destinations."
+        description="If true, also return an NxN distance/duration matrix over [origin] + destinations.",
     )
 
     @field_validator("origin", mode="before")
@@ -81,7 +81,6 @@ class RoutePlannerToolSchema(BaseModel):
                     flat.append(x)
             v = flat
 
-        # If already a list sanitize items
         if not isinstance(v, list):
             return v
 
@@ -118,7 +117,6 @@ class RoutePlannerToolSchema(BaseModel):
 
         if isinstance(v, str):
             s = v.strip()
-            # handle stringified list like '["walking","public_transport"]' or "['walking','public_transport']"
             if s.startswith("[") and s.endswith("]"):
                 try:
                     s_json = s.replace("'", '"')
@@ -151,13 +149,15 @@ class RoutePlannerTool(BaseTool):
 
     args_schema = RoutePlannerToolSchema
 
+    # -------------------- INTERNAL HELPERS --------------------
+
     def _distance_matrix(
         self,
         client: httpx.Client,
         origins: List[str],
         destinations: List[str],
         mode: str,
-        api_key: str
+        api_key: str,
     ) -> Dict[str, Any]:
         """Call Google Distance Matrix for origins -> destinations in one request."""
         url = "https://maps.googleapis.com/maps/api/distancematrix/json"
@@ -191,13 +191,11 @@ class RoutePlannerTool(BaseTool):
         r.raise_for_status()
         data = r.json()
 
-        # clean status/error handling 
         status = data.get("status")
         if status != "OK":
             err = data.get("error_message", "")
             raise RuntimeError(f"DistanceMatrix status={status}: {err}")
 
-        # TTL: transit is short-lived; others are longer
         ttl = 30 * 60 if mode_k == "transit" else 24 * 3600
         cache.set(cache_key, data, ttl_seconds=ttl)
         return data
@@ -226,21 +224,17 @@ class RoutePlannerTool(BaseTool):
 
         return {"distance_km": dist_km, "duration_min": dur_min}
 
+    # -------------------- MAIN ENTRY --------------------
+
     def _run(
         self,
         origin: str,
         destinations: List[str],
         modes: Union[str, List[str]] = "walking",
         max_results: int = 10,
-        return_matrix: bool = False,  # ✅ NEW
+        return_matrix: bool = False,
     ) -> Union[List[Dict[str, Union[str, float]]], Dict[str, Any]]:
-        """
-        Calculates travel routes between a starting location and multiple destinations.
 
-        Returns:
-          - default: List[Dict] (same as before)
-          - if return_matrix=True: Dict with stops + origin_routes + matrix
-        """
         api_key = os.getenv("GOOGLE_MAPS_API_KEY")
         if not api_key:
             raise ValueError("Missing GOOGLE_MAPS_API_KEY in environment variables")
@@ -257,7 +251,8 @@ class RoutePlannerTool(BaseTool):
         else:
             modes_list = [str(m).strip() for m in modes if m is not None]
 
-        # normalize mode labels
+        # normalize input labels -> Google API labels
+        # user: public_transport/cycling -> api: transit/bicycling
         norm_modes: List[str] = []
         for m in modes_list:
             if m == "public_transport":
@@ -269,15 +264,34 @@ class RoutePlannerTool(BaseTool):
 
         norm_modes = [m for m in norm_modes if m]  # sanitize
 
+        # output labels expected by planner
+        api_to_user = {
+            "walking": "walking",
+            "transit": "public_transport",
+            "driving": "driving",
+            "bicycling": "cycling",
+        }
+
         # Destination list
         MAX_DM_DESTS = 25
-        dests = [str(d).strip() for d in destinations if str(d).strip()][:min(max_results, MAX_DM_DESTS)]
+        dests = [str(d).strip() for d in destinations if str(d).strip()][
+            : min(max_results, MAX_DM_DESTS)
+        ]
+
         if not dests:
-            return [] if not return_matrix else {"stops": [origin], "origin_routes": [], "matrix": {}}
+            if not return_matrix:
+                return []
+            return {
+                "origin": origin,
+                "destinations": [],
+                "stops": [origin],
+                "modes_requested": [api_to_user[m] for m in norm_modes if m in api_to_user],
+                "origin_routes": [],
+                "matrix": {},
+            }
 
-        # NxN matrix safety: Distance Matrix elements = origins*destinations (cap ~100)
-        # => stops_total <= 10 keeps NxN <= 100
-        MAX_STOPS_FOR_NXN = 10
+        # NxN safety: origins*destinations should stay <= ~100 elements
+        MAX_STOPS_FOR_NXN = 10  # origin + first 9 destinations
 
         with httpx.Client(timeout=20.0) as client:
             # 1) origin -> dests (1xN) per requested mode
@@ -338,23 +352,25 @@ class RoutePlannerTool(BaseTool):
                     best["destination"] = dest
                     results.append(best)
 
-            # 2) Optional: NxN matrix over [origin] + destinations (still within this single tool run)
+            # 2) Optional: NxN matrix over [origin] + destinations (still within single tool run)
             if not return_matrix:
                 return results
 
             stops = [origin] + dests
             if len(stops) > MAX_STOPS_FOR_NXN:
-                stops = stops[:MAX_STOPS_FOR_NXN]  # origin + first 9 destinations
+                stops = stops[:MAX_STOPS_FOR_NXN]
 
             nxn_by_mode: Dict[str, Any] = {}
             for m in ("walking", "transit", "driving", "bicycling"):
                 if m in norm_modes:
                     dm_nxn = self._distance_matrix(client, stops, stops, m, api_key)
-                    nxn_by_mode[m] = self._parse_nxn(dm_nxn)
+                    nxn_by_mode[api_to_user[m]] = self._parse_nxn(dm_nxn)
 
             return {
-                "stops": stops,
-                "modes_requested": norm_modes,
-                "origin_routes": results,
-                "matrix": nxn_by_mode,
+                "origin": origin,
+                "destinations": dests,
+                "stops": stops,  # indexable list used by planner
+                "modes_requested": [api_to_user[m] for m in norm_modes if m in api_to_user],
+                "origin_routes": results,  # origin -> each stop (best mode per stop)
+                "matrix": nxn_by_mode,      # NxN per mode (planner keys!)
             }