eulerian-marketing-platform 0.2.4__tar.gz → 0.2.6__tar.gz

{eulerian_marketing_platform-0.2.4 → eulerian_marketing_platform-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: eulerian_marketing_platform
-Version: 0.2.4
+Version: 0.2.6
 Summary: MCP server for Eulerian Marketing Platform - enables AI assistants to interact with Eulerian's marketing analytics and campaign management APIs
 Author-email: Eulerian Technologies <mathieu@eulerian.com>
 License: MIT

{eulerian_marketing_platform-0.2.4 → eulerian_marketing_platform-0.2.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "eulerian_marketing_platform"
-version = "0.2.4"
+version = "0.2.6"
 description = "MCP server for Eulerian Marketing Platform - enables AI assistants to interact with Eulerian's marketing analytics and campaign management APIs"
 readme = "README.md"
 authors = [

{eulerian_marketing_platform-0.2.4 → eulerian_marketing_platform-0.2.6}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = eulerian_marketing_platform
-version = 0.2.4
+version = 0.2.6
 
 [options]
 package_dir = 

{eulerian_marketing_platform-0.2.4 → eulerian_marketing_platform-0.2.6}/src/eulerian_marketing_platform/__init__.py

@@ -4,7 +4,7 @@ This package provides a Model Context Protocol (MCP) server that enables
 AI assistants to interact with Eulerian Marketing Platform APIs.
 """
 
-__version__ = "0.2.4"
+__version__ = "0.2.6"
 __author__ = "Eulerian Technologies"
 __all__ = []
 

{eulerian_marketing_platform-0.2.4 → eulerian_marketing_platform-0.2.6}/src/eulerian_marketing_platform/server.py

@@ -74,13 +74,12 @@ def forward_request(request_data: dict) -> dict:
         request_data: The JSON-RPC request to forward
         
     Returns:
-        The JSON-RPC response from the remote server, or None for notifications
+        The JSON-RPC response from the remote server
     """
     timeout = float(os.environ.get("EMP_TIMEOUT", "300"))
     
     request_id = request_data.get("id")
     method = request_data.get("method")
-    is_notification = request_id is None
     
     logger.info(f">>> REQUEST: {method} (id: {request_id})")
     logger.debug(f"    Full request: {json.dumps(request_data)[:200]}...")
@@ -101,15 +100,18 @@ def forward_request(request_data: dict) -> dict:
         
         logger.info(f"<<< RESPONSE: HTTP {response.status_code}")
         
+        # Handle HTTP 204 No Content (common for notifications)
+        if response.status_code == 204:
+            logger.info("    HTTP 204 No Content - creating empty success response")
+            return {
+                "jsonrpc": "2.0",
+                "id": request_id,
+                "result": {}
+            }
+        
         if response.status_code != 200:
             error_msg = f"HTTP {response.status_code}: {response.reason_phrase}"
             logger.error(f"    Error: {response.text[:200]}")
-            
-            # For notifications, don't return error responses
-            if is_notification:
-                logger.info("    Notification error - no response sent")
-                return None
-            
             return {
                 "jsonrpc": "2.0",
                 "id": request_id,
@@ -119,35 +121,77 @@ def forward_request(request_data: dict) -> dict:
                 }
             }
         
-        # Parse response
+        # Parse response for HTTP 200
         try:
             response_data = response.json()
             logger.debug(f"    Response: {json.dumps(response_data)[:200]}...")
             
-            # For notifications, we should not send back any response, regardless of what the remote server returns
-            if is_notification:
-                logger.info("    Notification processed - no response sent")
-                return None
+            # Add detailed logging for different MCP methods
+            if "result" in response_data:
+                logger.info("    Has 'result' field [OK]")
+                
+                result = response_data.get("result", {})
+                
+                if method == "initialize":
+                    logger.info(f"    Initialize result: protocolVersion={result.get('protocolVersion')}")
+                    capabilities = result.get("capabilities", {})
+                    logger.info(f"    Server capabilities: {list(capabilities.keys())}")
+                    server_info = result.get("serverInfo", {})
+                    logger.info(f"    Server info: name={server_info.get('name')}, version={server_info.get('version')}")
+                
+                elif method == "tools/list":
+                    tools = result.get("tools", [])
+                    logger.info(f"    Tools available: {len(tools)} tools")
+                    for i, tool in enumerate(tools):
+                        tool_name = tool.get("name", "unnamed")
+                        tool_desc = tool.get("description", "no description")[:50]
+                        logger.info(f"      Tool {i+1}: {tool_name} - {tool_desc}")
+                        # Log input schema info
+                        input_schema = tool.get("inputSchema", {})
+                        if "properties" in input_schema:
+                            props = list(input_schema["properties"].keys())[:3]
+                            logger.info(f"        Input properties: {props}")
+                
+                elif method == "resources/list":
+                    resources = result.get("resources", [])
+                    logger.info(f"    Resources available: {len(resources)} resources")
+                    for i, resource in enumerate(resources[:3]):
+                        res_uri = resource.get("uri", "no uri")
+                        res_name = resource.get("name", "unnamed")
+                        logger.info(f"      Resource {i+1}: {res_name} ({res_uri})")
+                    if len(resources) > 3:
+                        logger.info(f"      ... and {len(resources) - 3} more resources")
+                
+                elif method.startswith("tools/call"):
+                    logger.info(f"    Tool call result keys: {list(result.keys())}")
+                    if "content" in result:
+                        content = result["content"]
+                        if isinstance(content, list) and len(content) > 0:
+                            logger.info(f"    Tool returned {len(content)} content items")
+                            first_item = content[0]
+                            if isinstance(first_item, dict):
+                                logger.info(f"    First content type: {first_item.get('type', 'unknown')}")
+                        elif isinstance(content, str):
+                            logger.info(f"    Tool returned string content: {len(content)} chars")
+                
+                else:
+                    # Generic logging for unknown methods
+                    logger.info(f"    Method '{method}' result keys: {list(result.keys())}")
+                    
+            elif "error" in response_data:
+                error = response_data["error"]
+                error_code = error.get("code", "no code")
+                error_message = error.get("message", "no message")
+                logger.info(f"    Has 'error' field: code={error_code}, message={error_message}")
             
             # Validate JSON-RPC response
             if "jsonrpc" not in response_data:
                 logger.warning("    WARNING: Missing 'jsonrpc' field")
             
-            if "result" in response_data:
-                logger.info("    Has 'result' field [OK]")
-            elif "error" in response_data:
-                logger.info(f"    Has 'error' field: {response_data['error']}")
-            
             return response_data
             
         except json.JSONDecodeError as e:
             logger.error(f"    ERROR: Invalid JSON - {e}")
-            
-            # For notifications, don't return error responses
-            if is_notification:
-                logger.info("    Notification JSON error - no response sent")
-                return None
-            
             return {
                 "jsonrpc": "2.0",
                 "id": request_id,
@@ -159,12 +203,6 @@ def forward_request(request_data: dict) -> dict:
     
     except httpx.TimeoutException:
         logger.error("ERROR: Request timeout")
-        
-        # For notifications, don't return error responses
-        if is_notification:
-            logger.info("    Notification timeout - no response sent")
-            return None
-            
         return {
             "jsonrpc": "2.0",
             "id": request_id,
@@ -176,12 +214,6 @@ def forward_request(request_data: dict) -> dict:
     
     except httpx.RequestError as e:
         logger.error(f"ERROR: Request failed - {str(e)}")
-        
-        # For notifications, don't return error responses
-        if is_notification:
-            logger.info("    Notification request error - no response sent")
-            return None
-            
         return {
             "jsonrpc": "2.0",
             "id": request_id,
@@ -195,12 +227,6 @@ def forward_request(request_data: dict) -> dict:
         logger.error(f"ERROR: Unexpected error - {str(e)}")
         import traceback
         logger.error(f"Traceback: {traceback.format_exc()}")
-        
-        # For notifications, don't return error responses
-        if is_notification:
-            logger.info("    Notification unexpected error - no response sent")
-            return None
-            
         return {
             "jsonrpc": "2.0",
             "id": request_id,
@@ -251,15 +277,12 @@ def main() -> None:
                     # Forward to remote server
                     response_data = forward_request(request_data)
                     
-                    # Only send response for non-notifications (when response_data is not None)
-                    if response_data is not None:
-                        response_json = json.dumps(response_data)
-                        print(response_json, flush=True)
-                        sys.stdout.flush()
-                        logger.info("    Response forwarded [OK]")
-                    else:
-                        logger.info("    Notification processed (no response sent)")
-                        
+                    # Always send response back to Claude Desktop (MCP requires this)
+                    response_json = json.dumps(response_data)
+                    print(response_json, flush=True)
+                    sys.stdout.flush()
+                    logger.info("    Response forwarded [OK]")
+                    
                 except json.JSONDecodeError as e:
                     logger.error(f"ERROR: Invalid JSON in request - {e}")
                     logger.error(f"    Problematic line: {line[:200]}")

{eulerian_marketing_platform-0.2.4 → eulerian_marketing_platform-0.2.6}/src/eulerian_marketing_platform.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: eulerian-marketing-platform
-Version: 0.2.4
+Version: 0.2.6
 Summary: MCP server for Eulerian Marketing Platform - enables AI assistants to interact with Eulerian's marketing analytics and campaign management APIs
 Author-email: Eulerian Technologies <mathieu@eulerian.com>
 License: MIT