fix(runner): close the adversarial-review findings on the approvals train

Author: mmabrouk

api/oss/src/apis/fastapi/sessions/models.py

@@ -1,8 +1,8 @@
 from datetime import datetime
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Literal, Optional
 from uuid import UUID
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, ConfigDict, Field, model_validator
 
 from oss.src.core.sessions.streams.dtos import (
     SessionStream,
@@ -101,17 +101,34 @@ class SessionInteractionCreateRequest(BaseModel):
     meta: Optional[Dict[str, Any]] = None
 
 
+class SessionInteractionResolution(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    verdict: Literal["approved", "denied"]
+    tool_call_id: str
+
+
 class SessionInteractionTransitionRequest(BaseModel):
     # No project_id: scope comes from the caller's credential (request.state).
     session_id: str
     token: str
     status: SessionInteractionStatus
-    resolution: Optional[Dict[str, Any]] = None
+    resolution: Optional[SessionInteractionResolution] = None
+
+    @model_validator(mode="after")
+    def validate_resolution_status(self) -> "SessionInteractionTransitionRequest":
+        # Resolution is answer data, so it is valid only on the resolved lifecycle edge.
+        if (
+            self.resolution is not None
+            and self.status != SessionInteractionStatus.resolved
+        ):
+            raise ValueError("resolution is only valid when status is resolved")
+        return self
 
 
 class SessionInteractionCancelStaleRequest(BaseModel):
-    # Cancels prior turns' pending gates, sparing this turn's own (`turn_id`) and any gates
-    # the current turn answers in-band (`tokens` — a resume must resolve them, not cancel).
+    # Cancels prior turns' pending gates, sparing this turn's own (`turn_id`) and every prior
+    # gate still owned by a live partial resume (`tokens`, including carried gates).
     session_id: str
     turn_id: str
     tokens: Optional[List[str]] = None

api/oss/src/apis/fastapi/sessions/router.py

@@ -54,6 +54,8 @@
 from oss.src.core.sessions.records.streaming import publish_record
 from oss.src.core.sessions.interactions.dtos import (
     SessionInteractionCreate,
+    SessionInteractionKind,
+    SessionInteractionQuery,
     SessionInteractionStatus,
     SessionInteractionTransition,
 )
@@ -638,14 +640,41 @@ async def transition_interaction(
         ):
             raise FORBIDDEN_EXCEPTION
 
+        resolution = (
+            body.resolution.model_dump() if body.resolution is not None else None
+        )
+        if resolution is not None:
+            interactions = await self.interactions_service.query_interactions(
+                project_id=project_id,
+                query=SessionInteractionQuery(session_id=body.session_id),
+            )
+            source = next(
+                (
+                    interaction
+                    for interaction in interactions
+                    if interaction.token == body.token
+                ),
+                None,
+            )
+            if source is None:
+                raise HTTPException(
+                    status_code=status.HTTP_404_NOT_FOUND,
+                    detail="Interaction not found or already terminal",
+                )
+            if source.kind != SessionInteractionKind.user_approval:
+                raise HTTPException(
+                    status_code=status.HTTP_409_CONFLICT,
+                    detail="Resolution is only valid for user approval interactions",
+                )
+
         try:
             interaction = await self.interactions_service.transition_interaction(
                 transition=SessionInteractionTransition(
                     project_id=project_id,
                     session_id=body.session_id,
                     token=body.token,
                     status=body.status,
-                    resolution=body.resolution,
+                    resolution=resolution,
                 ),
             )
         except InteractionNotFound:

api/oss/tests/pytest/unit/sessions/test_transition_interaction_resolution.py

@@ -1,7 +1,9 @@
 from unittest.mock import AsyncMock, patch
 from uuid import uuid4
 
-from fastapi import FastAPI, Request
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.testclient import TestClient
+import pytest
 
 from oss.src.apis.fastapi.sessions.models import SessionInteractionTransitionRequest
 from oss.src.apis.fastapi.sessions.router import InteractionsRouter
@@ -34,6 +36,17 @@ async def test_transition_route_passes_resolution_to_the_domain_transition():
     captured = []
 
     class _InteractionsService:
+        async def query_interactions(self, *, project_id, query):
+            return [
+                SessionInteraction(
+                    project_id=project_id,
+                    session_id=query.session_id,
+                    token="approval-token",
+                    kind=SessionInteractionKind.user_approval,
+                    status=SessionInteractionStatus.pending,
+                )
+            ]
+
         async def transition_interaction(self, *, transition):
             captured.append(transition)
             return SessionInteraction(
@@ -75,3 +88,80 @@ async def transition_interaction(self, *, transition):
     assert response.interaction is not None
     assert response.interaction.data is not None
     assert response.interaction.data.resolution == captured[0].resolution
+
+
+@pytest.mark.parametrize(
+    "payload",
+    [
+        {
+            "session_id": "session-1",
+            "token": "approval-token",
+            "status": "pending",
+            "resolution": {"verdict": "approved", "tool_call_id": "tool-1"},
+        },
+        {
+            "session_id": "session-1",
+            "token": "approval-token",
+            "status": "resolved",
+            "resolution": {"verdict": "maybe", "tool_call_id": "tool-1"},
+        },
+        {
+            "session_id": "session-1",
+            "token": "approval-token",
+            "status": "resolved",
+            "resolution": {"verdict": "approved"},
+        },
+    ],
+)
+def test_transition_route_rejects_invalid_approval_resolution_with_422(payload):
+    router = InteractionsRouter(
+        interactions_service=AsyncMock(),
+        workflows_service=AsyncMock(),
+        respond_task=AsyncMock(),
+    )
+    app = FastAPI()
+    app.include_router(router.router)
+
+    response = TestClient(app).post("/transition", json=payload)
+
+    assert response.status_code == 422
+
+
+async def test_transition_route_rejects_resolution_for_client_tool_with_409():
+    project_id = uuid4()
+    user_id = uuid4()
+    interactions_service = AsyncMock()
+    interactions_service.query_interactions.return_value = [
+        SessionInteraction(
+            project_id=project_id,
+            session_id="session-1",
+            token="client-tool-token",
+            kind=SessionInteractionKind.client_tool,
+            status=SessionInteractionStatus.pending,
+        )
+    ]
+    router = InteractionsRouter(
+        interactions_service=interactions_service,
+        workflows_service=AsyncMock(),
+        respond_task=AsyncMock(),
+    )
+    body = SessionInteractionTransitionRequest(
+        session_id="session-1",
+        token="client-tool-token",
+        status=SessionInteractionStatus.resolved,
+        resolution={"verdict": "approved", "tool_call_id": "tool-1"},
+    )
+
+    with patch(
+        "oss.src.apis.fastapi.sessions.router.check_action_access",
+        new_callable=AsyncMock,
+        return_value=True,
+    ):
+        with pytest.raises(HTTPException) as caught:
+            await router.transition_interaction(
+                request=_make_authed_request(FastAPI(), project_id, user_id),
+                body=body,
+            )
+
+    assert caught.value.status_code == 409
+    interactions_service.transition_interaction.assert_not_awaited()

sdks/python/agenta/sdk/agents/adapters/vercel/messages.py

@@ -196,12 +196,19 @@ def _tool_part_blocks(part: Dict[str, Any], ptype: str) -> List[ContentBlock]:
                 if isinstance(_input, dict)
                 else type(_input).__name__,
             )
+            approval_output: Dict[str, Any] = {"approved": approved}
+            approval = part.get("approval")
+            interaction_token = (
+                approval.get("id") if isinstance(approval, dict) else None
+            )
+            if isinstance(interaction_token, str) and interaction_token:
+                approval_output["interactionToken"] = interaction_token
             blocks.append(
                 ContentBlock(
                     type="tool_result",
                     tool_call_id=tool_call_id,
                     tool_name=tool_name,
-                    output={"approved": approved},
+                    output=approval_output,
                 )
             )
     return blocks
@@ -229,7 +236,13 @@ def _approval_response_blocks(part: Dict[str, Any]) -> List[ContentBlock]:
     output = part.get("output")
     if output is None:
         approved = part.get("approved")
-        output = {"approved": approved} if approved is not None else part.get("reason")
+        if approved is not None:
+            output = {"approved": approved}
+            interaction_token = part.get("approvalId")
+            if isinstance(interaction_token, str) and interaction_token:
+                output["interactionToken"] = interaction_token
+        else:
+            output = part.get("reason")
     return [ContentBlock(type="tool_result", tool_call_id=tool_call_id, output=output)]
 
 

sdks/python/oss/tests/pytest/unit/agents/test_ui_messages.py

@@ -212,7 +212,10 @@ def test_inline_approval_responded_deny_emits_approved_envelope(self):
                 "type": "tool_result",
                 "toolCallId": "call_1",
                 "toolName": "deleteFile",
-                "output": {"approved": False},
+                "output": {
+                    "approved": False,
+                    "interactionToken": "perm_1",
+                },
             },
         ]
 
