first stab at converting to msgspec

Author: CamDavidsonPilon

.envrc

@@ -0,0 +1,3 @@
+export VIRTUAL_ENV=.venv
+export VIRTUAL_ENV_PROMPT=$(basename "$PWD")
+layout python3

.pre-commit-config.yaml

@@ -22,7 +22,7 @@ classifiers = [
     "Programming Language :: Python :: 3.11",
 ]
 dependencies = [
-    "pydantic>=2.0.0",
+    "msgspec>=0.18.0",
 ]
 
 [project.urls]
@@ -31,44 +31,15 @@ Repository = "https://github.com/fulfilio/mcp-utils.git"
 
 [project.optional-dependencies]
 dev = [
-    "pre-commit>=3.6.0",
-    "ruff>=0.3.0",
     "pytest>=8.0.0",
-    "pytest-cov>=4.1.0",
     "bump-my-version>=0.15.0",
 ]
 
 [tool.hatch.build.targets.wheel]
 packages = ["src/mcp_utils"]
 
-[tool.ruff]
-target-version = "py310"
-line-length = 88
-extend-include = ["*.ipynb"]
-
-[tool.ruff.lint]
-select = [
-    "E",  # pycodestyle errors
-    "W",  # pycodestyle warnings
-    "F",  # pyflakes
-    "I",  # isort
-    "B",  # flake8-bugbear
-    "C4", # flake8-comprehensions
-    "UP", # pyupgrade
-]
-ignore = []
-
-[tool.ruff.format]
-quote-style = "double"
-indent-style = "space"
-skip-magic-trailing-comma = false
-line-ending = "auto"
-
-[tool.ruff.lint.isort]
-known-first-party = ["mcp_utils"]
 
 [tool.pytest.ini_options]
-addopts = "--cov=mcp_utils --cov-report=term-missing"
 testpaths = ["tests"]
 python_files = ["test_*.py"]
 

pyproject.toml

@@ -9,7 +9,7 @@
 from dataclasses import dataclass, field
 from typing import Any, TypeVar
 
