voidx 3.6.0__tar.gz → 3.7.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voidx
-Version: 3.6.0
+Version: 3.7.1
 Summary: A coding agent that quantifies everything and solves with tools, not fuzzy prompts.
 Author: chikhamx
 License: MIT
@@ -54,7 +54,7 @@ isolated environment — nothing else is needed on your machine.
 ### pip
 
 ```bash
-pip install voidx
+python -m pip install voidx voidx-cli
 voidx
 ```
 
@@ -65,6 +65,24 @@ npm install -g @chikhamx/voidx
 voidx
 ```
 
+## Upgrade
+
+Upgrade both Python packages together so the core and terminal UI stay on the
+same version:
+
+```bash
+python -m pip install --upgrade voidx voidx-cli
+```
+
+For npm installations, upgrade the npm package instead:
+
+```bash
+npm update -g @chikhamx/voidx
+```
+
+The one-line installers can be rerun to repair or upgrade their managed
+environment.
+
 ### From source
 
 ```bash

{voidx-3.6.0 → voidx-3.7.1}/README.md

@@ -24,7 +24,7 @@ isolated environment — nothing else is needed on your machine.
 ### pip
 
 ```bash
-pip install voidx
+python -m pip install voidx voidx-cli
 voidx
 ```
 
@@ -35,6 +35,24 @@ npm install -g @chikhamx/voidx
 voidx
 ```
 
+## Upgrade
+
+Upgrade both Python packages together so the core and terminal UI stay on the
+same version:
+
+```bash
+python -m pip install --upgrade voidx voidx-cli
+```
+
+For npm installations, upgrade the npm package instead:
+
+```bash
+npm update -g @chikhamx/voidx
+```
+
+The one-line installers can be rerun to repair or upgrade their managed
+environment.
+
 ### From source
 
 ```bash

voidx-3.7.1/src/tests/test_agent/graph/conftest.py

@@ -0,0 +1 @@
+"""Existing conftest."""

{voidx-3.6.0 → voidx-3.7.1}/src/tests/test_agent/graph/stream_llm_helpers.py

@@ -39,6 +39,10 @@ class FakeStreamingModel:
         self.messages = messages
         yield AIMessageChunk(content=[{"type": "thinking", "text": "think"}])
         yield AIMessageChunk(content="answer")
+        yield AIMessageChunk(
+            content="",
+            tool_calls=[{"name": "turn", "args": {"operation": "stop", "intent": "", "goal": ""}, "id": "turn-1", "type": "tool_call"}],
+        )
 
 
 class FakeUsageStreamingModel:
@@ -54,6 +58,10 @@ class FakeUsageStreamingModel:
                 "total_tokens": 10,
             },
         )
+        yield AIMessageChunk(
+            content="",
+            tool_calls=[{"name": "turn", "args": {"operation": "stop", "intent": "", "goal": ""}, "id": "turn-1", "type": "tool_call"}],
+        )
 
 
 class FakeDuplicatedReasoningStreamingModel:
@@ -63,6 +71,10 @@ class FakeDuplicatedReasoningStreamingModel:
             additional_kwargs={"reasoning_content": "622"},
         )
         yield AIMessageChunk(content="final answer")
+        yield AIMessageChunk(
+            content="",
+            tool_calls=[{"name": "turn", "args": {"operation": "stop", "intent": "", "goal": ""}, "id": "turn-1", "type": "tool_call"}],
+        )
 
 
 class FakeDsmlStreamingModel:
@@ -130,6 +142,10 @@ class RepairsMalformedToolCallStreamingModel:
             ))
             return
         yield AIMessageChunk(content="repaired answer")
+        yield AIMessageChunk(
+            content="",
+            tool_calls=[{"name": "turn", "args": {"operation": "stop", "intent": "", "goal": ""}, "id": "turn-1", "type": "tool_call"}],
+        )
 
 
 class AlwaysMalformedToolCallStreamingModel:
@@ -208,6 +224,10 @@ class FailsOnceStreamingModel(FakeStreamingModel):
             raise ConnectionError("Connection error.")
         self.messages = messages
         yield AIMessageChunk(content="answer")
