voidx 3.5.1__tar.gz → 3.6.0__tar.gz

{voidx-3.5.1/src/voidx.egg-info → voidx-3.6.0}/PKG-INFO

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

{voidx-3.5.1 → voidx-3.6.0}/pyproject.toml

@@ -55,7 +55,7 @@ where = ["src"]
     "bundled/*/SKILL.md",
 ]
 "voidx.data" = [
-    "templates/*.md",
+    "documents/**/*.md",
 ]
 
 [tool.pytest.ini_options]

{voidx-3.5.1 → voidx-3.6.0}/src/tests/test_agent/graph/test_execute_tools_guard.py

@@ -49,7 +49,7 @@ from voidx.tools.base import ToolContext, ToolResult
 from voidx.tools.agent import AgentResultContract, AgentTool
 from voidx.tools.registry import ToolRegistry
 from voidx.ui.output.dock import BottomInputDock, set_dock
-from voidx.ui.output.events import DockEventConsumer, TurnStarted, ui_events
+from voidx.ui.output.events import DockEventConsumer, StatusUpdated, ToolResultAppended, TurnStarted, ui_events
 
 
 def _graph(tmp_path):
@@ -669,3 +669,130 @@ async def test_execute_tools_terminates_turn_when_tool_started_notification_time
         and "UI event bus timed out" in str(message.content)
         for message in result["messages"]
     )
+
+
+@pytest.mark.asyncio
+async def test_execute_tools_returns_tool_error_when_result_rendering_fails(tmp_path, monkeypatch):
+    graph = _graph(tmp_path)
+
+    class FakeReadTool:
+        id = "read"
+        description = "fake read"
+
+        def parameters_schema(self):
+            return {"type": "object", "properties": {}}
+
+        async def execute(self, args: dict, ctx: ToolContext) -> ToolResult:
+            return ToolResult(output="File not found: missing.py", metadata={"error": True})
+
+    class FailingResultConsumer:
+        def handle(self, event):
+            if isinstance(event, ToolResultAppended):
+                raise RuntimeError("render exploded")
+            return None
+
+    graph.tools.register("read", FakeReadTool(), "fake read", {"type": "object", "properties": {}})
+
+    async def allow_all(
+        tool_calls,
+        plan_mode: bool,
+        session_id: str,
+        interaction_mode=None,
+        workflow_runs=None,
+        runtime_persona=None,
+    ):
+        return tool_calls, []
+
+    graph._authorize_tool_calls = allow_all
+    monkeypatch.setattr(graph._ui, "via_events", lambda: True)
+    graph._ui.events.start(FailingResultConsumer())
+
+    parent = AIMessage(
+        content="",
+        tool_calls=[{"name": "read", "args": {"file_path": "missing.py"}, "id": "call_read", "type": "tool_call"}],
+    )
+
+    try:
+        result = await graph._execute_tools({
+            "messages": [parent],
+            "workspace": str(tmp_path),
+            "persona": "voidx",
+            "plan_mode": False,
+        })
+    finally:
+        await graph._ui.events.stop()
+
+    assert result["messages"][0].tool_call_id == "call_read"
+    assert result["messages"][0].status == "error"
+    assert result["messages"][0].content == "File not found: missing.py"
+
+
+@pytest.mark.asyncio
+async def test_execute_tools_emits_heartbeat_while_tool_is_still_running(tmp_path, monkeypatch):
+    from voidx.agent.graph.tool_executor import executor as executor_module
+
+    graph = _graph(tmp_path)
+    emitted: list = []
+
+    class SlowReadTool:
+        id = "read"
+        description = "slow read"
+
+        def parameters_schema(self):
+            return {"type": "object", "properties": {}}
+
+        async def execute(self, args: dict, ctx: ToolContext) -> ToolResult:
+            await asyncio.sleep(0.03)
+            return ToolResult(output="read output")
+
+    graph.tools.register("read", SlowReadTool(), "slow read", {"type": "object", "properties": {}})
+
+    async def allow_all(
+        tool_calls,
+        plan_mode: bool,
+        session_id: str,
+        interaction_mode=None,
+        workflow_runs=None,
+        runtime_persona=None,
+    ):
+        return tool_calls, []
+
+    async def fake_request(event):
+        emitted.append(event)
+        return None
+
+    async def fake_emit(event):
+        emitted.append(event)
+        return True
+
+    async def fake_drain():
+        return None
+
+    graph._authorize_tool_calls = allow_all
+    monkeypatch.setattr(graph._ui, "via_events", lambda: True)
+    monkeypatch.setattr(graph._ui.events, "request", fake_request)
+    monkeypatch.setattr(graph._ui.events, "emit", fake_emit)
+    monkeypatch.setattr(graph._ui.events, "drain", fake_drain)
+    monkeypatch.setattr(executor_module, "TOOL_HEARTBEAT_INITIAL_SECONDS", 0.01)
+    monkeypatch.setattr(executor_module, "TOOL_HEARTBEAT_INTERVAL_SECONDS", 0.01)
+
+    parent = AIMessage(
+        content="",
+        tool_calls=[{"name": "read", "args": {}, "id": "call_read", "type": "tool_call"}],
+    )
+
+    result = await graph._execute_tools({
+        "messages": [parent],
+        "workspace": str(tmp_path),
+        "persona": "voidx",
+        "plan_mode": False,
+    })
+
+    heartbeats = [
+        event for event in emitted
+        if isinstance(event, StatusUpdated)
+        and event.status_id == "tool-heartbeat:call_read"
+    ]
+    assert heartbeats
+    assert "read still running" in heartbeats[0].detail
+    assert result["messages"][0].content == "read output"

