@openhands/extensions 0.25.0 → 0.27.0

package/plugins/runtime-api-configs/tests/test_warm_runtime_configs.py

@@ -0,0 +1,338 @@
+"""End-to-end tests for warm_runtime_configs against an in-process HTTP server.
+
+Uses only the standard library. Boots a threading HTTP server, points
+RUNTIME_API_URL at it, and runs each CLI subcommand as if it were a real
+runtime-api install.
+"""
+
+from __future__ import annotations
+
+import binascii
+import contextlib
+import hashlib
+import importlib.util
+import io
+import json
+import os
+import sys
+import threading
+import unittest
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from pathlib import Path
+
+
+PLUGIN_DIR = Path(__file__).resolve().parents[1]
+SCRIPT_PATH = PLUGIN_DIR / "scripts" / "warm_runtime_configs.py"
+
+spec = importlib.util.spec_from_file_location("wrc", SCRIPT_PATH)
+assert spec and spec.loader
+wrc = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(wrc)
+
+
+ADMIN_PASSWORD = "hunter2"
+API_KEY = "test-api-key"
+SALT = "salt-value"
+CHALLENGE = "challenge-value"
+ITERATIONS = 1000
+
+EXPECTED_HASH = binascii.hexlify(
+    hashlib.pbkdf2_hmac(
+        "sha256",
+        ADMIN_PASSWORD.encode(),
+        (SALT + CHALLENGE).encode(),
+        ITERATIONS,
+        dklen=32,
+    )
+).decode()
+
+ADMIN_JWT = "test-jwt"
+
+
+class FakeRuntimeAPI(BaseHTTPRequestHandler):
+    """In-process stand-in for the runtime-api admin endpoints."""
+
+    configs: dict[str, dict] = {}
+    calls: list[tuple[str, str, dict, dict]] = []
+    initial_configs: list[dict] = []
+
+    def log_message(self, format, *args):  # silence stdout noise
+        pass
+
+    def _read_body(self) -> dict:
+        length = int(self.headers.get("Content-Length") or 0)
+        raw = self.rfile.read(length).decode() if length else ""
+        return json.loads(raw) if raw else {}
+
+    def _respond(self, status: int, payload: dict) -> None:
+        body = json.dumps(payload).encode()
+        self.send_response(status)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def do_GET(self):
+        if self.path == "/api/admin/challenge":
+            self._respond(200, {"salt": SALT, "challenge": CHALLENGE, "iterations": ITERATIONS})
+            return
+        if self.path == "/api/admin/api-keys":
+            if self.headers.get("Authorization") != f"Bearer {ADMIN_JWT}":
+                self._respond(401, {"error": "bad token"})
+                return
+            self.calls.append(("GET", self.path, dict(self.headers), {}))
+            # Real runtime-api returns a top-level JSON array of ApiKeyResponse.
+            self._respond_raw(200, json.dumps([
+                {"id": 1, "name": "default", "key_value": API_KEY},
+                {"id": 2, "name": "other",   "key_value": "other-key"},
+            ]).encode())
+            return
+        if self.path == "/api/warm-runtime-configs":
+            if self.headers.get("X-API-Key") != API_KEY:
+                self._respond(401, {"error": "bad api key"})
+                return
+            merged = list(self.initial_configs) + [
+                dict(name=n, source="db", **c) for n, c in self.configs.items()
+            ]
+            self._respond(200, {"configs": merged})
+            return
+        self._respond(404, {"error": "not found"})
+
+    def _respond_raw(self, status: int, body: bytes) -> None:
+        self.send_response(status)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def do_POST(self):
+        if self.path == "/api/admin/login":
+            body = self._read_body()
+            if body.get("challenge") == CHALLENGE and body.get("hash") == EXPECTED_HASH:
+                self._respond(200, {"token": ADMIN_JWT})
+            else:
+                self._respond(401, {"error": "bad password"})
+            return
+        self._respond(404, {"error": "not found"})
+
+    def do_PUT(self):
+        prefix = "/api/admin/warm-runtime-configs/"
+        if not self.path.startswith(prefix):
+            self._respond(404, {"error": "not found"})
+            return
+        if self.headers.get("Authorization") != f"Bearer {ADMIN_JWT}":
+            self._respond(401, {"error": "bad token"})
+            return
+        name = self.path[len(prefix):]
+        body = self._read_body()
+        self.configs[name] = body
+        self.calls.append(("PUT", name, dict(self.headers), body))
+        self._respond(200, {"name": name, **body})
+
+    def do_DELETE(self):
+        prefix = "/api/admin/warm-runtime-configs/"
+        if not self.path.startswith(prefix):
+            self._respond(404, {"error": "not found"})
+            return
+        if self.headers.get("Authorization") != f"Bearer {ADMIN_JWT}":
+            self._respond(401, {"error": "bad token"})
+            return
+        name = self.path[len(prefix):]
+        removed = self.configs.pop(name, None)
+        self.calls.append(("DELETE", name, dict(self.headers), {}))
+        if removed is None:
+            self._respond(404, {"error": f"no such config {name}"})
+        else:
+            self._respond(200, {"message": f"deleted {name}"})
+
+
+class CliIntegrationTests(unittest.TestCase):
+    server: HTTPServer
+    thread: threading.Thread
+
+    @classmethod
+    def setUpClass(cls) -> None:
+        cls.server = HTTPServer(("127.0.0.1", 0), FakeRuntimeAPI)
+        cls.thread = threading.Thread(target=cls.server.serve_forever, daemon=True)
+        cls.thread.start()
+        host, port = cls.server.server_address
+        os.environ["RUNTIME_API_URL"] = f"http://{host}:{port}"
+        os.environ["API_KEY"] = API_KEY
+        os.environ["ADMIN_PASSWORD"] = ADMIN_PASSWORD
+
+    @classmethod
+    def tearDownClass(cls) -> None:
+        cls.server.shutdown()
+        cls.thread.join(timeout=2)
+
+    def setUp(self) -> None:
+        FakeRuntimeAPI.configs.clear()
+        FakeRuntimeAPI.calls.clear()
+        FakeRuntimeAPI.initial_configs = [
+            {
+                "name": "v1_current",
+                "source": "file",
+                "image": "ghcr.io/openhands/agent-server:1.46.0-python",
+                "count": 1,
+                "command": ["/usr/local/bin/openhands-agent-server", "--port", "60000"],
+                "working_dir": "/workspace/project",
+                "environment": {"BASE": "1"},
+            }
+        ]
+        os.environ.pop("ADMIN_TOKEN", None)
+
+    @contextlib.contextmanager
+    def _capture_stdout(self):
+        buf = io.StringIO()
+        old = sys.stdout
+        sys.stdout = buf
+        try:
+            yield buf
+        finally:
+            sys.stdout = old
+
+    def test_list_returns_configs(self) -> None:
+        with self._capture_stdout() as out:
+            wrc.main(["list"])
+        configs = json.loads(out.getvalue())
+        self.assertEqual([c["name"] for c in configs], ["v1_current"])
+
+    def test_template_strips_identity_and_applies_overrides(self) -> None:
+        with self._capture_stdout() as out:
+            wrc.main(
+                [
+                    "template", "v1_current",
+                    "--image", "ghcr.io/your-org/openhands-php:8.4-v1",
+                    "--count", "2",
+                ]
+            )
+        derived = json.loads(out.getvalue())
+        self.assertNotIn("name", derived)
+        self.assertNotIn("source", derived)
+        self.assertEqual(derived["image"], "ghcr.io/your-org/openhands-php:8.4-v1")
+        self.assertEqual(derived["count"], 2)
+        self.assertEqual(derived["environment"], {"BASE": "1"})
+
+    def test_save_upserts_via_admin_auth(self) -> None:
+        body = {
+            "image": "ghcr.io/your-org/openhands-php:8.4-v1",
+            "count": 1,
+            "command": ["x"],
+            "working_dir": "/w",
+            "environment": {},
+        }
+        sys.stdin = io.StringIO(json.dumps(body))
+        try:
+            with self._capture_stdout():
+                wrc.main(["save", "php-web"])
+        finally:
+            sys.stdin = sys.__stdin__
+
+        self.assertIn("php-web", FakeRuntimeAPI.configs)
+        method, name, headers, sent = FakeRuntimeAPI.calls[-1]
+        self.assertEqual(method, "PUT")
+        self.assertEqual(name, "php-web")
+        self.assertEqual(headers.get("Authorization"), f"Bearer {ADMIN_JWT}")
+        self.assertEqual(sent["image"], body["image"])
+
+    def test_save_from_file(self) -> None:
+        path = Path(self.id().split(".")[-1] + ".json")
+        path.write_text(json.dumps({"image": "x", "command": [], "working_dir": "/", "environment": {}, "count": 1}))
+        try:
+            with self._capture_stdout():
+                wrc.main(["save", "from-file", "--file", str(path)])
+        finally:
+            path.unlink()
+        self.assertIn("from-file", FakeRuntimeAPI.configs)
+
+    def test_delete_removes_config(self) -> None:
+        FakeRuntimeAPI.configs["php-web"] = {"image": "x"}
+        with self._capture_stdout():
+            wrc.main(["delete", "php-web"])
+        self.assertNotIn("php-web", FakeRuntimeAPI.configs)
+
+    def test_admin_token_env_skips_login(self) -> None:
+        FakeRuntimeAPI.configs["php-web"] = {"image": "x"}
+        os.environ["ADMIN_TOKEN"] = ADMIN_JWT
+        os.environ.pop("ADMIN_PASSWORD", None)  # would fail if handshake ran
+        try:
+            with self._capture_stdout():
+                wrc.main(["delete", "php-web"])
+            # Handshake would have called /api/admin/challenge; verify it didn't.
+            self.assertNotIn("php-web", FakeRuntimeAPI.configs)
+            self.assertEqual(FakeRuntimeAPI.calls[-1][0], "DELETE")
+        finally:
+            os.environ["ADMIN_PASSWORD"] = ADMIN_PASSWORD
+
+    def test_missing_env_fails_fast(self) -> None:
+        os.environ.pop("RUNTIME_API_URL", None)
+        try:
+            with self.assertRaises(SystemExit) as cm:
+                wrc.main(["list"])
+            self.assertEqual(cm.exception.code, 1)
+        finally:
+            host, port = self.server.server_address
+            os.environ["RUNTIME_API_URL"] = f"http://{host}:{port}"
+
+    def test_list_falls_back_to_admin_when_api_key_missing(self) -> None:
+        """Without API_KEY set, list must log in as admin and fetch it."""
+        os.environ.pop("API_KEY", None)
+        try:
+            with self._capture_stdout() as out:
+                wrc.main(["list"])
+            self.assertEqual(
+                [c["name"] for c in json.loads(out.getvalue())], ["v1_current"]
+            )
+            # Fallback path hit /api/admin/api-keys with the admin JWT.
+            paths = [c[1] for c in FakeRuntimeAPI.calls]
+            self.assertIn("/api/admin/api-keys", paths)
+        finally:
+            os.environ["API_KEY"] = API_KEY
+
+    def test_list_fails_when_no_api_key_and_no_admin_creds(self) -> None:
+        """No fallback possible: neither API_KEY nor admin creds set."""
+        os.environ.pop("API_KEY", None)
+        os.environ.pop("ADMIN_PASSWORD", None)
+        os.environ.pop("ADMIN_TOKEN", None)
+        try:
+            with self.assertRaises(SystemExit) as cm:
+                wrc.main(["list"])
+            self.assertEqual(cm.exception.code, 1)
+        finally:
+            os.environ["API_KEY"] = API_KEY
+            os.environ["ADMIN_PASSWORD"] = ADMIN_PASSWORD
+
+    def test_bootstrap_shell_quotes_hostile_secret_values(self) -> None:
+        """Guards against `eval` breakout when a secret contains shell metacharacters."""
+        hostile_password = "p@ss word;echo INJECTED"
+        hostile_key = "key$(touch /tmp/pwned)"
+
+        original_which = wrc.shutil.which
+        original_decode = wrc._decode_secret
+        wrc.shutil.which = lambda _cmd: "/usr/bin/kubectl"
+        wrc._decode_secret = lambda _ns, secret, _key: (
+            hostile_password if secret == "admin-password" else hostile_key
+        )
+        try:
+            with self._capture_stdout() as out:
+                wrc.main(["bootstrap", "--skip-url"])
+            rendered = out.getvalue()
+        finally:
+            wrc.shutil.which = original_which
+            wrc._decode_secret = original_decode
+
+        # Parse the emitted export lines through the shell's own tokenizer,
+        # then verify each variable ends up with the exact original value.
+        env: dict[str, str] = {}
+        for line in rendered.strip().splitlines():
+            tokens = __import__("shlex").split(line)
+            assert tokens[0] == "export" and len(tokens) == 2, tokens
+            key, _, value = tokens[1].partition("=")
+            env[key] = value
+
+        self.assertEqual(env["ADMIN_PASSWORD"], hostile_password)
+        self.assertEqual(env["API_KEY"], hostile_key)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/plugins/vulnerability-remediation/skills/github/scripts/agent_conversation.py