+        yield AIMessageChunk(
+            content="",
+            tool_calls=[{"name": "turn", "args": {"operation": "stop", "intent": "", "goal": ""}, "id": "turn-1", "type": "tool_call"}],
+        )
 
 
 class FakeRenderer:

{voidx-3.6.0 → voidx-3.7.1}/src/tests/test_agent/graph/test_call_llm_compaction.py

@@ -1,6 +1,7 @@
 """Tests for call_llm compaction and retry."""
 
 import sys
+import warnings
 from pathlib import Path
 from types import SimpleNamespace
 
@@ -17,7 +18,7 @@ from voidx.agent.runtime_context import RuntimeContextBuilder
 from voidx.agent.task_state import TaskState, TodoRunState
 from voidx.config import Config, ModelConfig
 from voidx.agent.graph.compaction_coordinator import CompactionResult, PreflightCompactionResult
-from voidx.llm.compaction import CompactionSelection
+from voidx.llm.compaction import CompactionSelection, SUMMARY_TEMPLATE
 from voidx.llm.message_markers import is_guidance_message
 from voidx.memory.context_frames import load_context_frames
 from voidx.memory.session import MessageRow, create_session, delete_session, save_message
@@ -123,9 +124,48 @@ async def test_call_llm_injects_current_todo_runtime_context(tmp_path, monkeypat
 
 
 @pytest.mark.asyncio
-async def test_call_llm_updates_usage_stats(tmp_path, monkeypatch):
+async def test_call_llm_updates_usage_stats_across_turn_control_calls(tmp_path, monkeypatch):
     import voidx.agent.graph.core.llm as graph_module
 
+    class TurnControlUsageStreamingModel:
+        def __init__(self):
+            self.calls = 0
+
+        def bind_tools(self, _tool_defs):
+            return self
+
+        async def astream(self, _messages):
+            self.calls += 1
+            if self.calls == 1:
+                yield AIMessageChunk(
+                    content="answer",
+                    usage_metadata={
+                        "input_tokens": 7,
+                        "output_tokens": 3,
+                        "total_tokens": 10,
+                    },
+                )
+                return
+            if self.calls == 2:
+                yield AIMessageChunk(
+                    content="",
+                    tool_calls=[
+                        {
+                            "name": "turn",
+                            "args": {"operation": "stop", "intent": "", "goal": ""},
+                            "id": "turn-usage",
+                            "type": "tool_call",
+                        }
+                    ],
+                    usage_metadata={
+                        "input_tokens": 2,
+                        "output_tokens": 1,
+                        "total_tokens": 3,
+                    },
+                )
+                return
+            pytest.fail(f"Unexpected LLM call {self.calls}")
+
     monkeypatch.setattr(graph_module, "StreamingRenderer", FakeRenderer)
 
     graph = VoidXGraph(
@@ -135,7 +175,7 @@ async def test_call_llm_updates_usage_stats(tmp_path, monkeypatch):
         ),
         api_key=None,
     )
-    graph.model = FakeUsageStreamingModel()
+    graph.model = TurnControlUsageStreamingModel()
 
     result = await graph._call_llm({
         "messages": [HumanMessage(content="hi")],
@@ -144,11 +184,13 @@ async def test_call_llm_updates_usage_stats(tmp_path, monkeypatch):
     })
 
     assert result["step_count"] == 1
-    assert graph._usage_stats.last_input_tokens == 7
-    assert graph._usage_stats.last_output_tokens == 3
-    assert graph._usage_stats.total_input_tokens == 7
-    assert graph._usage_stats.total_output_tokens == 3
-    assert graph._usage_stats.total_calls == 1
+    assert result["messages"][0].content == "answer"
+    assert graph.model.calls == 2
+    assert graph._usage_stats.last_input_tokens == 2
+    assert graph._usage_stats.last_output_tokens == 1
+    assert graph._usage_stats.total_input_tokens == 9
+    assert graph._usage_stats.total_output_tokens == 4
+    assert graph._usage_stats.total_calls == 2
 
 
 @pytest.mark.asyncio
