react-agent-harness 0.3.0__tar.gz → 0.3.2__tar.gz

{react_agent_harness-0.3.0/react_agent_harness.egg-info → react_agent_harness-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: react-agent-harness
-Version: 0.3.0
+Version: 0.3.2
 Summary: Multi-agent LLM orchestration: hybrid DAG planning, two-tier memory, streaming
 Requires-Python: >=3.10
 License-File: LICENSE

{react_agent_harness-0.3.0 → react_agent_harness-0.3.2}/README.md

@@ -909,3 +909,20 @@ key-bindings (like Enter-submits and Alt-Enter/Ctrl-J-newline) across both paths
 
 See `examples/complex_sysaudit_demo.py` for stdin steering across three
 agents alongside HITL on the shell tool.
+
+## AgentConfig reference
+
+| Field | Default | Description |
+|---|---|---|
+| `agent_id` | required | Unique identifier for the agent |
+| `role` | required | Plain-English description used by the planner for agent selection |
+| `system_prompt` | required | Base system prompt for the agent |
+| `allowed_tools` | required | Tool names the agent may call |
+| `max_steps` | `10` | Maximum ReAct iterations before the run is terminated |
+| `max_wall_time_seconds` | (guardrail) | See `GuardrailConfig` |
+| `memory_context_enabled` | `True` | Prepend relevant long-term memory to the system prompt |
+| `confidence_from_llm` | `True` | Use the `confidence` field from the LLM response; set `False` to always return `1.0` |
+| `working_memory_max_tokens` | `8000` | Token budget for in-context working memory before rolling summarisation kicks in |
+| `hitl_tools` | `[]` | Tool names that require human approval before execution |
+| `checkpoint_every` | `0` | Write a crash-resumable checkpoint every N steps; `0` disables periodic checkpoints |
+| `stream_tokens` | `False` | Emit `TOKEN` events as the LLM streams. Disabled by default — enable if you want to render partial output in real time: `AgentConfig(..., stream_tokens=True)` |

{react_agent_harness-0.3.0 → react_agent_harness-0.3.2}/agents/base.py

@@ -61,6 +61,7 @@ class AgentConfig:
     max_steps: int = 10
     memory_context_enabled: bool = True
     confidence_from_llm: bool = True  # if False, confidence=1.0 on success
+    stream_tokens: bool = False  # if True, TOKEN events are emitted as the LLM streams
     working_memory_max_tokens: int = 8000  # WorkingMemory eviction threshold; tune per agent
     hitl_tools: list[str] = None  # tools requiring human approval; None = no HITL
     checkpoint_every: int = 0  # write a resumable checkpoint every N steps; 0 = disabled
@@ -649,11 +650,12 @@ class BaseAgent:
                     messages=messages,
                 ):
                     accumulated += token
-                    yield BusEvent(
-                        type=EventType.TOKEN,
-                        agent_id=self.config.agent_id,
-                        token=token,
-                    )
+                    if self.config.stream_tokens:
+                        yield BusEvent(
+                            type=EventType.TOKEN,
+                            agent_id=self.config.agent_id,
+                            token=token,
+                        )
                 response = _parse_action_json(accumulated)
                 if response is None:
                     logger.warning(

{react_agent_harness-0.3.0 → react_agent_harness-0.3.2}/harness/runtime.py

@@ -781,8 +781,9 @@ class AgentRuntime:
         run_id = str(uuid.uuid4())
         tracer.start_run(run_id, task)
         try:
-            async for event in self._run_agent_with_tracer(agent_id, task, tracer, run_id):
-                yield event
+            async with self._steering_lifecycle():
+                async for event in self._run_agent_with_tracer(agent_id, task, tracer, run_id):
+                    yield event
         finally:
             tracer.end_run()
 

{react_agent_harness-0.3.0 → react_agent_harness-0.3.2}/harness/steering.py

@@ -150,7 +150,6 @@ class StdinRouter:
         input_: Any | None = None,
         output: Any | None = None,
         history: Any | None = None,
-        patch_stdout_: bool = True,
     ) -> None:
         self._task: asyncio.Task | None = None
         self._stop = asyncio.Event()
@@ -159,8 +158,6 @@ class StdinRouter:
         # subscription_id → (prefix, callback). prefix=None is catch-all.
         self._subs: dict[int, tuple[str | None, Callable[[str], None]]] = {}
         self._next_sub_id: int = 0