@@ -2,22 +2,37 @@
 
 import json
 import os
+import time
 from urllib.error import HTTPError
 from urllib.request import Request, urlopen
-from uuid import NAMESPACE_URL, UUID, uuid5
-
-import httpx
-from openhands.sdk import RemoteConversation
-from openhands.sdk.conversation.request import (
-    SendMessageRequest,
-    StartConversationRequest,
-)
-from openhands.sdk.conversation.state import ConversationExecutionStatus
-from openhands.sdk.llm.message import TextContent
-from openhands.sdk.workspace import LocalWorkspace, RemoteWorkspace
+from uuid import NAMESPACE_URL, UUID, uuid4, uuid5
+
+try:
+    import httpx
+    from openhands.sdk import RemoteConversation
+    from openhands.sdk.conversation.request import (
+        SendMessageRequest,
+        StartConversationRequest,
+    )
+    from openhands.sdk.conversation.state import ConversationExecutionStatus
+    from openhands.sdk.llm.message import TextContent
+    from openhands.sdk.workspace import LocalWorkspace, RemoteWorkspace
+except ImportError:
+    # A run on OpenHands Cloud or Enterprise has no SDK on its Python path and
+    # does not need one: CloudConversations speaks the OpenHands API instead.
+    httpx = RemoteConversation = SendMessageRequest = None
+    StartConversationRequest = ConversationExecutionStatus = None
+    TextContent = LocalWorkspace = RemoteWorkspace = None
 
 _CONVERSATION_KEY_PREFIX = "agent-conversation-"
 
