alex/voyage
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

changes

Browse Source
This commit is contained in:
alex wiesner
2026-03-13 20:15:22 +00:00
parent e68c95b2dd
commit c4d39f2812
33 changed files with 2383 additions and 162 deletions
Download Patch File Download Diff File Expand all files Collapse all files

39
backend/server/chat/views/__init__.py
View File

@@ -2,10 +2,12 @@ import asyncio
import json
import logging
import re
from datetime import timedelta
from asgiref.sync import sync_to_async
from adventures.models import Collection
from django.http import StreamingHttpResponse
from django.utils import timezone
from integrations.models import UserAISettings
from rest_framework import status, viewsets
from rest_framework.decorators import action
@@ -276,6 +278,33 @@ class ChatViewSet(viewsets.ModelViewSet):
continue
return None
@staticmethod
def _derive_weather_dates_from_collection(collection, max_days=7):
"""Derive a bounded weather date list from collection dates, or fallback to today."""
today = timezone.localdate()
if collection is None:
return [today.isoformat()]
start_date = getattr(collection, "start_date", None)
end_date = getattr(collection, "end_date", None)
if start_date and end_date:
range_start = min(start_date, end_date)
range_end = max(start_date, end_date)
day_count = min((range_end - range_start).days + 1, max_days)
return [
(range_start + timedelta(days=offset)).isoformat()
for offset in range(day_count)
]
if start_date:
return [start_date.isoformat()]
if end_date:
return [end_date.isoformat()]
return [today.isoformat()]
@staticmethod
def _build_search_places_location_clarification_message():
return (
@@ -744,6 +773,12 @@ class ChatViewSet(viewsets.ModelViewSet):
retry_arguments = dict(prepared_arguments)
retry_arguments["latitude"] = retry_lat
retry_arguments["longitude"] = retry_lon
if not retry_arguments.get("dates"):
retry_arguments["dates"] = (
self._derive_weather_dates_from_collection(
collection
)
)
attempted_weather_coord_retry = True
retry_result = await sync_to_async(
execute_tool,
@@ -774,6 +809,10 @@ class ChatViewSet(viewsets.ModelViewSet):
if (
attempted_weather_coord_retry
and self._is_required_param_tool_error(result)
and self._is_get_weather_missing_latlong_error(
function_name,
result,
)
):
result = {
"error": "Could not fetch weather for the collection locations"

209
backend/server/chat/views/day_suggestions.py
View File

@@ -72,7 +72,12 @@ class DaySuggestionsView(APIView):
)
try:
places_context = self._get_places_context(request.user, category, location)
place_candidates = self._fetch_place_candidates(
request.user,
category,
location,
)
places_context = self._build_places_context(place_candidates)
prompt = self._build_prompt(
category=category,
filters=filters,
@@ -89,17 +94,30 @@ class DaySuggestionsView(APIView):
provider=provider,
model=model,
)
suggestions = self._enrich_suggestions_with_coordinates(
suggestions,
place_candidates,
)
return Response({"suggestions": suggestions}, status=status.HTTP_200_OK)
except Exception as exc:
logger.exception("Failed to generate day suggestions")
payload = _safe_error_payload(exc)
status_code = {
error_category = (
payload.get("error_category") if isinstance(payload, dict) else None
)
status_code_map = {
"model_not_found": status.HTTP_400_BAD_REQUEST,
"authentication_failed": status.HTTP_401_UNAUTHORIZED,
"rate_limited": status.HTTP_429_TOO_MANY_REQUESTS,
"invalid_request": status.HTTP_400_BAD_REQUEST,
"provider_unreachable": status.HTTP_503_SERVICE_UNAVAILABLE,
}.get(payload.get("error_category"), status.HTTP_500_INTERNAL_SERVER_ERROR)
}
status_code = status.HTTP_500_INTERNAL_SERVER_ERROR
if isinstance(error_category, str):
status_code = status_code_map.get(
error_category,
status.HTTP_500_INTERNAL_SERVER_ERROR,
)
return Response(
payload,
status=status_code,
@@ -176,11 +194,12 @@ class DaySuggestionsView(APIView):
prompt += (
" Return 3-5 specific suggestions as a JSON array."
" Each suggestion should have: name, description, why_fits, category, location, rating, price_level."
" Include latitude and longitude when known from nearby-place context."
" Return ONLY valid JSON, no markdown, no surrounding text."
)
return prompt
def _get_places_context(self, user, category, location):
def _fetch_place_candidates(self, user, category, location):
tool_category_map = {
"restaurant": "food",
"activity": "tourism",
@@ -194,24 +213,190 @@ class DaySuggestionsView(APIView):
radius=8,
)
if not isinstance(result, dict):
return ""
return []
if result.get("error"):
return ""
return []
raw_results = result.get("results")
if not isinstance(raw_results, list):
return []
return [entry for entry in raw_results if isinstance(entry, dict)]
def _build_places_context(self, place_candidates):
if not isinstance(place_candidates, list):
return ""
entries = []
for place in raw_results[:5]:
if not isinstance(place, dict):
continue
for place in place_candidates[:5]:
name = place.get("name")
address = place.get("address") or ""
if name:
entries.append(f"{name} ({address})" if address else name)
latitude = place.get("latitude")
longitude = place.get("longitude")
if not name:
continue
details = [name]
if address:
details.append(address)
if latitude is not None and longitude is not None:
details.append(f"lat={latitude}")
details.append(f"lon={longitude}")
entries.append(" | ".join(details))
return "; ".join(entries)
def _tokenize_text(self, value):
normalized = self._normalize_text(value)
if not normalized:
return set()
return set(re.findall(r"[a-z0-9]+", normalized))
def _normalize_text(self, value):
if not isinstance(value, str):
return ""
return value.strip().lower()
def _extract_suggestion_identity(self, suggestion):
if not isinstance(suggestion, dict):
return "", ""
name = self._normalize_text(
suggestion.get("name")
or suggestion.get("title")
or suggestion.get("place_name")
or suggestion.get("venue")
)
location_text = self._normalize_text(
suggestion.get("location")
or suggestion.get("address")
or suggestion.get("neighborhood")
)
return name, location_text
def _best_place_match(self, suggestion, place_candidates):
suggestion_name, suggestion_location = self._extract_suggestion_identity(
suggestion
)
if not suggestion_name and not suggestion_location:
return None
suggestion_name_tokens = self._tokenize_text(suggestion_name)
suggestion_location_tokens = self._tokenize_text(suggestion_location)
def has_coordinates(candidate):
return (
candidate.get("latitude") is not None
and candidate.get("longitude") is not None
)
best_candidate = None
best_score = -1
best_coordinate_candidate = None
best_coordinate_score = -1
for candidate in place_candidates:
candidate_name = self._normalize_text(candidate.get("name"))
candidate_address = self._normalize_text(candidate.get("address"))
candidate_name_tokens = self._tokenize_text(candidate_name)
candidate_address_tokens = self._tokenize_text(candidate_address)
score = 0
if suggestion_name and candidate_name:
if suggestion_name == candidate_name:
score += 4
elif (
suggestion_name in candidate_name
or candidate_name in suggestion_name
):
score += 2
shared_name_tokens = suggestion_name_tokens & candidate_name_tokens
if len(shared_name_tokens) >= 2:
score += 3
elif len(shared_name_tokens) == 1:
score += 1
if suggestion_location and candidate_address:
if suggestion_location == candidate_address:
score += 2
elif (
suggestion_location in candidate_address
or candidate_address in suggestion_location
):
score += 1
shared_location_tokens = (
suggestion_location_tokens & candidate_address_tokens
)
if len(shared_location_tokens) >= 2:
score += 2
elif len(shared_location_tokens) == 1:
score += 1
if score > best_score:
best_score = score
best_candidate = candidate
elif (
score == best_score
and best_candidate is not None
and not has_coordinates(best_candidate)
and has_coordinates(candidate)
):
best_candidate = candidate
if has_coordinates(candidate) and score > best_coordinate_score:
best_coordinate_score = score
best_coordinate_candidate = candidate
if best_score <= 0:
return None
if has_coordinates(best_candidate):
return best_candidate
# Bounded fallback: if the strongest text match has no coordinates,
# accept the best coordinate-bearing candidate only with a
# reasonably strong lexical overlap score.
if best_coordinate_score >= 2:
return best_coordinate_candidate
return best_candidate
def _enrich_suggestions_with_coordinates(self, suggestions, place_candidates):
if not isinstance(suggestions, list) or not isinstance(place_candidates, list):
return suggestions
enriched = []
for suggestion in suggestions:
if not isinstance(suggestion, dict):
continue
if (
suggestion.get("latitude") is not None
and suggestion.get("longitude") is not None
):
enriched.append(suggestion)
continue
matched_place = self._best_place_match(suggestion, place_candidates)
if not matched_place:
enriched.append(suggestion)
continue
if (
matched_place.get("latitude") is None
or matched_place.get("longitude") is None
):
enriched.append(suggestion)
continue
merged = dict(suggestion)
merged["latitude"] = matched_place.get("latitude")
merged["longitude"] = matched_place.get("longitude")
merged["location"] = merged.get("location") or matched_place.get("address")
enriched.append(merged)
return enriched
def _resolve_provider_and_model(self, request):
request_provider = (request.data.get("provider") or "").strip().lower() or None
request_model = (request.data.get("model") or "").strip() or None
@@ -262,7 +447,7 @@ class DaySuggestionsView(APIView):
if not api_key:
raise ValueError("No API key available")
provider_config = CHAT_PROVIDER_CONFIG.get(provider, {})
provider_config = CHAT_PROVIDER_CONFIG.get(provider or "", {})
resolved_model = normalize_gateway_model(
provider,
model or provider_config.get("default_model"),