machinaos 0.0.1

package/server/services/maps.py

@@ -0,0 +1,289 @@
+"""Google Maps service for location operations."""
+
+import time
+import googlemaps
+from datetime import datetime
+from typing import Dict, Any
+
+from core.config import Settings
+from core.logging import get_logger, log_execution_time
+from services.auth import AuthService
+
+logger = get_logger(__name__)
+
+
+class MapsService:
+    """Google Maps and Places API service."""
+
+    def __init__(self, auth_service: AuthService, settings: Settings):
+        self.auth = auth_service
+        self.settings = settings
+
+    def validate_coordinates(self, lat: float, lng: float) -> bool:
+        """Validate latitude and longitude."""
+        return -90 <= lat <= 90 and -180 <= lng <= 180
+
+    def validate_zoom_level(self, zoom: int) -> bool:
+        """Validate Google Maps zoom level."""
+        return 0 <= zoom <= 21
+
+    async def create_map(self, node_id: str, parameters: Dict[str, Any]) -> Dict[str, Any]:
+        """Create Google Maps configuration."""
+        start_time = time.time()
+
+        try:
+            api_key = parameters.get('api_key') or self.settings.google_maps_api_key
+            if not api_key:
+                raise ValueError("Google Maps API key is required")
+
+            # Extract and validate parameters (snake_case)
+            lat = float(parameters.get('lat', 40.7128))
+            lng = float(parameters.get('lng', -74.0060))
+            zoom = int(parameters.get('zoom', 13))
+            map_type = parameters.get('map_type_id', 'ROADMAP')
+
+            if not self.validate_coordinates(lat, lng):
+                raise ValueError("Invalid coordinates")
+            if not self.validate_zoom_level(zoom):
+                raise ValueError("Invalid zoom level")
+            if map_type not in ['ROADMAP', 'SATELLITE', 'HYBRID', 'TERRAIN']:
+                raise ValueError("Invalid map type")
+
+            result = {
+                "map_config": {
+                    "center": {"lat": lat, "lng": lng},
+                    "zoom": zoom,
+                    "mapTypeId": map_type
+                },
+                "static_map_url": f"https://maps.googleapis.com/maps/api/staticmap?center={lat},{lng}&zoom={zoom}&size=600x400&maptype={map_type.lower()}&key={api_key}",
+                "status": "OK"
+            }
+
+            log_execution_time(logger, "create_map", start_time, time.time())
+
+            return {
+                "success": True,
+                "node_id": node_id,
+                "node_type": "createMap",
+                "operation": "map_initialization",
+                "result": result,
+                "execution_time": time.time() - start_time,
+                "timestamp": datetime.now().isoformat()
+            }
+
+        except Exception as e:
+            logger.error("Create map failed", node_id=node_id, error=str(e))
+            return {
+                "success": False,
+                "node_id": node_id,
+                "node_type": "createMap",
+                "error": str(e),
+                "execution_time": time.time() - start_time,
+                "timestamp": datetime.now().isoformat()
+            }
+
+    async def geocode_location(self, node_id: str, parameters: Dict[str, Any]) -> Dict[str, Any]:
+        """Geocode addresses or reverse geocode coordinates."""
+        start_time = time.time()
+
+        try:
+            api_key = parameters.get('api_key') or self.settings.google_maps_api_key
+            if not api_key:
+                raise ValueError("Google Maps API key is required")
+
+            gmaps = googlemaps.Client(key=api_key)
+            service_type = parameters.get('service_type', 'geocode')
+
+            if service_type == 'geocode':
+                address = parameters.get('address', '')
+                if not address:
+                    raise ValueError("Address is required for geocoding")
+
+                geocode_result = gmaps.geocode(address=address)
+                result = {
+                    "service_type": "geocoding",
+                    "input": {"address": address},
+                    "results": geocode_result,
+                    "status": "OK" if geocode_result else "ZERO_RESULTS"
+                }
+
+            elif service_type == 'reverse_geocode':
+                lat = float(parameters.get('lat', 0))
+                lng = float(parameters.get('lng', 0))
+
+                if not self.validate_coordinates(lat, lng):
+                    raise ValueError("Invalid coordinates")
+
+                reverse_result = gmaps.reverse_geocode((lat, lng))
+                result = {
+                    "service_type": "reverse_geocoding",
+                    "input": {"lat": lat, "lng": lng},
+                    "results": reverse_result,
+                    "status": "OK" if reverse_result else "ZERO_RESULTS"
+                }
+
+            else:
+                raise ValueError(f"Unsupported service type: {service_type}")
+
+            log_execution_time(logger, f"geocoding_{service_type}", start_time, time.time())
+
+            return {
+                "success": True,
+                "node_id": node_id,
+                "node_type": "addLocations",
+                "operation": service_type,
+                "result": result,
+                "execution_time": time.time() - start_time,
+                "timestamp": datetime.now().isoformat()
+            }
+
+        except googlemaps.exceptions.ApiError as e:
+            logger.error("Google Maps API error", node_id=node_id, error=str(e))
+            return {
+                "success": False,
+                "node_id": node_id,
+                "node_type": "addLocations",
+                "error": f"Google Maps API error: {str(e)}",
+                "execution_time": time.time() - start_time,
+                "timestamp": datetime.now().isoformat()
+            }
+
+        except Exception as e:
+            logger.error("Geocoding failed", node_id=node_id, error=str(e))
+            return {
+                "success": False,
+                "node_id": node_id,
+                "node_type": "addLocations",
+                "error": str(e),
+                "execution_time": time.time() - start_time,
+                "timestamp": datetime.now().isoformat()
+            }
+
+    async def find_nearby_places(self, node_id: str, parameters: Dict[str, Any]) -> Dict[str, Any]:
+        """Find nearby places using Google Places API."""
+        start_time = time.time()
+
+        try:
+            api_key = parameters.get('api_key') or self.settings.google_maps_api_key
+            if not api_key:
+                raise ValueError("Google Maps API key is required")
+
+            gmaps = googlemaps.Client(key=api_key)
+
+            # Extract and validate parameters
+            lat = float(parameters.get('lat', 40.7484))
+            lng = float(parameters.get('lng', -73.9857))
+            radius = int(parameters.get('radius', 500))
+
+            if not self.validate_coordinates(lat, lng):
+                raise ValueError("Invalid coordinates")
+            if not (1 <= radius <= 50000):
+                raise ValueError("Radius must be between 1 and 50000 meters")
+
+            # Optional parameters (snake_case)
+            place_type = parameters.get('type', 'restaurant')
+            page_size = min(int(parameters.get('page_size', 20)), 20)
+
+            # Extract options (may contain keyword, name, min_price, max_price, open_now, language, rank_by)
+            options = parameters.get('options', {})
+
+            # Support both nested options and top-level parameters (snake_case)
+            keyword = options.get('keyword', '') if isinstance(options, dict) else parameters.get('keyword', '')
+            name_filter = options.get('name', '') if isinstance(options, dict) else parameters.get('name', '')
+            min_price = options.get('min_price') if isinstance(options, dict) else parameters.get('min_price')
+            max_price = options.get('max_price') if isinstance(options, dict) else parameters.get('max_price')
+            open_now = options.get('open_now', False) if isinstance(options, dict) else parameters.get('open_now', False)
+            language = options.get('language', 'en') if isinstance(options, dict) else parameters.get('language', 'en')
+            rank_by = options.get('rank_by', 'prominence') if isinstance(options, dict) else parameters.get('rank_by', 'prominence')
+
+            logger.debug("[Nearby Places] Extracted parameters",
+                        keyword=keyword,
+                        name_filter=name_filter,
+                        min_price=min_price,
+                        max_price=max_price,
+                        open_now=open_now,
+                        language=language,
+                        rank_by=rank_by,
+                        place_type=place_type)
+
+            # Build search request
+            search_params = {
+                'location': (lat, lng),
+                'type': place_type
+            }
+
+            # Add radius unless ranking by distance
+            if rank_by != 'distance':
+                search_params['radius'] = radius
+            else:
+                search_params['rank_by'] = rank_by
+
+            # Add optional parameters
+            if keyword:
+                search_params['keyword'] = keyword
+            if name_filter:
+                search_params['name'] = name_filter
+            if min_price is not None and min_price != '':
+                search_params['min_price'] = int(min_price)
+            if max_price is not None and max_price != '':
+                search_params['max_price'] = int(max_price)
+            if open_now:
+                search_params['open_now'] = True
+            if language:
+                search_params['language'] = language
+
+            nearby_result = gmaps.places_nearby(**search_params)
+            results = nearby_result.get('results', [])[:page_size]
+
+            result = {
+                "search_parameters": {
+                    "location": {"lat": lat, "lng": lng},
+                    "radius": radius if rank_by != 'distance' else None,
+                    "type": place_type,
+                    "keyword": keyword or None,
+                    "name_filter": name_filter or None,
+                    "min_price": min_price if min_price not in [None, ''] else None,
+                    "max_price": max_price if max_price not in [None, ''] else None,
+                    "open_now": open_now,
+                    "language": language,
+                    "rank_by": rank_by,
+                    "page_size": page_size
+                },
+                "results": results,
+                "total_results": len(results),
+                "status": nearby_result.get('status', 'OK')
+            }
+
+            log_execution_time(logger, "nearby_places", start_time, time.time())
+
+            return {
+                "success": True,
+                "node_id": node_id,
+                "node_type": "showNearbyPlaces",
+                "operation": "nearby_search",
+                "result": result,
+                "execution_time": time.time() - start_time,
+                "timestamp": datetime.now().isoformat()
+            }
+
+        except googlemaps.exceptions.ApiError as e:
+            logger.error("Google Places API error", node_id=node_id, error=str(e))
+            return {
+                "success": False,
+                "node_id": node_id,
+                "node_type": "showNearbyPlaces",
+                "error": f"Google Places API error: {str(e)}",
+                "execution_time": time.time() - start_time,
+                "timestamp": datetime.now().isoformat()
+            }
+
+        except Exception as e:
+            logger.error("Nearby places search failed", node_id=node_id, error=str(e))
+            return {
+                "success": False,
+                "node_id": node_id,
+                "node_type": "showNearbyPlaces",
+                "error": str(e),
+                "execution_time": time.time() - start_time,
+                "timestamp": datetime.now().isoformat()
+            }