+# How long a conversation the OpenHands API was asked to start may take to
+# appear before the start is taken to have failed and is made again.
+_CLOUD_START_GRACE_SECONDS = 10 * 60
+# How long to wait for a paused conversation's sandbox to come back up.
+_CLOUD_RESUME_TIMEOUT_SECONDS = 120
+_CLOUD_POLL_SECONDS = 3
+
 
 def _register_tools() -> None:
     """Register tool models needed to deserialize an attached agent."""
@@ -50,19 +65,106 @@ def _kv_request(key: str, method: str, value: dict | None = None) -> dict | None
     return body.get("value") if method == "GET" else body
 
 
+class CloudConversations:
+    """The conversations of a run on OpenHands Cloud or Enterprise.
+
+    Such a run has no Agent Server to attach to. The OpenHands API starts each
+    conversation in a sandbox of its own, which outlives the run's, with the
+    agent profile's model, tools and secrets resolved on the server.
+    """
+
+    def __init__(self) -> None:
+        self.api = os.environ["OPENHANDS_CLOUD_API_URL"].rstrip("/")
+        self.headers = {
+            "Authorization": f"Bearer {os.environ['OPENHANDS_API_KEY']}",
+            "Content-Type": "application/json",
+        }
+
+    def _request(self, method: str, url: str, body=None, headers=None):
+        request = Request(
+            url if url.startswith("http") else f"{self.api}{url}",
+            data=json.dumps(body).encode() if body is not None else None,
+            headers=headers or self.headers,
+            method=method,
+        )
+        with urlopen(request, timeout=90) as response:
+            raw = response.read()
+        return json.loads(raw) if raw.strip() else {}
+
+    def get(self, conversation_id) -> dict | None:
+        """The conversation, or None while the API has no record of it."""
+        found = self._request("GET", f"/api/v1/app-conversations?ids={conversation_id}")
+        return found[0] if found else None
+
+    def start(self, conversation_id, profile_id, title: str, prompt: str) -> None:
+        self._request(
+            "POST",
+            "/api/v1/app-conversations",
+            {
+                "conversation_id": str(conversation_id),
+                "agent_profile_id": str(profile_id),
+                "title": title,
+                "initial_message": _user_message(prompt),
+            },
+        )
+
+    def run(self, conversation: dict) -> None:
+        """Start the next turn of an idle conversation on its own Agent Server."""
+        try:
+            self._request(
+                "POST",
+                f"{conversation['conversation_url']}/run",
+                headers={"X-Session-API-Key": conversation["session_api_key"]},
+            )
+        except HTTPError as exc:
+            if exc.code != 409:  # 409: a turn is already running
+                raise
+
+    def send(self, conversation: dict, prompt: str) -> None:
+        """Send the next turn, waking the conversation's sandbox if it is paused."""
+        conversation_id = conversation["id"]
+        if conversation.get("sandbox_status") != "RUNNING":
+            self._request(
+                "POST", f"/api/v1/sandboxes/{conversation['sandbox_id']}/resume"
+            )
+            deadline = time.monotonic() + _CLOUD_RESUME_TIMEOUT_SECONDS
+            # The execution status is only reported once the sandbox's Agent
+            # Server answers, which is when it can take the message.
+            while not (self.get(conversation_id) or {}).get("execution_status"):
+                if time.monotonic() > deadline:
+                    raise RuntimeError(
+                        f"Conversation {conversation_id} did not resume in time"
+                    )
+                time.sleep(_CLOUD_POLL_SECONDS)
+        self._request(
+            "POST",
+            f"/api/v1/app-conversations/{conversation_id}/send-message",
+            {**_user_message(prompt), "run": True},
+        )
+
+
+def _user_message(text: str) -> dict:
+    return {"role": "user", "content": [{"type": "text", "text": text}]}
+
+
 class AgentConversationDispatcher:
     """Deliver one revision at a time to a stable conversation for each subject."""
 
     def __init__(self) -> None:
