machinaos 0.0.78 → 0.0.80

package/server/nodes/groups.py

@@ -22,37 +22,37 @@ from services.node_registry import register_group
 # Normal-mode groups (visible in simple mode — the core agent building blocks)
 # ---------------------------------------------------------------------------
 
-register_group(key="agent",       metadata={"label": "AI Agents",    "icon": "🤖", "color": "#bd93f9", "visibility": "normal"})
-register_group(key="model",       metadata={"label": "AI Models",    "icon": "🧬", "color": "#8be9fd", "visibility": "normal"})
-register_group(key="skill",       metadata={"label": "AI Skills",    "icon": "🎯", "color": "#50fa7b", "visibility": "normal"})
-register_group(key="tool",        metadata={"label": "AI Tools",     "icon": "🛠️", "color": "#50fa7b", "visibility": "normal"})
+register_group(key="agent", metadata={"label": "AI Agents", "icon": "🤖", "color": "#bd93f9", "visibility": "normal"})
+register_group(key="model", metadata={"label": "AI Models", "icon": "🧬", "color": "#8be9fd", "visibility": "normal"})
+register_group(key="skill", metadata={"label": "AI Skills", "icon": "🎯", "color": "#50fa7b", "visibility": "normal"})
+register_group(key="tool", metadata={"label": "AI Tools", "icon": "🛠️", "color": "#50fa7b", "visibility": "normal"})
 
 
 # ---------------------------------------------------------------------------
 # Dev-mode groups (shown when pro/dev mode is toggled on)
 # ---------------------------------------------------------------------------
 
