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

agent_runtime_py-0.2.2/CHANGELOG.md

@@ -0,0 +1,21 @@
+# Changelog
+
+## 0.2.2
+
+- Add `LaunchOptions.effort` (`low`, `medium`, `high`, `xhigh` or `max`), passed to native Claude.
+- A worker that fails adds `native_stderr` to its result: the last lines (at most 20, each at most 500 characters) that native Claude wrote to stderr since its last result. They are often the reason of a failed start, where the SDK's error only says to check stderr. They are not redacted; a consumer decides whether to show them.
+- Fix: `LaunchOptions.claude` and the `claude` found on PATH are used as given (made absolute), not as their link target. A version manager's shim (a link to the manager) was resolved to the manager, which then did not run Claude. A path that is not a file, also a directory, now raises `ValueError`; a missing path raised `FileNotFoundError` before.
+- A repeated launch ID no longer compares the path of the Claude executable, so a launch that 0.2.1 recorded can be repeated.
+
+## 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.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agent-runtime-py
-Version: 0.2.0
+Version: 0.2.2
 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.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "agent-runtime-py"
-version = "0.2.0"
+version = "0.2.2"
 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.2}/src/agent_runtime/claude.py

@@ -33,6 +33,7 @@ class LaunchOptions:
     permission_mode: str = "default"
     allowed_tools: tuple[str, ...] = ()
     model: str | None = None
+    effort: str | None = None
     metadata: dict[str, Any] = field(default_factory=dict)
 
     def configuration(self) -> dict[str, Any]:
@@ -48,18 +49,34 @@ class LaunchOptions:
             "auto",
         }:
             raise ValueError("unknown Claude permission mode")
+        if self.effort is not None and self.effort not in ("low", "medium", "high", "xhigh", "max"):
+            raise ValueError("unknown Claude effort level")
         cwd = self.cwd.expanduser().resolve(strict=True)
         if not cwd.is_dir():
             raise ValueError("cwd must be a directory")
         executable = str(self.claude) if self.claude else shutil.which("claude")
         if not executable:
             raise ValueError("Claude Code executable not found")
+        # The path as given, not its link target: a version manager's shim is a link to the
+        # manager, which chooses the program by the name it was called with.
+        claude = Path(executable).expanduser().absolute()
+        if not claude.is_file():
+            raise ValueError(f"Claude Code executable not found: {claude}")
         value = asdict(self)
         value.pop("environment")
-        value.update(cwd=str(cwd), claude=str(Path(executable).expanduser().resolve(strict=True)))
+        if self.effort is None:
+            value.pop("effort")  # as a record of a version without the field
+        value.update(cwd=str(cwd), claude=str(claude))
         return json.loads(json.dumps(value))
 
 
+def launch_identity(configuration: dict[str, Any]) -> dict[str, Any]:
+    """The part of a launch configuration that a repeated launch ID must repeat. The path of
+    the Claude executable is not part of it: its spelling changes with the installation and
+    between versions of this package (0.2.1 stored the link's target)."""
+    return {key: value for key, value in configuration.items() if key != "claude"}
+
+
 def process_alive(value: dict[str, Any]) -> bool:
     """PID reuse must never attach a client to an unrelated process."""
     if not value.get("pid") or not value.get("process_created_at"):
@@ -145,15 +162,11 @@ class ClaudeRuntime:
             }
             if not self.store.create_execution(value):
                 existing = self.inspect(execution_id)
-                for key in (
-                    "initial_message_id",
-                    "initial_digest",
-                    "resume",
-                    "fork",
-                    "configuration",
-                ):
+                for key in ("initial_message_id", "initial_digest", "resume", "fork"):
                     if existing[key] != value[key]:
                         raise ValueError(f"launch ID already used with different {key}")
+                if launch_identity(existing["configuration"]) != launch_identity(configuration):
+                    raise ValueError("launch ID already used with different configuration")
                 return existing
             self.store.accept(session_id, execution_id, message_id, text)
             environment = {**os.environ, **options.environment}
@@ -177,6 +190,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.2}/src/agent_runtime/worker.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import asyncio
+import collections
 import logging
 import os
 import signal
@@ -45,6 +46,14 @@ class Worker:
         self.last_activity = time.monotonic()
         self.background_tasks: set[str] = set()
         self.presentation_started = False
