harness-sdk-python 0.4.4__tar.gz → 0.5.0__tar.gz

{harness_sdk_python-0.4.4 → harness_sdk_python-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: harness-sdk-python
-Version: 0.4.4
+Version: 0.5.0
 Summary: RunManager: the harness-sdk runs subsystem for Python Statewire hosts
 Project-URL: Repository, https://github.com/assistant-ui/harness-sdk
 License-Expression: MIT

{harness_sdk_python-0.4.4 → harness_sdk_python-0.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "harness-sdk-python"
-version = "0.4.4"
+version = "0.5.0"
 description = "RunManager: the harness-sdk runs subsystem for Python Statewire hosts"
 readme = "README.md"
 license = "MIT"

harness_sdk_python-0.5.0/src/harness_sdk/__init__.py

@@ -0,0 +1,4 @@
+from .linear_thread import linear_thread_meta
+from .run_manager import RunManager
+
+__all__ = ["RunManager", "linear_thread_meta"]

harness_sdk_python-0.5.0/src/harness_sdk/linear_thread.py

@@ -0,0 +1,31 @@
+from typing import Any, Callable
+
+from .run_manager import GetMessageMeta
+
+
+def linear_thread_meta(
+    *,
+    messages: Callable[[], list[dict[str, Any]]],
+    role: Callable[[dict[str, Any]], str],
+) -> GetMessageMeta:
+    """RunManager ``get_message_meta`` for a linear message list: ``messages`` returns the current list, ``role`` maps a message to its role."""
+    if not callable(messages):
+        raise TypeError("messages must be callable")
+    if not callable(role):
+        raise TypeError("role must be callable")
+
+    async def get_message_meta(message_id: str | None) -> dict[str, Any] | None:
+        items = messages()
+        if message_id is None:
+            return {"isLeaf": not items}
+        for index, message in enumerate(items):
+            if message.get("id") == message_id:
+                return {
+                    "parentId": items[index - 1].get("id") if index > 0 else None,
+                    "role": role(message),
+                    "isLeaf": index == len(items) - 1,
+                    "onActiveBranch": True,
+                }
+        return None
+
+    return get_message_meta

{harness_sdk_python-0.4.4 → harness_sdk_python-0.5.0}/src/harness_sdk/run_manager.py

@@ -1,7 +1,7 @@
 """RunManager: the harness-sdk runs subsystem over a Statewire host.
 
 Implements the full state x command matrix from runs.mdx on a single
-``start(ctx)`` executor entrypoint, per the RunManager design (d4987).
+``run(ctx)`` executor entrypoint, per the RunManager design (d4987).
 
 Commands stage entries into an intake list and schedule a drain; the drain
 reduces the whole intake into the lanes in order (pure placement), then takes
@@ -17,6 +17,7 @@ initiators settle rejected (``stopped`` or the failure).
 """
 
 import asyncio
+import uuid
 from dataclasses import dataclass, field
 from typing import Any, Awaitable, Callable, Iterable
 
@@ -39,7 +40,7 @@ _CAPABILITIES = frozenset(
     }
 )
 
-_ENTRY_TYPES = (
+_TRIGGERS = (
     "message-send",
     "message-edit",
     "message-reload",
@@ -146,7 +147,7 @@ class RunManager:
         self,
         *,
         state: Any,
-        start: Callable[["RunManager.StartContext"], Awaitable[Any]],
+        run: Callable[["RunManager.RunContext"], Awaitable[Any]],
         get_message_meta: GetMessageMeta,
         create_task: Callable[[Any], "asyncio.Task[Any]"],
         schedule: Callable[[Callable[[], None]], None],
@@ -162,14 +163,14 @@ class RunManager:
         if max_queued < 1:
             raise ValueError("max_queued must be >= 1")
         self._state = state
-        self._start = start
+        self._run = run
         self._get_message_meta = get_message_meta
         self._capabilities = caps
         self._create_task = create_task
         self._schedule = schedule
         self._max_queued = max_queued
         self._task: "asyncio.Task[Any] | None" = None
-        self._ctx: "RunManager.StartContext | None" = None
+        self._ctx: "RunManager.RunContext | None" = None
         self._dispatched_ids: tuple[str, ...] = ()
         self._dispatch_record: dict[str, Any] | None = None
         self._intake: list[Any] = []
@@ -196,20 +197,52 @@ class RunManager:
     def _init_state(self) -> None:
         # Runs state is write-only and not durable: overwrite whatever is there.
         self._state["status"] = "ready"
-        self._state["error"] = None
-        self._state["queue"] = []
-        self._state["steerQueue"] = []
-        self._state["runLeafMessageId"] = None
-        self._state.pop("dispatch", None)
-        self._state.pop("inputRequests", None)
+        self._state["runs"] = []
+        for key in (
+            "error",
+            "queue",
+            "steerQueue",
+            "runId",
+            "runLeafMessageId",
+            "dispatch",
+            "inputRequests",
+        ):
+            self._state.pop(key, None)
 
     # ─── State access ───────────────────────────────────────
 
     def _status(self) -> str:
         return self._state["status"]
 
+    def _entry(self) -> Any:
+        runs = self._state["runs"]
+        return runs[0] if len(runs) else None
+
+    def _ensure_entry(self) -> Any:
+        if len(self._state["runs"]) == 0:
+            self._state["runs"].append(
+                {
+                    "runId": None,
+                    "status": "ready",
+                    "queue": [],
+                    "steerQueue": [],
+                    "error": None,
+                    "runLeafMessageId": None,
+                }
+            )
+        return self._state["runs"][0]
+
+    def _set_status(self, status: str) -> None:
+        self._entry()["status"] = status
+        self._state["status"] = status
+
+    def _to_ready(self) -> None:
+        self._state["runs"] = []
+        self._state["status"] = "ready"
+
     def _lane_items(self, lane: str) -> list[dict[str, Any]]:
-        return list(plain(self._state[lane]))
+        entry = self._entry()
+        return list(plain(entry[lane])) if entry is not None else []
 
     def _lane_of(self, message_id: str) -> str | None:
         for lane in ("steerQueue", "queue"):
@@ -326,96 +359,107 @@ class RunManager:
                 fx.continues.clear()
             elif fx.new_added and pre_empty:
                 self._pop_dispatchable()
-        elif (
-            status == "input-required"
-            and self._input_requests
-            and len(self._input_answers) == len(self._input_requests)
-        ):
-            responses = tuple(
-                (request, *self._input_answers[request["id"]])
-                for request in self._input_requests
-            )
-            self._clear_input()
-            self._dispatch("input-resume", [], responses=responses)
+        elif status == "input-required":
+            if fx.steer_added and self._lane_items("steerQueue"):
+                self._pop_dispatchable(input_outcomes=self._take_input_outcomes())
+            elif self._input_requests and len(self._input_answers) == len(
+                self._input_requests
+            ):
+                self._dispatch(
+                    "input-resume", [], input_outcomes=self._take_input_outcomes()
+                )
 
     def _settle_outcome(self, outcome: Any) -> None:
         if isinstance(outcome, RunManager.Complete):
             if not self._pop_dispatchable():
-                self._state["status"] = "ready"
-                self._state["runLeafMessageId"] = None
+                self._to_ready()
             return
         if isinstance(outcome, RunManager.InputRequired):
-            self._state["status"] = "input-required"
             self._input_requests = [dict(r) for r in outcome.requests]
             self._input_answers = {}
-            self._state["inputRequests"] = [
+            entry = self._entry()
+            entry["inputRequests"] = [
                 {**r, "response": None} for r in outcome.requests
             ]
+            self._set_status("input-required")
             return
         status = "error" if isinstance(outcome, RunManager.Error) else "stopped"
         if outcome.dispatch_queue and self._pop_dispatchable():
             return
-        self._state["status"] = status
+        self._set_status(status)
+        self._entry()["runId"] = None
 
     # ─── Dispatch and settle ────────────────────────────────
 
     def _clear_input(self) -> None:
         self._input_requests = []
         self._input_answers = {}
-        self._state.pop("inputRequests", None)
+        entry = self._entry()
+        if entry is not None:
+            entry.pop("inputRequests", None)
+
+    def _take_input_outcomes(self) -> tuple[tuple[dict[str, Any], Any, Any], ...]:
+        outcomes = tuple(
+            (request, *self._input_answers.get(request["id"], (None, None)))
+            for request in self._input_requests
+        )
+        self._clear_input()
+        return outcomes
 
     def _dispatch(
         self,
-        type: str,
+        trigger: str,
         messages: list[dict[str, Any]],
         *,
         rollback_to: Any = _ABSENT,
-        responses: Any = _ABSENT,
         root_meta: Any = None,
+        input_outcomes: tuple[tuple[dict[str, Any], Any, Any], ...] = (),
     ) -> None:
-        if type not in _ENTRY_TYPES:
-            raise ValueError(f"invalid entry type: {type!r}")
+        if trigger not in _TRIGGERS:
+            raise ValueError(f"invalid trigger: {trigger!r}")
         if self._task is not None:
             raise RuntimeError("a run is already in flight")
         message_meta = {m["id"]: m.get("meta") for m in messages}
         messages = [
             {k: v for k, v in message.items() if k != "meta"} for message in messages
         ]
-        record: dict[str, Any] = {"type": type, "messages": list(messages)}
+        record: dict[str, Any] = {"trigger": trigger, "messages": list(messages)}
         if rollback_to is not _ABSENT:
             record["rollbackTo"] = rollback_to
-        if responses is not _ABSENT:
-            record["responses"] = responses
+        if input_outcomes:
+            record["inputOutcomes"] = input_outcomes
         self._dispatch_record = record
         self._stop_reason = None
         self._run_acked = False
-        self._leaf_confirmed = plain(self._state["runLeafMessageId"])
-        self._state["error"] = None
+        entry = self._ensure_entry()
+        self._leaf_confirmed = plain(entry["runLeafMessageId"])
+        entry["error"] = None
         if messages:
             self._dispatched_ids = tuple(m["id"] for m in messages)
         if rollback_to is not _ABSENT:
-            self._state["runLeafMessageId"] = rollback_to
+            entry["runLeafMessageId"] = rollback_to
         if messages:
-            self._state["runLeafMessageId"] = messages[-1]["id"]
-        self._state["status"] = "running"
-        ctx = RunManager.StartContext(
-            type=type,
+            entry["runLeafMessageId"] = messages[-1]["id"]
+        entry["runId"] = uuid.uuid4().hex
+        self._set_status("running")
+        ctx = RunManager.RunContext(
+            trigger=trigger,
             messages=tuple(messages),
             stop_requested=asyncio.Event(),
             _manager=self,
             _rollback_to=rollback_to,
-            _responses=responses,
             _message_meta=message_meta,
             _root_meta=root_meta,
+            _input_outcomes=input_outcomes,
         )
         self._ctx = ctx
         self._sync_steering()
         self._idle.clear()
-        self._task = self._create_task(self._run(ctx))
+        self._task = self._create_task(self._execute(ctx))
 
-    async def _run(self, ctx: "RunManager.StartContext") -> None:
+    async def _execute(self, ctx: "RunManager.RunContext") -> None:
         try:
-            outcome = await self._start(ctx)
+            outcome = await self._run(ctx)
             if not isinstance(
                 outcome,
                 (
@@ -426,7 +470,7 @@ class RunManager:
                 ),
             ):
                 raise TypeError(
-                    "start must return a RunManager outcome, got "
+                    "run must return a RunManager outcome, got "
                     f"{type(outcome).__name__}"
                 )
             if isinstance(
@@ -437,7 +481,8 @@ class RunManager:
                 )
         except asyncio.CancelledError:
             self._settle(ctx)
-            self._state["status"] = "stopped"
+            self._set_status("stopped")
+            self._entry()["runId"] = None
             self._settle_initiators(_reject("stopped", "run cancelled"))
             self._revert_dispatching()
             self._idle.set()
@@ -466,7 +511,7 @@ class RunManager:
         self._outcome = outcome
         self._drain()
 
-    def _settle(self, ctx: "RunManager.StartContext") -> None:
+    def _settle(self, ctx: "RunManager.RunContext") -> None:
         if self._ctx is ctx:
             self._ctx = None
             self._task = None
@@ -491,7 +536,7 @@ class RunManager:
     def _ack_messages(self) -> None:
         self._dispatching = []
         self._run_acked = True
-        self._leaf_confirmed = plain(self._state["runLeafMessageId"])
+        self._leaf_confirmed = plain(self._entry()["runLeafMessageId"])
         self._settle_sends()
         self._settle_initiators(None)
 
@@ -500,38 +545,43 @@ class RunManager:
         taken, self._dispatching = self._dispatching, []
         if not taken:
             return
+        entry = self._ensure_entry()
         for lane in ("steerQueue", "queue"):
             front = [item for taken_lane, item in taken if taken_lane == lane]
             if front:
-                self._state[lane] = front + self._lane_items(lane)
+                entry[lane] = front + self._lane_items(lane)
         ids = {item["id"] for _, item in taken}
         self._dispatched_ids = tuple(id for id in self._dispatched_ids if id not in ids)
-        if plain(self._state["runLeafMessageId"]) in ids:
-            self._state["runLeafMessageId"] = self._leaf_confirmed
+        if plain(entry["runLeafMessageId"]) in ids:
+            entry["runLeafMessageId"] = self._leaf_confirmed
 
-    def _pop_dispatchable(self) -> bool:
+    def _pop_dispatchable(
+        self, *, input_outcomes: tuple[tuple[dict[str, Any], Any, Any], ...] = ()
+    ) -> bool:
         steer = self._lane_items("steerQueue")
         if steer:
-            self._state["steerQueue"] = []
+            self._entry()["steerQueue"] = []
             self._dispatching = [("steerQueue", item) for item in steer]
-            self._dispatch("message-send", steer)
+            self._dispatch("message-send", steer, input_outcomes=input_outcomes)
             return True
         queue = self._lane_items("queue")
         if queue:
-            self._state["queue"].pop(0)
+            self._entry()["queue"].pop(0)
             self._dispatching = [("queue", queue[0])]
-            self._dispatch("message-send", [queue[0]])
+            self._dispatch("message-send", [queue[0]], input_outcomes=input_outcomes)
             return True
         return False
 
     def _freeze(self, message: str, payload: Any = None) -> None:
-        self._state["status"] = "error"
+        self._set_status("error")
+        entry = self._entry()
+        entry["runId"] = None
         if isinstance(payload, dict):
-            self._state["error"] = {**payload, "message": message}
+            entry["error"] = {**payload, "message": message}
         elif payload is not None:
-            self._state["error"] = {"message": message, "payload": payload}
+            entry["error"] = {"message": message, "payload": payload}
         else:
-            self._state["error"] = {"message": message}
+            entry["error"] = {"message": message}
 
     # ─── Message and placement validation ───────────────────
 
@@ -684,9 +734,10 @@ class RunManager:
         )
         items = list(base)
         items.insert(index, self._stamped(message, meta))
+        entry = self._entry()
         if lane_change:
-            self._state[current] = without
-        self._state[target] = items
+            entry[current] = without
+        entry[target] = items
         self._sync_steering()
 
     def _insert_new(
@@ -698,7 +749,7 @@ class RunManager:
             self._resolve_index(items, placement, len(items)),
             self._stamped(message, meta),
         )
-        self._state[lane] = items
+        self._ensure_entry()[lane] = items
         self._sync_steering()
 
     # ─── Intake application ─────────────────────────────────
@@ -775,7 +826,7 @@ class RunManager:
         lane = self._lane_of(e.message_id)
         if lane is None:
             raise _reject("unknown-id", f"message {e.message_id} is not queued")
-        self._state[lane] = [
+        self._entry()[lane] = [
             item for item in self._lane_items(lane) if item["id"] != e.message_id
         ]
         self._sync_steering()
@@ -800,7 +851,7 @@ class RunManager:
                 f"input request {e.request_id} is already answered",
             )
         self._input_answers[e.request_id] = (e.response, e.meta)
-        self._state["inputRequests"][index]["response"] = e.response
+        self._entry()["inputRequests"][index]["response"] = e.response
         return None
 
     def _apply_edit(self, e: _Edit) -> Any:
@@ -982,19 +1033,20 @@ class RunManager:
         if reason is not _ABSENT and not isinstance(reason, str):
             raise _reject("invalid-message", "reason must be a string")
         status = self._status()
-        if status == "running":
-            if reason is not _ABSENT:
-                self._stop_reason = reason
-            entry = _Stop()
-            self._intake.append(entry)
-            ack()
-            self._schedule(self._drain)
-            return await entry.future
-        if status == "input-required":
-            self._clear_input()
-            self._state["status"] = "stopped"
-            return None
-        raise _reject("wrong-state", f"run/stop is rejected in {status}")
+        if status != "running":
+            raise _reject("wrong-state", f"run/stop is rejected in {status}")
+        run_id = (params or {}).get("runId")
+        if run_id != plain(self._entry()["runId"]):
+            raise _reject(
+                "wrong-state", f"runId {run_id!r} does not name the live run"
+            )
+        if reason is not _ABSENT:
+            self._stop_reason = reason
+        entry = _Stop()
+        self._intake.append(entry)
+        ack()
+        self._schedule(self._drain)
+        return await entry.future
 
     def _validated_response(self, request_type: str, response: Any) -> dict[str, Any]:
         if not isinstance(response, dict):
@@ -1104,17 +1156,18 @@ class RunManager:
     @dataclass(frozen=True, eq=False)
     class Steering:
         available: asyncio.Event
-        _ctx: "RunManager.StartContext"
+        _ctx: "RunManager.RunContext"
 
         def take(self) -> tuple[dict[str, Any], ...]:
             """Drain the steer lane into this run; items leave the projection, retained until the ack."""
             self._ctx._ensure_active()
             manager = self._ctx._manager
             items = manager._lane_items("steerQueue")
-            manager._state["steerQueue"] = []
+            entry = manager._entry()
+            entry["steerQueue"] = []
             manager._dispatching.extend(("steerQueue", item) for item in items)
             if items:
-                manager._state["runLeafMessageId"] = items[-1]["id"]
+                entry["runLeafMessageId"] = items[-1]["id"]
             self._ctx._message_meta.update(
                 {item["id"]: item.get("meta") for item in items}
             )
@@ -1124,15 +1177,15 @@ class RunManager:
             )
 
     @dataclass(frozen=True, eq=False)
-    class StartContext:
-        type: str
+    class RunContext:
+        trigger: str
         messages: tuple[dict[str, Any], ...]
         stop_requested: asyncio.Event
         _manager: "RunManager"
         _rollback_to: Any
-        _responses: Any
         _message_meta: dict[str, Any]
         _root_meta: Any
+        _input_outcomes: tuple[tuple[dict[str, Any], Any, Any], ...]
         steering: "RunManager.Steering" = field(init=False)
 
         def __post_init__(self) -> None:
@@ -1148,6 +1201,11 @@ class RunManager:
                 raise ValueError(f"message {message_id} was not dispatched to this run")
             return self._message_meta[message_id]
 
+        @property
+        def input_outcomes(self) -> tuple[tuple[dict[str, Any], Any, Any], ...]:
+            """The consumed pending set's ordered (request, response, meta) triples; response None marks unanswered."""
+            return self._input_outcomes
+
         @property
         def stop_reason(self) -> str | None:
             return self._manager._stop_reason
@@ -1164,14 +1222,6 @@ class RunManager:
                 )
             return self._rollback_to
 
-        @property
-        def responses(self) -> tuple[tuple[dict[str, Any], dict[str, Any], Any], ...]:
-            if self._responses is _ABSENT:
-                raise AttributeError(
-                    "responses is only present on input-resume entries"
-                )
-            return self._responses
-
         def _ensure_active(self) -> None:
             if self._manager._ctx is not self:
                 raise RuntimeError("this run has already settled")
@@ -1186,7 +1236,7 @@ class RunManager:
                 raise ValueError("message_id must be a non-empty string")
             if self._manager._dispatching or not self._manager._run_acked:
                 raise RuntimeError("ack_messages must precede set_leaf_message_id")
-            self._manager._state["runLeafMessageId"] = message_id
+            self._manager._entry()["runLeafMessageId"] = message_id
 
         def set_recovery_state(self, value: Any) -> None:
             self._ensure_active()

{harness_sdk_python-0.4.4 → harness_sdk_python-0.5.0}/tests/run_helpers.py

@@ -12,7 +12,7 @@ from harness_sdk import RunManager
 
 @dataclass
 class Call:
-    ctx: RunManager.StartContext
+    ctx: RunManager.RunContext
     outcome: "asyncio.Future[Any]"
 
     def ack(self) -> None:
@@ -26,14 +26,14 @@ class Call:
 
 
 class Script:
-    """Scripted executor: each start() parks as a Call the test settles, and
+    """Scripted executor: each run() parks as a Call the test settles, and
     ``thread`` is the message-meta table the executor is pretending to write."""
 
     def __init__(self) -> None:
         self.calls: asyncio.Queue[Call] = asyncio.Queue()
         self.thread: dict[str, dict[str, Any]] = {}
 
-    async def start(self, ctx: RunManager.StartContext) -> Any:
+    async def run(self, ctx: RunManager.RunContext) -> Any:
         call = Call(ctx, asyncio.get_running_loop().create_future())
         self.calls.put_nowait(call)
         return await call.outcome
@@ -66,7 +66,7 @@ def make_host(script: Script, capabilities=(), initial_runs=None, max_queued=50)
             )
             self.runs = RunManager(
                 state=self.state,
-                start=script.start,
+                run=script.run,
                 get_message_meta=script.get_message_meta,
                 create_task=self.create_task,
                 schedule=self.schedule,
@@ -191,6 +191,31 @@ class RunDriver:
             lambda s: s["status"] in statuses, timeout=timeout
         )
 
+    @property
+    def run(self) -> dict[str, Any]:
+        """The single run entry; asserts one exists."""
+        runs = self.replica["runs"]
+        assert runs, "no run entry in the replica"
+        return runs[0]
+
+    async def run_id(self, timeout: float = 5) -> str:
+        """The live run's id; waits for the replica to catch up to the dispatch."""
+        await self.wait(
+            lambda s: bool(s["runs"]) and s["runs"][0]["runId"] is not None,
+            timeout=timeout,
+        )
+        return self.run["runId"]
+
+    async def stop(
+        self, params: Any = None, *, terminal: bool = True
+    ) -> dict[str, Any]:
+        """run/stop targeting the live run's id read from the replica."""
+        return await self.command(
+            "run/stop",
+            {"runId": await self.run_id(), **(params or {})},
+            terminal=terminal,
+        )
+
 
 @asynccontextmanager
 async def run_host(script: Script, capabilities=(), initial_runs=None, max_queued=50):
@@ -222,5 +247,12 @@ def assert_rejected(rsp: dict[str, Any], reason: str) -> None:
     assert rsp["payload"] == {"reason": reason}, rsp
 
 
-def queue_ids(runs: dict[str, Any], lane: str) -> list[str]:
-    return [item["id"] for item in runs[lane]]
+def run_of(replica: dict[str, Any]) -> dict[str, Any]:
+    """The run entry of a replica snapshot; empty dict while resting."""
+    runs = replica["runs"]
+    return runs[0] if runs else {}
+
+
+def queue_ids(replica: dict[str, Any], lane: str) -> list[str]:
+    runs = replica["runs"]
+    return [item["id"] for item in runs[0][lane]] if runs else []

{harness_sdk_python-0.4.4 → harness_sdk_python-0.5.0}/tests/test_batches.py

@@ -23,7 +23,7 @@ async def test_multi_steer_batch_places_all_and_dispatches_once():
         for offset in range(3):
             assert (await drv.res(first + offset, terminal=False))["type"] == "pending"
         call = await script.next_call()
-        assert call.ctx.type == "message-send"
+        assert call.ctx.trigger == "message-send"
         assert [m["id"] for m in call.ctx.messages] == ["s1", "s2", "s3"]
         script.no_call()
         assert queue_ids(drv.replica, "steerQueue") == []
@@ -39,7 +39,7 @@ async def test_steer_and_stop_in_one_batch_nets_to_stop():
         await drv.command("run/enqueue", add("m1"), terminal=False)
         call = await script.next_call()
         first = await drv.batch(
-            [("run/steer", add("s1")), ("run/stop", None)]
+            [("run/steer", add("s1")), ("run/stop", {"runId": await drv.run_id()})]
         )
         assert (await drv.res(first))["type"] == "accepted"
         assert (await drv.res(first + 1, terminal=False))["type"] == "pending"
@@ -56,7 +56,7 @@ async def test_stop_settles_only_after_the_run_task_ends():
     async with run_host(script) as (drv, host):
         await drv.command("run/enqueue", add("m1"), terminal=False)
         call = await script.next_call()
-        pending = await drv.command("run/stop", terminal=False)
+        pending = await drv.stop(terminal=False)
         assert pending["type"] == "pending"
         for _ in range(5):
             await asyncio.sleep(0)