statewire 0.3.0__tar.gz → 0.3.1__tar.gz

{statewire-0.3.0 → statewire-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: statewire
-Version: 0.3.0
+Version: 0.3.1
 Summary: Replicate one JSON object over an SSE op stream + a command endpoint
 Project-URL: Repository, https://github.com/assistant-ui/harness-sdk
 License-Expression: MIT

{statewire-0.3.0 → statewire-0.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "statewire"
-version = "0.3.0"
+version = "0.3.1"
 description = "Replicate one JSON object over an SSE op stream + a command endpoint"
 readme = "README.md"
 license = "MIT"

{statewire-0.3.0 → statewire-0.3.1}/src/statewire/api.py

@@ -391,11 +391,14 @@ class Statewire(PinnedAPI):
                         f"{cls.__name__}.{fn.__name__} declares @route on reserved "
                         f"path {spec.path!r}; it is a Statewire protocol endpoint"
                     )
-        merged = dict(cls._statewire_commands)
-        for name, fn in vars(cls).items():
-            method = getattr(fn, "_statewire_command_method", None)
-            if method is not None:
-                merged[method] = name
+        # Full-MRO scan so plain mixins (no Statewire base) contribute their
+        # @command handlers; the most derived registration of a method wins.
+        merged: dict[str, str] = {}
+        for base in reversed(cls.__mro__):
+            for name, fn in vars(base).items():
+                method = getattr(fn, "_statewire_command_method", None)
+                if method is not None:
+                    merged[method] = name
         cls._statewire_commands = merged
         lifespan = cls.__dict__.get("lifespan")
         if lifespan is not None and not getattr(lifespan, "_statewire_checked", False):

{statewire-0.3.0 → statewire-0.3.1}/src/statewire/assistant_transport.py

@@ -12,7 +12,28 @@ context, readable via ``ctx.caller`` in handlers that declare a keyword-only
 ``ctx`` parameter. Unknown fields below the top level are ignored. All
 commands ``{"type": <name>, ...}`` are submitted as one batch through the
 normal Statewire admission path to the ``@command`` handlers registered under
-those names, each with the whole command object as the single param. The response streams
+those names, each with the whole command object as the single param — except
+the legacy commands, which are normalized to the canonical ``run/*`` dialect
+(a host-registered handler of the same legacy name always wins and receives
+the command whole):
+
+- ``add-message`` becomes ``run/steer`` with ``{"message": <wire message>}``:
+  a fresh ``legacy_`` id is synthesized, image parts become
+  ``{"type": "file", "mediaType": "image/*", "url"}`` parts, and command-level
+  anchors are dropped. When the body carries a top-level ``parentId`` and
+  ``get_message_child_id`` resolves it to a child, the command becomes
+  ``run/edit`` with ``{"sourceId": <child>, "message": <wire message>}``.
+- ``add-tool-result`` becomes ``run/input`` with ``{"requestId": <resolved>,
+  "response": {"output": <result>, "isError"?, "artifact"?}}``; the requestId
+  comes from ``get_input_request_id(toolCallId)``, whose default peeks the
+  unanswered tool-call request in ``state["inputRequests"]`` (None rejects),
+  and a ``modelContent`` field rejects (unsupported in ``run/input``).
+- A body with a ``parentId`` and no commands is the legacy reload: it becomes
+  ``run/reload`` with ``{"sourceId": <child>}`` via ``get_message_child_id``
+  (None rejects).
+
+A host without the target ``run/*`` handler rejects the batch via the
+ordinary unknown-command path. The response streams
 state changes as legacy frames until every submitted command settles, then
 EOF; a rejection or crash becomes an error frame followed by EOF. Client
 disconnect before EOF invokes ``on_assistant_transport_disconnect`` (a plain
@@ -26,9 +47,11 @@ response is 200 with an empty body and ``X-Stream-Status: not_found``. If the
 run already completed, the replay carries ``X-Stream-Status: completed``. A
 resume disconnect never invokes the cancel hook.
 
-``POST /assistant-transport/api/cancel`` invokes the same disconnect hook and
-responds ``{"success": true, "found": <bool>}``; ``found`` is true when a live
-run existed at request time.
+``POST /assistant-transport/api/cancel`` invokes the same disconnect hook,
+dispatches the host's registered ``run/stop`` handler (if any; a rejection —
+e.g. wrong-state while idle — is swallowed), and responds
+``{"success": true, "found": <bool>}``; ``found`` is true when a live run
+existed at request time.
 
 ``POST /assistant-transport/api/status`` responds 200 always:
 ``{"isRunning": true, "status": "running"}`` while a run is active,
@@ -52,6 +75,7 @@ import json
 import secrets
 import time
 from typing import Any, AsyncIterator
+from uuid import uuid4
 
 import httpx
 from fastapi import FastAPI, HTTPException, Request
@@ -60,7 +84,7 @@ from starlette.background import BackgroundTask
 from starlette.responses import Response, StreamingResponse
 
 from .api import _LAGGARD, Statewire
-from .state import _frozen
+from .state import _frozen, plain
 
 _STREAM_HEADERS = {
     "Cache-Control": "no-cache, no-store, no-transform",
@@ -162,6 +186,28 @@ class _RunError(Exception):
     pass
 
 
+def _legacy_wire_message(message: Any) -> dict[str, Any]:
+    if not isinstance(message, dict):
+        raise _RunError("add-message: message must be an object")
+    parts = message.get("parts")
+    if not isinstance(parts, list):
+        raise _RunError("add-message: message.parts must be an array")
+    converted = []
+    for part in parts:
+        if isinstance(part, dict) and part.get("type") == "image":
+            image = part.get("image")
+            if not isinstance(image, str):
+                raise _RunError("add-message: image part requires a string image field")
+            converted.append({"type": "file", "mediaType": "image/*", "url": image})
+        else:
+            converted.append(part)
+    return {
+        "id": f"legacy_{uuid4().hex}",
+        "role": message.get("role"),
+        "parts": converted,
+    }
+
+
 _Item = tuple[str, Any]
 
 
@@ -193,6 +239,35 @@ class AssistantTransport(Statewire):
     async def on_assistant_transport_disconnect(self) -> None:
         """The legacy client went away or asked to stop; treat as a cancel signal."""
 
+    async def get_input_request_id(self, tool_call_id: str) -> str | None:
+        """Resolve a legacy toolCallId to the pending run/input requestId.
+
+        The default peeks the RunManager root-state mount:
+        ``state["inputRequests"]`` holds ``{..., "response": null}`` entries;
+        the unanswered tool-call request matching ``tool_call_id`` wins. None
+        rejects the legacy ``add-tool-result`` command."""
+        state = plain(self.state)
+        requests = state.get("inputRequests") if isinstance(state, dict) else None
+        if not isinstance(requests, list):
+            return None
+        for request in requests:
+            if (
+                isinstance(request, dict)
+                and request.get("type") == "tool-call"
+                and request.get("toolCallId") == tool_call_id
+                and request.get("response") is None
+            ):
+                return request.get("id")
+        return None
+
+    async def get_message_child_id(self, parent_id: str) -> str | None:
+        """Resolve a message id to its child message id.
+
+        Anchors the legacy reload (``run/reload``) and edit (``run/edit``)
+        translations. None (the default) rejects a legacy reload and sends
+        ``add-message`` as ``run/steer``."""
+        return None
+
     @route.post("/assistant-transport/api/chat")
     async def assistant_transport_chat(self, request: Request) -> Response:
         await self.authorize(request)
@@ -228,10 +303,15 @@ class AssistantTransport(Statewire):
         self._clients[client_id].context = context
         lease = self._clients[client_id].lease
         assert lease is not None
+        parent_id = body.get("parentId")
+        if not isinstance(parent_id, str):
+            parent_id = None
         run = _Run(json.loads(snapshot)["ops"][0]["value"])
         self._at_run = run
         self.create_task(
-            self._assistant_transport_run(run, q, client_id, lease, commands)
+            self._assistant_transport_run(
+                run, q, client_id, lease, commands, parent_id
+            )
         )
         return StreamingResponse(
             self._assistant_transport_attach(fmt, run, initial=True),
@@ -277,6 +357,8 @@ class AssistantTransport(Statewire):
         found = run is not None and not run.done
         if found:
             await self.on_assistant_transport_disconnect()
+        if "run/stop" in type(self)._statewire_commands:
+            await self._assistant_transport_dispatch("run/stop")
         return {"success": True, "found": found}
 
     @route.post("/assistant-transport/api/status")
@@ -299,16 +381,22 @@ class AssistantTransport(Statewire):
         }
 
     async def _assistant_transport_submit(
-        self, client_id: str, lease: str, commands: list[dict[str, Any]]
+        self,
+        client_id: str,
+        lease: str,
+        commands: list[dict[str, Any]],
+        parent_id: str | None,
     ) -> None:
         if not commands:
-            return
-        body = {
-            "commands": [
-                {"method": command["type"], "params": [command]}
+            if parent_id is None:
+                return
+            members = [await self._legacy_reload(parent_id)]
+        else:
+            members = [
+                await self._assistant_transport_member(command, parent_id)
                 for command in commands
             ]
-        }
+        body = {"commands": members}
         outcome, detail = await self._admit(client_id, 1, body, lease)
         if outcome == "rejected":
             raise _RunError(
@@ -320,6 +408,67 @@ class AssistantTransport(Statewire):
         if outcome != "executed":
             raise _RunError(f"command submission failed: {outcome}")
 
+    async def _assistant_transport_member(
+        self, command: dict[str, Any], parent_id: str | None
+    ) -> dict[str, Any]:
+        kind = command["type"]
+        registered = type(self)._statewire_commands
+        if kind == "add-message" and "add-message" not in registered:
+            message = _legacy_wire_message(command.get("message"))
+            source_id = (
+                await self.get_message_child_id(parent_id)
+                if parent_id is not None
+                else None
+            )
+            if source_id is not None:
+                return {
+                    "method": "run/edit",
+                    "params": [{"sourceId": source_id, "message": message}],
+                }
+            return {"method": "run/steer", "params": [{"message": message}]}
+        if kind == "add-tool-result" and "add-tool-result" not in registered:
+            return {
+                "method": "run/input",
+                "params": [await self._legacy_input(command)],
+            }
+        return {"method": kind, "params": [command]}
+
+    async def _legacy_input(self, command: dict[str, Any]) -> dict[str, Any]:
+        if command.get("modelContent") is not None:
+            raise _RunError("add-tool-result: modelContent is not supported")
+        tool_call_id = command.get("toolCallId")
+        if not isinstance(tool_call_id, str):
+            raise _RunError("add-tool-result: toolCallId must be a string")
+        request_id = await self.get_input_request_id(tool_call_id)
+        if request_id is None:
+            raise _RunError(
+                f"add-tool-result: no input request for toolCallId {tool_call_id!r}"
+            )
+        response: dict[str, Any] = {"output": command.get("result")}
+        if command.get("isError"):
+            response["isError"] = True
+        if "artifact" in command:
+            response["artifact"] = command["artifact"]
+        return {"requestId": request_id, "response": response}
+
+    async def _legacy_reload(self, parent_id: str) -> dict[str, Any]:
+        source_id = await self.get_message_child_id(parent_id)
+        if source_id is None:
+            raise _RunError(f"reload: no child message for parentId {parent_id!r}")
+        return {"method": "run/reload", "params": [{"sourceId": source_id}]}
+
+    async def _assistant_transport_dispatch(self, method: str) -> None:
+        client_id = "at-" + secrets.token_urlsafe(9)
+        q, _ = self._register(client_id)
+        try:
+            lease = self._clients[client_id].lease
+            assert lease is not None
+            await self._admit(
+                client_id, 1, {"commands": [{"method": method, "params": []}]}, lease
+            )
+        finally:
+            self._subscribers.pop(q, None)
+
     async def _assistant_transport_run(
         self,
         run: _Run,
@@ -327,13 +476,14 @@ class AssistantTransport(Statewire):
         client_id: str,
         lease: str,
         commands: list[dict[str, Any]],
+        parent_id: str | None,
     ) -> None:
         submit = asyncio.create_task(
-            self._assistant_transport_submit(client_id, lease, commands)
+            self._assistant_transport_submit(client_id, lease, commands, parent_id)
         )
         q_get: asyncio.Task[Any] = asyncio.create_task(q.get())
         try:
-            total = len(commands)
+            total = len(commands) or (1 if parent_id is not None else 0)
             acked = 0
             open_pending: set[int] = set()
             try:

{statewire-0.3.0 → statewire-0.3.1}/tests/test_assistant_transport.py

@@ -595,3 +595,423 @@ async def test_status_reports_not_found_running_and_completed():
         body = (await client.post(status_url, json={"threadId": "t1"})).json()
         assert body["isRunning"] is False and body["status"] == "completed"
         assert isinstance(body["completedAt"], int)
+
+
+class RunHarness(AssistantTransport):
+    """Host speaking the canonical run/* dialect; no legacy handlers."""
+
+    def __init__(self, ctx):
+        super().__init__(ctx)
+        self.steered = []
+        self.edited = []
+        self.inputs = []
+        self.reloaded = []
+        self.stopped = 0
+        self.cancelled = 0
+
+    async def lifespan(self):
+        self.state = {"messages": []}
+        yield
+
+    @command("run/steer")
+    async def run_steer(self, params, *, ctx):
+        self.steered.append((params, ctx.caller.client_id))
+        self.state["messages"].append(params["message"])
+
+    @command("run/edit")
+    async def run_edit(self, params):
+        self.edited.append(params)
+
+    @command("run/input")
+    async def run_input(self, params):
+        self.inputs.append(params)
+
+    @command("run/reload")
+    async def run_reload(self, params):
+        self.reloaded.append(params)
+
+    @command("run/stop")
+    async def run_stop(self, params=None, *, ctx):
+        self.stopped += 1
+
+    async def on_assistant_transport_disconnect(self):
+        self.cancelled += 1
+
+
+class AnchoredHarness(RunHarness):
+    async def get_message_child_id(self, parent_id):
+        return {"m1": "m2"}.get(parent_id)
+
+
+class InputHarness(RunHarness):
+    async def lifespan(self):
+        self.state = {
+            "messages": [],
+            "inputRequests": [
+                {
+                    "type": "tool-call",
+                    "id": "req-old",
+                    "toolCallId": "call-1",
+                    "response": {"output": "done"},
+                },
+                {
+                    "type": "tool-call",
+                    "id": "req-1",
+                    "toolCallId": "call-1",
+                    "response": None,
+                },
+                {
+                    "type": "tool-approval",
+                    "id": "req-2",
+                    "toolCallId": "call-2",
+                    "response": None,
+                },
+            ],
+        }
+        yield
+
+
+async def test_add_message_is_normalized_to_run_steer():
+    async with statewire_client(RunHarness) as (app, client):
+        response = await post_run(
+            client,
+            {
+                "commands": [
+                    {
+                        "type": "add-message",
+                        "message": {
+                            "role": "user",
+                            "parts": [
+                                {"type": "text", "text": "hi"},
+                                {"type": "image", "image": "data:image/png;base64,xx"},
+                            ],
+                        },
+                        "parentId": "m0",
+                        "sourceId": None,
+                    }
+                ],
+                "state": {},
+                "threadId": "t1",
+            },
+        )
+        assert response.status_code == 200
+        instance = (await app.state.pinned_host.directory.get("t1")).instance
+        [(params, caller_id)] = instance.steered
+        assert set(params) == {"message"}
+        message = params["message"]
+        assert message["id"].startswith("legacy_")
+        assert message["role"] == "user"
+        assert message["parts"] == [
+            {"type": "text", "text": "hi"},
+            {
+                "type": "file",
+                "mediaType": "image/*",
+                "url": "data:image/png;base64,xx",
+            },
+        ]
+        assert caller_id.startswith("at-")
+        frames = data_stream_frames(response.text)
+        assert all(prefix == "aui-state" for prefix, _ in frames)
+
+
+async def test_add_message_prefers_a_host_registered_handler():
+    class LegacyHarness(Harness):
+        @command("add-message")
+        async def add_message_raw(self, cmd):
+            self.seen.append(cmd)
+
+    async with statewire_client(LegacyHarness) as (app, client):
+        command_body = {
+            "type": "add-message",
+            "message": {"role": "user", "parts": [{"type": "text", "text": "hi"}]},
+        }
+        response = await post_run(client, {"commands": [command_body], "state": {}})
+        assert response.status_code == 200
+        instance = (await app.state.pinned_host.directory.get("t1")).instance
+        assert instance.seen == [command_body]
+
+
+async def test_add_message_without_run_steer_is_an_error_frame():
+    async with statewire_client(Harness) as (app, client):
+        response = await post_run(
+            client,
+            {
+                "commands": [
+                    {
+                        "type": "add-message",
+                        "message": {"role": "user", "parts": []},
+                    }
+                ],
+                "state": {},
+            },
+        )
+        assert response.status_code == 200
+        frames = data_stream_frames(response.text)
+        assert frames[-1][0] == "3"
+        assert "unknown method: 'run/steer'" in frames[-1][1]
+
+
+async def test_malformed_add_message_is_an_error_frame():
+    async with statewire_client(RunHarness) as (app, client):
+        response = await post_run(
+            client,
+            {"commands": [{"type": "add-message", "message": "hi"}], "state": {}},
+        )
+        assert response.status_code == 200
+        frames = data_stream_frames(response.text)
+        assert frames[-1] == ("3", "add-message: message must be an object")
+        instance = (await app.state.pinned_host.directory.get("t1")).instance
+        assert instance.steered == []
+
+
+async def test_image_part_without_image_field_is_an_error_frame():
+    async with statewire_client(RunHarness) as (app, client):
+        response = await post_run(
+            client,
+            {
+                "commands": [
+                    {
+                        "type": "add-message",
+                        "message": {"role": "user", "parts": [{"type": "image"}]},
+                    }
+                ],
+                "state": {},
+            },
+        )
+        assert response.status_code == 200
+        frames = data_stream_frames(response.text)
+        assert frames[-1] == (
+            "3",
+            "add-message: image part requires a string image field",
+        )
+        instance = (await app.state.pinned_host.directory.get("t1")).instance
+        assert instance.steered == []
+
+
+async def test_cancel_dispatches_run_stop_when_registered():
+    async with statewire_client(RunHarness) as (app, client):
+        response = await client.post(
+            "/threads/t1/assistant-transport/api/cancel", json={"threadId": "t1"}
+        )
+        assert response.status_code == 200
+        assert response.json() == {"success": True, "found": False}
+        instance = (await app.state.pinned_host.directory.get("t1")).instance
+        assert instance.stopped == 1
+        assert instance.cancelled == 0
+
+
+async def test_cancel_swallows_a_run_stop_rejection():
+    class RejectingStop(RunHarness):
+        @command("run/stop")
+        async def run_stop(self, params=None, *, ctx):
+            raise StatewireReject("wrong-state")
+
+    async with statewire_client(RejectingStop) as (app, client):
+        response = await client.post(
+            "/threads/t1/assistant-transport/api/cancel", json={"threadId": "t1"}
+        )
+        assert response.status_code == 200
+        assert response.json() == {"success": True, "found": False}
+
+
+async def test_add_tool_result_is_normalized_to_run_input():
+    async with statewire_client(InputHarness) as (app, client):
+        response = await post_run(
+            client,
+            {
+                "commands": [
+                    {
+                        "type": "add-tool-result",
+                        "toolCallId": "call-1",
+                        "toolName": "search",
+                        "result": {"ok": True},
+                        "isError": True,
+                        "artifact": {"trace": [1, 2]},
+                    }
+                ],
+                "state": {},
+            },
+        )
+        assert response.status_code == 200
+        instance = (await app.state.pinned_host.directory.get("t1")).instance
+        assert instance.inputs == [
+            {
+                "requestId": "req-1",
+                "response": {
+                    "output": {"ok": True},
+                    "isError": True,
+                    "artifact": {"trace": [1, 2]},
+                },
+            }
+        ]
+
+        response = await post_run(
+            client,
+            {
+                "commands": [
+                    {
+                        "type": "add-tool-result",
+                        "toolCallId": "call-1",
+                        "result": "plain",
+                        "isError": False,
+                    }
+                ],
+                "state": {},
+            },
+        )
+        assert response.status_code == 200
+        assert instance.inputs[1] == {
+            "requestId": "req-1",
+            "response": {"output": "plain"},
+        }
+
+
+async def test_default_request_id_resolution_skips_answered_and_non_tool_requests():
+    async with statewire_client(InputHarness) as (app, client):
+        response = await post_run(
+            client,
+            {
+                "commands": [
+                    {"type": "add-tool-result", "toolCallId": "call-2", "result": 1}
+                ],
+                "state": {},
+            },
+        )
+        frames = data_stream_frames(response.text)
+        assert frames[-1] == (
+            "3",
+            "add-tool-result: no input request for toolCallId 'call-2'",
+        )
+
+
+async def test_add_tool_result_without_input_requests_state_is_an_error_frame():
+    async with statewire_client(RunHarness) as (app, client):
+        response = await post_run(
+            client,
+            {
+                "commands": [
+                    {"type": "add-tool-result", "toolCallId": "call-1", "result": 1}
+                ],
+                "state": {},
+            },
+        )
+        frames = data_stream_frames(response.text)
+        assert frames[-1] == (
+            "3",
+            "add-tool-result: no input request for toolCallId 'call-1'",
+        )
+        instance = (await app.state.pinned_host.directory.get("t1")).instance
+        assert instance.inputs == []
+
+
+async def test_add_tool_result_with_model_content_is_rejected():
+    async with statewire_client(InputHarness) as (app, client):
+        response = await post_run(
+            client,
+            {
+                "commands": [
+                    {
+                        "type": "add-tool-result",
+                        "toolCallId": "call-1",
+                        "result": 1,
+                        "modelContent": [{"type": "text", "text": "x"}],
+                    }
+                ],
+                "state": {},
+            },
+        )
+        frames = data_stream_frames(response.text)
+        assert frames[-1] == ("3", "add-tool-result: modelContent is not supported")
+
+
+async def test_add_tool_result_prefers_a_host_registered_handler():
+    class LegacyToolHarness(Harness):
+        @command("add-tool-result")
+        async def add_tool_result_raw(self, cmd):
+            self.seen.append(cmd)
+
+    async with statewire_client(LegacyToolHarness) as (app, client):
+        command_body = {
+            "type": "add-tool-result",
+            "toolCallId": "call-1",
+            "result": {"ok": True},
+        }
+        response = await post_run(client, {"commands": [command_body], "state": {}})
+        assert response.status_code == 200
+        instance = (await app.state.pinned_host.directory.get("t1")).instance
+        assert instance.seen == [command_body]
+
+
+async def test_parent_id_without_commands_is_normalized_to_run_reload():
+    async with statewire_client(AnchoredHarness) as (app, client):
+        response = await post_run(
+            client, {"commands": [], "state": {}, "parentId": "m1"}
+        )
+        assert response.status_code == 200
+        frames = data_stream_frames(response.text)
+        assert all(prefix == "aui-state" for prefix, _ in frames)
+        instance = (await app.state.pinned_host.directory.get("t1")).instance
+        assert instance.reloaded == [{"sourceId": "m2"}]
+
+
+async def test_reload_without_a_resolvable_child_is_an_error_frame():
+    async with statewire_client(RunHarness) as (app, client):
+        response = await post_run(
+            client, {"commands": [], "state": {}, "parentId": "m1"}
+        )
+        frames = data_stream_frames(response.text)
+        assert frames[-1] == ("3", "reload: no child message for parentId 'm1'")
+        instance = (await app.state.pinned_host.directory.get("t1")).instance
+        assert instance.reloaded == []
+
+
+async def test_add_message_with_a_resolvable_parent_is_normalized_to_run_edit():
+    async with statewire_client(AnchoredHarness) as (app, client):
+        response = await post_run(
+            client,
+            {
+                "commands": [
+                    {
+                        "type": "add-message",
+                        "message": {
+                            "role": "user",
+                            "parts": [{"type": "text", "text": "again"}],
+                        },
+                    }
+                ],
+                "state": {},
+                "parentId": "m1",
+            },
+        )
+        assert response.status_code == 200
+        instance = (await app.state.pinned_host.directory.get("t1")).instance
+        assert instance.steered == []
+        [params] = instance.edited
+        assert params["sourceId"] == "m2"
+        assert params["message"]["id"].startswith("legacy_")
+        assert params["message"]["parts"] == [{"type": "text", "text": "again"}]
+
+
+async def test_add_message_with_an_unresolvable_parent_falls_back_to_run_steer():
+    async with statewire_client(AnchoredHarness) as (app, client):
+        response = await post_run(
+            client,
+            {
+                "commands": [
+                    {
+                        "type": "add-message",
+                        "message": {
+                            "role": "user",
+                            "parts": [{"type": "text", "text": "hi"}],
+                        },
+                    }
+                ],
+                "state": {},
+                "parentId": "unknown",
+            },
+        )
+        assert response.status_code == 200
+        instance = (await app.state.pinned_host.directory.get("t1")).instance
+        assert instance.edited == []
+        [(params, _)] = instance.steered
+        assert set(params) == {"message"}

{statewire-0.3.0 → statewire-0.3.1}/tests/test_commands.py

@@ -551,6 +551,25 @@ async def test_duplicate_while_original_executing_does_not_rerun():
     assert runs == ["go"]
 
 
+async def test_plain_mixin_commands_register_on_the_subclass():
+    class Mixin:
+        @command("mixin/inc")
+        async def mixin_inc(self, by: int = 1):
+            self.state["count"] += by
+
+    class Host(Mixin, make_counter()):
+        pass
+
+    assert Host._statewire_commands["mixin/inc"] == "mixin_inc"
+    assert Host._statewire_commands["inc"] == "inc"
+    async with statewire_client(Host) as (app, client):
+        await attach(app)
+        await post_command(client, {"method": "mixin/inc", "params": [4]}, seq=1)
+        async with stream_of(app) as stream:
+            snapshot = await stream.next_event()
+        assert snapshot["ops"][0]["value"]["count"] == 4
+
+
 async def test_subclass_override_without_redecorating_dispatches_the_override():
     base = make_counter()