487 lines
18 KiB
Python
487 lines
18 KiB
Python
import logging
|
|
import json
|
|
import re
|
|
|
|
import litellm
|
|
from django.conf import settings
|
|
from django.shortcuts import get_object_or_404
|
|
from rest_framework import status
|
|
from rest_framework.permissions import IsAuthenticated
|
|
from rest_framework.response import Response
|
|
from rest_framework.views import APIView
|
|
|
|
from adventures.models import Collection
|
|
from chat.agent_tools import search_places
|
|
from chat.llm_client import (
|
|
CHAT_PROVIDER_CONFIG,
|
|
_safe_error_payload,
|
|
get_llm_api_key,
|
|
get_system_prompt,
|
|
is_chat_provider_available,
|
|
normalize_gateway_model,
|
|
)
|
|
from integrations.models import UserAISettings
|
|
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
class DaySuggestionsView(APIView):
|
|
permission_classes = [IsAuthenticated]
|
|
|
|
def post(self, request):
|
|
collection_id = request.data.get("collection_id")
|
|
date = request.data.get("date")
|
|
category = request.data.get("category")
|
|
filters = request.data.get("filters", {}) or {}
|
|
location_context = request.data.get("location_context", "")
|
|
|
|
if not all([collection_id, date, category]):
|
|
return Response(
|
|
{"error": "collection_id, date, and category are required"},
|
|
status=status.HTTP_400_BAD_REQUEST,
|
|
)
|
|
|
|
valid_categories = ["restaurant", "activity", "event", "lodging"]
|
|
if category not in valid_categories:
|
|
return Response(
|
|
{"error": f"category must be one of: {', '.join(valid_categories)}"},
|
|
status=status.HTTP_400_BAD_REQUEST,
|
|
)
|
|
|
|
collection = get_object_or_404(Collection, id=collection_id)
|
|
if (
|
|
collection.user != request.user
|
|
and not collection.shared_with.filter(id=request.user.id).exists()
|
|
):
|
|
return Response(
|
|
{"error": "You don't have access to this collection"},
|
|
status=status.HTTP_403_FORBIDDEN,
|
|
)
|
|
|
|
location = location_context or self._get_collection_location(collection)
|
|
system_prompt = get_system_prompt(request.user, collection)
|
|
provider, model = self._resolve_provider_and_model(request)
|
|
|
|
if not is_chat_provider_available(provider):
|
|
return Response(
|
|
{
|
|
"error": "AI suggestions are not available. Please configure an API key."
|
|
},
|
|
status=status.HTTP_503_SERVICE_UNAVAILABLE,
|
|
)
|
|
|
|
try:
|
|
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,
|
|
location=location,
|
|
date=date,
|
|
collection=collection,
|
|
places_context=places_context,
|
|
)
|
|
|
|
suggestions = self._get_suggestions_from_llm(
|
|
system_prompt=system_prompt,
|
|
user_prompt=prompt,
|
|
user=request.user,
|
|
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)
|
|
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,
|
|
}
|
|
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,
|
|
)
|
|
|
|
def _get_collection_location(self, collection):
|
|
for loc in collection.locations.select_related("city", "country").all():
|
|
if loc.city:
|
|
city_name = getattr(loc.city, "name", str(loc.city))
|
|
country_name = getattr(loc.country, "name", "") if loc.country else ""
|
|
return ", ".join([x for x in [city_name, country_name] if x])
|
|
if loc.location:
|
|
return loc.location
|
|
if loc.name:
|
|
return loc.name
|
|
return "Unknown location"
|
|
|
|
def _build_prompt(
|
|
self,
|
|
category,
|
|
filters,
|
|
location,
|
|
date,
|
|
collection,
|
|
places_context="",
|
|
):
|
|
category_prompts = {
|
|
"restaurant": f"Find restaurant recommendations for {location}",
|
|
"activity": f"Find activity recommendations for {location}",
|
|
"event": f"Find event recommendations for {location} around {date}",
|
|
"lodging": f"Find lodging recommendations for {location}",
|
|
}
|
|
|
|
prompt = category_prompts.get(
|
|
category, f"Find {category} recommendations for {location}"
|
|
)
|
|
|
|
if filters:
|
|
filter_parts = []
|
|
if filters.get("cuisine_type"):
|
|
filter_parts.append(f"cuisine type: {filters['cuisine_type']}")
|
|
if filters.get("price_range"):
|
|
filter_parts.append(f"price range: {filters['price_range']}")
|
|
if filters.get("dietary"):
|
|
filter_parts.append(f"dietary restrictions: {filters['dietary']}")
|
|
if filters.get("activity_type"):
|
|
filter_parts.append(f"type: {filters['activity_type']}")
|
|
if filters.get("duration"):
|
|
filter_parts.append(f"duration: {filters['duration']}")
|
|
if filters.get("event_type"):
|
|
filter_parts.append(f"event type: {filters['event_type']}")
|
|
if filters.get("lodging_type"):
|
|
filter_parts.append(f"lodging type: {filters['lodging_type']}")
|
|
amenities = filters.get("amenities")
|
|
if isinstance(amenities, list) and amenities:
|
|
filter_parts.append(
|
|
f"amenities: {', '.join(str(x) for x in amenities)}"
|
|
)
|
|
|
|
if filter_parts:
|
|
prompt += f" with these preferences: {', '.join(filter_parts)}"
|
|
|
|
prompt += f". The trip date is {date}."
|
|
|
|
if collection.start_date or collection.end_date:
|
|
prompt += (
|
|
" Collection trip window: "
|
|
f"{collection.start_date or 'unknown'} to {collection.end_date or 'unknown'}."
|
|
)
|
|
|
|
if places_context:
|
|
prompt += f" Nearby place context: {places_context}."
|
|
|
|
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 _fetch_place_candidates(self, user, category, location):
|
|
tool_category_map = {
|
|
"restaurant": "food",
|
|
"activity": "tourism",
|
|
"event": "tourism",
|
|
"lodging": "lodging",
|
|
}
|
|
result = search_places(
|
|
user,
|
|
location=location,
|
|
category=tool_category_map.get(category, "tourism"),
|
|
radius=8,
|
|
)
|
|
if not isinstance(result, dict):
|
|
return []
|
|
if result.get("error"):
|
|
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 place_candidates[:5]:
|
|
name = place.get("name")
|
|
address = place.get("address") or ""
|
|
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
|
|
|
|
user_settings = UserAISettings.objects.filter(user=request.user).first() # type: ignore[attr-defined]
|
|
preferred_provider = (
|
|
(user_settings.preferred_provider or "").strip().lower()
|
|
if user_settings and user_settings.preferred_provider
|
|
else None
|
|
)
|
|
preferred_model = (
|
|
(user_settings.preferred_model or "").strip()
|
|
if user_settings and user_settings.preferred_model
|
|
else None
|
|
)
|
|
|
|
settings_provider = (settings.VOYAGE_AI_PROVIDER or "").strip().lower() or None
|
|
|
|
provider = request_provider or preferred_provider or settings_provider
|
|
if not provider or not is_chat_provider_available(provider):
|
|
provider = (
|
|
settings_provider
|
|
if is_chat_provider_available(settings_provider)
|
|
else None
|
|
)
|
|
if not provider or not is_chat_provider_available(provider):
|
|
provider = "openai" if is_chat_provider_available("openai") else provider
|
|
|
|
provider_config = CHAT_PROVIDER_CONFIG.get(provider or "", {})
|
|
default_model = (
|
|
(settings.VOYAGE_AI_MODEL or "").strip()
|
|
if provider == settings_provider and settings.VOYAGE_AI_MODEL
|
|
else None
|
|
) or provider_config.get("default_model")
|
|
|
|
model_from_user_defaults = (
|
|
preferred_model
|
|
if preferred_provider and provider == preferred_provider
|
|
else None
|
|
)
|
|
model = request_model or model_from_user_defaults or default_model
|
|
return provider, model
|
|
|
|
def _get_suggestions_from_llm(
|
|
self, system_prompt, user_prompt, user, provider, model
|
|
):
|
|
api_key = get_llm_api_key(user, provider)
|
|
if not api_key:
|
|
raise ValueError("No API key available")
|
|
|
|
provider_config = CHAT_PROVIDER_CONFIG.get(provider or "", {})
|
|
resolved_model = normalize_gateway_model(
|
|
provider,
|
|
model or provider_config.get("default_model"),
|
|
)
|
|
if not resolved_model:
|
|
raise ValueError("No model configured for provider")
|
|
|
|
completion_kwargs = {
|
|
"model": resolved_model,
|
|
"messages": [
|
|
{"role": "system", "content": system_prompt},
|
|
{"role": "user", "content": user_prompt},
|
|
],
|
|
"api_key": api_key,
|
|
"max_tokens": 1000,
|
|
}
|
|
|
|
if provider_config.get("api_base"):
|
|
completion_kwargs["api_base"] = provider_config["api_base"]
|
|
|
|
response = litellm.completion(
|
|
**completion_kwargs,
|
|
)
|
|
|
|
content = (response.choices[0].message.content or "").strip()
|
|
try:
|
|
json_match = re.search(r"\[.*\]", content, re.DOTALL)
|
|
parsed = (
|
|
json.loads(json_match.group())
|
|
if json_match
|
|
else json.loads(content or "[]")
|
|
)
|
|
suggestions = parsed if isinstance(parsed, list) else [parsed]
|
|
return suggestions[:5]
|
|
except json.JSONDecodeError:
|
|
return []
|