-register_group(key="workflow",    metadata={"label": "Workflows",         "icon": "⚡",  "color": "#ffb86c", "visibility": "dev"})
-register_group(key="trigger",     metadata={"label": "Triggers",          "icon": "🕐", "color": "#ff79c6", "visibility": "dev"})
-register_group(key="ai",          metadata={"label": "AI",                "icon": "🤖", "color": "#bd93f9", "visibility": "dev"})
-register_group(key="location",    metadata={"label": "Location",          "icon": "📍", "color": "#ff5555", "visibility": "dev"})
-register_group(key="social",      metadata={"label": "Social",            "icon": "📱", "color": "#50fa7b", "visibility": "dev"})
-register_group(key="android",     metadata={"label": "Android",           "icon": "📱", "color": "#8be9fd", "visibility": "dev"})
-register_group(key="chat",        metadata={"label": "Chat",              "icon": "💭", "color": "#f1fa8c", "visibility": "dev"})
-register_group(key="code",        metadata={"label": "Code",              "icon": "💻", "color": "#ffb86c", "visibility": "dev"})
-register_group(key="document",    metadata={"label": "Documents",         "icon": "🗄️", "color": "#ff79c6", "visibility": "dev"})
-register_group(key="utility",     metadata={"label": "Utilities",         "icon": "🔧", "color": "#bd93f9", "visibility": "dev"})
-register_group(key="api",         metadata={"label": "API & Scraping",    "icon": "🕷️", "color": "#ffb86c", "visibility": "dev"})
-register_group(key="search",      metadata={"label": "Search",            "icon": "🔍", "color": "#8be9fd", "visibility": "dev"})
-register_group(key="google",      metadata={"label": "Google Workspace",  "icon": "asset:google", "color": "#4285F4", "visibility": "dev"})
-register_group(key="scheduler",   metadata={"label": "Schedulers",        "icon": "📅", "color": "#ff79c6", "visibility": "dev"})
-register_group(key="proxy",       metadata={"label": "Proxy",             "icon": "🛡", "color": "#bd93f9", "visibility": "dev"})
-register_group(key="whatsapp",    metadata={"label": "WhatsApp",          "icon": "💬", "color": "#25D366", "visibility": "dev"})
-register_group(key="email",       metadata={"label": "Email",             "icon": "✉️", "color": "#8be9fd", "visibility": "dev"})
-register_group(key="payments",    metadata={"label": "Payments",          "icon": "asset:stripe", "color": "#635BFF", "visibility": "dev"})
-register_group(key="browser",     metadata={"label": "Browser",           "icon": "🌐", "color": "#ff79c6", "visibility": "dev"})
-register_group(key="scraper",     metadata={"label": "Scrapers",          "icon": "🕸", "color": "#ff79c6", "visibility": "dev"})
-register_group(key="filesystem",  metadata={"label": "Filesystem",        "icon": "📁", "color": "#8be9fd", "visibility": "dev"})
-register_group(key="service",     metadata={"label": "Services",          "icon": "⚙️", "color": "#50fa7b", "visibility": "dev"})
-register_group(key="text",        metadata={"label": "Text",              "icon": "📝", "color": "#bd93f9", "visibility": "dev"})
-register_group(key="memory",      metadata={"label": "Memory",            "icon": "💾", "color": "#f1fa8c", "visibility": "dev"})
+register_group(key="workflow", metadata={"label": "Workflows", "icon": "⚡", "color": "#ffb86c", "visibility": "dev"})
+register_group(key="trigger", metadata={"label": "Triggers", "icon": "🕐", "color": "#ff79c6", "visibility": "dev"})
+register_group(key="ai", metadata={"label": "AI", "icon": "🤖", "color": "#bd93f9", "visibility": "dev"})
+register_group(key="location", metadata={"label": "Location", "icon": "📍", "color": "#ff5555", "visibility": "dev"})
+register_group(key="social", metadata={"label": "Social", "icon": "📱", "color": "#50fa7b", "visibility": "dev"})
+register_group(key="android", metadata={"label": "Android", "icon": "📱", "color": "#8be9fd", "visibility": "dev"})
+register_group(key="chat", metadata={"label": "Chat", "icon": "💭", "color": "#f1fa8c", "visibility": "dev"})
+register_group(key="code", metadata={"label": "Code", "icon": "💻", "color": "#ffb86c", "visibility": "dev"})
+register_group(key="document", metadata={"label": "Documents", "icon": "🗄️", "color": "#ff79c6", "visibility": "dev"})
+register_group(key="utility", metadata={"label": "Utilities", "icon": "🔧", "color": "#bd93f9", "visibility": "dev"})
+register_group(key="api", metadata={"label": "API & Scraping", "icon": "🕷️", "color": "#ffb86c", "visibility": "dev"})
+register_group(key="search", metadata={"label": "Search", "icon": "🔍", "color": "#8be9fd", "visibility": "dev"})
+register_group(key="google", metadata={"label": "Google Workspace", "icon": "asset:google", "color": "#4285F4", "visibility": "dev"})
+register_group(key="scheduler", metadata={"label": "Schedulers", "icon": "📅", "color": "#ff79c6", "visibility": "dev"})
+register_group(key="proxy", metadata={"label": "Proxy", "icon": "🛡", "color": "#bd93f9", "visibility": "dev"})
+register_group(key="whatsapp", metadata={"label": "WhatsApp", "icon": "💬", "color": "#25D366", "visibility": "dev"})
+register_group(key="email", metadata={"label": "Email", "icon": "✉️", "color": "#8be9fd", "visibility": "dev"})
+register_group(key="payments", metadata={"label": "Payments", "icon": "asset:stripe", "color": "#635BFF", "visibility": "dev"})
+register_group(key="browser", metadata={"label": "Browser", "icon": "🌐", "color": "#ff79c6", "visibility": "dev"})
+register_group(key="scraper", metadata={"label": "Scrapers", "icon": "🕸", "color": "#ff79c6", "visibility": "dev"})
+register_group(key="filesystem", metadata={"label": "Filesystem", "icon": "📁", "color": "#8be9fd", "visibility": "dev"})
+register_group(key="service", metadata={"label": "Services", "icon": "⚙️", "color": "#50fa7b", "visibility": "dev"})
+register_group(key="text", metadata={"label": "Text", "icon": "📝", "color": "#bd93f9", "visibility": "dev"})
+register_group(key="memory", metadata={"label": "Memory", "icon": "💾", "color": "#f1fa8c", "visibility": "dev"})

package/server/nodes/location/__init__.py

