stinger-python-utils 0.1.8rc4__tar.gz → 0.1.8rc5__tar.gz

{stinger_python_utils-0.1.8rc4 → stinger_python_utils-0.1.8rc5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stinger-python-utils
-Version: 0.1.8rc4
+Version: 0.1.8rc5
 Summary: Common utilities for Stinger Python services.
 License-Expression: MIT
 License-File: LICENSE

{stinger_python_utils-0.1.8rc4 → stinger_python_utils-0.1.8rc5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "stinger-python-utils"
-version = "0.1.8rc4"
+version = "0.1.8rc5"
 description = "Common utilities for Stinger Python services."
 readme = "README.md"
 license = "MIT"

{stinger_python_utils-0.1.8rc4 → stinger_python_utils-0.1.8rc5}/src/stinger_python_utils/mcp/plugin.py

@@ -17,6 +17,8 @@ from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
 from typing import Any
 
+from pydantic import BaseModel
+
 
 # ------------------------------------------------------------------
 # Data models
@@ -66,19 +68,18 @@ class MethodDefinition:
     """Describes a callable method on a stinger-ipc client.
 
     Each method is exposed as an MCP **tool** whose ``inputSchema`` is
-    *arguments_schema*.
+    derived from *arguments_model* via ``model_json_schema()``.
 
-    *arguments_schema* must be a valid `JSON Schema`_ of type
-    ``"object"``.  The property names **must** match the keyword
-    argument names accepted by the client method.
+    *arguments_model* must be a :class:`pydantic.BaseModel` subclass.
+    When the tool is invoked, the raw JSON arguments are loaded into
+    an instance of this model and the model is passed to
+    ``call_{method_name}`` on the client.
 
-    .. _JSON Schema: https://json-schema.org/
+    If *arguments_model* is ``None`` the tool accepts no arguments.
     """
 
     name: str
-    arguments_schema: dict[str, Any] = field(
-        default_factory=lambda: {"type": "object"}
-    )
+    arguments_model: type[BaseModel] | None = None
     description: str = ""
 
 
@@ -189,19 +190,24 @@ class StingerMCPPlugin(ABC):
         setattr(client, prop_name, list(arguments.values())[0])
 
     def call_method(
-        self, client: Any, method_name: str, arguments: dict[str, Any]
+        self, client: Any, method_name: str, arguments: BaseModel | None
     ) -> Any:
         """Invoke *method_name* on *client* with *arguments*.
 
+        *arguments* is a validated :class:`pydantic.BaseModel` instance
+        (or ``None`` when the method takes no parameters).
+
         The default implementation calls::
 
-            getattr(client, method_name)(**arguments)
+            getattr(client, f"call_{method_name}")(arguments)
 
         and returns whatever the method returns (typically a
         ``concurrent.futures.Future``).
         """
         method = getattr(client, f"call_{method_name}")
-        return method(**arguments)
+        if arguments is None:
+            return method()
+        return method(arguments)
 
     def serialize_property(self, prop_name: str, value: Any) -> str:
         """Serialize a property *value* to a JSON string for the MCP resource.

{stinger_python_utils-0.1.8rc4 → stinger_python_utils-0.1.8rc5}/src/stinger_python_utils/mcp/server.py

@@ -193,7 +193,11 @@ class StingerMCPServer:
                                 or f"Call {mdef.name} on {state.plugin_name} "
                                 f"instance {state.instance_id}"
                             ),
-                            inputSchema=mdef.arguments_schema,
+                            inputSchema=(
+                                mdef.arguments_model.model_json_schema()
+                                if mdef.arguments_model is not None
+                                else {"type": "object"}
+                            ),
                         )
                     )
 
@@ -214,8 +218,8 @@ class StingerMCPServer:
 
     def _resolve_tool(
         self, name: str
-    ) -> tuple[InstanceState, str, str] | None:
-        """Map a tool *name* → ``(state, kind, item_name)``.
+    ) -> tuple[InstanceState, str, MethodDefinition | PropertyDefinition] | None:
+        """Map a tool *name* → ``(state, kind, definition)``.
 
         *kind* is ``"method"`` or ``"property"``.  Methods are checked
         first so that a method named ``set_foo`` takes precedence over
@@ -235,7 +239,7 @@ class StingerMCPServer:
                 # Methods take priority
                 for mdef in state.plugin.get_methods():
                     if _sanitize(mdef.name) == remainder:
-                        return state, "method", mdef.name
+                        return state, "method", mdef
 
                 # Property setters: set_<prop_name>
                 if remainder.startswith("set_"):
@@ -245,7 +249,7 @@ class StingerMCPServer:
                             _sanitize(pdef.name) == prop_token
                             and not pdef.readonly
                         ):
-                            return state, "property", pdef.name
+                            return state, "property", pdef
 
         return None
 
@@ -256,23 +260,32 @@ class StingerMCPServer:
         if target is None:
             raise ValueError(f"Unknown tool: {name}")
 
-        state, kind, item_name = target
+        state, kind, defn = target
 
         if kind == "property":
             try:
-                state.plugin.write_property(state.client, item_name, arguments)
-                text = json.dumps({"status": "ok", "property": item_name})
+                state.plugin.write_property(
+                    state.client, defn.name, arguments
+                )
+                text = json.dumps({"status": "ok", "property": defn.name})
             except Exception as exc:
-                logger.exception("Error setting property %s", item_name)
+                logger.exception("Error setting property %s", defn.name)
                 text = json.dumps(
                     {"status": "error", "error": str(exc)}, default=str
                 )
             return [types.TextContent(type="text", text=text)]
 
         # kind == "method"
+        assert isinstance(defn, MethodDefinition)
         try:
+            # Load the pydantic model from the raw arguments
+            model = (
+                defn.arguments_model(**arguments)
+                if defn.arguments_model is not None
+                else None
+            )
             result = state.plugin.call_method(
-                state.client, item_name, arguments
+                state.client, defn.name, model
             )
             if isinstance(result, Future):
                 result = await _resolve_future(result)
@@ -284,7 +297,7 @@ class StingerMCPServer:
             else:
                 text = json.dumps(result, default=str)
         except Exception as exc:
-            logger.exception("Error calling method %s", item_name)
+            logger.exception("Error calling method %s", defn.name)
             text = json.dumps(
                 {"status": "error", "error": str(exc)}, default=str
             )