-        # Tests turn off patch_stdout to avoid interfering with pytest capture.
-        self._patch_stdout = patch_stdout_
         self._session: PromptSession = PromptSession(
             history=history or InMemoryHistory(),
             input=input_,
@@ -282,18 +279,13 @@ class StdinRouter:
     # ── Internals ─────────────────────────────────────────────────────────────
 
     async def _run(self) -> None:
-        # patch_stdout makes prints from other tasks scroll above the prompt
-        # instead of corrupting the input line. Tests skip it because it
-        # interferes with pytest's stdout capture.
-        cm = patch_stdout(raw=True) if self._patch_stdout else contextlib.nullcontext()
-        with cm:
-            while not self._stop.is_set():
-                claim = self._hitl_claim
-                if claim is not None:
-                    await self._serve_hitl(*claim)
-                    self._hitl_claim = None
-                else:
-                    await self._serve_steering()
+        while not self._stop.is_set():
+            claim = self._hitl_claim
+            if claim is not None:
+                await self._serve_hitl(*claim)
+                self._hitl_claim = None
+            else:
+                await self._serve_steering()
 
     async def _serve_steering(self) -> None:
         try:
@@ -575,10 +567,13 @@ class _StdinSteeringFactory:
         self,
         router: StdinRouter | None = None,
         prefix_template: str = "{agent_id}",
+        patch_stdout_: bool = True,
     ) -> None:
         self._router = router or StdinRouter()
         self._owned = router is None
         self._prefix_template = prefix_template
+        self._patch_stdout = patch_stdout_ and router is None  # only patch when we own the router
+        self._patch_stdout_cm: Any | None = None
         # Ref-counted lifecycle: nested AgentRuntime wraps (dispatch_stream
         # → run_stream) re-enter the factory; only the outermost
         # enter/exit actually starts/stops the router.
@@ -590,6 +585,9 @@ class _StdinSteeringFactory:
 
     async def __aenter__(self) -> _StdinSteeringFactory:
         if self._owned and self._enter_count == 0:
+            if self._patch_stdout:
+                self._patch_stdout_cm = patch_stdout(raw=True)
+                self._patch_stdout_cm.__enter__()
             await self._router.__aenter__()
         self._enter_count += 1
         return self
@@ -598,11 +596,15 @@ class _StdinSteeringFactory:
         self._enter_count = max(0, self._enter_count - 1)
         if self._owned and self._enter_count == 0:
             await self._router.__aexit__(exc_type, exc, tb)
+            if self._patch_stdout_cm is not None:
+                self._patch_stdout_cm.__exit__(exc_type, exc, tb)
+                self._patch_stdout_cm = None
 
 
 def stdin_steering_factory(
     router: StdinRouter | None = None,
     prefix_template: str = "{agent_id}",
+    patch_stdout_: bool = True,
 ) -> _StdinSteeringFactory:
     """Return a steering factory that lifecycles its own StdinRouter.
 
@@ -616,7 +618,9 @@ def stdin_steering_factory(
     `prefix_template` may reference `{agent_id}`; default subscribes
     each agent to its own `agent_id`.
     """
-    return _StdinSteeringFactory(router=router, prefix_template=prefix_template)
+    return _StdinSteeringFactory(
+        router=router, prefix_template=prefix_template, patch_stdout_=patch_stdout_
+    )
 
 
 # ── Direct-use shims (no AgentRuntime / no factory) ───────────────────────────
@@ -639,6 +643,7 @@ class StdinSteer:
         agents: BaseAgent | list[BaseAgent],
         *,
         router: StdinRouter | None = None,
+        patch_stdout_: bool = True,
     ) -> None:
         if not isinstance(agents, list):
             agents = [agents]
@@ -647,9 +652,14 @@ class StdinSteer:
         self._agents = agents
         self._router = router or StdinRouter()
         self._owned_router = router is None
+        self._patch_stdout = patch_stdout_
+        self._patch_stdout_cm: Any | None = None
         self._sub_ids: list[int] = []
 
     async def __aenter__(self) -> StdinSteer:
+        if self._patch_stdout:
+            self._patch_stdout_cm = patch_stdout(raw=True)
+            self._patch_stdout_cm.__enter__()
         if self._owned_router:
             await self._router.start()
         # Always register one subscription per agent under its agent_id.
