muscles-jsonrpc 1.0.0__tar.gz

muscles_jsonrpc-1.0.0/PKG-INFO

@@ -0,0 +1,74 @@
+Metadata-Version: 2.4
+Name: muscles-jsonrpc
+Version: 1.0.0
+Summary: JSON-RPC adapter for Muscles actions
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: muscles<2.0.0,>=1.0.0rc1
+
+# Muscles JSON-RPC
+
+JSON-RPC protocol projection for Muscles actions.
+
+This package makes Muscles action-first applications callable over JSON-RPC
+while preserving the same schemas, rules, dispatcher, and context used by other
+projections.
+
+## Related Repositories
+
+- [`muscles`](https://github.com/butkoden/muscles) - core action contracts, dispatcher and inspect contract.
+- [`muscles-cli`](https://github.com/butkoden/muscles-cli) - CLI action inspection and execution over the same contracts.
+- [`muscles-mcp`](https://github.com/butkoden/muscles-mcp) - MCP projection over the same action model.
+- [`muscles-sse`](https://github.com/butkoden/muscles-sse) - streaming projection for action output.
+- [`muscles-benchmarks`](https://github.com/butkoden/muscles-benchmarks) - protocol projection regression checks.
+
+## Concept Guardrails
+
+- JSON-RPC is a protocol projection, not a new framework layer.
+- Methods must be discovered from `inspect_application(app)`.
+- Validation and error normalization must reuse Muscles core schema/rules/errors.
+- Auth/rules must run through `ActionDispatcher`.
+- The same use case must be callable from CLI, HTTP, MCP, and JSON-RPC without
+  duplicating implementation.
+- JSON-RPC state is scoped to the application instance; no mutable module-level
+  method registry is the source of truth.
+
+## Initial Goal
+
+Implement a JSON-RPC 2.0 projection around Muscles actions with typed
+request/response contracts, deterministic error mapping, notifications, and
+batch dispatch.
+
+## Current Stage (Issue #1)
+
+Implemented JSON-RPC 2.0 projection:
+
+- request validation (`jsonrpc`, `method`, `params`);
+- method discovery from `inspect_application(app)`;
+- dispatch through `ActionDispatcher(..., transport="jsonrpc")`;
+- notification calls;
+- batch calls;
+- deterministic error mapping:
+  - `-32600` invalid request;
+  - `-32601` method not found;
+  - `-32602` invalid params;
+  - `-32001` permission denied;
+  - `-32603` internal error.
+
+### Run tests
+
+```bash
+python -m pytest -q
+```
+
+When testing against local core changes:
+
+```bash
+PYTHONPATH=../muscles/src:src python -m pytest -q
+```
+
+User docs:
+
+- English: [docs/jsonrpc-projection.en.md](docs/jsonrpc-projection.en.md)
+- Русский: [docs/jsonrpc-projection.ru.md](docs/jsonrpc-projection.ru.md)

muscles_jsonrpc-1.0.0/README.md

@@ -0,0 +1,65 @@
+# Muscles JSON-RPC
+
+JSON-RPC protocol projection for Muscles actions.
+
+This package makes Muscles action-first applications callable over JSON-RPC
+while preserving the same schemas, rules, dispatcher, and context used by other
+projections.
+
+## Related Repositories
+
+- [`muscles`](https://github.com/butkoden/muscles) - core action contracts, dispatcher and inspect contract.
+- [`muscles-cli`](https://github.com/butkoden/muscles-cli) - CLI action inspection and execution over the same contracts.
+- [`muscles-mcp`](https://github.com/butkoden/muscles-mcp) - MCP projection over the same action model.
+- [`muscles-sse`](https://github.com/butkoden/muscles-sse) - streaming projection for action output.
+- [`muscles-benchmarks`](https://github.com/butkoden/muscles-benchmarks) - protocol projection regression checks.
+
+## Concept Guardrails
+
+- JSON-RPC is a protocol projection, not a new framework layer.
+- Methods must be discovered from `inspect_application(app)`.
+- Validation and error normalization must reuse Muscles core schema/rules/errors.
+- Auth/rules must run through `ActionDispatcher`.
+- The same use case must be callable from CLI, HTTP, MCP, and JSON-RPC without
+  duplicating implementation.
+- JSON-RPC state is scoped to the application instance; no mutable module-level
+  method registry is the source of truth.
+
+## Initial Goal
+
+Implement a JSON-RPC 2.0 projection around Muscles actions with typed
+request/response contracts, deterministic error mapping, notifications, and
+batch dispatch.
+
+## Current Stage (Issue #1)
+
+Implemented JSON-RPC 2.0 projection:
+
+- request validation (`jsonrpc`, `method`, `params`);
+- method discovery from `inspect_application(app)`;
+- dispatch through `ActionDispatcher(..., transport="jsonrpc")`;
+- notification calls;
+- batch calls;
+- deterministic error mapping:
+  - `-32600` invalid request;
+  - `-32601` method not found;
+  - `-32602` invalid params;
+  - `-32001` permission denied;
+  - `-32603` internal error.
+
+### Run tests
+
+```bash
+python -m pytest -q
+```
+
+When testing against local core changes:
+
+```bash
+PYTHONPATH=../muscles/src:src python -m pytest -q
+```
+
+User docs:
+
+- English: [docs/jsonrpc-projection.en.md](docs/jsonrpc-projection.en.md)
+- Русский: [docs/jsonrpc-projection.ru.md](docs/jsonrpc-projection.ru.md)

muscles_jsonrpc-1.0.0/pyproject.toml

@@ -0,0 +1,15 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "muscles-jsonrpc"
+version = "1.0.0"
+description = "JSON-RPC adapter for Muscles actions"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+dependencies = ["muscles>=1.0.0rc1,<2.0.0"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

muscles_jsonrpc-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

muscles_jsonrpc-1.0.0/src/muscles_jsonrpc/__init__.py

@@ -0,0 +1,3 @@
+from .adapter import JsonRpcAdapter, JsonRpcError, JsonRpcServer
+
+__all__ = ["JsonRpcAdapter", "JsonRpcError", "JsonRpcServer"]

muscles_jsonrpc-1.0.0/src/muscles_jsonrpc/adapter.py

@@ -0,0 +1,149 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from typing import Any
+
+
+JSONRPC_VERSION = "2.0"
+DISCOVERY_METHODS = {"rpc.discover", "rpc.methods"}
+
+
+@dataclass(frozen=True)
+class JsonRpcError(Exception):
+    code: int
+    message: str
+    data: dict[str, Any] | None = None
+
+
+class JsonRpcAdapter:
+    """Projects Muscles actions into JSON-RPC 2.0 methods."""
+
+    def __init__(self, app) -> None:
+        self._app = app
+
+    @classmethod
+    def from_application(cls, app):
+        return cls(app)
+
+    @property
+    def _contract(self) -> dict[str, Any]:
+        from muscles.core import inspect_application
+
+        return inspect_application(self._app)
+
+    def list_methods(self) -> list[dict[str, Any]]:
+        methods: list[dict[str, Any]] = []
+        for action in self._contract.get("actions", []):
+            name = action.get("name")
+            if not name:
+                continue
+            transports = action.get("transports") or []
+            if transports and "jsonrpc" not in transports:
+                continue
+            methods.append(
+                {
+                    "name": name,
+                    "description": action.get("description", ""),
+                    "params_schema": action.get("input_schema", {"type": "object", "properties": {}}),
+                }
+            )
+        return methods
+
+    def handle(self, request: dict[str, Any] | list[Any]) -> dict[str, Any] | list[dict[str, Any]] | None:
+        if isinstance(request, list):
+            if not request:
+                return self._error(None, -32600, "Invalid Request")
+            responses = [response for item in request if (response := self._handle_single(item)) is not None]
+            return responses or None
+        return self._handle_single(request)
+
+    def _handle_single(self, request: Any) -> dict[str, Any] | None:
+        if not isinstance(request, dict):
+            return self._error(None, -32600, "Invalid Request")
+        req_id = request.get("id")
+        is_notification = "id" not in request
+        if request.get("jsonrpc") != JSONRPC_VERSION:
+            return self._error(req_id, -32600, "Invalid Request")
+        if "method" not in request or not isinstance(request.get("method"), str):
+            return self._error(req_id, -32600, "Invalid Request")
+
+        params = request.get("params", {})
+        if params is None:
+            params = {}
+        if not isinstance(params, dict):
+            if is_notification:
+                return None
+            return self._error(req_id, -32602, "Invalid params")
+        if request["method"] in DISCOVERY_METHODS:
+            if is_notification:
+                return None
+            return {"jsonrpc": JSONRPC_VERSION, "id": req_id, "result": self.list_methods()}
+
+        try:
+            from muscles.core import ActionDispatcher
+
+            result = ActionDispatcher(self._app).execute(request["method"], params, transport="jsonrpc")
+            if result.is_stream:
+                raise JsonRpcError(
+                    -32002,
+                    "Streaming not supported",
+                    {
+                        "action": request["method"],
+                        "reason": "Use a stream-capable projection such as SSE or MCP for stream actions.",
+                    },
+                )
+            if is_notification:
+                return None
+            return {
+                "jsonrpc": JSONRPC_VERSION,
+                "id": req_id,
+                "result": self._json_value(result.value),
+            }
+        except Exception as exc:
+            if is_notification:
+                return None
+            mapped = self._map_core_error(exc)
+            if mapped is not None:
+                return self._error(req_id, mapped.code, mapped.message, mapped.data)
+            return self._error(req_id, -32603, "Internal error")
+
+    @staticmethod
+    def _map_core_error(exc: Exception) -> JsonRpcError | None:
+        try:
+            from muscles.core import (
+                ActionExecutionError,
+                ActionNotFound,
+                ActionPermissionDenied,
+                ActionValidationError,
+            )
+        except Exception:
+            return None
+
+        if isinstance(exc, ActionNotFound):
+            return JsonRpcError(-32601, "Method not found")
+        if isinstance(exc, ActionValidationError):
+            return JsonRpcError(-32602, "Invalid params", {"reason": exc.message, "data": exc.data})
+        if isinstance(exc, ActionPermissionDenied):
+            return JsonRpcError(-32001, "Permission denied", {"reason": exc.message, "data": exc.data})
+        if isinstance(exc, ActionExecutionError):
+            return JsonRpcError(-32603, "Internal error")
+        if isinstance(exc, JsonRpcError):
+            return exc
+        return None
+
+    @staticmethod
+    def _error(req_id: Any, code: int, message: str, data: dict[str, Any] | None = None) -> dict[str, Any]:
+        payload: dict[str, Any] = {"jsonrpc": JSONRPC_VERSION, "id": req_id, "error": {"code": code, "message": message}}
+        if data is not None:
+            payload["error"]["data"] = data
+        return payload
+
+    @staticmethod
+    def _json_value(value: Any) -> Any:
+        """Validate the JSON-RPC result without silently stringifying values."""
+
+        return json.loads(json.dumps(value, ensure_ascii=False))
+
+
+JsonRpcServer = JsonRpcAdapter

muscles_jsonrpc-1.0.0/src/muscles_jsonrpc.egg-info/PKG-INFO

@@ -0,0 +1,74 @@
+Metadata-Version: 2.4
+Name: muscles-jsonrpc
+Version: 1.0.0
+Summary: JSON-RPC adapter for Muscles actions
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: muscles<2.0.0,>=1.0.0rc1
+
+# Muscles JSON-RPC
+
+JSON-RPC protocol projection for Muscles actions.
+
+This package makes Muscles action-first applications callable over JSON-RPC
+while preserving the same schemas, rules, dispatcher, and context used by other
+projections.
+
+## Related Repositories
+
+- [`muscles`](https://github.com/butkoden/muscles) - core action contracts, dispatcher and inspect contract.
+- [`muscles-cli`](https://github.com/butkoden/muscles-cli) - CLI action inspection and execution over the same contracts.
+- [`muscles-mcp`](https://github.com/butkoden/muscles-mcp) - MCP projection over the same action model.
+- [`muscles-sse`](https://github.com/butkoden/muscles-sse) - streaming projection for action output.
+- [`muscles-benchmarks`](https://github.com/butkoden/muscles-benchmarks) - protocol projection regression checks.
+
+## Concept Guardrails
+
+- JSON-RPC is a protocol projection, not a new framework layer.
+- Methods must be discovered from `inspect_application(app)`.
+- Validation and error normalization must reuse Muscles core schema/rules/errors.
+- Auth/rules must run through `ActionDispatcher`.
+- The same use case must be callable from CLI, HTTP, MCP, and JSON-RPC without
+  duplicating implementation.
+- JSON-RPC state is scoped to the application instance; no mutable module-level
+  method registry is the source of truth.
+
+## Initial Goal
+
+Implement a JSON-RPC 2.0 projection around Muscles actions with typed
+request/response contracts, deterministic error mapping, notifications, and
+batch dispatch.
+
+## Current Stage (Issue #1)
+
+Implemented JSON-RPC 2.0 projection:
+
+- request validation (`jsonrpc`, `method`, `params`);
+- method discovery from `inspect_application(app)`;
+- dispatch through `ActionDispatcher(..., transport="jsonrpc")`;
+- notification calls;
+- batch calls;
+- deterministic error mapping:
+  - `-32600` invalid request;
+  - `-32601` method not found;
+  - `-32602` invalid params;
+  - `-32001` permission denied;
+  - `-32603` internal error.
+
+### Run tests
+
+```bash
+python -m pytest -q
+```
+
+When testing against local core changes:
+
+```bash
+PYTHONPATH=../muscles/src:src python -m pytest -q
+```
+
+User docs:
+
+- English: [docs/jsonrpc-projection.en.md](docs/jsonrpc-projection.en.md)
+- Русский: [docs/jsonrpc-projection.ru.md](docs/jsonrpc-projection.ru.md)

muscles_jsonrpc-1.0.0/src/muscles_jsonrpc.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+src/muscles_jsonrpc/__init__.py
+src/muscles_jsonrpc/adapter.py
+src/muscles_jsonrpc.egg-info/PKG-INFO
+src/muscles_jsonrpc.egg-info/SOURCES.txt
+src/muscles_jsonrpc.egg-info/dependency_links.txt
+src/muscles_jsonrpc.egg-info/requires.txt
+src/muscles_jsonrpc.egg-info/top_level.txt
+tests/test_adapter.py

muscles_jsonrpc-1.0.0/src/muscles_jsonrpc.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

muscles_jsonrpc-1.0.0/src/muscles_jsonrpc.egg-info/requires.txt

@@ -0,0 +1 @@
+muscles<2.0.0,>=1.0.0rc1

muscles_jsonrpc-1.0.0/src/muscles_jsonrpc.egg-info/top_level.txt

@@ -0,0 +1 @@
+muscles_jsonrpc

muscles_jsonrpc-1.0.0/tests/test_adapter.py

@@ -0,0 +1,280 @@
+from muscles.core import (
+    ActionPermissionDenied,
+    ApplicationMeta,
+    BaseStrategy,
+    Context,
+    StreamResult,
+    register_action,
+)
+
+from muscles_jsonrpc import JsonRpcAdapter
+
+
+class _EchoStrategy(BaseStrategy):
+    def execute(self, *args, **kwargs):
+        return kwargs
+
+
+BOOKING_INPUT_SCHEMA = {
+    "type": "object",
+    "properties": {
+        "title": {"type": "string"},
+        "guest_count": {"type": "integer"},
+    },
+    "required": ["title"],
+}
+
+
+def _build_app(handler=None, transports=None):
+    class _App(metaclass=ApplicationMeta):
+        context = Context(_EchoStrategy)
+
+    app = _App()
+    calls = []
+
+    def default_handler(payload, context):
+        calls.append((context.action.name, payload, context.transport))
+        return {
+            "id": len(calls),
+            "title": payload["title"],
+            "guest_count": payload.get("guest_count", 1),
+        }
+
+    register_action(
+        app,
+        name="bookings.create",
+        description="Create booking",
+        input_schema=BOOKING_INPUT_SCHEMA,
+        output_schema={"type": "object", "properties": {"id": {"type": "integer"}}},
+        transports=transports if transports is not None else ["http", "jsonrpc"],
+        handler=handler or default_handler,
+    )
+    return app, calls
+
+
+def test_jsonrpc_success_uses_core_dispatcher_once():
+    app, calls = _build_app()
+    adapter = JsonRpcAdapter.from_application(app)
+
+    response = adapter.handle(
+        {"jsonrpc": "2.0", "id": 7, "method": "bookings.create", "params": {"title": "Call"}}
+    )
+
+    assert calls == [("bookings.create", {"title": "Call"}, "jsonrpc")]
+    assert response == {
+        "jsonrpc": "2.0",
+        "id": 7,
+        "result": {"id": 1, "title": "Call", "guest_count": 1},
+    }
+
+
+def test_jsonrpc_method_list_comes_from_inspect_contract_and_transport_filter():
+    app, _ = _build_app()
+    register_action(
+        app,
+        name="bookings.http_only",
+        input_schema=BOOKING_INPUT_SCHEMA,
+        transports=["http"],
+        handler=lambda payload, context: {"ok": True},
+    )
+    adapter = JsonRpcAdapter.from_application(app)
+
+    assert adapter.list_methods() == [
+        {
+            "name": "bookings.create",
+            "description": "Create booking",
+            "params_schema": BOOKING_INPUT_SCHEMA,
+        }
+    ]
+
+
+def test_jsonrpc_discovery_method_returns_action_surface():
+    app, _ = _build_app()
+    adapter = JsonRpcAdapter.from_application(app)
+
+    response = adapter.handle({"jsonrpc": "2.0", "id": "discover", "method": "rpc.discover"})
+
+    assert response == {"jsonrpc": "2.0", "id": "discover", "result": adapter.list_methods()}
+
+
+def test_jsonrpc_methods_alias_returns_action_surface():
+    app, _ = _build_app()
+    adapter = JsonRpcAdapter.from_application(app)
+
+    response = adapter.handle({"jsonrpc": "2.0", "id": "methods", "method": "rpc.methods"})
+
+    assert response == {"jsonrpc": "2.0", "id": "methods", "result": adapter.list_methods()}
+
+
+def test_jsonrpc_method_not_found_maps_core_error():
+    app, _ = _build_app()
+    adapter = JsonRpcAdapter.from_application(app)
+
+    response = adapter.handle({"jsonrpc": "2.0", "id": 5, "method": "missing", "params": {}})
+
+    assert response["error"]["code"] == -32601
+    assert response["error"]["message"] == "Method not found"
+
+
+def test_jsonrpc_invalid_params_shape():
+    app, _ = _build_app()
+    adapter = JsonRpcAdapter.from_application(app)
+
+    response = adapter.handle({"jsonrpc": "2.0", "id": 1, "method": "bookings.create", "params": []})
+
+    assert response["error"]["code"] == -32602
+
+
+def test_jsonrpc_invalid_params_from_core_validation():
+    app, _ = _build_app()
+    adapter = JsonRpcAdapter.from_application(app)
+
+    response = adapter.handle({"jsonrpc": "2.0", "id": 1, "method": "bookings.create", "params": {}})
+
+    assert response["error"]["code"] == -32602
+    assert response["error"]["message"] == "Invalid params"
+    assert "title" in response["error"]["data"]["reason"]
+
+
+def test_jsonrpc_permission_denied_from_core_rules():
+    def deny(payload, context):
+        raise ActionPermissionDenied(context.action.name, "Denied by core rules")
+
+    app, _ = _build_app(handler=deny)
+    adapter = JsonRpcAdapter.from_application(app)
+
+    response = adapter.handle({"jsonrpc": "2.0", "id": 2, "method": "bookings.create", "params": {"title": "Call"}})
+
+    assert response["error"]["code"] == -32001
+    assert response["error"]["message"] == "Permission denied"
+    assert response["error"]["data"]["reason"] == "Denied by core rules"
+
+
+def test_jsonrpc_denies_method_not_open_to_jsonrpc_transport():
+    app, _ = _build_app(transports=["http"])
+    adapter = JsonRpcAdapter.from_application(app)
+
+    response = adapter.handle({"jsonrpc": "2.0", "id": 3, "method": "bookings.create", "params": {"title": "Call"}})
+
+    assert response["error"]["code"] == -32001
+
+
+def test_jsonrpc_execution_error_for_async_handler():
+    async def create_booking(payload, context):
+        return {"title": payload["title"]}
+
+    app, _ = _build_app(handler=create_booking)
+    adapter = JsonRpcAdapter.from_application(app)
+
+    response = adapter.handle({"jsonrpc": "2.0", "id": 4, "method": "bookings.create", "params": {"title": "Call"}})
+
+    assert response["error"]["code"] == -32603
+
+
+def test_jsonrpc_rejects_non_serializable_result_with_stable_internal_error():
+    app, _ = _build_app(handler=lambda payload, context: object())
+    adapter = JsonRpcAdapter.from_application(app)
+
+    response = adapter.handle(
+        {"jsonrpc": "2.0", "id": 11, "method": "bookings.create", "params": {"title": "Call"}}
+    )
+
+    assert response == {
+        "jsonrpc": "2.0",
+        "id": 11,
+        "error": {"code": -32603, "message": "Internal error"},
+    }
+
+
+def test_jsonrpc_stream_action_returns_explicit_unsupported_error():
+    app, _ = _build_app()
+
+    def stream_booking(payload, context):
+        return StreamResult(source=[])
+
+    register_action(
+        app,
+        name="bookings.stream",
+        input_schema=BOOKING_INPUT_SCHEMA,
+        transports=["jsonrpc"],
+        stream_output=True,
+        handler=stream_booking,
+    )
+    adapter = JsonRpcAdapter.from_application(app)
+
+    response = adapter.handle({"jsonrpc": "2.0", "id": 9, "method": "bookings.stream", "params": {"title": "Live"}})
+
+    assert response["error"]["code"] == -32002
+    assert response["error"]["message"] == "Streaming not supported"
+    assert response["error"]["data"]["action"] == "bookings.stream"
+
+
+def test_jsonrpc_notification_returns_none_but_dispatches():
+    app, calls = _build_app()
+    adapter = JsonRpcAdapter.from_application(app)
+
+    response = adapter.handle({"jsonrpc": "2.0", "method": "bookings.create", "params": {"title": "Notify"}})
+
+    assert response is None
+    assert calls == [("bookings.create", {"title": "Notify"}, "jsonrpc")]
+
+
+def test_jsonrpc_invalid_notification_returns_none():
+    app, _ = _build_app()
+    adapter = JsonRpcAdapter.from_application(app)
+
+    response = adapter.handle({"jsonrpc": "2.0", "method": "bookings.create", "params": []})
+
+    assert response is None
+
+
+def test_jsonrpc_batch_dispatches_each_request_without_bypassing_core():
+    app, calls = _build_app()
+    adapter = JsonRpcAdapter.from_application(app)
+
+    response = adapter.handle(
+        [
+            {"jsonrpc": "2.0", "id": 1, "method": "bookings.create", "params": {"title": "A"}},
+            {"jsonrpc": "2.0", "id": 2, "method": "missing", "params": {}},
+            {"jsonrpc": "2.0", "method": "bookings.create", "params": {"title": "Notification"}},
+        ]
+    )
+
+    assert response == [
+        {"jsonrpc": "2.0", "id": 1, "result": {"id": 1, "title": "A", "guest_count": 1}},
+        {"jsonrpc": "2.0", "id": 2, "error": {"code": -32601, "message": "Method not found"}},
+    ]
+    assert calls == [
+        ("bookings.create", {"title": "A"}, "jsonrpc"),
+        ("bookings.create", {"title": "Notification"}, "jsonrpc"),
+    ]
+
+
+def test_jsonrpc_invalid_request():
+    app, _ = _build_app()
+    adapter = JsonRpcAdapter.from_application(app)
+
+    response = adapter.handle({"id": 1, "method": "x"})
+
+    assert response["error"]["code"] == -32600
+
+
+def test_jsonrpc_state_is_scoped_to_application_instance():
+    app_a, _ = _build_app()
+
+    class _OtherApp(metaclass=ApplicationMeta):
+        context = Context(_EchoStrategy)
+
+    app_b = _OtherApp()
+    register_action(
+        app_b,
+        name="tasks.create",
+        input_schema={"type": "object", "properties": {}},
+        handler=lambda payload, context: {"ok": True},
+    )
+
+    methods_a = JsonRpcAdapter.from_application(app_a).list_methods()
+    methods_b = JsonRpcAdapter.from_application(app_b).list_methods()
+
+    assert [method["name"] for method in methods_a] == ["bookings.create"]
+    assert [method["name"] for method in methods_b] == ["tasks.create"]