Update start_mcp.py

start_mcp.py

@@ -36,8 +36,15 @@ def run_sse_server(host: str, port: int):
     from starlette.responses import JSONResponse, HTMLResponse, StreamingResponse
     from starlette.requests import Request
     
-    # Import MCP service
-    from mcp_service import mcp
+    # Try import MCP service
+    try:
+        from mcp_service import mcp
+        mcp_available = True
+        logger.info("MCP service loaded successfully")
+    except Exception as e:
+        mcp_available = False
+        mcp = None
+        logger.error(f"Failed to load MCP service: {e}")
     
     # Store SSE connections
     connections = {}
@@ -52,8 +59,7 @@ def run_sse_server(host: str, port: int):
         
         async def generate():
             try:
-                # Send the message endpoint URL
-                # MCP expects: event: endpoint, data: /messages?sessionId=xxx
+                # Send the message endpoint URL (just the path, not JSON)
                 yield f"event: endpoint\ndata: /messages?sessionId={conn_id}\n\n"
                 
                 while True:
@@ -64,6 +70,8 @@ def run_sse_server(host: str, port: int):
                         yield ": keepalive\n\n"
             except asyncio.CancelledError:
                 pass
+            except Exception as e:
+                logger.error(f"SSE generate error: {e}")
             finally:
                 connections.pop(conn_id, None)
                 logger.info(f"SSE closed: {conn_id}")
@@ -72,9 +80,10 @@ def run_sse_server(host: str, port: int):
             generate(),
             media_type="text/event-stream",
             headers={
-                "Cache-Control": "no-cache",
+                "Cache-Control": "no-cache, no-store, must-revalidate",
                 "Connection": "keep-alive",
                 "X-Accel-Buffering": "no",
+                "Access-Control-Allow-Origin": "*",
             }
         )
     
@@ -83,16 +92,20 @@ def run_sse_server(host: str, port: int):
         session_id = request.query_params.get("sessionId")
         
         if not session_id or session_id not in connections:
+            logger.error(f"Invalid session: {session_id}, active: {list(connections.keys())}")
             return JSONResponse({"error": "Invalid session"}, status_code=400)
         
+        if not mcp_available:
+            return JSONResponse({"error": "MCP service not available"}, status_code=500)
+        
         try:
             body = await request.json()
-            logger.info(f"Request: {body.get('method')}")
-            
             method = body.get("method", "")
             params = body.get("params", {})
             msg_id = body.get("id")
             
+            logger.info(f"Method: {method}, ID: {msg_id}")
+            
             # Process MCP methods
             if method == "initialize":
                 result = {
@@ -101,17 +114,18 @@ def run_sse_server(host: str, port: int):
                     "capabilities": {"tools": {}}
                 }
             elif method == "notifications/initialized":
-                # Just acknowledge, no response needed
                 return JSONResponse({"ok": True})
             elif method == "tools/list":
                 tools = []
-                for name, func in mcp._tool_manager._tools.items():
+                for name, tool in mcp._tool_manager._tools.items():
+                    # Tool object has name, description, parameters attributes
                     tools.append({
-                        "name": name,
-                        "description": (func.__doc__ or "").split("\n")[0].strip(),
-                        "inputSchema": {"type": "object", "properties": {}}
+                        "name": tool.name,
+                        "description": tool.description or name,
+                        "inputSchema": tool.parameters if hasattr(tool, 'parameters') else {"type": "object", "properties": {}}
                     })
                 result = {"tools": tools}
+                logger.info(f"Listed {len(tools)} tools")
             elif method == "tools/call":
                 tool_name = params.get("name")
                 tool_args = params.get("arguments", {})
@@ -119,18 +133,31 @@ def run_sse_server(host: str, port: int):
                 if tool_name not in mcp._tool_manager._tools:
                     raise Exception(f"Unknown tool: {tool_name}")
                 
-                tool_result = mcp._tool_manager._tools[tool_name](**tool_args)
+                logger.info(f"Calling tool: {tool_name} with args: {list(tool_args.keys())}")
+                
+                # Get the Tool object and call its fn (the original function)
+                tool = mcp._tool_manager._tools[tool_name]
+                
+                # Call the underlying function directly
+                if tool.is_async:
+                    tool_result = await tool.fn(**tool_args)
+                else:
+                    tool_result = tool.fn(**tool_args)
+                
                 result = {"content": [{"type": "text", "text": json.dumps(tool_result)}]}
+                logger.info(f"Tool {tool_name} completed successfully")
             else:
                 raise Exception(f"Unknown method: {method}")
             
             response = {"jsonrpc": "2.0", "id": msg_id, "result": result}
             
         except Exception as e:
-            logger.error(f"Error: {e}")
+            logger.error(f"Error processing request: {e}")
+            import traceback
+            traceback.print_exc()
             response = {
                 "jsonrpc": "2.0",
-                "id": body.get("id"),
+                "id": body.get("id") if 'body' in dir() else None,
                 "error": {"code": -32000, "message": str(e)}
             }