feat: optimize hubspot tools (#393)

Author: zihaolin96

mcp_servers/hubspot/tools/deals.py

@@ -6,6 +6,28 @@
 # Configure logging
 logger = logging.getLogger(__name__)
 
+def _build_dealstage_label_map(client) -> dict:
+    """
+    Build a mapping from deal stage ID to its human-readable label across all deal pipelines.
+
+    Returns:
+    - dict mapping stage_id -> label (e.g., {"appointmentscheduled": "Appointment Scheduled", "1890285259": "POC"})
+    """
+    stage_id_to_label: dict = {}
+    try:
+        pipelines = client.crm.pipelines.pipelines_api.get_all("deals")
+        for pipeline in getattr(pipelines, "results", []) or []:
+            try:
+                stages = client.crm.pipelines.pipeline_stages_api.get_all("deals", pipeline.id)
+                for stage in getattr(stages, "results", []) or []:
+                    if getattr(stage, "id", None) and getattr(stage, "label", None):
+                        stage_id_to_label[stage.id] = stage.label
+            except Exception as inner_exc:
+                logger.debug(f"Failed to fetch stages for pipeline {getattr(pipeline, 'id', 'unknown')}: {inner_exc}")
+    except Exception as exc:
+        logger.debug(f"Failed to fetch pipelines for deals: {exc}")
+    return stage_id_to_label
+
 async def hubspot_get_deals(limit: int = 10):
     """
     Fetch a list of deals from HubSpot.
@@ -23,6 +45,14 @@ async def hubspot_get_deals(limit: int = 10):
     try:
         logger.info(f"Fetching up to {limit} deals...")
         result = client.crm.deals.basic_api.get_page(limit=limit)
+        # Enrich with human-readable dealstage label
+        stage_label_map = _build_dealstage_label_map(client)
+        for obj in getattr(result, "results", []) or []:
+            props = getattr(obj, "properties", {}) or {}
+            stage_id = props.get("dealstage")
+            if stage_id and stage_id in stage_label_map:
+                props["dealstage_label"] = stage_label_map[stage_id]
+                obj.properties = props
         logger.info(f"Fetched {len(result.results)} deals successfully.")
         return result
     except Exception as e:
@@ -46,6 +76,13 @@ async def hubspot_get_deal_by_id(deal_id: str):
     try:
         logger.info(f"Fetching deal ID: {deal_id}...")
         result = client.crm.deals.basic_api.get_by_id(deal_id)
+        # Enrich with human-readable dealstage label
+        stage_label_map = _build_dealstage_label_map(client)
+        props = getattr(result, "properties", {}) or {}
+        stage_id = props.get("dealstage")
+        if stage_id and stage_id in stage_label_map:
+            props["dealstage_label"] = stage_label_map[stage_id]
+            result.properties = props
         logger.info(f"Fetched deal ID: {deal_id} successfully.")
         return result
     except Exception as e:

mcp_servers/hubspot/tools/properties.py

@@ -1,7 +1,10 @@
 import logging
+import json
+import ast
 from hubspot.crm.objects import Filter, FilterGroup, PublicObjectSearchRequest
 from hubspot.crm.properties import PropertyCreate
 from .base import get_hubspot_client
+from .deals import _build_dealstage_label_map
 
 # Configure logging
 logger = logging.getLogger(__name__)
@@ -121,10 +124,64 @@ async def hubspot_search_by_property(
     logger.info(f"Executing hubspot_search_by_property on {object_type}: {property_name} {operator} {value}")
 
     try:
+        # Build Filter with correct fields depending on operator
+        filter_kwargs = {"property_name": property_name, "operator": operator}
+
+        # Operators that require no value
+        if operator in {"HAS_PROPERTY", "NOT_HAS_PROPERTY"}:
+            pass
+
+        # Operators that require a list of values
+        elif operator in {"IN", "NOT_IN"}:
+            values_list: list[str] = []
+            try:
+                parsed = json.loads(value)
+                if isinstance(parsed, list):
+                    values_list = [str(v) for v in parsed]
+            except Exception:
+                try:
+                    parsed = ast.literal_eval(value)
+                    if isinstance(parsed, list):
+                        values_list = [str(v) for v in parsed]
+                except Exception:
+                    # Fallback: split by comma
+                    values_list = [v.strip().strip('"\'') for v in value.split(',') if v.strip()]
+
+            if not values_list:
+                raise ValueError("Operator IN/NOT_IN requires a non-empty list of values")
+
+            filter_kwargs["values"] = values_list
+
+        # Between expects two endpoints: low and high
+        elif operator == "BETWEEN":
+            low = None
+            high = None
+            try:
+                parsed = json.loads(value)
+                if isinstance(parsed, list) and len(parsed) >= 2:
+                    low, high = str(parsed[0]), str(parsed[1])
+            except Exception:
+                try:
+                    parsed = ast.literal_eval(value)
+                    if isinstance(parsed, list) and len(parsed) >= 2:
+                        low, high = str(parsed[0]), str(parsed[1])
+                except Exception:
+                    pass
+
+            if low is None or high is None:
+                raise ValueError("Operator BETWEEN requires a list with two values [low, high]")
+
+            filter_kwargs["value"] = low
+            filter_kwargs["high_value"] = high
+
+        # All other operators use single value
+        else:
+            filter_kwargs["value"] = value
+
         search_request = PublicObjectSearchRequest(
             filter_groups=[
                 FilterGroup(filters=[
-                    Filter(property_name=property_name, operator=operator, value=value)
+                    Filter(**filter_kwargs)
                 ])
             ],
             properties=list(properties),
@@ -143,6 +200,18 @@ async def hubspot_search_by_property(
             raise ValueError(f"Unsupported object type: {object_type}")
 
         logger.info(f"hubspot_search_by_property: Found {len(results.results)} result(s)")
+        # Enrich deals with human-readable dealstage label
+        if object_type == "deals":
+            stage_label_map = _build_dealstage_label_map(client)
+            enriched: list[dict] = []
+            for obj in results.results:
+                props = (getattr(obj, "properties", {}) or {}).copy()
+                stage_id = props.get("dealstage")
+                if stage_id and stage_id in stage_label_map:
+                    props["dealstage_label"] = stage_label_map[stage_id]
+                enriched.append(props)
+            return enriched
+        # For other objects, return properties as-is
         return [obj.properties for obj in results.results]
 
     except Exception as e: