agent-runtime-py 0.2.0__tar.gz → 0.2.1__tar.gz

agent_runtime_py-0.2.1/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Changelog
+
+## 0.2.1
+
+- Fix: a Claude input that native Claude folded into a turn started by something else (a peer message, a background task) never settled, because that turn's result carries the other origin. The worker then took no further input and never exited on idle. A result now settles the active input when the input's echo arrived before it.
+- Fix: a turn that native Claude runs for another origin (a peer message) counts as work: the worker reports `turn.started` when that message arrives, not at the first assistant text, and does not exit on idle while the turn runs.
+- Fix: the Claude worker starts with `-P`, so the session's working folder is not on its import path.
+
+## 0.2.0
+
+- Breaking: requires typed-agent-hooks 0.3. Run the hooks with `agent_runtime.hooks.app.main()` and the host name (`codex` or `claude`) as the only argument; the host hook file sets the timeout. The `agent-runtime-hooks` console script is removed.
+- Breaking: the Claude Agent SDK moves to the `claude` extra. `ClaudeRuntime` needs `agent-runtime-py[claude]`.
+- Fix: a monitor worker whose command exceeded the output limit never exited and ignored SIGTERM.
+- Fix: a Claude SessionStart, which carries no permission mode, kept the mode empty; it now keeps the mode that the same live Claude process reported.