+        # The last lines that native Claude wrote to stderr since its last result. When the
+        # worker fails, they go into its result apart from the error: they are often the
+        # reason (the SDK's error only says to check stderr), but not always.
+        self.stderr: collections.deque[str] = collections.deque(maxlen=20)
+
+    def native_stderr(self, line: str) -> None:
+        log.debug("claude: %s", line)
+        self.stderr.append(line[:500])
 
     def emit(self, kind: str, **fields: Any) -> None:
         self.store.append(self.execution_id, self.session_id, {"type": kind, **fields})
@@ -100,6 +109,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")
@@ -112,8 +132,17 @@ class Worker:
             elif isinstance(message, ResultMessage):
                 if message.session_id != self.session_id:
                     raise RuntimeError("native Claude returned a different session ID")
+                self.stderr.clear()  # what it wrote before a result is not about a later failure
                 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"
@@ -170,6 +199,7 @@ class Worker:
             permission_mode=policy["permission_mode"],
             allowed_tools=policy["allowed_tools"],
             model=policy["model"],
+            effort=policy.get("effort"),  # absent in the record of an older version
             setting_sources=["user", "project", "local"],
             system_prompt={
                 "type": "preset",
@@ -177,7 +207,7 @@ class Worker:
                 "append": policy["instructions"] or "",
             },
             can_use_tool=self.permission,
-            stderr=lambda line: log.debug("claude: %s", line),
+            stderr=self.native_stderr,
             extra_args={"replay-user-messages": None},
             session_id=self.session_id
             if not self.execution["resume"] or self.execution["fork"]
