Fix MCP spec compliance: capabilities, prompts, error codes

- Advertise resources and prompts capabilities in initialize response
- Fix prompt messages: role "system" → "user", content string → {type, text}
- Return JSON-RPC errors for not-found: -32002 (resource), -32602 (tool/prompt)
- Include outputSchema in tools/list when defined
- Update tests for new error handling behavior

Author: loglux

app/main.py

@@ -186,6 +186,8 @@ async def mcp(request: Request) -> Response:
             "protocolVersion": negotiated_version,
             "capabilities": {
                 "tools": {"listChanged": False},
+                "resources": {},
+                "prompts": {},
             },
             "serverInfo": {"name": "sql-cortex-mcp", "version": "0.1.0"},
         }
@@ -220,6 +222,11 @@ async def mcp(request: Request) -> Response:
             err = _jsonrpc_error(-32602, "Missing resource uri", req_id)
             return _response(err, status_code=400)
         result = resources.read_resource(uri)
+        if result is None:
+            err = _jsonrpc_error(-32002, f"Resource not found: {uri}", req_id)
+            if session_id and await _enqueue(session_id, err):
+                return Response(status_code=202)
+            return _response(err)
         response_payload = _jsonrpc_response(result, req_id)
         if session_id and await _enqueue(session_id, response_payload):
             return Response(status_code=202)
@@ -231,6 +238,11 @@ async def mcp(request: Request) -> Response:
         if not tool_name:
             err = _jsonrpc_error(-32602, "Missing tool name", req_id)
             return _response(err, status_code=400)
+        if not registry.has_tool(tool_name):
+            err = _jsonrpc_error(-32602, f"Unknown tool: {tool_name}", req_id)
+            if session_id and await _enqueue(session_id, err):
+                return Response(status_code=202)
+            return _response(err)
         tool_result = registry.call(tool_name, arguments)
         is_error = bool(tool_result.get("error"))
         content = [
@@ -259,6 +271,11 @@ async def mcp(request: Request) -> Response:
             err = _jsonrpc_error(-32602, "Missing prompt name", req_id)
             return _response(err, status_code=400)
         result = prompts.get_prompt(name, arguments)
+        if result is None:
+            err = _jsonrpc_error(-32602, f"Unknown prompt: {name}", req_id)
+            if session_id and await _enqueue(session_id, err):
+                return Response(status_code=202)
+            return _response(err)
         response_payload = _jsonrpc_response(result, req_id)
         if session_id and await _enqueue(session_id, response_payload):
             return Response(status_code=202)

app/mcp/prompts.py

@@ -50,7 +50,10 @@ def get_prompt(self, name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
             )
             return {
                 "messages": [
-                    {"role": "system", "content": content},
+                    {
+                        "role": "user",
+                        "content": {"type": "text", "text": content},
+                    },
                 ]
             }
 
@@ -65,8 +68,11 @@ def get_prompt(self, name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
             )
             return {
                 "messages": [
-                    {"role": "system", "content": content},
+                    {
+                        "role": "user",
+                        "content": {"type": "text", "text": content},
+                    },
                 ]
             }
 
-        return {"error": f"Prompt not found: {name}"}
+        return None

app/mcp/registry.py

@@ -37,24 +37,26 @@ def list_tools(self) -> Dict[str, Any]:
         tools: List[Dict[str, Any]] = []
         for tool in self._defs.values():
             a = tool.annotations
-            tools.append(
-                {
-                    "name": tool.name,
-                    "title": tool.title,
-                    "description": tool.description,
-                    "inputSchema": tool.input_schema,
-                    "annotations": {
-                        "readOnlyHint": a.read_only_hint,
-                        "destructiveHint": a.destructive_hint,
-                        "idempotentHint": a.idempotent_hint,
-                        "openWorldHint": a.open_world_hint,
-                    },
-                }
-            )
+            entry: Dict[str, Any] = {
+                "name": tool.name,
+                "title": tool.title,
+                "description": tool.description,
+                "inputSchema": tool.input_schema,
+                "annotations": {
+                    "readOnlyHint": a.read_only_hint,
+                    "destructiveHint": a.destructive_hint,
+                    "idempotentHint": a.idempotent_hint,
+                    "openWorldHint": a.open_world_hint,
+                },
+            }
+            if tool.output_schema:
+                entry["outputSchema"] = tool.output_schema
+            tools.append(entry)
         tools.sort(key=lambda t: t["name"])
         return {"tools": tools}
 
+    def has_tool(self, name: str) -> bool:
+        return name in self._tools
+
     def call(self, name: str, payload: Dict[str, Any]) -> Dict[str, Any]:
-        if name not in self._tools:
-            return {"error": f"Tool not found: {name}"}
         return self._tools[name](payload)

app/mcp/resources.py

@@ -56,7 +56,7 @@ def read_resource(self, uri: str) -> Dict[str, Any]:
                     }
                 ]
             }
-        return {"error": f"Resource not found: {uri}"}
+        return None
 
 
 def _json_text(data: Any) -> str:

tests/test_mcp_api.py

@@ -138,8 +138,10 @@ async def test_unknown_tool_returns_error(client: AsyncClient) -> None:
         },
     )
     assert resp.status_code == 200
-    content = resp.json()["result"]["structuredContent"]
-    assert "error" in content
+    body = resp.json()
+    assert "error" in body
+    assert body["error"]["code"] == -32602
+    assert "nonexistent.tool" in body["error"]["message"]
 
 
 async def test_tools_list_has_annotations(client: AsyncClient) -> None:

tests/test_registry.py

@@ -31,10 +31,13 @@ def test_call_known_tool() -> None:
     assert result == {"echo": "hello"}
 
 
-def test_call_unknown_tool_returns_error() -> None:
+def test_call_unknown_tool_raises_key_error() -> None:
     reg = _make_registry()
-    result = reg.call("nonexistent", {})
-    assert "error" in result
+    assert not reg.has_tool("nonexistent")
+    import pytest
+
+    with pytest.raises(KeyError):
+        reg.call("nonexistent", {})
 
 
 def test_tools_list_sorted() -> None: