voidx 3.7.0__tar.gz → 3.7.2__tar.gz

{voidx-3.7.0/src/voidx.egg-info → voidx-3.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voidx
-Version: 3.7.0
+Version: 3.7.2
 Summary: A coding agent that quantifies everything and solves with tools, not fuzzy prompts.
 Author: chikhamx
 License: MIT

{voidx-3.7.0 → voidx-3.7.2}/src/tests/test_agent/graph/test_call_llm_compaction.py

@@ -792,3 +792,23 @@ def test_llm_retry_delay_exponential_cap():
     assert _llm_retry_delay(8) == 60.0
     assert _llm_retry_delay(9) == 60.0
     assert _llm_retry_delay(10) == 60.0
+
+
+def test_clean_error_message():
+    from voidx.agent.graph.core.helpers import _clean_error_message
+
+    # Test case 1: OpenAI rate limit error with dict representation
+    exc1 = Exception("Error code: 402 - {'error': {'type': 'rate_limit_error', 'message': '每日额度超限: 当前 $50.813...'}}")
+    assert _clean_error_message(exc1) == "Error code: 402 - 每日额度超限: 当前 $50.813..."
+
+    # Test case 2: OpenAI error with json representation
+    exc2 = Exception('Error code: 400 - {"error": {"message": "Invalid prompt", "type": "invalid_request_error"}}')
+    assert _clean_error_message(exc2) == "Error code: 400 - Invalid prompt"
+
+    # Test case 3: Standard exception with no JSON/dict
+    exc3 = Exception("Connection refused")
+    assert _clean_error_message(exc3) == "Connection refused"
+
+    # Test case 4: Dict representation without error key
+    exc4 = Exception("Error: {'message': 'Something went wrong'}")
+    assert _clean_error_message(exc4) == "Error - Something went wrong"

{voidx-3.7.0 → voidx-3.7.2}/src/tests/test_agent/graph/test_graph_authorization.py

@@ -72,6 +72,10 @@ def _result_task_state(result: dict) -> TaskState:
     return TaskState.model_validate(result["task_state"])
 
 
+def _asked_tool_calls(batch):
+    return [getattr(item, "tool_call", item) for item in batch]
+
+
 def _child_goal_resolution(
     goal_type: str = "feature",
     *,
@@ -191,7 +195,7 @@ async def test_graph_authorization_prompts_for_implement_agent(tmp_path):
 
     assert [tc["name"] for tc in approved] == ["agent"]
     assert denied == []
-    assert [[tc["args"]["goal_resolution"]["plan"]["join"] for tc in batch] for batch in asked] == [["tdd"]]
+    assert [[tc["args"]["goal_resolution"]["plan"]["join"] for tc in _asked_tool_calls(batch)] for batch in asked] == [["tdd"]]
 
 
 @pytest.mark.asyncio
@@ -210,6 +214,34 @@ async def test_graph_authorization_respects_session_deny_for_safe_bash(tmp_path)
     assert "Permission denied" in denied[0][1]
 
 
+@pytest.mark.asyncio
+async def test_graph_authorization_never_approves_mixed_blocked_batch(tmp_path):
+    graph = _graph(tmp_path)
+    graph._permission.permission_preset = "safe"
+    asked: list[list[object]] = []
+
+    async def approve(tool_calls):
+        asked.append(tool_calls)
+        return "y"
+
+    graph._ask_tool_permission = approve
+
+    approved, denied = await graph._authorize_tool_calls(
+        [
+            {"name": "bash", "args": {"command": "rm -rf /"}, "id": "blocked"},
+            {"name": "bash", "args": {"command": "echo $(date)"}, "id": "ask"},
+        ],
+        plan_mode=False,
+        session_id="test",
+    )
+
+    assert [call["id"] for call in approved] == ["ask"]
+    assert [call["id"] for call, _ in denied] == ["blocked"]
+    assert len(asked) == 2
+    assert [item.tool_call["id"] for item in asked[0]] == ["blocked"]
+    assert [item.tool_call["id"] for item in asked[1]] == ["ask"]
+
+
 @pytest.mark.asyncio
 async def test_graph_authorization_asks_for_write_by_active_workflow_gate(tmp_path):
     graph = _graph(tmp_path)
@@ -231,7 +263,7 @@ async def test_graph_authorization_asks_for_write_by_active_workflow_gate(tmp_pa
         ],
     )
 
-    assert [[call["id"] for call in batch] for batch in asked] == [["call_1"]]
+    assert [[call["id"] for call in _asked_tool_calls(batch)] for batch in asked] == [["call_1"]]
     assert [call["id"] for call in approved] == ["call_1"]
     assert denied == []
 
@@ -294,7 +326,7 @@ async def test_graph_authorization_allows_plan_gate_doc_paths_only(tmp_path):
     )
 
     assert [call["id"] for call in approved] == ["call_docs"]