@@ -243,6 +273,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(
@@ -256,6 +288,8 @@ class Worker:
         except Exception as error:
             log.exception("Claude worker failed")
             result = {"status": "failed", "error": str(error)}
+            if self.stderr:
+                result["native_stderr"] = list(self.stderr)
         finally:
             self.stopping.set()
             try:

agent_runtime_py-0.2.2/tests/test_claude_runtime.py

@@ -0,0 +1,345 @@
+"""Exercise the real SDK and detached processes against a deterministic native boundary."""
+
+import asyncio
+import json
+import os
+import sys
+from pathlib import Path
+
+import pytest
+
+from agent_runtime import ClaudeRuntime, LaunchOptions
+
+
+@pytest.fixture
+def native(tmp_path: Path) -> Path:
+    cli = tmp_path / "claude"
+    cli.write_text(
+        f"#!{sys.executable}\n"
+        + r"""
+import json, os, sys
+if "--version" in sys.argv:
+    print("2.1.281 (Claude Code)")
+    raise SystemExit(0)
+if os.environ.get("FAKE_CLAUDE_ARGV"):
+    with open(os.environ["FAKE_CLAUDE_ARGV"], "w") as log:
+        json.dump(sys.argv, log)
+if os.environ.get("FAKE_CLAUDE_FAILS"):
+    for number in range(30):
+        print(f"line {number} " + "x" * 600, file=sys.stderr, flush=True)
+    print("Invalid API key - Please run /login", file=sys.stderr, flush=True)
+    raise SystemExit(1)
+print("warning: a line at the start", file=sys.stderr, flush=True)
+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=")))
+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":origin,"usage":{}})
+pending = None
+for line in sys.stdin:
+    message = json.loads(line)
+    if message["type"] == "control_request":
+        emit({"type":"control_response","response":{"subtype":"success",
+              "request_id":message["request_id"],"response":{}}})
+    elif message["type"] == "user":
+        text = message["message"]["content"]
+        with open(os.environ["FAKE_CLAUDE_LOG"], "a") as log:
+            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 == "wrong-session":
+            # A failure of the worker's own check, late in a session, with no stderr line.
+            emit({"type":"result", "subtype":"success", "is_error":False, "duration_ms":1,
+                  "duration_api_ms":1, "num_turns":1, "session_id":"another-session",
+                  "result":"x", "origin":{"kind":"human"}, "usage":{}})
+            continue
+        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",
+                  "request":{"subtype":"can_use_tool","tool_name":"Bash",
+                             "input":{"command":"touch example"},"tool_use_id":"tool-1"}})
+        elif text != "hold":
+            result("echo: " + text)
+    elif message["type"] == "control_response" and pending:
+        result(json.dumps(message["response"]["response"]))
+        pending = None
+"""
+    )
+    cli.chmod(0o700)
+    return cli
+
+
+async def wait_for(predicate):
+    for _ in range(200):
+        if value := predicate():
+            return value
+        await asyncio.sleep(0.05)
+    raise AssertionError("condition did not become true")
+
+
+def options(tmp_path: Path, native: Path) -> LaunchOptions:
+    return LaunchOptions(
+        cwd=tmp_path,
+        claude=native,
+        idle_timeout_seconds=0,
+        environment={
+            "FAKE_CLAUDE_LOG": str(tmp_path / "inputs.jsonl"),
+            "PRIVATE_TEST_SECRET": "do-not-persist-this",
+        },
+    )
+
+
+async def test_reconnect_duplicate_admission_and_explicit_resume(tmp_path, native):
+    root = tmp_path / "runtime"
+    runtime = ClaudeRuntime(root)
+    opts = options(tmp_path, native)
+    first = await runtime.start("hello", message_id="m1", options=opts, launch_id="launch1")
+    sid, eid = first["session_id"], first["execution_id"]
+    try:
+        await wait_for(
+            lambda: any(e["event"]["type"] == "work.settled" for e in runtime.store.events(sid))
+        )
+        # A new client is the entire application-service restart contract.
+        runtime = ClaudeRuntime(root)
+        assert runtime.inspect(eid)["result"] is None
+        assert runtime.store.receipt(sid, "m1")["status"] == "delivered"
+        assert (await runtime.start("hello", message_id="m1", options=opts, launch_id="launch1"))[
+            "execution_id"
+        ] == eid
+        with pytest.raises(ValueError, match="different"):
+            await runtime.start("changed", message_id="m1", options=opts, launch_id="launch1")
+        await runtime.submit(sid, "next", message_id="m2", options=opts, resume=False)
+        await wait_for(lambda: runtime.store.receipt(sid, "m2")["status"] == "delivered")
+        receipt = await runtime.submit(sid, "next", message_id="m2", options=opts, resume=False)
+        assert receipt["status"] == "delivered"
+        with pytest.raises(ValueError):
+            await runtime.submit(sid, "different", message_id="m2", options=opts, resume=False)
+        assert "do-not-persist-this" not in runtime.store.path.read_bytes().decode(errors="ignore")
+        assert os.stat(root).st_mode & 0o777 == 0o700
+        assert os.stat(runtime.store.path).st_mode & 0o777 == 0o600
+        assert (await runtime.stop(eid))["result"]["status"] == "stopped"
+        rejected = await runtime.submit(sid, "later", message_id="m3", options=opts, resume=False)
+        assert rejected["status"] == "rejected"
+        resumed = await runtime.submit(sid, "later", message_id="m3", options=opts, resume=True)
+        eid = resumed["execution_id"]
+        assert eid != first["execution_id"]
+        await wait_for(lambda: runtime.store.receipt(sid, "m3")["status"] == "delivered")
+        recorded = [
+            json.loads(line) for line in (tmp_path / "inputs.jsonl").read_text().splitlines()
+        ]
+        assert [r["text"] for r in recorded] == ["hello", "next", "later"]
+        assert {r["session"] for r in recorded} == {sid}
+    finally:
+        await runtime.stop(eid)
+
+
+async def test_lost_native_ack_is_uncertain_and_never_replayed(tmp_path, native):
+    runtime = ClaudeRuntime(tmp_path / "runtime")
+    opts = options(tmp_path, native)
+    value = await runtime.start(
+        "crash-before-echo", message_id="m1", options=opts, launch_id="crash"
+    )
+    sid, eid = value["session_id"], value["execution_id"]
+    try:
+        await wait_for(lambda: runtime.inspect(eid)["result"])
+        assert runtime.store.receipt(sid, "m1")["status"] == "uncertain"
+        saved = await runtime.submit(
+            sid, "crash-before-echo", message_id="m1", options=opts, resume=True
+        )
+        assert saved["status"] == "uncertain"
+        assert len((tmp_path / "inputs.jsonl").read_text().splitlines()) == 1
+    finally:
+        await runtime.stop(eid)
+
+
+async def test_permission_waits_for_durable_explicit_answer(tmp_path, native):
+    runtime = ClaudeRuntime(tmp_path / "runtime")
+    value = await runtime.start(
+        "permission", message_id="m1", options=options(tmp_path, native), launch_id="permission"
+    )
+    sid, eid = value["session_id"], value["execution_id"]
+    try:
+        requests = await wait_for(lambda: runtime.store.interactions(eid))
+        assert requests[0]["params"]["tool"] == "Bash"
+        assert not any(e["event"]["type"] == "work.settled" for e in runtime.store.events(sid))
+        runtime = ClaudeRuntime(tmp_path / "runtime")
+        runtime.store.answer(eid, requests[0]["id"], {"decision": "deny"})
+        settled = await wait_for(
+            lambda: [
+                e["event"]
+                for e in runtime.store.events(sid)
+                if e["event"]["type"] == "work.settled"
+            ]
+        )
+        assert json.loads(settled[0]["message"])["behavior"] == "deny"
+        with pytest.raises(ValueError):
+            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)
+
+
+async def test_effort_reaches_native_claude_and_a_link_to_it_is_not_resolved(tmp_path, native):
+    link = tmp_path / "shim"
+    link.symlink_to(native)
+    opts = LaunchOptions(
+        cwd=tmp_path,
+        claude=link,
+        effort="high",
+        idle_timeout_seconds=0,
+        environment={
+            "FAKE_CLAUDE_LOG": str(tmp_path / "inputs.jsonl"),
+            "FAKE_CLAUDE_ARGV": str(tmp_path / "argv.json"),
+        },
+    )
+    assert opts.configuration()["claude"] == str(link)
+    with pytest.raises(ValueError, match="effort"):
+        LaunchOptions(cwd=tmp_path, claude=native, effort="extreme").configuration()
+    with pytest.raises(ValueError, match="not found"):
+        LaunchOptions(cwd=tmp_path, claude=tmp_path / "missing").configuration()
+    runtime = ClaudeRuntime(tmp_path / "runtime")
+    value = await runtime.start("hello", message_id="m1", options=opts, launch_id="effort")
+    try:
+        await wait_for(
+            lambda: runtime.store.receipt(value["session_id"], "m1")["status"] == "delivered"
+        )
+        argv = json.loads((tmp_path / "argv.json").read_text())
+        assert argv[0] == str(link) and argv[argv.index("--effort") + 1] == "high"
+    finally:
+        await runtime.stop(value["execution_id"])
+
+
+async def test_a_native_claude_that_fails_at_its_start_reports_what_it_wrote(tmp_path, native):
+    runtime = ClaudeRuntime(tmp_path / "runtime")
+    opts = options(tmp_path, native)
+    opts.environment["FAKE_CLAUDE_FAILS"] = "1"
+    value = await runtime.start("hello", message_id="m1", options=opts, launch_id="fails")
+    result = await wait_for(lambda: runtime.inspect(value["execution_id"])["result"])
+    assert result["status"] == "failed" and "Invalid API key" not in result["error"]
+    # The last 20 lines, each cut to 500 characters, apart from the error.
+    lines = result["native_stderr"]
+    assert len(lines) == 20 and lines[-1] == "Invalid API key - Please run /login"
+    assert all(len(line) <= 500 for line in lines) and lines[0].startswith("line 11 ")
+    assert runtime.store.receipt(value["session_id"], "m1")["status"] == "rejected"
+
+
+async def test_stderr_from_before_a_result_is_not_reported_with_a_later_failure(tmp_path, native):
+    runtime = ClaudeRuntime(tmp_path / "runtime")
+    opts = options(tmp_path, native)
+    value = await runtime.start("hello", message_id="m1", options=opts, launch_id="late")
+    sid, eid = value["session_id"], value["execution_id"]
+    await wait_for(lambda: runtime.store.receipt(sid, "m1")["status"] == "delivered")
+    await runtime.submit(sid, "wrong-session", message_id="m2", options=opts, resume=False)
+    result = await wait_for(lambda: runtime.inspect(eid)["result"])
+    assert result["status"] == "failed" and "different session ID" in result["error"]
+    assert "native_stderr" not in result  # the warning at the start came before the first result
+
+
+async def test_a_launch_id_from_an_older_version_can_be_repeated(tmp_path, native):
+    """0.2.1 stored no effort and the link target of the executable; a repeat of that launch
+    by this version must find the same execution."""
+    link = tmp_path / "shim"
+    link.symlink_to(native)
+    runtime = ClaudeRuntime(tmp_path / "runtime")
+    opts = LaunchOptions(
+        cwd=tmp_path,
+        claude=link,
+        idle_timeout_seconds=0,
+        environment={"FAKE_CLAUDE_LOG": str(tmp_path / "inputs.jsonl")},
+    )
+    assert "effort" not in opts.configuration()
+    first = await runtime.start("hello", message_id="m1", options=opts, launch_id="old")
+    eid = first["execution_id"]
+    try:
+        stored = dict(runtime.store.execution(eid)["configuration"], claude=str(native.resolve()))
+        runtime.store.update(eid, configuration=stored)
+        again = await runtime.start("hello", message_id="m1", options=opts, launch_id="old")
+        assert again["execution_id"] == eid
+        with pytest.raises(ValueError, match="configuration"):
+            changed = LaunchOptions(
+                cwd=tmp_path, claude=link, effort="high", idle_timeout_seconds=0
+            )
+            await runtime.start("hello", message_id="m1", options=changed, launch_id="old")
+    finally:
+        await runtime.stop(eid)