@@ -1 +1,31 @@
-"""Plugins for the 'location' palette group. See ../__init__.py for the package layout."""
+"""Plugins for the 'location' palette group. See ../__init__.py for the package layout.
+
+Self-registration on import:
+  - Wave 12 C4 sub-piece C: ``MapsService`` is published as the
+    ``"maps"`` service factory via
+    ``services.plugin.service_factories.register_service_factory``.
+    The DI container's ``maps_service`` provider looks up the factory
+    at instantiation time, so the framework no longer carries a
+    top-level ``from nodes.location._service import MapsService``.
+  - Eager-import the three gmaps subpackages so their ``BaseNode``
+    subclasses auto-register regardless of ``pkgutil.walk_packages``
+    recursion behaviour. The conftest plugin-discovery path was
+    occasionally skipping nested subpackages on CI Linux; this
+    belt-and-braces approach makes the registration deterministic.
+"""
+
+from services.plugin.service_factories import register_service_factory
+
+from ._service import MapsService
+
+# Eager-import the three gmaps subpackages so their ``BaseNode``
+# subclasses auto-register regardless of ``pkgutil.walk_packages``
+# recursion quirks on CI Linux. The factory call below runs
+# unconditionally after these — if any eager import raises, the
+# exception propagates and ``nodes/__init__.py:_discover`` catches +
+# logs it (and the factory test will catch the missing registration).
+from . import gmaps_create as _gmaps_create  # noqa: F401 — registers GmapsCreateNode
+from . import gmaps_locations as _gmaps_locations  # noqa: F401 — registers GmapsLocationsNode
+from . import gmaps_nearby_places as _gmaps_nearby_places  # noqa: F401 — registers GmapsNearbyPlacesNode
+
+register_service_factory("maps", MapsService)

package/server/nodes/location/_credentials.py

@@ -25,7 +25,6 @@ class GoogleMapsCredential(ApiKeyCredential):
     id = "google_maps"
     display_name = "Google Maps"
     category = "Location"
-    icon = "asset:google_maps"
     key_name = "key"
     key_location = "query"
     docs_url = "https://developers.google.com/maps/documentation"
@@ -57,9 +56,5 @@ class GoogleMapsCredential(ApiKeyCredential):
             )
         return ProbeResult(
             valid=True,
-            message=(
-                "Google Maps API key is valid"
-                if status == "OK"
-                else f"API key is valid (status: {status})"
-            ),
+            message=("Google Maps API key is valid" if status == "OK" else f"API key is valid (status: {status})"),
         )

package/server/nodes/location/_service.py