-    assert [[call["id"] for call in batch] for batch in asked] == [["call_src"]]
+    assert [[call["id"] for call in _asked_tool_calls(batch)] for batch in asked] == [["call_src"]]
     assert [call["id"] for call, _reason in denied] == ["call_src"]
     assert denied[0][1] == "User denied: replace"
 
@@ -371,7 +403,7 @@ async def test_graph_authorization_asks_for_workflow_gate_tools_instead_of_denyi
         ],
     )
 
-    assert [[call["id"] for call in batch] for batch in asked] == [["call_src"]]
+    assert [[call["id"] for call in _asked_tool_calls(batch)] for batch in asked] == [["call_src"]]
     assert [call["id"] for call in approved] == ["call_src"]
     assert denied == []
 
@@ -470,6 +502,9 @@ async def test_permission_prompt_uses_dock_details_when_events_are_active(tmp_pa
             "name": "bash",
             "pattern": "npm install lodash",
             "args": {"command": "npm install lodash"},
+            "risk": None,
+            "allowed_scopes": [],
+            "default_scope": None,
         }]
         record = test_dock.status_record("permission:request")
         assert record is not None
@@ -480,3 +515,154 @@ async def test_permission_prompt_uses_dock_details_when_events_are_active(tmp_pa
         await graph._ui.events.stop()
         test_dock.deactivate()
         set_dock(None)
+
+
+@pytest.mark.asyncio
+async def test_read_only_permission_prompt_limits_choices_to_once(tmp_path):
+    graph = _graph(tmp_path)
+    graph._permission.sandbox_mode = "read-only"
+    graph._permission.permission_mode = "read-only"
+    graph._permission.approval_policy = "untrusted"
+    captured_choices = None
+
+    class FakeApp:
+        async def ask_choice(self, _prompt, choices, details=None):
+            nonlocal captured_choices
+            captured_choices = choices
+            return "y"
+
+    graph._app = FakeApp()
+
+    approved, denied = await graph._authorize_tool_calls(
+        [{"name": "bash", "args": {"command": "cat input.txt > output.txt"}, "id": "call_1"}],
+        plan_mode=False,
+        session_id="s",
+    )
+
+    assert [tc["name"] for tc in approved] == ["bash"]
+    assert denied == []
+    assert captured_choices == [
+        ("Yes", "y", "Allow this tool use once"),
+        ("No", "n", "Deny these tools"),
+    ]
+
+
+@pytest.mark.asyncio
+async def test_permission_prompt_details_include_risk_and_scopes(tmp_path):
+    graph = _graph(tmp_path)
+    graph._permission.permission_mode = "default"
+    graph._permission.approval_policy = "untrusted"
+    received_details = None
+
+    class FakeApp:
+        async def ask_choice(self, _prompt, _choices, details=None):
+            nonlocal received_details
+            received_details = details
+            return "y"
+
+    graph._app = FakeApp()
+
+    approved, denied = await graph._authorize_tool_calls(
+        [{"name": "bash", "args": {"command": "npm install lodash"}, "id": "call_1"}],
+        plan_mode=False,
+        session_id="s",
+    )
+
+    assert [tc["name"] for tc in approved] == ["bash"]
+    assert denied == []
+    assert received_details == [{
+        "name": "bash",
+        "pattern": "npm install lodash",
+        "args": {"command": "npm install lodash"},
+        "risk": {
+            "level": "extreme",
+            "tags": ["dependency_install"],
+            "reason": "shell policy deferred: dependency install command",
+            "tool_name": "bash",
+            "pattern": "npm install lodash",
+        },
+        "allowed_scopes": ["once"],
+        "default_scope": "once",
+    }]
+
+
+@pytest.mark.asyncio
+async def test_graph_authorization_attaches_approved_risk_token_to_approved_shell_call(tmp_path):
+    graph = _graph(tmp_path)
+    graph._permission.sandbox_mode = "read-only"
+    graph._permission.permission_mode = "read-only"
+    graph._permission.approval_policy = "untrusted"
+
+    async def approve(_tool_calls):
+        return "y"
+
+    graph._ask_tool_permission = approve
+    command = "cat input.txt > output.txt"
+
+    approved, denied = await graph._authorize_tool_calls(
+        [{"name": "bash", "args": {"command": command}, "id": "call_1"}],
+        plan_mode=False,
+        session_id="s",
+    )
+
+    assert denied == []
+    assert approved[0]["metadata"]["approved_risk"] == {
+        "tool_name": "bash",
+        "pattern": command,
+        "risk_level": "extreme",
+        "tags": ["dynamic_shell"],
+        "reason": "shell policy deferred: compound shell syntax, compound shell operator",
+    }
+
+
+@pytest.mark.asyncio
+async def test_blocked_permission_prompt_only_acknowledges_and_denies_execution(tmp_path):
+    graph = _graph(tmp_path)
+    graph._permission.permission_mode = "default"
+    graph._permission.approval_policy = "untrusted"
+    captured_choices = None
+    captured_details = None
+
+    class FakeApp:
+        async def ask_choice(self, _prompt, choices, details=None):
+            nonlocal captured_choices, captured_details
+            captured_choices = choices
+            captured_details = details
+            return "n"
+
+    graph._app = FakeApp()
+
+    approved, denied = await graph._authorize_tool_calls(
+        [{"name": "bash", "args": {"command": "sudo true"}, "id": "call_blocked"}],
+        plan_mode=False,
+        session_id="s",
+    )
+
+    assert approved == []
+    assert denied == [({"name": "bash", "args": {"command": "sudo true"}, "id": "call_blocked"}, "Blocked: sudo is blocked — privilege escalation")]
+    assert captured_choices == [("Do not run", "n", "This command is blocked")]
+    assert captured_details[0]["risk"]["level"] == "blocked"
+    assert captured_details[0]["allowed_scopes"] == []
+    assert captured_details[0]["default_scope"] is None
+
+
+@pytest.mark.asyncio
+async def test_blocked_permission_prompt_cannot_be_approved_with_yes(tmp_path):
+    graph = _graph(tmp_path)
+    graph._permission.permission_mode = "default"
+    graph._permission.approval_policy = "untrusted"
+
+    class FakeApp:
+        async def ask_choice(self, _prompt, _choices, details=None):
+            return "y"
+
+    graph._app = FakeApp()
+
+    approved, denied = await graph._authorize_tool_calls(
+        [{"name": "bash", "args": {"command": "sudo true"}, "id": "call_blocked"}],
+        plan_mode=False,
+        session_id="s",
+    )
+
+    assert approved == []
+    assert denied == [({"name": "bash", "args": {"command": "sudo true"}, "id": "call_blocked"}, "Blocked: sudo is blocked — privilege escalation")]

{voidx-3.7.0 → voidx-3.7.2}/src/tests/test_agent/graph/test_subagent_runner.py

@@ -72,6 +72,10 @@ def _result_task_state(result: dict) -> TaskState:
     return TaskState.model_validate(result["task_state"])
 
 
+def _asked_tool_calls(batch):
+    return [getattr(item, "tool_call", item) for item in batch]
+
+
 def _child_goal_resolution(
     goal_type: str = "feature",
     *,
@@ -320,6 +324,13 @@ async def test_subagent_runner_authorizes_with_child_interaction_mode(tmp_path,
 async def test_graph_authorization_does_not_treat_goal_as_read_only_mode(tmp_path):
     graph = _graph(tmp_path)
     graph._permission.approval_policy = "on-request"
+    asked: list[list[dict]] = []
+
+    async def approve(tool_calls):
+        asked.append(tool_calls)
+        return "y"
+
+    graph._ask_tool_permission = approve
 
     approved, denied = await graph._authorize_tool_calls(
         [{"name": "edit", "args": {"file_path": "src/app.py"}, "id": "call_1"}],
@@ -331,6 +342,7 @@ async def test_graph_authorization_does_not_treat_goal_as_read_only_mode(tmp_pat
 
     assert [tc["name"] for tc in approved] == ["replace"]
     assert denied == []
+    assert [[tc["name"] for tc in _asked_tool_calls(batch)] for batch in asked] == [["replace"]]
 
 
 @pytest.mark.asyncio
@@ -369,7 +381,7 @@ async def test_graph_authorization_prompts_for_edit(tmp_path):
 
     assert [tc["name"] for tc in approved] == ["replace"]
     assert denied == []
-    assert [[tc["name"] for tc in batch] for batch in asked] == [["replace"]]
+    assert [[tc["name"] for tc in _asked_tool_calls(batch)] for batch in asked] == [["replace"]]
 
 
 @pytest.mark.asyncio
@@ -413,4 +425,4 @@ async def test_graph_authorization_prompts_for_unsafe_bash(tmp_path):
 
     assert [tc["name"] for tc in approved] == ["bash"]
     assert denied == []
-    assert [[tc["name"] for tc in batch] for batch in asked] == [["bash"]]
+    assert [[tc["name"] for tc in _asked_tool_calls(batch)] for batch in asked] == [["bash"]]

{voidx-3.7.0 → voidx-3.7.2}/src/tests/test_agent/graph/test_tool_execution_auth.py

@@ -135,7 +135,7 @@ def _tree_nodes(root):
 @pytest.mark.asyncio
 async def test_graph_on_request_auto_approves_need_ask_tools(tmp_path):
     graph = _graph(tmp_path)
-    graph._permission.approval_policy = "on-request"
+    graph._permission.permission_preset = "full_access"
 
     approved, denied = await graph._authorize_tool_calls(
         [{"name": "write", "args": {"file_path": "app.py", "op": "append", "new_string": "x"}, "id": "call_1"}],

voidx-3.7.2/src/tests/test_agent/graph/test_turn_stop_without_pending.py

@@ -0,0 +1,236 @@
+"""Test: turn stop without pending provisional text in running state.
+
+When the main agent calls a child agent (e.g. review) and the child returns,
+the main agent may call turn operation='stop' directly without first emitting
+plain text. In that case pending_provisional is None and validate_turn_call
+rejects the stop. The INVALID_TURN_PROMPT then tells the LLM to "not output
+text, call turn stop" — which is contradictory because there is no pending
+text to commit. This creates a dead loop that ends with a failure message
+and should_continue=False, producing no user-facing text.
+"""
+
+import pytest
+from langchain_core.messages import AIMessage, AIMessageChunk, HumanMessage, ToolMessage
+
+from voidx.agent.graph import VoidXGraph
+from voidx.config import Config, ModelConfig
+from voidx.ui.output.events import AssistantStreamCommitted, AssistantStreamUpdated
+from tests.test_agent.graph.stream_llm_helpers import FakeRenderer
+
+
+class ScriptedStreamingModel:
+    def __init__(self, scripts: list[list[AIMessageChunk]]) -> None:
+        self.scripts = list(scripts)
+        self.call_index = 0
+        self.bound_tools = None
+
+    def bind_tools(self, tool_defs):
+        self.bound_tools = tool_defs
+        return self
+
+    async def astream(self, messages):
+        idx = self.call_index
+        self.call_index += 1
+        if idx >= len(self.scripts):
+            pytest.fail(
+                f"Unexpected LLM call {idx + 1}; "
+                f"only {len(self.scripts)} scripted responses were provided"
+            )
+        for chunk in self.scripts[idx]:
+            yield chunk
+
+
+def _turn_stop_chunk() -> AIMessageChunk:
+    return AIMessageChunk(
+        content="",
+        tool_calls=[{
+            "name": "turn",
+            "args": {"operation": "stop", "intent": "", "goal": ""},
+            "id": "tc1",
+            "type": "tool_call",
+        }],
+    )
+
+
+def _text_chunk(text: str) -> AIMessageChunk:
+    return AIMessageChunk(content=text)
+
+
+def _text_and_turn_stop_chunk(text: str) -> AIMessageChunk:
+    return AIMessageChunk(
+        content=text,
+        tool_calls=[{
+            "name": "turn",
+            "args": {"operation": "stop", "intent": "", "goal": ""},
+            "id": "tc1",
+            "type": "tool_call",
+        }],
+    )
+
+
+def _make_graph(tmp_path, model, monkeypatch, provider="openai"):
+    import voidx.agent.graph.core.llm as graph_module
+
+    async def fail_on_retry(delay):
+        pytest.fail(f"Unexpected LLM retry with delay {delay}s")
+
+    monkeypatch.setattr(graph_module, "StreamingRenderer", FakeRenderer)
+    monkeypatch.setattr(graph_module.asyncio, "sleep", fail_on_retry)
+
+    graph = VoidXGraph(
+        Config(
+            model=ModelConfig(provider=provider, model="test-model"),
+            workspace=str(tmp_path),
+        ),
+        api_key=None,
+    )
+    graph.model = model
+    return graph
+
+
+@pytest.mark.asyncio
+async def test_turn_stop_in_running_state_without_pending_emits_text(tmp_path, monkeypatch):
+    """When turn_state='running' and LLM calls turn stop without prior text,
+    the agent should recover by prompting the LLM to produce text, not enter
+    a dead loop that ends with a bare failure message.
+    """
+    model = ScriptedStreamingModel([
+        # 1) LLM calls turn stop directly (no text, no pending_provisional)
+        [_turn_stop_chunk()],
+        # 2) After MISSING_PENDING_PROMPT, LLM outputs plain text summary
+        [_text_chunk("Review completed: PASS")],
+        # 3) After TURN_STOP_PROMPT, LLM calls turn stop to commit
+        [_turn_stop_chunk()],
+    ])
+    graph = _make_graph(tmp_path, model, monkeypatch)
+
+    result = await graph._call_llm({
+        "messages": [HumanMessage(content="Run review")],
+        "step_count": 1,
+        "persona": "coordinate",
+        "turn_state": "running",
+    })
+
+    # The agent should produce user-facing text, not a bare failure message.
+    msg = result["messages"][0]
+    assert isinstance(msg, AIMessage)
+    assert not msg.tool_calls
+    text = (msg.content or "").strip() if isinstance(msg.content, str) else ""
+    assert "Review completed" in text
+    assert "LLM call failed" not in text
+
+
+@pytest.mark.parametrize("repair_shape", ["text_then_stop", "text_and_stop"])
+@pytest.mark.asyncio
+async def test_headless_repair_commit_emits_user_visible_stream(tmp_path, monkeypatch, repair_shape):
+    """Gemini often repairs missing pending text by returning text + turn stop
+    in one headless repair call. The committed answer must still be emitted to
+    the UI; checking only result["messages"] misses the user-visible blank turn.
+    """
+    import voidx.agent.graph.core.llm as graph_module
+
+    emitted = []
+
+    class TrackingEvents:
+        async def emit(self, event):
+            emitted.append(event)
+            return True
+
+        def emit_direct(self, event):
+            emitted.append(event)
+            return True
+
+        async def drain(self):
+            pass
+
+        @property
+        def is_running(self):
+            return True
+
+    class TrackingUi:
+        class Output:
+            def print(self, *args, **kwargs):
+                pass
+
+            def error(self, *args, **kwargs):
+                pass
+
+        def __init__(self):
+            self.events = TrackingEvents()
+            self.console = None
+            self.ui = self.Output()
+
+        def via_events(self):
+            return True
+
+    class HeadlessAwareRenderer(FakeRenderer):
+        def __init__(self, *args, **kwargs) -> None:
+            super().__init__(*args, **kwargs)
+            self.headless = bool(kwargs.get("headless", False))
+
+        def feed_text(self, text: str) -> None:
+            if not self.headless:
+                super().feed_text(text)
+
+    async def fail_on_retry(delay):
+        pytest.fail(f"Unexpected LLM retry with delay {delay}s")
+
+    monkeypatch.setattr(graph_module, "StreamingRenderer", HeadlessAwareRenderer)
+    monkeypatch.setattr(graph_module.asyncio, "sleep", fail_on_retry)
+
+    scripts = [[_turn_stop_chunk()]]
+    if repair_shape == "text_then_stop":
+        scripts.extend([[_text_chunk("Review completed: PASS")], [_turn_stop_chunk()]])
+    else:
+        scripts.append([_text_and_turn_stop_chunk("Review completed: PASS")])
+    model = ScriptedStreamingModel(scripts)
+    graph = VoidXGraph(
+        Config(
+            model=ModelConfig(provider="gemini", model="gemini-test"),
+            workspace=str(tmp_path),
+        ),
+        api_key=None,
+    )
+    graph.model = model
+    graph._ui = TrackingUi()
+
+    result = await graph._call_llm({
+        "messages": [HumanMessage(content="Run review")],
+        "step_count": 1,
+        "persona": "coordinate",
+        "turn_state": "running",
+    })
+
+    assert result["messages"][0].content == "Review completed: PASS"
+    stream_updates = [event for event in emitted if isinstance(event, AssistantStreamUpdated)]
+    assert any("Review completed: PASS" in event.text for event in stream_updates)
+    assert any(isinstance(event, AssistantStreamCommitted) for event in emitted)
+
+
+@pytest.mark.asyncio
+async def test_turn_stop_with_text_after_missing_pending(tmp_path, monkeypatch):
+    """When MISSING_PENDING_PROMPT is injected and LLM responds with text +
+    turn stop in the same message, the agent should accept the text as
+    pending and commit it, not treat it as INVALID_TURN.
+    """
+    model = ScriptedStreamingModel([
+        # 1) LLM calls turn stop directly (no text, no pending_provisional)
+        [_turn_stop_chunk()],
+        # 2) After MISSING_PENDING_PROMPT, LLM outputs text + turn stop together
+        [_text_chunk("Review completed: PASS"), _turn_stop_chunk()],
+    ])
+    graph = _make_graph(tmp_path, model, monkeypatch)
+
+    result = await graph._call_llm({
+        "messages": [HumanMessage(content="Run review")],
+        "step_count": 1,
+        "persona": "coordinate",
+        "turn_state": "running",
+    })
+
+    msg = result["messages"][0]
+    assert isinstance(msg, AIMessage)
+    assert not msg.tool_calls
+    text = (msg.content or "").strip() if isinstance(msg.content, str) else ""
+    assert "Review completed" in text
+    assert "LLM call failed" not in text

{voidx-3.7.0 → voidx-3.7.2}/src/tests/test_agent/graph/test_workflow_done.py

@@ -132,7 +132,9 @@ def _tree_nodes(root):
 
 
 @pytest.mark.asyncio
-async def test_workflow_done_stops_before_followup_llm_when_workflow_complete(tmp_path):
+async def test_workflow_done_returns_to_llm_when_workflow_complete(tmp_path):
+    from voidx.agent.graph.topology import route_after_execute_tools
+
     graph = _graph(tmp_path)
     parent = AIMessage(
         content="",
@@ -164,7 +166,8 @@ async def test_workflow_done_stops_before_followup_llm_when_workflow_complete(tm
         ),
     })
 
-    assert result["should_continue"] is False
+    assert result.get("should_continue") is not False
+    assert route_after_execute_tools(result) == "call_llm"
     by_name = {run.name: run for run in _result_task_state(result).workflow_runs.values()}
     assert by_name["verify"].status == WorkflowRunStatus.SATISFIED
 
@@ -256,7 +259,9 @@ async def test_workflow_route_end_satisfies_non_review_without_successor(tmp_pat
 
 
 @pytest.mark.asyncio
-async def test_multiple_workflow_done_calls_finish_batch_before_stopping(tmp_path):
+async def test_multiple_workflow_done_calls_finish_batch_before_returning_to_llm(tmp_path):
+    from voidx.agent.graph.topology import route_after_execute_tools
+
     graph = _graph(tmp_path)
     parent = AIMessage(
         content="",
@@ -303,9 +308,9 @@ async def test_multiple_workflow_done_calls_finish_batch_before_stopping(tmp_pat
         "call_design_done",
         "call_verify_done",
     ]
-    assert result["should_continue"] is False
+    assert result.get("should_continue") is not False
+    assert route_after_execute_tools(result) == "call_llm"
     by_name = {run.name: run for run in _result_task_state(result).workflow_runs.values()}
     assert by_name["design"].status == WorkflowRunStatus.SATISFIED
     assert by_name["verify"].status == WorkflowRunStatus.SATISFIED
 
-

{voidx-3.7.0 → voidx-3.7.2}/src/tests/test_agent/graph/test_workflow_transactions_barrier.py

@@ -301,6 +301,9 @@ async def test_workflow_transaction_reauthorizes_following_write(tmp_path):
             nonlocal invalidations
             invalidations += 1
 
+        async def ask_choice(self, _prompt, _choices, details=None):
+            return "y"
+
     graph._app = FakeApp()
     parent = AIMessage(
         content="",