@@ -224,6 +266,35 @@ def test_inline_compaction_guide_disabled_by_default(tmp_path):
     assert guide is None
 
 
+
+def test_inline_compaction_guide_uses_shared_summary_template(tmp_path):
+    graph = VoidXGraph(
+        Config(
+            model=ModelConfig(provider="mimo", model="mimo-v2.5"),
+            workspace=str(tmp_path),
+        ),
+        api_key=None,
+    )
+    graph.config.inline_compaction_enabled = True
+    graph._compaction.usable_window = lambda: 1
+    graph._compaction.is_overflow = lambda _tokens: False
+    graph._compaction.select_details = lambda _messages: CompactionSelection(
+        head=[HumanMessage(content="old", id="old")],
+        tail_id="current",
+        keep_from=1,
+        mode="normal",
+    )
+
+    guide = graph._inline_compaction_guide_for([
+        HumanMessage(content="old", id="old"),
+        AIMessage(content="old answer"),
+        HumanMessage(content="current", id="current"),
+    ])
+
+    assert guide is not None
+    assert SUMMARY_TEMPLATE in str(guide.content)
+    assert "tail_anchor_id: current" in str(guide.content)
+
 @pytest.mark.asyncio
 async def test_call_llm_overflow_compaction_does_not_send_temporary_summary_message(tmp_path, monkeypatch):
     import voidx.agent.graph.core.llm as graph_module
@@ -280,6 +351,66 @@ async def test_call_llm_overflow_compaction_does_not_send_temporary_summary_mess
     )
 
 
+@pytest.mark.asyncio
+async def test_call_llm_coerces_todo_state_dict_before_compaction_dump(tmp_path, monkeypatch):
+    import voidx.agent.graph.core.llm as graph_module
+
+    monkeypatch.setattr(graph_module, "StreamingRenderer", FakeRenderer)
+    graph = VoidXGraph(
+        Config(
+            model=ModelConfig(provider="mimo", model="mimo-v2.5"),
+            workspace=str(tmp_path),
+        ),
+        api_key=None,
+    )
+    graph.model = FakeStreamingModel()
+    graph._compaction.is_overflow = lambda _tokens: True
+
+    async def preflight(messages, session_msgs=None, *, force=False, reason="threshold", ask=False):
+        result = CompactionResult(
+            summary="compacted",
+            removed_messages=list(messages[:1]),
+            live_messages=list(messages[1:]),
+            tail_id=getattr(messages[1], "id", None) if len(messages) > 1 else None,
+            metadata={"compaction_reason": reason},
+        )
+        return result, PreflightCompactionResult.from_compaction_result(result)
+
+    graph._preflight_compact_if_needed = preflight
+
+    todo_state = {
+        "summary": "0/1 done · 1 active · 0 pending",
+        "total": 1,
+        "done": 0,
+        "active": 1,
+        "pending": 0,
+        "active_items": [
+            {"id": "inspect", "content": "inspect warning", "status": "active"},
+        ],
+        "items": [
+            {"id": "inspect", "content": "inspect warning", "status": "active"},
+        ],
+    }
+
+    with warnings.catch_warnings(record=True) as caught:
+        warnings.simplefilter("always")
+        await graph._call_llm({
+            "messages": [
+                HumanMessage(content="old question", id="old_user"),
+                AIMessage(content="old answer"),
+                HumanMessage(content="current question", id="current_user"),
+            ],
+            "step_count": 0,
+            "persona": "voidx",
+            "todo_state": todo_state,
+        })
+
+    assert not any(
+        "PydanticSerializationUnexpectedValue" in str(warning.message)
+        for warning in caught
+    )
+
+
 @pytest.mark.asyncio
 async def test_call_llm_repairs_malformed_tool_call_once(tmp_path, monkeypatch):
     import voidx.agent.graph.core.llm as graph_module
@@ -360,6 +491,10 @@ class MalformedThenRepairsAfterCompactionStreamingModel:
             ))
             return
         yield AIMessageChunk(content="repaired after compaction")