-        self.agent_url = os.environ["AGENT_SERVER_URL"]
+        # The automation service hands a run the Agent Server URL only on a
+        # local Agent Canvas; elsewhere conversations go through the OpenHands API.
+        self.agent_url = os.environ.get("AGENT_SERVER_URL")
         self.api_key = os.environ["SESSION_API_KEY"]
         self.profile_id = UUID(os.environ["AUTOMATION_AGENT_PROFILE_ID"])
         payload = json.loads(os.environ["AUTOMATION_EVENT_PAYLOAD"])
         self.automation_id = str(payload["automation_id"])
+        self._cloud = None if self.agent_url else CloudConversations()
         self._workspace: RemoteWorkspace | None = None
         self._secrets = {}
 
     def __enter__(self):
+        if self._cloud:
+            return self
         _register_tools()
         self._workspace = RemoteWorkspace(
             host=self.agent_url,
@@ -76,17 +178,107 @@ class AgentConversationDispatcher:
         return self
 
     def __exit__(self, *args):
+        if self._cloud:
+            return None
         assert self._workspace is not None
         return self._workspace.__exit__(*args)
 
-    def deliver(self, subject: str, delivery: str, prompt: str) -> dict[str, str]:
+    def deliver(
+        self, subject: str, delivery: str, prompt: str, head: str = ""
+    ) -> dict[str, str]:
+        """Deliver one revision of `subject`, deduping a repeated head.
+
+        `delivery` keys the revision: a second trigger for the same revision
+        reuses the conversation without a new turn, and a changed head becomes a
+        new delivery. `head` is the revision's commit, and it is the guard that
+        matters when two triggers name the same commit - a re-request after the
+        bot's own handoff, say - because a delivery key that only counts triggers
+        would send a second turn and publish a second review of identical code.
+        A conversation already running for this head is reported `in_progress`
+        and left alone, whatever the new delivery says. Callers with no revision
+        identity leave `head` empty and keep the delivery-key-only behavior.
+        """
         conversation_id = uuid5(NAMESPACE_URL, f"{self.automation_id}:{subject}")
         state_key = f"{_CONVERSATION_KEY_PREFIX}{conversation_id}"
         record = _kv_request(state_key, "GET") or {}
-        if self._workspace is None:
-            raise RuntimeError("AgentConversationDispatcher must be used as a context")
 
         same_delivery = record.get("delivery") == delivery
+        same_head = bool(head) and record.get("head") == head
+
+        if self._cloud:
+            disposition, conversation_id = self._deliver_cloud(
+                record, conversation_id, subject, prompt, same_delivery, same_head
+            )
+        else:
+            disposition = self._deliver_local(
+                conversation_id, prompt, same_delivery, same_head
+            )
+
+        if disposition in ("deduplicated", "in_progress"):
+            return {
+                "disposition": disposition,
+                "conversation_id": str(conversation_id),
+            }
+
+        new_record = {
+            "subject": subject,
+            "conversation_id": str(conversation_id),
+            "delivery": delivery,
+            "head": head or record.get("head") or "",
+        }
+        if disposition == "created" and self._cloud:
+            new_record["started_at"] = time.time()
+        _kv_request(state_key, "PUT", new_record)
+        return {
+            "disposition": disposition,
+            "conversation_id": str(conversation_id),
+        }
+
+    def _deliver_cloud(
+        self, record, conversation_id, subject, prompt, same_delivery, same_head
+    ):
+        """Deliver through the OpenHands API; return the disposition and the id.
+
+        The id is the subject's stable one until its conversation can no longer
+        take a turn - its start never completed, or its sandbox is gone - and a
+        fresh id from then on, because the API does not start an id twice. The
+        KV record carries whichever is current.
+        """
+        current_id = record.get("conversation_id") or conversation_id
+        conversation = self._cloud.get(current_id)
+
+        if conversation is None:
+            started = time.time() - float(record.get("started_at") or 0)
+            if started < _CLOUD_START_GRACE_SECONDS:
+                # The API is still bringing the subject's conversation up and
+                # does not list it yet. Starting another would run two for one
+                # subject, so even a new revision waits: the record is left as
+                # it is and the next trigger delivers it.
+                return "in_progress", current_id
+        elif conversation.get("sandbox_status") in ("ERROR", "MISSING"):
+            if same_delivery:
+                return "deduplicated", current_id
+            conversation = None
+
+        if conversation is None:
+            new_id = uuid4() if record else conversation_id
+            self._cloud.start(new_id, self.profile_id, subject, prompt)
+            return "created", new_id
+
+        status = conversation.get("execution_status")
+        if status == "running" and (same_delivery or same_head):
+            return "in_progress", current_id
+        if same_delivery:
+            if status in ("idle", "paused"):
+                self._cloud.run(conversation)
+                return "resumed", current_id
+            return "deduplicated", current_id
+        self._cloud.send(conversation, prompt)
+        return "resumed", current_id
+
+    def _deliver_local(self, conversation_id, prompt, same_delivery, same_head) -> str:
+        if self._workspace is None:
+            raise RuntimeError("AgentConversationDispatcher must be used as a context")
 
         try:
             conversation = RemoteConversation.attach(
@@ -112,14 +304,18 @@ class AgentConversationDispatcher:
             disposition = "created"
         try:
             if disposition == "resumed":
-                if same_delivery:
-                    if (
-                        conversation.state.execution_status
-                        == ConversationExecutionStatus.RUNNING
-                    ):
-                        conversation.update_secrets(self._secrets)
-                        disposition = "in_progress"
-                    elif conversation.state.execution_status in (
+                running = (
+                    conversation.state.execution_status
+                    == ConversationExecutionStatus.RUNNING
+                )
+                if running and (same_delivery or same_head):
+                    # A turn is already running for this very revision, so a new
+                    # trigger is not new work: report the live conversation
+                    # rather than starting a second pass beside it.
+                    conversation.update_secrets(self._secrets)
+                    disposition = "in_progress"
+                elif same_delivery:
+                    if conversation.state.execution_status in (
                         ConversationExecutionStatus.IDLE,
                         ConversationExecutionStatus.PAUSED,
                     ):
@@ -128,28 +324,12 @@ class AgentConversationDispatcher:
                     else:
                         disposition = "deduplicated"
                 else:
+                    # A changed head, or a head a human clarified since, is new
+                    # work on the same subject: reuse the conversation and send
+                    # the revision as its next turn.
                     conversation.update_secrets(self._secrets)
                     conversation.send_message(prompt)
                     conversation.run(blocking=False)
         finally:
             conversation.close()
-
-        if disposition in ("deduplicated", "in_progress"):
-            return {
-                "disposition": disposition,
-                "conversation_id": str(conversation_id),
-            }
-
-        _kv_request(
-            state_key,
-            "PUT",
-            {
-                "subject": subject,
-                "conversation_id": str(conversation_id),
-                "delivery": delivery,
-            },
-        )
-        return {
-            "disposition": disposition,
-            "conversation_id": str(conversation_id),
-        }
+        return disposition