@@ -672,3 +682,6 @@ class StdinSteer:
         self._sub_ids.clear()
         if self._owned_router:
             await self._router.stop()
+        if self._patch_stdout_cm is not None:
+            self._patch_stdout_cm.__exit__(exc_type, exc, tb)
+            self._patch_stdout_cm = None

{react_agent_harness-0.3.0 → react_agent_harness-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "react-agent-harness"
-version = "0.3.0"
+version = "0.3.2"
 description = "Multi-agent LLM orchestration: hybrid DAG planning, two-tier memory, streaming"
 requires-python = ">=3.10"
 dependencies = [

{react_agent_harness-0.3.0 → react_agent_harness-0.3.2/react_agent_harness.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: react-agent-harness
-Version: 0.3.0
+Version: 0.3.2
 Summary: Multi-agent LLM orchestration: hybrid DAG planning, two-tier memory, streaming
 Requires-Python: >=3.10
 License-File: LICENSE

{react_agent_harness-0.3.0 → react_agent_harness-0.3.2}/tests/test_steering.py

@@ -18,7 +18,14 @@ from prompt_toolkit.output import DummyOutput
 
 from agents.base import AgentConfig, BaseAgent
 from harness.events import EventType
-from harness.runtime import BudgetGuard, GuardrailConfig, Tracer
+from harness.runtime import (
+    AgentRegistry,
+    AgentRuntime,
+    BudgetGuard,
+    GuardrailConfig,
+    ToolRegistry,
+    Tracer,
+)
 from harness.steering import (
     FileSteer,
     StdinAgentSource,
@@ -57,7 +64,6 @@ def _piped_router():
         router = StdinRouter(
             input_=pipe_in,
             output=DummyOutput(),
-            patch_stdout_=False,
         )
         yield router, pipe_in
 
@@ -322,20 +328,6 @@ async def test_router_routes_to_catchall_subscriber():
     assert received == ["plain line"]
 
 
-@pytest.mark.asyncio
-async def test_router_default_patch_stdout_context_starts():
-    """Default patch_stdout path uses a sync context manager but still runs in async loop."""
-    received: list[str] = []
-    with create_pipe_input() as pipe_in:
-        router = StdinRouter(input_=pipe_in, output=DummyOutput())
-        router.subscribe(None, received.append)
-        await router.start()
-        pipe_in.send_text("plain line\r")
-        await _drain()
-        await router.stop()
-    assert received == ["plain line"]
-
-
 @pytest.mark.asyncio
 async def test_router_routes_by_prefix():
     a_received: list[str] = []
@@ -441,7 +433,7 @@ async def test_router_claim_next_line_resolves_with_typed_answer():
 
 
 def test_router_rejects_star_as_subscription_prefix():
-    router = StdinRouter(patch_stdout_=False)
+    router = StdinRouter()
     with pytest.raises(ValueError):
         router.subscribe("*", lambda _t: None)
 
@@ -455,7 +447,7 @@ async def test_stdin_single_agent_no_prefix_needed():
     with _piped_router() as (router, pipe_in):
         await router.start()
         try:
-            async with StdinSteer(a, router=router):
+            async with StdinSteer(a, router=router, patch_stdout_=False):
                 pipe_in.send_text("just do it\r")
                 await _drain()
         finally:
@@ -469,7 +461,7 @@ async def test_stdin_single_agent_prefix_also_works():
     with _piped_router() as (router, pipe_in):
         await router.start()
         try:
-            async with StdinSteer(a, router=router):
+            async with StdinSteer(a, router=router, patch_stdout_=False):
                 pipe_in.send_text("a: explicit\r")
                 await _drain()
         finally:
@@ -484,7 +476,7 @@ async def test_stdin_multi_agent_prefix_routes():
     with _piped_router() as (router, pipe_in):
         await router.start()
         try:
-            async with StdinSteer([a, b], router=router):
+            async with StdinSteer([a, b], router=router, patch_stdout_=False):
                 pipe_in.send_text("a: do A\r")
                 await _drain()
                 pipe_in.send_text("b: do B\r")
@@ -502,7 +494,7 @@ async def test_stdin_multi_agent_broadcast():
     with _piped_router() as (router, pipe_in):
         await router.start()
         try:
-            async with StdinSteer([a, b], router=router):
+            async with StdinSteer([a, b], router=router, patch_stdout_=False):
                 pipe_in.send_text("*: stop now\r")
                 await _drain()
         finally:
@@ -518,7 +510,7 @@ async def test_stdin_steer_registers_as_active_router():
         await router.start()
         try:
             assert get_active_router() is None
-            async with StdinSteer(a, router=router):
+            async with StdinSteer(a, router=router, patch_stdout_=False):
                 assert get_active_router() is router
             assert get_active_router() is None
         finally:
@@ -661,3 +653,62 @@ async def test_stdin_steering_factory_subscribes_each_agent():
         # Verify it actually subscribed.
         assert "a" in router.active_prefixes()
     assert "a" not in router.active_prefixes()
+
+
+# ── AgentRuntime.run_agent_stream steering lifecycle ─────────────────────────
+
+
+@pytest.mark.asyncio
+async def test_run_agent_stream_starts_steering_lifecycle(llm, memory):
+    """run_agent_stream must enter the steering lifecycle so the factory's
+    __aenter__/__aexit__ are called — regression test for the single-agent
+    steering bug where the lifecycle wrapper was missing."""
+    llm.routes = {
+        "react": lambda *_: {
+            "thought": "done",
+            "action": "finish",
+            "answer": "ok",
+            "confidence": 1.0,
+        }
+    }
+
+    entered = False
+    exited = False
+
+    class _LifecycleFactory:
+        """Looks like a stdin_steering_factory — has both lifecycle and per-agent call."""
+
+        async def __aenter__(self):
+            nonlocal entered
+            entered = True
+            return self
+
+        async def __aexit__(self, *exc):
+            nonlocal exited
+            exited = True
+
+        def __call__(self, agent: BaseAgent):
+            import contextlib
+
+            @contextlib.asynccontextmanager
+            async def _noop():
+                yield
+
+            return _noop()
+
+    config = AgentConfig(agent_id="solo", role="r", system_prompt="react", allowed_tools=[])
+    agent_reg = AgentRegistry()
+    agent_reg.register(config)
+
+    runtime = AgentRuntime(
+        agent_registry=agent_reg,
+        tool_registry=ToolRegistry(),
+        memory=memory,
+        llm=llm,
+        steering_source_factory=_LifecycleFactory(),
+    )
+
+    events = [ev async for ev in runtime.run_agent_stream("solo", "test task")]
+    assert any(ev.type == EventType.TASK_DONE for ev in events)
+    assert entered, "steering lifecycle __aenter__ was never called"
+    assert exited, "steering lifecycle __aexit__ was never called"

{react_agent_harness-0.3.0 → react_agent_harness-0.3.2}/tests/test_streaming.py

@@ -5,6 +5,7 @@ Verifies that BaseAgent.run_stream() and Orchestrator.run_stream() yield the
 expected BusEvent sequence, and that the blocking run() drains to the same
 result the stream's DONE event carries.
 """
+
 from __future__ import annotations
 
 from agents.base import AgentConfig
@@ -20,8 +21,11 @@ from tests.conftest import EchoTool, ScriptedLLM
 async def test_agent_run_stream_finish_yields_task_done(agent_factory):
     """Finish on first step → just one TASK_DONE event (no THOUGHT/ACTION pairs)."""
     cfg = AgentConfig(
-        agent_id="a", role="r", system_prompt="finish.",
-        allowed_tools=[], working_memory_max_tokens=2000,
+        agent_id="a",
+        role="r",
+        system_prompt="finish.",
+        allowed_tools=[],
+        working_memory_max_tokens=2000,
     )
     agent = agent_factory(cfg)
     events = [e async for e in agent.run_stream("hi")]
@@ -34,7 +38,8 @@ async def test_agent_run_stream_finish_yields_task_done(agent_factory):
 
 
 async def test_agent_run_stream_tool_call_yields_action_and_observation(
-    agent_factory, llm: ScriptedLLM,
+    agent_factory,
+    llm: ScriptedLLM,
 ):
     """A tool-using step should yield THOUGHT → ACTION → OBSERVATION → ... → TASK_DONE."""
     step = {"n": 0}
@@ -47,7 +52,9 @@ async def test_agent_run_stream_tool_call_yields_action_and_observation(
 
     llm.routes = {"react": react}
     cfg = AgentConfig(
-        agent_id="a", role="r", system_prompt="ReAct format.",
+        agent_id="a",
+        role="r",
+        system_prompt="ReAct format.",
         allowed_tools=["echo"],
     )
     agent = agent_factory(cfg, tools={"echo": EchoTool()})
@@ -68,7 +75,10 @@ async def test_agent_run_stream_tool_call_yields_action_and_observation(
 async def test_agent_run_is_drain_of_run_stream(agent_factory):
     """run() and the TASK_DONE payload from run_stream() must agree."""
     cfg = AgentConfig(
-        agent_id="a", role="r", system_prompt="finish.", allowed_tools=[],
+        agent_id="a",
+        role="r",
+        system_prompt="finish.",
+        allowed_tools=[],
     )
     agent = agent_factory(cfg)
 
@@ -98,7 +108,11 @@ async def test_agent_forwards_token_events_when_llm_streams(agent_factory):
                 yield tok
 
     cfg = AgentConfig(
-        agent_id="a", role="r", system_prompt="ReAct.", allowed_tools=[],
+        agent_id="a",
+        role="r",
+        system_prompt="ReAct.",
+        allowed_tools=[],
+        stream_tokens=True,
     )
     agent = agent_factory(cfg)
     agent._llm = StreamingLLM()
@@ -119,10 +133,20 @@ def _orchestrator_routes():
     def planner(system, messages, kwargs):
         return {
             "tasks": [
-                {"id": "t1", "agent_id": "analyst", "instruction": "do x",
-                 "depends_on": [], "on_failure": "skip"},
-                {"id": "t2", "agent_id": "reporter", "instruction": "do y",
-                 "depends_on": ["t1"], "on_failure": "skip"},
+                {
+                    "id": "t1",
+                    "agent_id": "analyst",
+                    "instruction": "do x",
+                    "depends_on": [],
+                    "on_failure": "skip",
+                },
+                {
+                    "id": "t2",
+                    "agent_id": "reporter",
+                    "instruction": "do y",
+                    "depends_on": ["t1"],
+                    "on_failure": "skip",
+                },
             ],
             "rationale": "two tasks",
         }
@@ -132,8 +156,10 @@ def _orchestrator_routes():
 
     def extract(system, messages, kwargs):
         return {
-            "semantic_facts": {}, "episodic_summary": "ok",
-            "metadata": {}, "ttl_seconds": None,
+            "semantic_facts": {},
+            "episodic_summary": "ok",
+            "metadata": {},
+            "ttl_seconds": None,
         }
 
     return {
@@ -147,14 +173,24 @@ def _build_runtime(llm):
     tools = ToolRegistry().register(EchoTool())
     agents = (
         AgentRegistry()
-        .register(AgentConfig(
-            agent_id="analyst", role="r", system_prompt="ReAct.",
-            allowed_tools=["echo"], max_steps=2,
-        ))
-        .register(AgentConfig(
-            agent_id="reporter", role="r", system_prompt="ReAct.",
-            allowed_tools=["echo"], max_steps=2,
-        ))
+        .register(
+            AgentConfig(
+                agent_id="analyst",
+                role="r",
+                system_prompt="ReAct.",
+                allowed_tools=["echo"],
+                max_steps=2,
+            )
+        )
+        .register(
+            AgentConfig(
+                agent_id="reporter",
+                role="r",
+                system_prompt="ReAct.",
+                allowed_tools=["echo"],
+                max_steps=2,
+            )
+        )
     )
     memory = MemoryManager(
         semantic_store=InMemorySemanticStore(),
@@ -162,10 +198,15 @@ def _build_runtime(llm):
         llm=llm,
     )
     return AgentRuntime(
-        agent_registry=agents, tool_registry=tools, memory=memory, llm=llm,
+        agent_registry=agents,
+        tool_registry=tools,
+        memory=memory,
+        llm=llm,
         guardrail_config=GuardrailConfig(
-            max_total_cost_usd=5.0, max_wall_time_seconds=30,
-            max_replan_count=1, confidence_threshold=0.5,
+            max_total_cost_usd=5.0,
+            max_wall_time_seconds=30,
+            max_replan_count=1,
+            confidence_threshold=0.5,
         ),
     )