+        yield AIMessageChunk(
+            content="",
+            tool_calls=[{"name": "turn", "args": {"operation": "stop", "intent": "", "goal": ""}, "id": "turn-1", "type": "tool_call"}],
+        )
 
 
 @pytest.mark.asyncio
@@ -627,3 +762,33 @@ async def test_call_llm_non_retryable_404_fail_fast(tmp_path, monkeypatch):
     assert result["should_continue"] is False
     assert result["step_count"] == 0
     assert result["messages"] == []
+
+
+def test_llm_retry_delay_schedule():
+    """Verify the two-phase delay schedule for all 10 retry attempts."""
+    from voidx.agent.graph.core.helpers import _llm_retry_delay
+
+    delays = [_llm_retry_delay(i) for i in range(1, 11)]
+    assert delays == [2.0, 2.0, 2.0, 4.0, 8.0, 16.0, 32.0, 60.0, 60.0, 60.0]
+
+
+def test_llm_retry_delay_fixed_phase():
+    """First two retries use fixed delay regardless of attempt number."""
+    from voidx.agent.graph.core.helpers import _llm_retry_delay
+
+    assert _llm_retry_delay(1) == 2.0
+    assert _llm_retry_delay(2) == 2.0
+
+
+def test_llm_retry_delay_exponential_cap():
+    """Exponential phase doubles until capped at 60s."""
+    from voidx.agent.graph.core.helpers import _llm_retry_delay
+
+    assert _llm_retry_delay(3) == 2.0
+    assert _llm_retry_delay(4) == 4.0
+    assert _llm_retry_delay(5) == 8.0
+    assert _llm_retry_delay(6) == 16.0
+    assert _llm_retry_delay(7) == 32.0
+    assert _llm_retry_delay(8) == 60.0
+    assert _llm_retry_delay(9) == 60.0
+    assert _llm_retry_delay(10) == 60.0

{voidx-3.6.0 → voidx-3.7.1}/src/tests/test_agent/graph/test_call_llm_compaction_advanced.py

@@ -182,7 +182,7 @@ class AlwaysFailsStreamingModel:
 
 
 @pytest.mark.asyncio
-async def test_call_llm_retries_five_times_then_renders_assistant_error_without_state_message(tmp_path, monkeypatch):
+async def test_call_llm_exhausts_retries_then_renders_assistant_error(tmp_path, monkeypatch):
     import voidx.agent.graph.core.llm as graph_module
 
     async def no_sleep(_delay: float) -> None:
@@ -224,24 +224,29 @@ async def test_call_llm_retries_five_times_then_renders_assistant_error_without_
         test_dock.reset()
         set_dock(None)
 
-    assert graph.model.calls == 6
+    assert graph.model.calls == 11
     assert result["should_continue"] is False
     assert result.get("messages", []) == []
     retry_events = [
         event for event in events
         if isinstance(event, StatusUpdated) and event.status_id == "llm:retry"
     ]
-    assert [event.label for event in retry_events] == ["Retrying"] * 5
+    assert [event.label for event in retry_events] == ["Retrying"] * 10
     assert [event.detail for event in retry_events] == [
         "retrying in 2s: Connection error 1.",
-        "retrying in 4s: Connection error 2.",
-        "retrying in 6s: Connection error 3.",
-        "retrying in 8s: Connection error 4.",
-        "retrying in 10s: Connection error 5.",
+        "retrying in 2s: Connection error 2.",
+        "retrying in 2s: Connection error 3.",
+        "retrying in 4s: Connection error 4.",
+        "retrying in 8s: Connection error 5.",
+        "retrying in 16s: Connection error 6.",
+        "retrying in 32s: Connection error 7.",
+        "retrying in 60s: Connection error 8.",
+        "retrying in 60s: Connection error 9.",
+        "retrying in 60s: Connection error 10.",
     ]
     assert any(
         isinstance(event, AssistantStreamUpdated)
-        and "LLM call failed after 6 attempts: Connection error 6." in event.text
+        and "LLM call failed after 11 attempts: Connection error 11." in event.text
         for event in events
     )
     assert any(isinstance(event, AssistantStreamCommitted) for event in events)