{voidx-3.5.1 → voidx-3.6.0}/src/tests/test_agent/graph/test_graph_authorization.py

@@ -459,19 +459,23 @@ async def test_permission_prompt_uses_dock_details_when_events_are_active(tmp_pa
         choice = await graph._ask_tool_permission([
             {
                 "name": "bash",
-                "args": {"command": "npm test"},
+                "args": {"command": "npm install lodash"},
                 "id": "call_1",
             }
         ])
         await graph._ui.events.drain()
 
         assert choice == "y"
-        assert received_details is None
+        assert received_details == [{
+            "name": "bash",
+            "pattern": "npm install lodash",
+            "args": {"command": "npm install lodash"},
+        }]
         record = test_dock.status_record("permission:request")
         assert record is not None
         assert record.label == "Requesting"
         assert "bash" in record.detail
-        assert "npm test" in record.detail
+        assert "npm install lodash" in record.detail
     finally:
         await graph._ui.events.stop()
         test_dock.deactivate()

{voidx-3.5.1 → voidx-3.6.0}/src/tests/test_agent/graph/test_prepare_workflow.py

@@ -352,3 +352,49 @@ async def test_implement_subagent_injects_workflow_nodes(tmp_path, monkeypatch):
         not (isinstance(message, HumanMessage) and "## Runtime State" in str(message.content))
         for message in captured["messages"]
     )
+
+
+
+@pytest.mark.asyncio
+async def test_prepare_does_not_reactivate_satisfied_workflow_via_stale_route(tmp_path):
+    """When a workflow tool advanced feedback->tdd, task_state.workflow_runs
+    has feedback=SATISFIED and tdd=ACTIVE. But workflow_route.join still
+    points at the old node (feedback) because workflow enter/advance does
+    not update the route. The LLM prepare step must not use the stale
+    route to reactivate feedback and overwrite its SATISFIED status."""
+    graph = VoidXGraph(
+        Config(workspace=str(tmp_path)),
+        api_key=None,
+        settings=Settings(str(tmp_path)),
+    )
+    result = await graph._prepare_with_stream({
+        "messages": [HumanMessage(content="继续实现")],
+        "workspace": str(tmp_path),
+        "persona": "implement",
+        "plan_mode": False,
+        "interaction_mode": "auto",
+        "task_state": TaskState(
+            current_intent=TaskIntent.CODING,
+            current_goal=GoalSpec(desc="实现 feature X"),
+            workflow_route=WorkflowRoute(join="feedback", leave=None),
+            workflow_runs={
+                "feedback": WorkflowRunState(
+                    name="feedback",
+                    status=WorkflowRunStatus.SATISFIED,
+                    reason="transition from feedback via nontrivial_fix",
+                ),
+                "tdd": WorkflowRunState(
+                    name="tdd",
+                    status=WorkflowRunStatus.ACTIVE,
+                    reason="transition from feedback via nontrivial_fix",
+                ),
+            },
+        ).model_dump(mode="json"),
+        "tool_results": {},
+        "step_count": 0,
+        "should_continue": True,
+    })
+
+    result_task_state = TaskState.model_validate(result["task_state"])
+    assert result_task_state.workflow_runs["tdd"].status == WorkflowRunStatus.ACTIVE
+    assert result_task_state.workflow_runs["feedback"].status == WorkflowRunStatus.SATISFIED