@@ -238,7 +241,10 @@ def test_inline_approval_responded_approve_emits_approved_envelope(self):
         result = msgs[0].content[1]
         assert result.type == "tool_result"
         assert result.tool_call_id == "call_2"
-        assert result.output == {"approved": True}
+        assert result.output == {
+            "approved": True,
+            "interactionToken": "perm_2",
+        }
 
     def test_concurrent_inline_approvals_each_emit_their_own_result(self):
         # Concurrent approvals: the browser round-trips TWO tool parts in one turn, each with its
@@ -274,11 +280,11 @@ def test_concurrent_inline_approvals_each_emit_their_own_result(self):
         # Each decision lands on its own toolCallId, in order, approve and deny preserved.
         assert (results[0].tool_call_id, results[0].output) == (
             "call_1",
-            {"approved": True},
+            {"approved": True, "interactionToken": "perm_1"},
         )
         assert (results[1].tool_call_id, results[1].output) == (
             "call_2",
-            {"approved": False},
+            {"approved": False, "interactionToken": "perm_2"},
         )
 
     def test_inline_output_denied_state_emits_denied_envelope(self):
@@ -304,7 +310,10 @@ def test_inline_output_denied_state_emits_denied_envelope(self):
         result = msgs[0].content[1]
         assert result.type == "tool_result"
         assert result.tool_call_id == "call_3"