{voidx-3.6.0 → voidx-3.7.1}/src/tests/test_agent/graph/test_call_llm_tools.py

@@ -23,7 +23,16 @@ from voidx.memory.context_frames import load_context_frames
 from voidx.memory.session import MessageRow, create_session, delete_session, save_message
 from voidx.ui.output.console import StreamingRenderer
 from voidx.ui.output.dock import ANSI_LINE_PREFIX, BottomInputDock, set_dock
-from voidx.ui.output.events import AnsiAppended, DockEventConsumer, StatusFinished, StatusUpdated, ui_events
+from voidx.ui.output.events import (
+    AnsiAppended,
+    DockEventConsumer,
+    GuidanceCommitted,
+    GuidanceSubmitted,
+    MessageAppended,
+    StatusFinished,
+    StatusUpdated,
+    ui_events,
+)
 from voidx.workflow.runtime import WorkflowRunState, WorkflowRunStatus
 from tests.test_agent.graph.stream_llm_helpers import (
     _plain,
@@ -66,6 +75,111 @@ async def test_call_llm_guidance_does_not_create_main_agent_convergence_hint(tmp
     assert not any(is_step_hint_message(message) for message in model.messages)
 
 
+@pytest.mark.asyncio
+async def test_call_llm_guard_guidance_stays_hidden_from_ui_events(tmp_path, monkeypatch):
+    import voidx.agent.graph.core.llm as graph_module
+
+    monkeypatch.setattr(graph_module, "StreamingRenderer", FakeRenderer)
+
+    class RecordingEvents:
+        def __init__(self) -> None:
+            self.emitted = []
+
+        def emit_direct(self, event) -> bool:
+            self.emitted.append(event)
+            return True
+
+        async def emit(self, event) -> bool:
+            self.emitted.append(event)
+            return True
+
+    graph = VoidXGraph(
+        Config(
+            model=ModelConfig(provider="mimo", model="mimo-v2.5"),
+            workspace=str(tmp_path),
+        ),
+        api_key=None,
+    )
+    events = RecordingEvents()
+    graph._ui = SimpleNamespace(
+        console=Console(file=sys.stdout),
+        events=events,
+        ui=SimpleNamespace(
+            print=lambda *args, **kwargs: None,
+            error=lambda *args, **kwargs: None,
+        ),
+        via_events=lambda: True,
+    )
+    model = TrackingStreamingModel()
+    graph.model = model
+
+    graph.submit_guidance("No meaningful progress has been detected", source="guard")
+    result = await graph._call_llm({
+        "messages": [HumanMessage(content="finish the task")],
+        "step_count": 1,
+        "persona": "voidx",
+    })
+
+    assert result["step_count"] == 2
+    assert model.messages is not None
+    assert is_guidance_message(model.messages[-1])
+    assert model.messages[-1].content == "No meaningful progress has been detected"
+    assert not any(isinstance(event, GuidanceSubmitted | MessageAppended | GuidanceCommitted) for event in events.emitted)
+
+
+@pytest.mark.asyncio
+async def test_call_llm_user_guidance_commits_preview_without_persistent_message(tmp_path, monkeypatch):
+    import voidx.agent.graph.core.llm as graph_module
+
+    monkeypatch.setattr(graph_module, "StreamingRenderer", FakeRenderer)
+
+    class RecordingEvents:
+        def __init__(self) -> None:
+            self.emitted = []
+
+        def emit_direct(self, event) -> bool:
+            self.emitted.append(event)
+            return True
+
+        async def emit(self, event) -> bool:
+            self.emitted.append(event)
+            return True
+
+    graph = VoidXGraph(
+        Config(
+            model=ModelConfig(provider="mimo", model="mimo-v2.5"),
+            workspace=str(tmp_path),
+        ),
+        api_key=None,
+    )
+    events = RecordingEvents()
+    graph._ui = SimpleNamespace(
+        console=Console(file=sys.stdout),
+        events=events,
+        ui=SimpleNamespace(
+            print=lambda *args, **kwargs: None,
+            error=lambda *args, **kwargs: None,
+        ),
+        via_events=lambda: True,
+    )
+    model = TrackingStreamingModel()
+    graph.model = model
+
+    graph.submit_guidance("先写 spedc文档", source="user")
+    events.emitted.clear()
+    result = await graph._call_llm({
+        "messages": [HumanMessage(content="finish the task")],
+        "step_count": 1,
+        "persona": "voidx",
+    })
+
+    assert result["step_count"] == 2
+    assert model.messages is not None
+    assert is_guidance_message(model.messages[-1])
+    assert model.messages[-1].content == "先写 spedc文档"
+    assert events.emitted == [GuidanceCommitted(text="先写 spedc文档")]
+
+
 @pytest.mark.asyncio
 async def test_call_llm_context_frame_records_no_main_agent_convergence_hint(tmp_path, monkeypatch):
     import voidx.agent.graph.core.llm as graph_module
@@ -233,7 +347,8 @@ async def test_call_llm_keeps_bound_tools_fixed_across_active_workflow_node(tmp_
     assert "clarify" in tool_names
     assert "workflow" in tool_names
     assert ("bash" if os.name != "nt" else "powershell") in tool_names
-    assert "file" in tool_names
+    assert "manage" in tool_names
+    assert "file" not in tool_names
     assert "write" in tool_names
     assert "replace" in tool_names
     assert "line" not in tool_names

{voidx-3.6.0 → voidx-3.7.1}/src/tests/test_agent/graph/test_compaction_flow_run_once.py

@@ -139,7 +139,7 @@ async def test_compaction_uses_previous_summary_and_prunes_persisted_head(tmp_pa
         await save_message(MessageRow(session_id=session.id, role="assistant", content="old answer"))
         await save_message(MessageRow(session_id=session.id, role="user", content="tail question"))
 
-        graph = VoidXGraph(Config(workspace=str(tmp_path)), api_key="test", session=session)
+        graph = VoidXGraph(Config(workspace=str(tmp_path)), api_key=None, session=session)
         graph._compaction_summary = "previous summary"
         graph._compaction.is_overflow = lambda _tokens: True
         graph._compaction.select_details = lambda messages: CompactionSelection(
@@ -189,7 +189,7 @@ async def test_compaction_uses_previous_summary_and_prunes_persisted_head(tmp_pa
         assert "current question" in initial_contents
         assert graph._compaction_summary == "updated summary"
 
-        resumed = VoidXGraph(Config(workspace=str(tmp_path)), api_key="test", session=session)
+        resumed = VoidXGraph(Config(workspace=str(tmp_path)), api_key=None, session=session)
         await resumed._restore_runtime_state()
 
         assert resumed._compaction_summary == "updated summary"
@@ -205,7 +205,7 @@ async def test_run_once_passes_compacted_messages_to_graph(tmp_path):
         await save_message(MessageRow(session_id=session.id, role="assistant", content="old answer"))
         await save_message(MessageRow(session_id=session.id, role="user", content="tail question"))
 
-        graph = VoidXGraph(Config(workspace=str(tmp_path)), api_key="test", session=session)
+        graph = VoidXGraph(Config(workspace=str(tmp_path)), api_key=None, session=session)
         graph._compaction.is_overflow = lambda _tokens: False
         graph._compaction.is_soft_overflow = lambda _tokens: True
         graph._compaction.select_preflight_details = lambda messages, *, model="": CompactionSelection(
@@ -257,7 +257,7 @@ async def test_run_once_finishes_analyzing_before_preflight_compaction_status(tm
         await save_message(MessageRow(session_id=session.id, role="assistant", content="old answer"))
         await save_message(MessageRow(session_id=session.id, role="user", content="tail question"))
 
-        graph = VoidXGraph(Config(workspace=str(tmp_path)), api_key="test", session=session)
+        graph = VoidXGraph(Config(workspace=str(tmp_path)), api_key=None, session=session)
         graph._compaction.is_overflow = lambda _tokens: False
         graph._compaction.is_soft_overflow = lambda _tokens: True
         graph._compaction.select_preflight_details = lambda messages, *, model="": CompactionSelection(