@@ -29,11 +29,7 @@ logger = get_logger(__name__)
 
 
 async def _track_maps_usage(
-    node_id: str,
-    action: str,
-    resource_count: int = 1,
-    workflow_id: str = None,
-    session_id: str = "default"
+    node_id: str, action: str, resource_count: int = 1, workflow_id: str = None, session_id: str = "default"
 ) -> Dict[str, float]:
     """Track Google Maps API usage for cost calculation.
 
@@ -50,20 +46,22 @@ async def _track_maps_usage(
     from services.plugin.deps import get_database
 
     pricing = get_pricing_service()
-    cost_data = pricing.calculate_api_cost('google_maps', action, resource_count)
+    cost_data = pricing.calculate_api_cost("google_maps", action, resource_count)
 
     # Save to database
     db = get_database()
-    await db.save_api_usage_metric({
-        'session_id': session_id,
-        'node_id': node_id,
-        'workflow_id': workflow_id,
-        'service': 'google_maps',
-        'operation': cost_data.get('operation', action),
-        'endpoint': action,
-        'resource_count': resource_count,
-        'cost': cost_data.get('total_cost', 0.0)
-    })
+    await db.save_api_usage_metric(
+        {
+            "session_id": session_id,
+            "node_id": node_id,
+            "workflow_id": workflow_id,
+            "service": "google_maps",
+            "operation": cost_data.get("operation", action),
+            "endpoint": action,
+            "resource_count": resource_count,
+            "cost": cost_data.get("total_cost", 0.0),
+        }
+    )
 
     logger.debug(f"[Maps] Tracked usage: {action} x{resource_count} = ${cost_data.get('total_cost', 0):.6f}")
     return cost_data
@@ -90,38 +88,31 @@ class MapsService:
         context = context or {}
 
         try:
-            api_key = parameters.get('api_key') or self.settings.google_maps_api_key
+            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')
+            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']:
+            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
-                },
+                "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"
+                "status": "OK",
             }
 
             # Track: static_map $0.002
-            await _track_maps_usage(
-                node_id, 'static_map', 1,
-                context.get('workflow_id'), context.get('session_id', 'default')
-            )
+            await _track_maps_usage(node_id, "static_map", 1, context.get("workflow_id"), context.get("session_id", "default"))
 
             log_execution_time(logger, "create_map", start_time, time.time())
 
@@ -132,7 +123,7 @@ class MapsService:
                 "operation": "map_initialization",
                 "result": result,
                 "execution_time": time.time() - start_time,
-                "timestamp": datetime.now().isoformat()
+                "timestamp": datetime.now().isoformat(),
             }
 
         except Exception as e:
@@ -143,7 +134,7 @@ class MapsService:
                 "node_type": "gmaps_create",
                 "error": str(e),
                 "execution_time": time.time() - start_time,
-                "timestamp": datetime.now().isoformat()
+                "timestamp": datetime.now().isoformat(),
             }
 
     async def geocode_location(self, node_id: str, parameters: Dict[str, Any], context: Dict[str, Any] = None) -> Dict[str, Any]:
@@ -152,15 +143,15 @@ class MapsService:
         context = context or {}
 
         try:
-            api_key = parameters.get('api_key') or self.settings.google_maps_api_key
+            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')
+            service_type = parameters.get("service_type", "geocode")
 
-            if service_type == 'geocode':
-                address = parameters.get('address', '')
+            if service_type == "geocode":
+                address = parameters.get("address", "")
                 if not address:
                     raise ValueError("Address is required for geocoding")
 
@@ -169,17 +160,14 @@ class MapsService:
                     "service_type": "geocoding",
                     "input": {"address": address},
                     "results": geocode_result,
-                    "status": "OK" if geocode_result else "ZERO_RESULTS"
+                    "status": "OK" if geocode_result else "ZERO_RESULTS",
                 }
                 # Track: geocode $0.005
-                await _track_maps_usage(
-                    node_id, 'geocode', 1,
-                    context.get('workflow_id'), context.get('session_id', 'default')
-                )
+                await _track_maps_usage(node_id, "geocode", 1, context.get("workflow_id"), context.get("session_id", "default"))
 
-            elif service_type == 'reverse_geocode':
-                lat = float(parameters.get('lat', 0))
-                lng = float(parameters.get('lng', 0))
+            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")
@@ -189,13 +177,10 @@ class MapsService:
                     "service_type": "reverse_geocoding",
                     "input": {"lat": lat, "lng": lng},
                     "results": reverse_result,
-                    "status": "OK" if reverse_result else "ZERO_RESULTS"
+                    "status": "OK" if reverse_result else "ZERO_RESULTS",
                 }
                 # Track: reverse_geocode $0.005
-                await _track_maps_usage(
-                    node_id, 'reverse_geocode', 1,
-                    context.get('workflow_id'), context.get('session_id', 'default')
-                )
+                await _track_maps_usage(node_id, "reverse_geocode", 1, context.get("workflow_id"), context.get("session_id", "default"))
 
             else:
                 raise ValueError(f"Unsupported service type: {service_type}")
@@ -209,7 +194,7 @@ class MapsService:
                 "operation": service_type,
                 "result": result,
                 "execution_time": time.time() - start_time,
-                "timestamp": datetime.now().isoformat()
+                "timestamp": datetime.now().isoformat(),
             }
 
         except googlemaps.exceptions.ApiError as e:
@@ -220,7 +205,7 @@ class MapsService:
                 "node_type": "gmaps_locations",
                 "error": f"Google Maps API error: {str(e)}",
                 "execution_time": time.time() - start_time,
-                "timestamp": datetime.now().isoformat()
+                "timestamp": datetime.now().isoformat(),
             }
 
         except Exception as e:
@@ -231,7 +216,7 @@ class MapsService:
                 "node_type": "gmaps_locations",
                 "error": str(e),
                 "execution_time": time.time() - start_time,
-                "timestamp": datetime.now().isoformat()
+                "timestamp": datetime.now().isoformat(),
             }
 
     async def find_nearby_places(self, node_id: str, parameters: Dict[str, Any], context: Dict[str, Any] = None) -> Dict[str, Any]:
@@ -240,16 +225,16 @@ class MapsService:
         context = context or {}
 
         try:
-            api_key = parameters.get('api_key') or self.settings.google_maps_api_key
+            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))
+            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")
@@ -257,83 +242,79 @@ class MapsService:
                 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)
+            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', {})
+            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)
+            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
-            }
+            search_params = {"location": (lat, lng), "type": place_type}
 
             # Add radius unless ranking by distance
-            if rank_by != 'distance':
-                search_params['radius'] = radius
+            if rank_by != "distance":
+                search_params["radius"] = radius
             else:
-                search_params['rank_by'] = rank_by
+                search_params["rank_by"] = rank_by
 
             # Add optional parameters
             if keyword:
-                search_params['keyword'] = 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)
+                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
+                search_params["open_now"] = True
             if language:
-                search_params['language'] = language
+                search_params["language"] = language
 
             nearby_result = gmaps.places_nearby(**search_params)
-            results = nearby_result.get('results', [])[:page_size]
+            results = nearby_result.get("results", [])[:page_size]
 
             # Track: nearby_search $0.032
-            await _track_maps_usage(
-                node_id, 'nearby_search', 1,
-                context.get('workflow_id'), context.get('session_id', 'default')
-            )
+            await _track_maps_usage(node_id, "nearby_search", 1, context.get("workflow_id"), context.get("session_id", "default"))
 
             result = {
                 "search_parameters": {
                     "location": {"lat": lat, "lng": lng},
-                    "radius": radius if rank_by != 'distance' else None,
+                    "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,
+                    "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
+                    "page_size": page_size,
                 },
                 "results": results,
                 "total_results": len(results),
-                "status": nearby_result.get('status', 'OK')
+                "status": nearby_result.get("status", "OK"),
             }
 
             log_execution_time(logger, "nearby_places", start_time, time.time())
@@ -345,7 +326,7 @@ class MapsService:
                 "operation": "nearby_search",
                 "result": result,
                 "execution_time": time.time() - start_time,
-                "timestamp": datetime.now().isoformat()
+                "timestamp": datetime.now().isoformat(),
             }
 
         except googlemaps.exceptions.ApiError as e:
@@ -356,7 +337,7 @@ class MapsService:
                 "node_type": "gmaps_nearby_places",
                 "error": f"Google Places API error: {str(e)}",
                 "execution_time": time.time() - start_time,
-                "timestamp": datetime.now().isoformat()
+                "timestamp": datetime.now().isoformat(),
             }
 
         except Exception as e:
@@ -367,5 +348,5 @@ class MapsService:
                 "node_type": "gmaps_nearby_places",
                 "error": str(e),
                 "execution_time": time.time() - start_time,
-                "timestamp": datetime.now().isoformat()
-            }
+                "timestamp": datetime.now().isoformat(),
+            }

package/server/nodes/location/{gmaps_create.py → gmaps_create/__init__.py}

@@ -8,7 +8,7 @@ from pydantic import BaseModel, ConfigDict, Field
 
 from services.plugin import ActionNode, NodeContext, NodeUserError, Operation, TaskQueue
 
-from ._credentials import GoogleMapsCredential
+from .._credentials import GoogleMapsCredential
 
 
 class GmapsCreateParams(BaseModel):
@@ -46,10 +46,8 @@ class GmapsCreateNode(ActionNode):
     description = "Google Maps creation with center, zoom, and map type"
     component_kind = "square"
     handles = (
-        {"name": "input-main", "kind": "input", "position": "left",
-         "label": "Input", "role": "main"},
-        {"name": "output-main", "kind": "output", "position": "right",
-         "label": "Output", "role": "main"},
+        {"name": "input-main", "kind": "input", "position": "left", "label": "Input", "role": "main"},
+        {"name": "output-main", "kind": "output", "position": "right", "label": "Output", "role": "main"},
     )
     ui_hints = {"showLocationPanel": True}
     annotations = {"destructive": False, "readonly": True, "open_world": False}
@@ -65,7 +63,9 @@ class GmapsCreateNode(ActionNode):
 
         maps_service = get_maps_service()
         response = await maps_service.create_map(
-            ctx.node_id, params.model_dump(), ctx.raw,
+            ctx.node_id,
+            params.model_dump(),
+            ctx.raw,
         )
         if response.get("success"):
             return response.get("result") or response

package/server/nodes/location/gmaps_create/meta.json

@@ -0,0 +1,3 @@
+{
+  "color": "#50fa7b"
+}

package/server/nodes/location/{gmaps_locations.py → gmaps_locations/__init__.py}

@@ -8,7 +8,7 @@ from pydantic import BaseModel, ConfigDict, Field
 
 from services.plugin import ActionNode, NodeContext, NodeUserError, Operation, TaskQueue
 
-from ._credentials import GoogleMapsCredential
+from .._credentials import GoogleMapsCredential
 
 
 class GmapsLocationsParams(BaseModel):
@@ -56,11 +56,11 @@ class GmapsLocationsNode(ActionNode):
     group = ("location", "service", "tool")
     description = "Google Maps Geocoding service"
     component_kind = "square"
+    tool_name = "geocode"
+    tool_description = "Geocode addresses to coordinates or reverse geocode coordinates to addresses using Google Maps."
     handles = (
-        {"name": "input-main", "kind": "input", "position": "left",
-         "label": "Input", "role": "main"},
-        {"name": "output-main", "kind": "output", "position": "right",
-         "label": "Output", "role": "main"},
+        {"name": "input-main", "kind": "input", "position": "left", "label": "Input", "role": "main"},
+        {"name": "output-main", "kind": "output", "position": "right", "label": "Output", "role": "main"},
     )
     annotations = {"destructive": False, "readonly": True, "open_world": True}
     credentials = (GoogleMapsCredential,)
@@ -76,7 +76,9 @@ class GmapsLocationsNode(ActionNode):
 
         maps_service = get_maps_service()
         response = await maps_service.geocode_location(
-            ctx.node_id, params.model_dump(), ctx.raw,
+            ctx.node_id,
+            params.model_dump(),
+            ctx.raw,
         )
         if response.get("success"):
             return response.get("result") or response

package/server/nodes/location/gmaps_locations/meta.json

@@ -0,0 +1,3 @@
+{
+  "color": "#50fa7b"
+}

package/server/nodes/location/{gmaps_nearby_places.py → gmaps_nearby_places/__init__.py}

@@ -8,7 +8,7 @@ from pydantic import BaseModel, ConfigDict, Field
 
 from services.plugin import ActionNode, NodeContext, NodeUserError, Operation, TaskQueue
 
-from ._credentials import GoogleMapsCredential
+from .._credentials import GoogleMapsCredential
 
 
 class GmapsNearbyPlacesParams(BaseModel):
@@ -35,11 +35,11 @@ class GmapsNearbyPlacesNode(ActionNode):
     group = ("location", "service", "tool")
     description = "Google Places API nearbySearch"
     component_kind = "square"
+    tool_name = "nearby_places"
+    tool_description = "Search for nearby places (restaurants, hospitals, banks, etc.) using Google Maps Places API."
     handles = (
-        {"name": "input-main", "kind": "input", "position": "left",
-         "label": "Input", "role": "main"},
-        {"name": "output-main", "kind": "output", "position": "right",
-         "label": "Output", "role": "main"},
+        {"name": "input-main", "kind": "input", "position": "left", "label": "Input", "role": "main"},
+        {"name": "output-main", "kind": "output", "position": "right", "label": "Output", "role": "main"},
     )
     annotations = {"destructive": False, "readonly": True, "open_world": True}
     credentials = (GoogleMapsCredential,)
@@ -55,7 +55,9 @@ class GmapsNearbyPlacesNode(ActionNode):
 
         maps_service = get_maps_service()
         response = await maps_service.find_nearby_places(
-            ctx.node_id, params.model_dump(), ctx.raw,
+            ctx.node_id,
+            params.model_dump(),
+            ctx.raw,
         )
         if response.get("success"):
             return response.get("result") or response

package/server/nodes/location/gmaps_nearby_places/meta.json

@@ -0,0 +1,3 @@
+{
+  "color": "#50fa7b"
+}