-        assert result.output == {"approved": False}
+        assert result.output == {
+            "approved": False,
+            "interactionToken": "perm_3",
+        }
 
     def test_pending_approval_request_only_part_emits_no_decision(self):
         # A tool part still awaiting a decision (`approval-requested`, no `approval.approved`)

sdks/python/oss/tests/pytest/unit/test_workflow_control_running.py

@@ -117,7 +117,6 @@ def row(self, sid: str) -> dict:
 
 @pytest.mark.asyncio
 async def test_send_on_idle_session_marks_alive_and_increments_token():
-
     store = _FakeSessionStore()
     started = asyncio.Event()
 
@@ -142,7 +141,6 @@ async def slow_run():
 
 @pytest.mark.asyncio
 async def test_send_collision_when_alive_without_control_is_409():
-
     store = _FakeSessionStore()
     store.row("s1")["alive"] = True
 
@@ -154,7 +152,6 @@ async def test_send_collision_when_alive_without_control_is_409():
 
 @pytest.mark.asyncio
 async def test_steer_cancels_alive_run_and_restarts():
-
     store = _FakeSessionStore()
     row = store.row("s1")
     row["alive"] = True
@@ -176,7 +173,6 @@ async def new_run():
 
 @pytest.mark.asyncio
 async def test_cancel_marks_dead():
-
     store = _FakeSessionStore()
     row = store.row("s1")
     row["alive"] = True
@@ -194,7 +190,6 @@ async def test_cancel_marks_dead():
 
 @pytest.mark.asyncio
 async def test_attach_to_alive_detached_run():
-
     store = _FakeSessionStore()
     row = store.row("s1")
     row["alive"] = True
@@ -211,7 +206,6 @@ async def test_attach_to_alive_detached_run():
 
 @pytest.mark.asyncio
 async def test_detach_on_client_disconnect_keeps_run_alive():
-
     store = _FakeSessionStore()
     row = store.row("s1")
     row["alive"] = True