Return -32601 (Method not found) for unknown JSON-RPC methods

An unrecognized `method` was raised as a bare ValueError and caught by the
generic handler, which mapped it to -32603 ("Internal error"). Per JSON-RPC
2.0 that is a client error, not a server fault: well-behaved clients could
not tell "you called something that does not exist" apart from "the server
broke."

Introduce MethodNotFoundError and map it to -32601 ("Method not found") in
handle_request; everything else still maps to -32603. Also aligns
core/mcp_server.py with server/http_handler.py, which already uses -32601.

Found while smoke-testing the prod MCP server after the log-group tagging
change; not a regression from that work.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: brendanbabb

core/mcp_server.py

@@ -17,6 +17,15 @@
 logger = logging.getLogger(__name__)
 
 
+class MethodNotFoundError(Exception):
+    """Raised when a JSON-RPC request names a method the server does not implement.
+
+    Mapped to JSON-RPC error code -32601 ("Method not found") rather than the
+    generic -32603 ("Internal error"), so well-behaved clients can tell an
+    unknown method apart from a genuine server-side failure.
+    """
+
+
 class MCPServer:
     """MCP Server that handles JSON-RPC requests and routes to Plugin Manager."""
 
@@ -86,7 +95,7 @@ async def handle_request(self, request: Dict[str, Any]) -> Optional[Dict[str, An
                         },
                     )
                     return None
-                raise ValueError(f"Unknown method: {method}")
+                raise MethodNotFoundError(f"Unknown method: {method}")
 
             # Don't send response for notifications
             if is_notification:
@@ -122,14 +131,24 @@ async def handle_request(self, request: Dict[str, Any]) -> Optional[Dict[str, An
 
         except Exception as e:
             duration_ms = (time.perf_counter() - start_time) * 1000
-            error_response = {
-                "jsonrpc": "2.0",
-                "id": request_id,
-                "error": {
+            # Unknown methods are a client error (-32601 Method not found), not a
+            # server fault (-32603 Internal error). Everything else is -32603.
+            if isinstance(e, MethodNotFoundError):
+                error = {
+                    "code": -32601,
+                    "message": "Method not found",
+                    "data": str(e),
+                }
+            else:
+                error = {
                     "code": -32603,
                     "message": "Internal error",
                     "data": str(e),
-                },
+                }
+            error_response = {
+                "jsonrpc": "2.0",
+                "id": request_id,
+                "error": error,
             }
 
             # Log JSON-RPC error response

tests/test_mcp_server.py

@@ -379,8 +379,8 @@ class TestUnknownMethods:
     """Test handling of unknown methods."""
 
     @pytest.mark.asyncio
-    async def test_unknown_method_raises_error(self):
-        """Test that unknown method raises ValueError."""
+    async def test_unknown_method_returns_method_not_found(self):
+        """Test that an unknown method returns JSON-RPC -32601 (Method not found)."""
         plugin_manager = MagicMock(spec=PluginManager)
         server = MCPServer(plugin_manager)
 
@@ -395,7 +395,8 @@ async def test_unknown_method_raises_error(self):
 
         assert response is not None
         assert "error" in response
-        assert response["error"]["code"] == -32603
+        assert response["error"]["code"] == -32601
+        assert response["error"]["message"] == "Method not found"
         assert "Unknown method" in response["error"]["data"]