{agent_runtime_py-0.2.0 → agent_runtime_py-0.2.2}/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.2"
 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.

agent_runtime_py-0.2.0/tests/test_claude_runtime.py

@@ -1,166 +0,0 @@
-"""Exercise the real SDK and detached processes against a deterministic native boundary."""
-
-import asyncio
-import json
-import os
-import sys
-from pathlib import Path
-
-import pytest
-
-from agent_runtime import ClaudeRuntime, LaunchOptions
-
-
-@pytest.fixture
-def native(tmp_path: Path) -> Path:
-    cli = tmp_path / "claude"
-    cli.write_text(
-        f"#!{sys.executable}\n"
-        + r"""
-import json, os, sys
-if "--version" in sys.argv:
-    print("2.1.281 (Claude Code)")
-    raise SystemExit(0)
-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):
-    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":{}})
-pending = None
-for line in sys.stdin:
-    message = json.loads(line)
-    if message["type"] == "control_request":
-        emit({"type":"control_response","response":{"subtype":"success",
-              "request_id":message["request_id"],"response":{}}})
-    elif message["type"] == "user":
-        text = message["message"]["content"]
-        with open(os.environ["FAKE_CLAUDE_LOG"], "a") as log:
-            log.write(json.dumps({"text": text, "uuid":message["uuid"], "session": session}) + "\n")
-        if text == "crash-before-echo":
-            raise SystemExit(23)
-        emit({"type":"user","uuid":message["uuid"],"message":{"role":"user","content":text},"origin":{"kind":"human"}})
-        if text == "permission":
-            pending = text
-            emit({"type":"control_request","request_id":"permission-1",
-                  "request":{"subtype":"can_use_tool","tool_name":"Bash",
-                             "input":{"command":"touch example"},"tool_use_id":"tool-1"}})
-        elif text != "hold":
-            result("echo: " + text)
-    elif message["type"] == "control_response" and pending:
-        result(json.dumps(message["response"]["response"]))
-        pending = None
-"""
-    )
-    cli.chmod(0o700)
-    return cli
-
-
-async def wait_for(predicate):
-    for _ in range(200):
-        if value := predicate():
-            return value
-        await asyncio.sleep(0.05)
-    raise AssertionError("condition did not become true")
-
-
-def options(tmp_path: Path, native: Path) -> LaunchOptions:
-    return LaunchOptions(
-        cwd=tmp_path,
-        claude=native,
-        idle_timeout_seconds=0,
-        environment={
-            "FAKE_CLAUDE_LOG": str(tmp_path / "inputs.jsonl"),
-            "PRIVATE_TEST_SECRET": "do-not-persist-this",
-        },
-    )
-
-
-async def test_reconnect_duplicate_admission_and_explicit_resume(tmp_path, native):
-    root = tmp_path / "runtime"
-    runtime = ClaudeRuntime(root)
-    opts = options(tmp_path, native)
-    first = await runtime.start("hello", message_id="m1", options=opts, launch_id="launch1")
-    sid, eid = first["session_id"], first["execution_id"]
-    try:
-        await wait_for(
-            lambda: any(e["event"]["type"] == "work.settled" for e in runtime.store.events(sid))
-        )
-        # A new client is the entire application-service restart contract.
-        runtime = ClaudeRuntime(root)
-        assert runtime.inspect(eid)["result"] is None
-        assert runtime.store.receipt(sid, "m1")["status"] == "delivered"
-        assert (await runtime.start("hello", message_id="m1", options=opts, launch_id="launch1"))[
-            "execution_id"
-        ] == eid
-        with pytest.raises(ValueError, match="different"):
-            await runtime.start("changed", message_id="m1", options=opts, launch_id="launch1")
-        await runtime.submit(sid, "next", message_id="m2", options=opts, resume=False)
-        await wait_for(lambda: runtime.store.receipt(sid, "m2")["status"] == "delivered")
-        receipt = await runtime.submit(sid, "next", message_id="m2", options=opts, resume=False)
-        assert receipt["status"] == "delivered"
-        with pytest.raises(ValueError):
-            await runtime.submit(sid, "different", message_id="m2", options=opts, resume=False)
-        assert "do-not-persist-this" not in runtime.store.path.read_bytes().decode(errors="ignore")
-        assert os.stat(root).st_mode & 0o777 == 0o700
-        assert os.stat(runtime.store.path).st_mode & 0o777 == 0o600
-        assert (await runtime.stop(eid))["result"]["status"] == "stopped"
-        rejected = await runtime.submit(sid, "later", message_id="m3", options=opts, resume=False)
-        assert rejected["status"] == "rejected"
-        resumed = await runtime.submit(sid, "later", message_id="m3", options=opts, resume=True)
-        eid = resumed["execution_id"]
-        assert eid != first["execution_id"]
-        await wait_for(lambda: runtime.store.receipt(sid, "m3")["status"] == "delivered")
-        recorded = [
-            json.loads(line) for line in (tmp_path / "inputs.jsonl").read_text().splitlines()
-        ]
-        assert [r["text"] for r in recorded] == ["hello", "next", "later"]
-        assert {r["session"] for r in recorded} == {sid}
-    finally:
-        await runtime.stop(eid)
-
-
-async def test_lost_native_ack_is_uncertain_and_never_replayed(tmp_path, native):
-    runtime = ClaudeRuntime(tmp_path / "runtime")
-    opts = options(tmp_path, native)
-    value = await runtime.start(
-        "crash-before-echo", message_id="m1", options=opts, launch_id="crash"
-    )
-    sid, eid = value["session_id"], value["execution_id"]
-    try:
-        await wait_for(lambda: runtime.inspect(eid)["result"])
-        assert runtime.store.receipt(sid, "m1")["status"] == "uncertain"
-        saved = await runtime.submit(
-            sid, "crash-before-echo", message_id="m1", options=opts, resume=True
-        )
-        assert saved["status"] == "uncertain"
-        assert len((tmp_path / "inputs.jsonl").read_text().splitlines()) == 1
-    finally:
-        await runtime.stop(eid)
-
-
-async def test_permission_waits_for_durable_explicit_answer(tmp_path, native):
-    runtime = ClaudeRuntime(tmp_path / "runtime")
-    value = await runtime.start(
-        "permission", message_id="m1", options=options(tmp_path, native), launch_id="permission"
-    )
-    sid, eid = value["session_id"], value["execution_id"]
-    try:
-        requests = await wait_for(lambda: runtime.store.interactions(eid))
-        assert requests[0]["params"]["tool"] == "Bash"
-        assert not any(e["event"]["type"] == "work.settled" for e in runtime.store.events(sid))
-        runtime = ClaudeRuntime(tmp_path / "runtime")
-        runtime.store.answer(eid, requests[0]["id"], {"decision": "deny"})
-        settled = await wait_for(
-            lambda: [
-                e["event"]
-                for e in runtime.store.events(sid)
-                if e["event"]["type"] == "work.settled"
-            ]
-        )
-        assert json.loads(settled[0]["message"])["behavior"] == "deny"
-        with pytest.raises(ValueError):
-            runtime.store.answer(eid, requests[0]["id"], {"decision": "allow"})
-    finally:
-        await runtime.stop(eid)