codex-a2a 0.6.0__tar.gz → 0.6.1__tar.gz

{codex_a2a-0.6.0 → codex_a2a-0.6.1}/.gitignore

@@ -43,6 +43,8 @@ logs/
 run/
 .codex-a2a/
 *.db
+*.db-shm
+*.db-wal
 
 # Unit test / coverage reports
 htmlcov/

{codex_a2a-0.6.0/src/codex_a2a.egg-info → codex_a2a-0.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codex-a2a
-Version: 0.6.0
+Version: 0.6.1
 Summary: Codex A2A runtime adapter
 Author: liujuanjuan1984@Intelligent-Internet
 License-Expression: Apache-2.0

{codex_a2a-0.6.0 → codex_a2a-0.6.1}/src/codex_a2a/execution/stream_interrupts.py

@@ -3,6 +3,8 @@ from __future__ import annotations
 from collections.abc import Mapping
 from typing import Any
 
+from codex_a2a.upstream.interrupts import resolve_permission_interrupt_semantic
+
 _INTERRUPT_ASKED_EVENT_TYPES = {
     "permission.asked",
     "question.asked",
@@ -189,12 +191,18 @@ def extract_interrupt_asked_event(event: Mapping[str, Any]) -> dict[str, Any] |
     if not normalized_request_id:
         return None
     if event_type == "permission.asked":
-        details: dict[str, Any] = {
-            "permission": _first_nested_string(
+        permission = _first_nested_string(
+            props,
+            ("permission",),
+            ("metadata", "raw", "permission"),
+        ) or resolve_permission_interrupt_semantic(
+            _first_nested_string(
                 props,
-                ("permission",),
-                ("metadata", "raw", "permission"),
-            ),
+                ("metadata", "method"),
+            )
+        )
+        details: dict[str, Any] = {
+            "permission": permission,
             "patterns": extract_interrupt_patterns(props),
             "always": extract_string_list(_nested_value(props, "always"))
             or extract_string_list(_nested_value(props, "metadata", "raw", "always")),

{codex_a2a-0.6.0 → codex_a2a-0.6.1}/src/codex_a2a/jsonrpc/session_control.py

@@ -35,6 +35,7 @@ from codex_a2a.jsonrpc.payload_mapping import (
     as_a2a_message,
     message_to_item,
 )
+from codex_a2a.upstream.models import CodexRPCError, is_thread_not_found_error
 
 if TYPE_CHECKING:
     from codex_a2a.jsonrpc.application import CodexSessionQueryJSONRPCApplication
@@ -187,6 +188,21 @@ async def handle_session_control_request(
                 data={"type": "UPSTREAM_UNREACHABLE", "session_id": session_id},
             ),
         )
+    except CodexRPCError as exc:
+        if is_thread_not_found_error(exc):
+            return app._generate_error_response(
+                base_request.id,
+                JSONRPCError(
+                    code=ERR_SESSION_NOT_FOUND,
+                    message="Session not found",
+                    data={"type": "SESSION_NOT_FOUND", "session_id": session_id},
+                ),
+            )
+        logger.exception("Codex session control JSON-RPC method failed")
+        return app._generate_error_response(
+            base_request.id,
+            A2AError(root=InternalError(message=str(exc))),
+        )
     except Exception as exc:
         logger.exception("Codex session control JSON-RPC method failed")
         return app._generate_error_response(

{codex_a2a-0.6.0 → codex_a2a-0.6.1}/src/codex_a2a/jsonrpc/session_query.py

@@ -24,6 +24,7 @@ from codex_a2a.jsonrpc.payload_mapping import (
     as_a2a_session_task,
     extract_raw_items,
 )
+from codex_a2a.upstream.models import CodexRPCError, is_thread_not_found_error
 
 if TYPE_CHECKING:
     from codex_a2a.jsonrpc.application import CodexSessionQueryJSONRPCApplication
@@ -81,6 +82,21 @@ async def handle_session_query_request(
                 data={"type": "UPSTREAM_UNREACHABLE"},
             ),
         )
+    except CodexRPCError as exc:
+        if is_thread_not_found_error(exc) and session_id is not None:
+            return app._generate_error_response(
+                base_request.id,
+                JSONRPCError(
+                    code=ERR_SESSION_NOT_FOUND,
+                    message="Session not found",
+                    data={"type": "SESSION_NOT_FOUND", "session_id": session_id},
+                ),
+            )
+        logger.exception("Codex session query JSON-RPC method failed")
+        return app._generate_error_response(
+            base_request.id,
+            A2AError(root=InternalError(message=str(exc))),
+        )
     except Exception as exc:
         logger.exception("Codex session query JSON-RPC method failed")
         return app._generate_error_response(

{codex_a2a-0.6.0 → codex_a2a-0.6.1}/src/codex_a2a/upstream/conversation_facade.py

@@ -7,7 +7,12 @@ from typing import Any
 
 from codex_a2a.execution.request_overrides import RequestExecutionOptions
 from codex_a2a.input_mapping import build_turn_input_from_normalized_items
-from codex_a2a.upstream.models import CodexMessage, _TurnTracker
+from codex_a2a.upstream.models import (
+    CodexMessage,
+    CodexRPCError,
+    _TurnTracker,
+    is_thread_not_found_error,
+)
 from codex_a2a.upstream.request_mapping import (
     apply_thread_start_execution_options,
     apply_turn_start_execution_options,
@@ -37,6 +42,8 @@ class CodexConversationFacade:
         self._rpc_request = rpc_request
         self._get_or_create_tracker = get_or_create_tracker
         self._turn_trackers = turn_trackers
+        self._loaded_thread_ids: set[str] = set()
+        self._thread_resume_locks: dict[str, asyncio.Lock] = {}
 
     async def create_session(
         self,
@@ -67,7 +74,9 @@ class CodexConversationFacade:
         session_id = thread.get("id")
         if not isinstance(session_id, str) or not session_id.strip():
             raise RuntimeError("codex thread/start response missing thread id")
-        return session_id.strip()
+        session_id = session_id.strip()
+        self._loaded_thread_ids.add(session_id)
+        return session_id
 
     async def list_sessions(self, *, query: dict[str, Any]) -> list[dict[str, Any]]:
         rpc_params: dict[str, Any] = {}
@@ -98,6 +107,7 @@ class CodexConversationFacade:
         thread = normalize_thread_summary(result.get("thread"))
         if thread is None:
             raise RuntimeError("codex thread/fork response missing thread")
+        self._loaded_thread_ids.add(thread["id"])
         return thread
 
     async def thread_archive(self, thread_id: str) -> None:
@@ -113,6 +123,7 @@ class CodexConversationFacade:
         thread = normalize_thread_summary(result.get("thread"))
         if thread is None:
             raise RuntimeError("codex thread/unarchive response missing thread")
+        self._loaded_thread_ids.add(thread["id"])
         return thread
 
     async def thread_metadata_update(
@@ -216,7 +227,12 @@ class CodexConversationFacade:
             default_model_id=self._model_id,
         )
 
-        result = await self._rpc_request("turn/start", params)
+        result = await self._start_turn(
+            session_id,
+            params,
+            directory=directory,
+            execution_options=execution_options,
+        )
         if not isinstance(result, dict):
             raise RuntimeError("codex turn/start response missing result object")
         turn = result.get("turn")
@@ -268,7 +284,12 @@ class CodexConversationFacade:
             execution_options=coerce_request_execution_options(execution_options),
             default_model_id=self._model_id,
         )
-        result = await self._rpc_request("turn/start", params)
+        result = await self._start_turn(
+            session_id,
+            params,
+            directory=directory,
+            execution_options=execution_options,
+        )
         if not isinstance(result, dict):
             raise RuntimeError("codex turn/start response missing result object")
         turn = result.get("turn")
@@ -279,6 +300,96 @@ class CodexConversationFacade:
             raise RuntimeError("codex turn/start response missing turn id")
         return {"ok": True, "session_id": session_id, "turn_id": turn_id.strip()}
 
+    async def _start_turn(
+        self,
+        session_id: str,
+        params: dict[str, Any],
+        *,
+        directory: str | None,
+        execution_options: RequestExecutionOptions | None,
+    ) -> Any:
+        await self._ensure_thread_loaded(
+            session_id,
+            directory=directory,
+            execution_options=execution_options,
+        )
+        try:
+            result = await self._rpc_request("turn/start", params)
+        except CodexRPCError as exc:
+            if not is_thread_not_found_error(exc):
+                raise
+            self._loaded_thread_ids.discard(session_id)
+            await self._ensure_thread_loaded(
+                session_id,
+                directory=directory,
+                execution_options=execution_options,
+                force_resume=True,
+            )
+            result = await self._rpc_request("turn/start", params)
+        self._loaded_thread_ids.add(session_id)
+        return result
+
+    async def _ensure_thread_loaded(
+        self,
+        session_id: str,
+        *,
+        directory: str | None,
+        execution_options: RequestExecutionOptions | None,
+        force_resume: bool = False,
+    ) -> None:
+        if not force_resume and session_id in self._loaded_thread_ids:
+            return
+
+        lock = self._thread_resume_locks.setdefault(session_id, asyncio.Lock())
+        async with lock:
+            if not force_resume and session_id in self._loaded_thread_ids:
+                return
+
+            if not force_resume:
+                loaded_threads = await self._list_loaded_thread_ids()
+                self._loaded_thread_ids.update(loaded_threads)
+                if session_id in self._loaded_thread_ids:
+                    return
+
+            await self._resume_thread(
+                session_id,
+                directory=directory,
+                execution_options=execution_options,
+            )
+            self._loaded_thread_ids.add(session_id)
+
+    async def _list_loaded_thread_ids(self) -> set[str]:
+        result = await self._rpc_request("thread/loaded/list", {})
+        if not isinstance(result, dict):
+            return set()
+        data = result.get("data")
+        if not isinstance(data, list):
+            return set()
+        loaded: set[str] = set()
+        for item in data:
+            if isinstance(item, str) and item.strip():
+                loaded.add(item.strip())
+        return loaded
+
+    async def _resume_thread(
+        self,
+        session_id: str,
+        *,
+        directory: str | None,
+        execution_options: RequestExecutionOptions | None,
+    ) -> Any:
+        params: dict[str, Any] = {"threadId": session_id}
+        if directory:
+            params["cwd"] = directory
+        elif self._workspace_root:
+            params["cwd"] = self._workspace_root
+        apply_thread_start_execution_options(
+            params,
+            execution_options=coerce_request_execution_options(execution_options),
+            default_model_id=self._model_id,
+        )
+        return await self._rpc_request("thread/resume", params)
+
     async def turn_steer(
         self,
         thread_id: str,

{codex_a2a-0.6.0 → codex_a2a-0.6.1}/src/codex_a2a/upstream/interrupts.py

@@ -5,6 +5,13 @@ from collections.abc import Mapping
 from dataclasses import dataclass
 from typing import Any
 
+_PERMISSION_INTERRUPT_METHOD_MAP = {
+    "item/commandExecution/requestApproval": "command_execution",
+    "execCommandApproval": "command_execution",
+    "item/fileChange/requestApproval": "file_change",
+    "applyPatchApproval": "apply_patch",
+}
+
 
 def _normalized_string(value: Any) -> str | None:
     if not isinstance(value, str):
@@ -87,6 +94,13 @@ def _extract_mapping(params: dict[str, Any], key: str) -> dict[str, Any] | None:
     return dict(value)
 
 
+def resolve_permission_interrupt_semantic(method: str | None) -> str | None:
+    normalized_method = _normalized_string(method)
+    if normalized_method is None:
+        return None
+    return _PERMISSION_INTERRUPT_METHOD_MAP.get(normalized_method)
+
+
 class InterruptRequestError(RuntimeError):
     def __init__(
         self,
@@ -149,6 +163,9 @@ def build_codex_permission_interrupt_properties(
     )
     if display_message is not None:
         properties["display_message"] = display_message
+    permission = resolve_permission_interrupt_semantic(method)
+    if permission is not None:
+        properties["permission"] = permission
     patterns = _extract_permission_patterns(params)
     if patterns:
         properties["patterns"] = patterns

{codex_a2a-0.6.0 → codex_a2a-0.6.1}/src/codex_a2a/upstream/models.py

@@ -24,6 +24,10 @@ class CodexRPCError(RuntimeError):
         self.data = data
 
 
+def is_thread_not_found_error(exc: BaseException) -> bool:
+    return isinstance(exc, CodexRPCError) and "thread not found" in str(exc).strip().lower()
+
+
 @dataclass
 class _PendingRpcRequest:
     request_id: str

{codex_a2a-0.6.0 → codex_a2a-0.6.1/src/codex_a2a.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codex-a2a
-Version: 0.6.0
+Version: 0.6.1
 Summary: Codex A2A runtime adapter
 Author: liujuanjuan1984@Intelligent-Internet
 License-Expression: Apache-2.0

{codex_a2a-0.6.0 → codex_a2a-0.6.1}/tests/execution/test_stream_interrupts.py

@@ -48,10 +48,11 @@ def test_extract_permission_interrupt_promotes_reason_and_parsed_paths() -> None
         "properties": {
             "id": "perm-2",
             "metadata": {
+                "method": "execCommandApproval",
                 "raw": {
                     "reason": "The command needs confirmation.",
                     "parsedCmd": [{"path": "/repo/.env"}],
-                }
+                },
             },
         },
     }
@@ -60,7 +61,7 @@ def test_extract_permission_interrupt_promotes_reason_and_parsed_paths() -> None
         "request_id": "perm-2",
         "interrupt_type": "permission",
         "details": {
-            "permission": None,
+            "permission": "command_execution",
             "patterns": ["/repo/.env"],
             "always": [],
             "display_message": "The command needs confirmation.",
@@ -68,6 +69,34 @@ def test_extract_permission_interrupt_promotes_reason_and_parsed_paths() -> None
     }
 
 
+def test_extract_permission_interrupt_derives_semantic_from_method_when_needed() -> None:
+    event = {
+        "type": "permission.asked",
+        "properties": {
+            "id": "perm-3",
+            "metadata": {
+                "method": "item/fileChange/requestApproval",
+                "raw": {
+                    "request": {
+                        "description": "Agent wants to update the patch.",
+                    }
+                },
+            },
+        },
+    }
+
+    assert extract_interrupt_asked_event(event) == {
+        "request_id": "perm-3",
+        "interrupt_type": "permission",
+        "details": {
+            "permission": "file_change",
+            "patterns": [],
+            "always": [],
+            "display_message": "Agent wants to update the patch.",
+        },
+    }
+
+
 def test_extract_question_interrupt_promotes_nested_questions() -> None:
     event = {
         "type": "question.asked",

{codex_a2a-0.6.0 → codex_a2a-0.6.1}/tests/jsonrpc/test_codex_session_extension.py

@@ -25,6 +25,7 @@ from codex_a2a.jsonrpc.application import CodexSessionQueryJSONRPCApplication
 from codex_a2a.jsonrpc.hooks import SessionGuardHooks
 from codex_a2a.profile.runtime import build_runtime_profile
 from codex_a2a.server.agent_card import build_agent_card
+from codex_a2a.upstream.models import CodexRPCError
 from tests.support.dummy_clients import DummySessionQueryCodexClient as DummyCodexClient
 from tests.support.settings import make_settings
 
@@ -565,6 +566,39 @@ async def test_session_query_extension_maps_404_to_session_not_found(monkeypatch
         assert payload["error"]["data"]["type"] == "SESSION_NOT_FOUND"
 
 
+@pytest.mark.asyncio
+async def test_session_query_extension_maps_thread_not_found_to_session_not_found(monkeypatch):
+    import codex_a2a.server.application as app_module
+
+    class NotFoundCodexClient(DummyCodexClient):
+        async def list_messages(self, session_id: str, *, params=None):
+            raise CodexRPCError(code=-32000, message=f"thread not found: {session_id}")
+
+    monkeypatch.setattr(app_module, "CodexClient", NotFoundCodexClient)
+    app = app_module.create_app(
+        make_settings(a2a_bearer_token="t-1", a2a_log_payloads=False, **_BASE_SETTINGS)
+    )
+
+    transport = httpx.ASGITransport(app=app)
+    async with httpx.AsyncClient(transport=transport, base_url="http://test") as client:
+        headers = {"Authorization": "Bearer t-1"}
+        resp = await client.post(
+            "/",
+            headers=headers,
+            json={
+                "jsonrpc": "2.0",
+                "id": 3,
+                "method": "codex.sessions.messages.list",
+                "params": {"session_id": "s-rpc-404"},
+            },
+        )
+        payload = resp.json()
+        assert payload["jsonrpc"] == "2.0"
+        assert payload["id"] == 3
+        assert payload["error"]["code"] == -32001
+        assert payload["error"]["data"]["type"] == "SESSION_NOT_FOUND"
+
+
 @pytest.mark.asyncio
 async def test_session_query_extension_does_not_log_response_bodies(monkeypatch, caplog):
     import codex_a2a.server.application as app_module
@@ -641,6 +675,48 @@ async def test_session_control_prompt_async_returns_turn_handle(monkeypatch):
         }
 
 
+@pytest.mark.asyncio
+async def test_session_control_prompt_async_maps_thread_not_found_to_session_not_found(monkeypatch):
+    import codex_a2a.server.application as app_module
+
+    class NotFoundCodexClient(DummyCodexClient):
+        async def session_prompt_async(
+            self,
+            session_id: str,
+            request: dict[str, Any],
+            *,
+            directory: str | None = None,
+            execution_options=None,
+        ):
+            del request, directory, execution_options
+            raise CodexRPCError(code=-32000, message=f"thread not found: {session_id}")
+
+    monkeypatch.setattr(app_module, "CodexClient", NotFoundCodexClient)
+    app = app_module.create_app(
+        make_settings(a2a_bearer_token="t-1", a2a_log_payloads=False, **_BASE_SETTINGS)
+    )
+
+    transport = httpx.ASGITransport(app=app)
+    async with httpx.AsyncClient(transport=transport, base_url="http://test") as client:
+        headers = {"Authorization": "Bearer t-1"}
+        resp = await client.post(
+            "/",
+            headers=headers,
+            json={
+                "jsonrpc": "2.0",
+                "id": 22,
+                "method": "codex.sessions.prompt_async",
+                "params": {
+                    "session_id": "s-rpc-404",
+                    "request": {"parts": [{"type": "text", "text": "resume"}]},
+                },
+            },
+        )
+        payload = resp.json()
+        assert payload["error"]["code"] == -32001
+        assert payload["error"]["data"]["type"] == "SESSION_NOT_FOUND"
+
+
 @pytest.mark.asyncio
 async def test_session_control_prompt_async_accepts_rich_input(monkeypatch):
     import codex_a2a.server.application as app_module
@@ -1163,6 +1239,7 @@ async def test_interrupt_recovery_extension_lists_identity_scoped_pending_reques
             "properties": {
                 "id": "perm-1",
                 "sessionID": "ses-1",
+                "permission": "command_execution",
                 "metadata": {
                     "method": "item/commandExecution/requestApproval",
                     "raw": {"patterns": ["/tmp/config.yml"]},

{codex_a2a-0.6.0 → codex_a2a-0.6.1}/tests/upstream/test_codex_client_params.py

@@ -17,6 +17,7 @@ from codex_a2a.upstream.client import (
     _PendingInterruptRequest,
     _PendingRpcRequest,
 )
+from codex_a2a.upstream.models import CodexRPCError
 from tests.support.fixtures import (
     replay_codex_jsonrpc_line_fixture,
     replay_codex_notification_fixture,
@@ -262,6 +263,7 @@ async def test_session_prompt_async_maps_rich_input_parts_to_turn_start() -> Non
         return {"turn": {"id": "turn-42"}}
 
     client._rpc_request = fake_rpc_request
+    client._conversation_facade._loaded_thread_ids.add("thr-1")
 
     result = await client.session_prompt_async(
         "thr-1",
@@ -304,6 +306,105 @@ async def test_session_prompt_async_maps_rich_input_parts_to_turn_start() -> Non
     ]
 
 
+@pytest.mark.asyncio
+async def test_session_prompt_async_resumes_unloaded_thread_before_turn_start() -> None:
+    client = CodexClient(
+        make_settings(
+            a2a_bearer_token="t-1",
+            codex_workspace_root="/safe",
+            codex_timeout=1.0,
+            codex_model_id="gpt-5.2-codex",
+        )
+    )
+
+    seen: list[tuple[str, dict | None]] = []
+
+    async def fake_rpc_request(method: str, params: dict | None = None):
+        seen.append((method, params))
+        if method == "thread/loaded/list":
+            return {"data": [], "nextCursor": None}
+        if method == "thread/resume":
+            return {"thread": {"id": "thr-1"}}
+        return {"turn": {"id": "turn-42"}}
+
+    client._rpc_request = fake_rpc_request
+
+    result = await client.session_prompt_async(
+        "thr-1",
+        {"parts": [{"type": "text", "text": "Use the app."}]},
+    )
+
+    assert result == {"ok": True, "session_id": "thr-1", "turn_id": "turn-42"}
+    assert seen == [
+        ("thread/loaded/list", {}),
+        ("thread/resume", {"threadId": "thr-1", "cwd": "/safe", "model": "gpt-5.2-codex"}),
+        (
+            "turn/start",
+            {
+                "threadId": "thr-1",
+                "input": [{"type": "text", "text": "Use the app.", "text_elements": []}],
+                "cwd": "/safe",
+                "model": "gpt-5.2-codex",
+            },
+        ),
+    ]
+
+
+@pytest.mark.asyncio
+async def test_session_prompt_async_retries_turn_start_after_thread_not_found() -> None:
+    client = CodexClient(
+        make_settings(
+            a2a_bearer_token="t-1",
+            codex_workspace_root="/safe",
+            codex_timeout=1.0,
+        )
+    )
+
+    seen: list[tuple[str, dict | None]] = []
+    turn_attempts = 0
+
+    async def fake_rpc_request(method: str, params: dict | None = None):
+        nonlocal turn_attempts
+        seen.append((method, params))
+        if method == "turn/start":
+            turn_attempts += 1
+            if turn_attempts == 1:
+                raise CodexRPCError(code=-32000, message="thread not found: thr-1")
+            return {"turn": {"id": "turn-43"}}
+        if method == "thread/resume":
+            return {"thread": {"id": "thr-1"}}
+        return {}
+
+    client._rpc_request = fake_rpc_request
+    client._conversation_facade._loaded_thread_ids.add("thr-1")
+
+    result = await client.session_prompt_async(
+        "thr-1",
+        {"parts": [{"type": "text", "text": "Retry after resume."}]},
+    )
+
+    assert result == {"ok": True, "session_id": "thr-1", "turn_id": "turn-43"}
+    assert seen == [
+        (
+            "turn/start",
+            {
+                "threadId": "thr-1",
+                "input": [{"type": "text", "text": "Retry after resume.", "text_elements": []}],
+                "cwd": "/safe",
+            },
+        ),
+        ("thread/resume", {"threadId": "thr-1", "cwd": "/safe"}),
+        (
+            "turn/start",
+            {
+                "threadId": "thr-1",
+                "input": [{"type": "text", "text": "Retry after resume.", "text_elements": []}],
+                "cwd": "/safe",
+            },
+        ),
+    ]
+
+
 @pytest.mark.asyncio
 async def test_exec_start_uses_interactive_command_exec_params() -> None:
     client = CodexClient(
@@ -1375,6 +1476,7 @@ async def test_send_message_uses_structured_input_items_when_provided() -> None:
         return {"turn": {"id": "turn-1"}}
 
     client._rpc_request = fake_rpc_request
+    client._conversation_facade._loaded_thread_ids.add("thr-1")
     tracker = client._get_or_create_tracker("thr-1", "turn-1")
     tracker.text_chunks.append("done")
     tracker.completed.set()
@@ -1426,6 +1528,7 @@ async def test_send_message_request_execution_options_are_forwarded_to_turn_star
         return {"turn": {"id": "turn-1"}}
 
     client._rpc_request = fake_rpc_request
+    client._conversation_facade._loaded_thread_ids.add("thr-1")
     tracker = client._get_or_create_tracker("thr-1", "turn-1")
     tracker.text_chunks.append("done")
     tracker.completed.set()
@@ -1513,8 +1616,8 @@ async def test_permission_request_emits_shared_message_and_patterns() -> None:
     assert props["id"] == "301"
     assert props["sessionID"] == "thr-1"
     assert props["display_message"] == "The command needs confirmation before continuing."
+    assert props["permission"] == "command_execution"
     assert props["patterns"] == ["/repo/.env"]
-    assert "permission" not in props
     assert "always" not in props
     assert "reason" not in props
     assert props["metadata"]["raw"]["parsedCmd"] == [
@@ -1676,6 +1779,7 @@ async def test_permission_request_promotes_nested_request_message() -> None:
     assert len(events) == 1
     props = events[0]["properties"]
     assert props["display_message"] == "Agent wants to read the environment file."
+    assert props["permission"] == "command_execution"
     assert props["patterns"] == ["/repo/.env"]
     assert "request" not in props
     assert props["metadata"]["raw"]["request"] == {