{agent_runtime_py-0.2.0 → agent_runtime_py-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agent-runtime-py
-Version: 0.2.0
+Version: 0.2.1
 Summary: Reconnectable native agent workers with durable input receipts and events
 Project-URL: Repository, https://github.com/nimashoghi/agent-runtime
 License-Expression: MIT

{agent_runtime_py-0.2.0 → agent_runtime_py-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "agent-runtime-py"
-version = "0.2.0"
+version = "0.2.1"
 description = "Reconnectable native agent workers with durable input receipts and events"
 readme = "README.md"
 license = "MIT"

{agent_runtime_py-0.2.0 → agent_runtime_py-0.2.1}/src/agent_runtime/claude.py

@@ -177,6 +177,9 @@ class ClaudeRuntime:
                     child = subprocess.Popen(
                         [
                             sys.executable,
+                            # The worker's cwd is the session's folder, which the agent
+                            # writes; it must not be on the worker's import path.
+                            "-P",
                             "-m",
                             "agent_runtime.worker",
                             str(self.store.root),

{agent_runtime_py-0.2.0 → agent_runtime_py-0.2.1}/src/agent_runtime/worker.py

@@ -100,6 +100,17 @@ class Worker:
             if isinstance(message, UserMessage) and message.uuid:
                 if admitted := self.store.admit(self.execution_id, message.uuid):
                     self.emit("input.delivered", message_id=admitted, native_uuid=message.uuid)
+                    if self.active and self.active["id"] == admitted:
+                        self.active["acknowledged"] = True
+                elif (
+                    (message.origin or {}).get("kind", "human") != "human"
+                    and message.parent_tool_use_id is None
+                    and not self.presentation_started
+                ):
+                    # A message from another origin (a peer session, a background task)
+                    # starts a turn that no input of this runtime asked for.
+                    self.emit("turn.started", origin="native")
+                    self.presentation_started = True
             elif isinstance(message, AssistantMessage) and message.parent_tool_use_id is None:
                 if not self.presentation_started:
                     self.emit("turn.started", origin="native")
@@ -113,7 +124,15 @@ class Worker:
                 if message.session_id != self.session_id:
                     raise RuntimeError("native Claude returned a different session ID")
                 human = message.origin is None or message.origin.get("kind") == "human"
-                active = self.active if human else None
+                # Native Claude can fold an input into a turn that something else started
+                # (a peer message, a background task); that turn's result carries the other
+                # origin. The turn that follows the input's echo is the one that consumed it.
+                # A non-human result before the echo belongs to an earlier turn.
+                active = (
+                    self.active
+                    if self.active and (human or self.active.get("acknowledged"))
+                    else None
+                )
                 status = "failed" if message.is_error else "completed"
                 if message.terminal_reason in {"aborted_streaming", "aborted_tools"}:
                     status = "interrupted"
@@ -243,6 +262,8 @@ class Worker:
                 if (
                     timeout
                     and self.active is None
+                    # A turn that native Claude runs for another origin is work too.
+                    and not self.presentation_started
                     and not self.background_tasks
                     and time.monotonic() - self.last_activity >= timeout
                     and not any(

{agent_runtime_py-0.2.0 → agent_runtime_py-0.2.1}/tests/test_claude_runtime.py

@@ -24,10 +24,11 @@ if "--version" in sys.argv:
 def emit(value):
     print(json.dumps(value), flush=True)
 session = next(a.split("=", 1)[1] for a in sys.argv if a.startswith(("--session-id=", "--resume=")))
-def result(text):
+PEER = {"kind":"peer","from":"unknown"}
+def result(text, origin={"kind":"human"}):
     emit({"type":"result", "subtype":"success", "is_error":False,
           "duration_ms":1,"duration_api_ms":1,"num_turns":1,"session_id":session,
-          "result":text,"origin":{"kind":"human"},"usage":{}})
+          "result":text,"origin":origin,"usage":{}})
 pending = None
 for line in sys.stdin:
     message = json.loads(line)
@@ -40,7 +41,25 @@ for line in sys.stdin:
             log.write(json.dumps({"text": text, "uuid":message["uuid"], "session": session}) + "\n")
         if text == "crash-before-echo":
             raise SystemExit(23)
+        if text == "folded-into-peer-turn":
+            # Native Claude, observed 2026-11-10: a peer message's turn ends, a second peer
+            # message starts a turn, the queued human input joins that turn, and the turn's
+            # result carries the peer origin.
+            result("first peer turn", PEER)
+            emit({"type":"user","uuid":"peer-message","message":{"role":"user","content":"peer"},"origin":PEER})
+            emit({"type":"user","uuid":message["uuid"],"message":{"role":"user","content":text},"origin":{"kind":"human"}})
+            result("answer to both", PEER)
+            continue
         emit({"type":"user","uuid":message["uuid"],"message":{"role":"user","content":text},"origin":{"kind":"human"}})
+        if text == "then-a-peer-turn":
+            # The input's own turn ends; a peer message then starts a turn that works
+            # in silence for longer than the idle timeout.
+            import time
+            result("echo: " + text)
+            emit({"type":"user","uuid":"peer-message","message":{"role":"user","content":"peer"},"origin":PEER})
+            time.sleep(1.5)
+            result("peer turn done", PEER)
+            continue
         if text == "permission":
             pending = text
             emit({"type":"control_request","request_id":"permission-1",
@@ -164,3 +183,63 @@ async def test_permission_waits_for_durable_explicit_answer(tmp_path, native):
             runtime.store.answer(eid, requests[0]["id"], {"decision": "allow"})
     finally:
         await runtime.stop(eid)
+
+
+async def test_input_folded_into_a_peer_turn_settles_with_that_turn(tmp_path, native):
+    runtime = ClaudeRuntime(tmp_path / "runtime")
+    opts = options(tmp_path, native)
+    value = await runtime.start(
+        "folded-into-peer-turn", message_id="m1", options=opts, launch_id="folded"
+    )
+    sid, eid = value["session_id"], value["execution_id"]
+
+    def settled():
+        return [
+            e["event"] for e in runtime.store.events(sid) if e["event"]["type"] == "work.settled"
+        ]
+
+    try:
+        await wait_for(lambda: len(settled()) >= 2)
+        # The first result came before the input's echo, so it is not the input's result.
+        assert [event["message_ids"] for event in settled()] == [[], ["m1"]]
+        assert settled()[1]["message"] == "answer to both"
+        # The worker is free again: it takes the next input.
+        await runtime.submit(sid, "next", message_id="m2", options=opts, resume=False)
+        await wait_for(lambda: len(settled()) >= 3)
+        assert settled()[2]["message_ids"] == ["m2"]
+    finally:
+        await runtime.stop(eid)
+
+
+async def test_a_turn_for_another_origin_is_not_ended_by_the_idle_timeout(tmp_path, native):
+    runtime = ClaudeRuntime(tmp_path / "runtime")
+    opts = LaunchOptions(
+        cwd=tmp_path,
+        claude=native,
+        idle_timeout_seconds=0.5,
+        environment={"FAKE_CLAUDE_LOG": str(tmp_path / "inputs.jsonl")},
+    )
+    value = await runtime.start("then-a-peer-turn", message_id="m1", options=opts, launch_id="peer")
+    sid, eid = value["session_id"], value["execution_id"]
+    try:
+        await wait_for(lambda: runtime.inspect(eid)["result"])
+        events = [e["event"] for e in runtime.store.events(sid)]
+        kinds = [
+            e["type"]
+            for e in events
+            if e["type"] in {"turn.started", "work.settled", "worker.exited"}
+        ]
+        # The worker saw the peer turn start and waited for its result before its idle exit.
+        assert kinds == [
+            "turn.started",
+            "work.settled",
+            "turn.started",
+            "work.settled",
+            "worker.exited",
+        ]
+        assert events[-1]["reason"] == "idle_timeout"
+        settled = [e for e in events if e["type"] == "work.settled"]
+        assert [e["message_ids"] for e in settled] == [["m1"], []]
+        assert settled[1]["message"] == "peer turn done"
+    finally:
+        await runtime.stop(eid)

{agent_runtime_py-0.2.0 → agent_runtime_py-0.2.1}/uv.lock

@@ -1,15 +1,15 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.11"
 resolution-markers = [
     "python_full_version >= '3.14'",
     "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten'",
-    "(python_full_version < '3.14' and sys_platform != 'emscripten') or (python_full_version < '3.12' and sys_platform == 'emscripten')",
+    "python_full_version < '3.12' or (python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten')",
 ]
 
 [[package]]
 name = "agent-runtime-py"
-version = "0.2.0"
+version = "0.2.1"
 source = { editable = "." }
 dependencies = [
     { name = "filelock" },

agent_runtime_py-0.2.0/CHANGELOG.md

@@ -1,8 +0,0 @@
-# Changelog
-
-## 0.2.0
-
-- Breaking: requires typed-agent-hooks 0.3. Run the hooks with `agent_runtime.hooks.app.main()` and the host name (`codex` or `claude`) as the only argument; the host hook file sets the timeout. The `agent-runtime-hooks` console script is removed.
-- Breaking: the Claude Agent SDK moves to the `claude` extra. `ClaudeRuntime` needs `agent-runtime-py[claude]`.
-- Fix: a monitor worker whose command exceeded the output limit never exited and ignored SIGTERM.
-- Fix: a Claude SessionStart, which carries no permission mode, kept the mode empty; it now keeps the mode that the same live Claude process reported.