{voidx-3.5.1 → voidx-3.6.0}/src/tests/test_agent/graph/test_run_loop_startup.py

@@ -138,6 +138,162 @@ async def test_quiet_slash_command_dispatches_without_turn(monkeypatch):
     assert dispatched == ["/model reasoning"]
 
 
+@pytest.mark.asyncio
+async def test_web_headless_uses_gateway_frontend_without_default_tui_factory(monkeypatch, tmp_path):
+    graph = _graph(workspace=str(tmp_path))
+    _disable_external_managers(graph)
+    monkeypatch.setattr(runtime_ui_port, "show_startup", lambda **_: None)
+
+    def fail_create_frontend(*_args, **_kwargs):
+        raise AssertionError("web_headless must not create the default TUI frontend")
+
+    class ExitHeadlessFrontend:
+        instances = []
+
+        def __init__(self, status, commands):
+            self.status = status
+            self.commands = commands
+            self.request_handler = None
+            ExitHeadlessFrontend.instances.append(self)
+
+        async def run_headless(self, on_submit):
+            return
+
+        def set_external_command_handler(self, handler):
+            self.command_handler = handler
+
+        def set_external_request_handler(self, handler):
+            self.request_handler = handler
+
+    monkeypatch.setattr("voidx.agent.graph.run_loop.create_frontend", fail_create_frontend)
+    monkeypatch.setattr("voidx.agent.graph.run_loop.GatewayHeadlessFrontend", ExitHeadlessFrontend)
+    monkeypatch.setattr("voidx.agent.graph.run_loop.emit_web_gateway_bootstrap", lambda _url: None)
+
+    test_dock = BottomInputDock()
+    set_dock(test_dock)
+    test_dock.begin_capture()
+    try:
+        await graph.run(web=True, web_headless=True)
+    finally:
+        test_dock.deactivate()
+        test_dock.reset()
+        set_dock(None)
+
+    assert len(ExitHeadlessFrontend.instances) == 1
+    assert ExitHeadlessFrontend.instances[0].request_handler is not None
+
+
+@pytest.mark.asyncio
+async def test_web_non_headless_falls_back_to_gateway_frontend_when_tui_unavailable(monkeypatch, tmp_path):
+    """--web without --web-headless should fall back to GatewayHeadlessFrontend
+    when voidx_cli is not installed, instead of crashing."""
+    graph = _graph(workspace=str(tmp_path))
+    _disable_external_managers(graph)
+    monkeypatch.setattr(runtime_ui_port, "show_startup", lambda **_: None)
+
+    class ExitHeadlessFrontend:
+        instances = []
+
+        def __init__(self, status, commands):
+            self.status = status
+            self.commands = commands
+            self.request_handler = None
+            ExitHeadlessFrontend.instances.append(self)
+
+        async def run(self, on_submit):
+            return
+
+        async def run_headless(self, on_submit):
+            return
+
+        def set_external_command_handler(self, handler):
+            self.command_handler = handler
+
+        def set_external_request_handler(self, handler):
+            self.request_handler = handler
+
+    def fail_create_frontend(*_args, **_kwargs):
+        raise RuntimeError("voidx_cli is required for terminal UI mode.")
+
+    monkeypatch.setattr("voidx.agent.graph.run_loop.create_frontend", fail_create_frontend)
+    monkeypatch.setattr("voidx.agent.graph.run_loop.GatewayHeadlessFrontend", ExitHeadlessFrontend)
+    monkeypatch.setattr("voidx.agent.graph.run_loop.emit_web_gateway_bootstrap", lambda _url: None)
+
+    test_dock = BottomInputDock()
+    set_dock(test_dock)
+    test_dock.begin_capture()
+    try:
+        await graph.run(web=True, web_headless=False)
+    finally:
+        test_dock.deactivate()
+        test_dock.reset()
+        set_dock(None)
+
+    assert len(ExitHeadlessFrontend.instances) == 1
+    assert ExitHeadlessFrontend.instances[0].request_handler is not None
+
+
+@pytest.mark.asyncio
+async def test_apply_settings_update_refreshes_live_model(monkeypatch, tmp_path):
+    from voidx.config import Profile, Settings
+
+    created_models: list[tuple[str | None, str, str, str | None]] = []
+
+    def fake_create_chat_model(api_key, model_config):
+        marker = SimpleNamespace(
+            api_key=api_key,
+            provider=model_config.provider,
+            model=model_config.model,
+            base_url=model_config.base_url,
+        )
+        created_models.append((api_key, model_config.provider, model_config.model, model_config.base_url))
+        return marker
+
+    monkeypatch.setattr("voidx.agent.graph.core.voidx_graph.create_chat_model", fake_create_chat_model)
+
+    settings = await Settings.create(str(tmp_path))
+    await settings.save_profile(
+        Profile(
+            name="deepseek/deepseek-v4-pro",
+            api_key="sk-deepseek",
+            base_url="https://api.deepseek.com",
+            protocol="openai",
+        )
+    )
+    graph = VoidXGraph(
+        Config(workspace=str(tmp_path), model=ModelConfig(provider="openai", model="gpt-4.1")),
+        api_key="sk-openai",
+        settings=settings,
+    )
+
+    graph._app = SimpleNamespace(
+        status=SimpleNamespace(
+            provider="openai",
+            model="gpt-4.1",
+            context_limit=0,
+            reasoning_effort="xhigh",
+        )
+    )
+
+    await graph._apply_settings_update(settings)
+
+    assert graph.config.workspace == str(tmp_path)
+    assert graph.config.model.provider == "deepseek"
+    assert graph.config.model.model == "deepseek-v4-pro"
+    assert graph.config.model.base_url == "https://api.deepseek.com"
+    assert graph.api_key == "sk-deepseek"
+    assert graph.model.provider == "deepseek"
+    assert graph.model.model == "deepseek-v4-pro"
+    assert created_models[-1] == (
+        "sk-deepseek",
+        "deepseek",
+        "deepseek-v4-pro",
+        "https://api.deepseek.com",
+    )
+    assert graph._app.status.provider == "deepseek"
+    assert graph._app.status.model == "deepseek-v4-pro"
+
+
 @pytest.mark.asyncio
 async def test_web_guide_submit_records_guidance_without_starting_turn():
     graph = _graph()