-from pydantic import ValidationError
+import msgspec
 
 from .queue import ResponseQueueProtocol
 from .schema import (
@@ -75,10 +75,18 @@ class MCPServer:
 
     _tools: dict[str, Callable] = field(default_factory=dict)
     _tools_list: dict[str, ToolInfo] = field(default_factory=dict)
+    _tool_arg_models: dict[str, type] = field(default_factory=dict)
 
     def register_tool(self, name: str, callable: Callable, tool_info: ToolInfo) -> None:
         self._tools_list[name] = tool_info
         self._tools[name] = callable
+        # Track arg model for validation separately from serializable ToolInfo
+        try:
+            from .utils import inspect_callable
+
+            self._tool_arg_models[name] = inspect_callable(callable).arg_model
+        except Exception:
+            pass
 
     def tool(self, name: str | None = None) -> Callable:
         """Register a tool"""
@@ -256,7 +264,7 @@ def get_list_tools(
         paginated_tools, next_page = get_page_of_items(tools, page, page_size)
 
         return ListToolsResult(
-            tools=[tool.model_dump(by_alias=True) for tool in paginated_tools],
+            tools=paginated_tools,
             nextCursor=next_page,
         )
 
@@ -341,13 +349,15 @@ def get_completions(
     def _handle_initialize(self, request: MCPRequest) -> MCPResponse:
         """Handle initialize method."""
         return MCPResponse(
+            jsonrpc="2.0",
             id=request.id,
             result=self.get_capabilities(),
         )
 
     def _handle_ping(self, request: MCPRequest) -> MCPResponse:
         """Handle ping method."""
         return MCPResponse(
+            jsonrpc="2.0",
             id=request.id,
             result={},
         )
@@ -358,6 +368,7 @@ def _handle_completion_complete(self, request: MCPRequest) -> MCPResponse:
         arg_name = request.params["argument"]["name"]
         value = request.params["argument"]["value"]
         return MCPResponse(
+            jsonrpc="2.0",
             id=request.id,
             result={"completion": self.get_completions(prompt_name, arg_name, value)},
         )
@@ -366,6 +377,7 @@ def _handle_prompts_list(self, request: MCPRequest) -> MCPResponse:
         """Handle prompts/list method."""
         page = int(request.params.get("cursor", "1"))
         return MCPResponse(
+            jsonrpc="2.0",
             id=request.id,
             result=self.get_list_prompts(page=page),
         )
@@ -377,13 +389,15 @@ def _handle_prompts_get(self, request: MCPRequest) -> MCPResponse:
             prompt = self._prompts[name]
         except KeyError:
             return MCPResponse(
+                jsonrpc="2.0",
                 id=request.id,
                 error=ErrorResponse(
                     code=400,
                     message="Prompt not found",
                 ),
             )
         return MCPResponse(
+            jsonrpc="2.0",
             id=request.id,
             result=prompt(**request.params["arguments"]),
         )
@@ -392,6 +406,7 @@ def _handle_tools_list(self, request: MCPRequest) -> MCPResponse:
         """Handle tools/list method."""
         page = int(request.params.get("cursor", "1"))
         return MCPResponse(
+            jsonrpc="2.0",
             id=request.id,
             result=self.get_list_tools(page=page),
         )
@@ -400,6 +415,7 @@ def _handle_resources_list(self, request: MCPRequest) -> MCPResponse:
         """Handle resources/list method."""
         page = int(request.params.get("cursor", "1"))
         return MCPResponse(
+            jsonrpc="2.0",
             id=request.id,
             result=self.get_list_resources(page=page),
         )
@@ -408,6 +424,7 @@ def _handle_resources_templates_list(self, request: MCPRequest) -> MCPResponse:
         """Handle resources/templates/list method."""
         page = int(request.params.get("cursor", "1"))
         return MCPResponse(
+            jsonrpc="2.0",
             id=request.id,
             result=self.get_list_resource_templates(page=page),
         )
@@ -419,54 +436,48 @@ def _handle_tools_call(self, request: MCPRequest) -> MCPResponse:
 
         try:
             callable = self._tools[tool_name]
-            arg_model = self._tools_list[tool_name].arg_model
-            args = arg_model(**kwargs)
-            result = callable(**dict(args))
+            arg_model = self._tool_arg_models[tool_name]
+            args = msgspec.convert(kwargs, arg_model)
+            result = callable(**msgspec.to_builtins(args))
             if isinstance(result, dict):
                 result = CallToolResult(
-                    content=[
-                        TextContent(
-                            text=json.dumps(result),
-                            type="text",
-                        )
-                    ],
+                    content=[TextContent(text=json.dumps(result))],
                     is_error=False,
                 )
             elif isinstance(result, str):
                 result = CallToolResult(
-                    content=[
-                        TextContent(
-                            text=result,
-                            type="text",
-                        )
-                    ],
+                    content=[TextContent(text=result)],
                     is_error=False,
                 )
             elif isinstance(result, CallToolResult):
                 result = result
             else:
                 logger.error("Invalid tool result type: %s", type(result))
                 return MCPResponse(
+                    jsonrpc="2.0",
                     id=request.id,
                     error=ErrorResponse(
                         code=400,
                         message="Invalid tool result type",
                     ),
                 )
             return MCPResponse(
+                jsonrpc="2.0",
                 id=request.id,
                 result=result,
             )
         except KeyError:
             return MCPResponse(
+                jsonrpc="2.0",
                 id=request.id,
                 error=ErrorResponse(
                     code=-32601,
                     message="Tool not found",
                 ),
             )
-        except ValidationError as e:
+        except Exception as e:
             return MCPResponse(
+                jsonrpc="2.0",
                 id=request.id,
                 error=ErrorResponse(
                     code=-32602,
@@ -476,6 +487,7 @@ def _handle_tools_call(self, request: MCPRequest) -> MCPResponse:
         except Exception as e:
             logger.error(f"Error in tool {tool_name}: {e}")
             return MCPResponse(
+                jsonrpc="2.0",
                 id=request.id,
                 error=ErrorResponse(
                     code=-32603,
@@ -501,18 +513,18 @@ def _handle_message(
             message_id = message["id"]
         except KeyError:
             return MCPResponse(
+                jsonrpc="2.0",
                 id=0,
                 error=ErrorResponse(
                     code=-32600,
                     message="Missing message id",
                 ),
             )
         try:
-            mcp_request = MCPRequest.model_validate(
-                {**message, "session_id": session_id},
-            )
-        except ValidationError as e:
+            mcp_request = msgspec.convert({**message}, MCPRequest)
+        except Exception as e:
             return MCPResponse(
+                jsonrpc="2.0",
                 id=0,
                 error=ErrorResponse(
                     code=-32600,
@@ -545,6 +557,7 @@ def _handle_message(
             return handler(mcp_request)
         else:
             return MCPResponse(
+                jsonrpc="2.0",
                 id=message_id,
                 error=ErrorResponse(
                     code=-32601,
@@ -570,5 +583,6 @@ def get_page_of_items(
     start_idx = (page - 1) * page_size
     end_idx = start_idx + page_size
     page_items = items[start_idx:end_idx]
-    next_page = str(page + 1) if len(items) > end_idx else None
+    # Use None to indicate no next page (not UNSET) for consistency with tests
+    next_page = str(page + 1) if len(items) > end_idx else msgspec.UNSET
     return page_items, next_page

src/mcp_utils/core.py

@@ -5,6 +5,8 @@
 import logging
 from typing import Protocol
 
+import msgspec
+
 from .schema import MCPResponse
 
 logger = logging.getLogger("mcp_utils")
@@ -58,7 +60,7 @@ def push_response(
             response: The response to push
         """
         queue_key = self._get_queue_key(session_id)
-        value = response.model_dump_json(exclude_none=True)
+        value = msgspec.json.encode(response).decode()
         logger.debug(f"Redis: Saving response for session: {session_id}: {value}")
         self.redis.rpush(queue_key, value)