package/server/services/memory_store.py

@@ -0,0 +1,103 @@
+"""Simple in-memory conversation storage for AI agents.
+
+Uses standard Python data structures with LangChain message compatibility.
+No deprecated APIs - follows LangChain 0.3+ recommendations.
+"""
+from typing import Dict, List, Optional, Callable
+from dataclasses import dataclass, field
+from datetime import datetime
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class Message:
+    """Single conversation message."""
+    role: str  # 'human' or 'ai'
+    content: str
+    timestamp: str = field(default_factory=lambda: datetime.now().isoformat())
+
+
+@dataclass
+class ConversationSession:
+    """Conversation session with message history."""
+    session_id: str
+    messages: List[Message] = field(default_factory=list)
+    created_at: str = field(default_factory=lambda: datetime.now().isoformat())
+
+
+# Global in-memory store
+_sessions: Dict[str, ConversationSession] = {}
+
+
+def get_session(session_id: str) -> ConversationSession:
+    """Get or create a conversation session."""
+    if session_id not in _sessions:
+        _sessions[session_id] = ConversationSession(session_id=session_id)
+        logger.info(f"[Memory] Created new session: {session_id}")
+    return _sessions[session_id]
+
+
+def add_message(session_id: str, role: str, content: str) -> None:
+    """Add a message to a session."""
+    session = get_session(session_id)
+    session.messages.append(Message(role=role, content=content))
+    logger.info(f"[Memory] Added {role} message to session '{session_id}' (total: {len(session.messages)})")
+
+
+def get_messages(session_id: str, window_size: Optional[int] = None) -> List[Dict]:
+    """Get messages from a session, optionally limited to last N."""
+    session = get_session(session_id)
+    messages = session.messages
+    if window_size and window_size > 0:
+        messages = messages[-window_size:]
+    return [{"role": m.role, "content": m.content, "timestamp": m.timestamp} for m in messages]
+
+
+def clear_session(session_id: str) -> int:
+    """Clear a session's messages. Returns count of cleared messages."""
+    if session_id in _sessions:
+        count = len(_sessions[session_id].messages)
+        _sessions[session_id].messages = []
+        logger.info(f"[Memory] Cleared {count} messages from session '{session_id}'")
+        return count
+    return 0
+
+
+def delete_session(session_id: str) -> bool:
+    """Delete a session entirely. Returns True if session existed."""
+    if session_id in _sessions:
+        del _sessions[session_id]
+        logger.info(f"[Memory] Deleted session: {session_id}")
+        return True
+    return False
+
+
+def get_all_sessions() -> List[Dict]:
+    """Get info about all sessions."""
+    return [
+        {
+            "session_id": s.session_id,
+            "message_count": len(s.messages),
+            "created_at": s.created_at
+        }
+        for s in _sessions.values()
+    ]
+
+
+def get_langchain_messages(session_id: str, window_size: Optional[int] = None):
+    """Convert session messages to LangChain message format.
+
+    Uses langchain_core.messages (modern API, not deprecated).
+    """
+    from langchain_core.messages import HumanMessage, AIMessage
+
+    messages = get_messages(session_id, window_size)
+    lc_messages = []
+    for m in messages:
+        if m['role'] == 'human':
+            lc_messages.append(HumanMessage(content=m['content']))
+        elif m['role'] == 'ai':
+            lc_messages.append(AIMessage(content=m['content']))
+    return lc_messages