{voidx-3.5.1 → voidx-3.6.0}/src/tests/test_agent/graph/test_run_loop_workflow.py

@@ -117,7 +117,7 @@ async def test_run_once_uses_general_fallback_when_structured_resolver_fails(tmp
 
     initial = captured["initial"]
     assert initial["task_state"]["current_intent"] == "general"
-    assert initial["task_state"]["current_goal"] is None
+    assert initial["task_state"]["current_goal"] is not None
     assert initial["task_state"]["recent_exchanges"] == []
     rows = await load_messages(graph._session.id)
     assert [row.role for row in rows] == ["user", "assistant"]

{voidx-3.5.1 → voidx-3.6.0}/src/tests/test_agent/graph/test_session_persistence.py

@@ -261,6 +261,104 @@ async def test_run_once_loads_execution_context_runtime_state(tmp_path):
         await delete_session(active.id)
         await delete_session(target.id)
 
+
+@pytest.mark.asyncio
+async def test_run_once_model_enabled_first_turn_syncs_default_task_state(tmp_path):
+    from voidx.agent.runtime_context import InteractionMode
+
+    graph = VoidXGraph(Config(workspace=str(tmp_path)), api_key="test", session=None)
+    graph._interaction_mode = InteractionMode.GOAL
+    ready = asyncio.Event()
+    proceed = asyncio.Event()
+    seen: list[str | None] = []
+
+    class FakeGraph:
+        async def ainvoke(self, initial, _config):
+            ready.set()
+            await asyncio.wait_for(proceed.wait(), timeout=1)
+            return {"messages": list(initial["messages"]) + [AIMessage(content="first answer")], "task_state": initial["task_state"]}
+
+    async def external_reader():
+        await asyncio.wait_for(ready.wait(), timeout=1)
+        seen.append(graph._task_state.current_goal.desc if graph._task_state.current_goal else None)
+        proceed.set()
+
+    graph.graph = FakeGraph()
+    reader_task = asyncio.create_task(external_reader())
+
+    test_dock = BottomInputDock()
+    set_dock(test_dock)
+    test_dock.begin_capture()
+    try:
+        await graph._run_once("first question")
+    finally:
+        test_dock.deactivate()
+        test_dock.reset()
+        set_dock(None)
+
+    await reader_task
+    assert seen == ["first question"]
+
+
+@pytest.mark.asyncio
+async def test_run_once_model_enabled_borrowed_context_does_not_leak_task_state(tmp_path):
+    from voidx.agent.runtime_context import InteractionMode
+    from voidx.memory.runtime_state import RuntimeStateSnapshot, load_runtime_state, save_runtime_state
+    from voidx.ui.output.types import ThreadExecutionContext
+
+    active = await create_session(workspace=str(tmp_path), title="Active")
+    target = await create_session(workspace=str(tmp_path), title="Target")
+    try:
+        active_state = TaskState(current_goal=GoalSpec(desc="active goal"))
+        target_state = TaskState(current_goal=GoalSpec(desc="target goal"))
+        await save_runtime_state(active.id, RuntimeStateSnapshot(interaction_mode=InteractionMode.GOAL, task_state=active_state))
+        await save_runtime_state(target.id, RuntimeStateSnapshot(interaction_mode=InteractionMode.PLAN, task_state=target_state))
+
+        graph = VoidXGraph(Config(workspace=str(tmp_path)), api_key="test", session=active)
+        await graph._restore_runtime_state()
+        captured: dict[str, str] = {}
+
+        class FakeGraph:
+            async def ainvoke(self, initial, _config):
+                state = TaskState.model_validate(initial["task_state"])
+                captured["goal"] = state.current_goal.desc if state.current_goal else ""
+                captured["interaction_mode"] = initial["interaction_mode"]
+                updated_state = state.model_copy(update={"current_goal": GoalSpec(desc="target mutated goal")})
+                return {
+                    "messages": list(initial["messages"]) + [AIMessage(content="target answer")],
+                    "task_state": updated_state.model_dump(mode="json"),
+                }
+
+        graph.graph = FakeGraph()
+
+        test_dock = BottomInputDock()
+        set_dock(test_dock)
+        test_dock.begin_capture()
+        try:
+            await graph._run_once(
+                "target question",
+                context=ThreadExecutionContext(thread_id=target.id, session_id=target.id),
+            )
+        finally:
+            test_dock.deactivate()
+            test_dock.reset()
+            set_dock(None)
+
+        assert captured == {"goal": "target goal", "interaction_mode": "plan"}
+        assert graph._session.id == active.id
+        assert graph._task_state.current_goal is not None
+        assert graph._task_state.current_goal.desc == "active goal"
+        assert graph._interaction_mode == InteractionMode.GOAL
+
+        active_snapshot = await load_runtime_state(active.id)
+        target_snapshot = await load_runtime_state(target.id)
+        assert active_snapshot.task_state.current_goal is not None
+        assert active_snapshot.task_state.current_goal.desc == "active goal"
+        assert target_snapshot.task_state.current_goal is not None
+        assert target_snapshot.task_state.current_goal.desc == "target mutated goal"
+    finally:
+        await delete_session(active.id)
+        await delete_session(target.id)
 @pytest.mark.asyncio
 async def test_run_once_isolates_concurrent_execution_context_state(tmp_path):
     from voidx.agent.runtime_context import InteractionMode

{voidx-3.5.1 → voidx-3.6.0}/src/tests/test_agent/graph/test_session_run_once.py

@@ -49,7 +49,13 @@ from voidx.tools.base import ToolContext, ToolResult
 from voidx.tools.agent import AgentResultContract, AgentTool
 from voidx.tools.registry import ToolRegistry
 from voidx.ui.output.dock import BottomInputDock, set_dock
-from voidx.ui.output.events import DockEventConsumer, TurnStarted, ui_events
+from voidx.ui.output.events import (
+    DockEventConsumer,
+    TurnCompleted,
+    TurnFailed,
+    TurnStarted,
+    ui_events,
+)
 
 
 def _graph(tmp_path):
@@ -189,6 +195,89 @@ async def test_run_once_persists_and_restores_transcript_snapshot(tmp_path):
         await delete_session(session.id)
 
 
+@pytest.mark.asyncio
+async def test_run_once_emits_turn_completed_event(tmp_path):
+    session = await create_session(workspace=str(tmp_path))
+    events: list[object] = []
+
+    class RecordingConsumer:
+        def handle(self, event):
+            events.append(event)
+            if isinstance(event, TurnStarted):
+                return object()
+            return None
+
+    try:
+        graph = VoidXGraph(Config(workspace=str(tmp_path)), api_key=None, session=session)
+
+        class FakeGraph:
+            async def ainvoke(self, initial, _config):
+                return {"messages": list(initial["messages"]) + [AIMessage(content="done")]}
+
+        graph.graph = FakeGraph()
+
+        test_dock = BottomInputDock()
+        set_dock(test_dock)
+        test_dock.begin_capture()
+        ui_events.start(RecordingConsumer())
+        try:
+            await graph._run_once("hello")
+            await ui_events.drain()
+        finally:
+            await ui_events.stop()
+            test_dock.deactivate()
+            test_dock.reset()
+            set_dock(None)
+
+        assert any(isinstance(event, TurnCompleted) for event in events)
+        assert not any(isinstance(event, TurnFailed) for event in events)
+    finally:
+        await delete_session(session.id)
+
+
+@pytest.mark.asyncio
+async def test_run_once_emits_turn_failed_event_on_exception(tmp_path):
+    session = await create_session(workspace=str(tmp_path))
+    events: list[object] = []
+
+    class RecordingConsumer:
+        def handle(self, event):
+            events.append(event)
+            if isinstance(event, TurnStarted):
+                return object()
+            return None
+
+    try:
+        graph = VoidXGraph(Config(workspace=str(tmp_path)), api_key=None, session=session)
+
+        class FakeGraph:
+            async def ainvoke(self, initial, _config):
+                raise RuntimeError("provider failed")
+
+        graph.graph = FakeGraph()
+
+        test_dock = BottomInputDock()
+        set_dock(test_dock)
+        test_dock.begin_capture()
+        ui_events.start(RecordingConsumer())
+        try:
+            with pytest.raises(RuntimeError, match="provider failed"):
+                await graph._run_once("hello")
+            await ui_events.drain()
+        finally:
+            await ui_events.stop()
+            test_dock.deactivate()
+            test_dock.reset()
+            set_dock(None)
+
+        failures = [event for event in events if isinstance(event, TurnFailed)]
+        assert len(failures) == 1
+        assert failures[0].message == "provider failed"
+        assert not any(isinstance(event, TurnCompleted) for event in events)
+    finally:
+        await delete_session(session.id)
+
+
 @pytest.mark.asyncio
 async def test_run_once_commits_event_todo_at_turn_end(tmp_path):
     session = await create_session(workspace=str(tmp_path))
@@ -338,4 +427,3 @@ async def test_run_once_persists_user_decision_tool_replay_rows(tmp_path):
     finally:
         await delete_session(session.id)
 
-