steerable-agent-runtime 0.6.7__tar.gz → 0.6.9__tar.gz

{steerable_agent_runtime-0.6.7 → steerable_agent_runtime-0.6.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steerable-agent-runtime
-Version: 0.6.7
+Version: 0.6.9
 Summary: Steerable agent runtime: LLM, tool, storage, and transport adapters.
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{steerable_agent_runtime-0.6.7 → steerable_agent_runtime-0.6.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "steerable-agent-runtime"
-version = "0.6.7"
+version = "0.6.9"
 description = "Steerable agent runtime: LLM, tool, storage, and transport adapters."
 readme = "README.md"
 requires-python = ">=3.10"

{steerable_agent_runtime-0.6.7 → steerable_agent_runtime-0.6.9}/src/steerable_agent_runtime/compaction.py

@@ -22,7 +22,9 @@ Strategy (deterministic first, LLM optional):
       message; otherwise drop the middle span behind a marker.
 
 System messages and the first user message (the goal) are always kept; the
-most recent ``keep_last_messages`` are never touched. Between compactions
+most recent ``keep_last_messages`` are never touched, and the kept tail is
+widened when that count would cut a tool-call group in half (an orphan
+``tool`` message is a provider-level 400). Between compactions
 the transcript is append-only, so provider prompt caches keep hitting; a
 rewrite invalidates the cache once, then the prefix is stable again.
 
@@ -440,6 +442,50 @@ class CompactionHooks(NoopHooks):
             for i, m in enumerate(transcript)
         ]
 
+    @staticmethod
+    def _orphan_tool_ids(tail: Sequence[LLMMessage]) -> set[str]:
+        """``tool_call_id``s answered inside ``tail`` but issued before it."""
+        issued: set[str] = set()
+        orphans: set[str] = set()
+        for m in tail:
+            for call in m.tool_calls or ():
+                issued.add(call.id)
+            if (
+                m.role == "tool"
+                and m.tool_call_id is not None
+                and m.tool_call_id not in issued
+            ):
+                orphans.add(m.tool_call_id)
+        return orphans
+
+    def _tail_start(self, transcript: list[LLMMessage], head_end: int) -> int:
+        """Where the untouched tail begins: ``keep_last_messages`` back, then
+        widened until the tail answers no tool call it does not also issue.
+
+        OpenAI-compatible providers reject a ``tool`` message whose
+        ``tool_call_id`` was never issued by a preceding ``assistant``
+        message (DeepSeek answers HTTP 400 ``invalid_request``). A count-only
+        cut can land inside a tool-call group, summarizing the issuing
+        assistant away while its results stay in the tail. Widening only ever
+        keeps more, and is bounded by one round's tool calls — including the
+        ``user`` image messages the read path interleaves between results.
+
+        Only orphans this cut created are worth widening for. A transcript
+        that arrives already missing an issuer (a host that resumed from a
+        truncated log) would otherwise widen to ``head_end`` and disable
+        summarization for the rest of the run, trading a provider 400 for a
+        context overflow.
+        """
+        tail_start = max(head_end, len(transcript) - self._keep_last)
+        issuable = {
+            call.id for m in transcript[head_end:] for call in m.tool_calls or ()
+        }
+        while tail_start > head_end and (
+            self._orphan_tool_ids(transcript[tail_start:]) & issuable
+        ):
+            tail_start -= 1
+        return tail_start
+
     async def _summarize_middle(self, transcript: list[LLMMessage]) -> list[LLMMessage]:
         # Keep every system message plus the first user message (the goal) as
         # the head; keep the recent tail untouched; summarize the middle.
@@ -451,7 +497,7 @@ class CompactionHooks(NoopHooks):
                 head_end = i + 1
             else:
                 break
-        tail_start = max(head_end, len(transcript) - self._keep_last)
+        tail_start = self._tail_start(transcript, head_end)
         middle = transcript[head_end:tail_start]
         if not middle:
             return transcript

{steerable_agent_runtime-0.6.7 → steerable_agent_runtime-0.6.9}/src/steerable_agent_runtime/loop.py

@@ -877,6 +877,13 @@ class CoreLoop:
             else None
         )
         wrap_up = False
+        # Terminal that triggered the current wrap-up when a budget wall
+        # (maxRounds) offered narration. The wrap-up summary is an interim
+        # report, not task completion: the no-tools terminal below restores
+        # this decision so the host's auto-continue sees budget_exhausted and
+        # resumes with a fresh budget instead of mistaking the summary for a
+        # finished task.
+        wrap_up_terminal: CompletionDecision | None = None
         wrap_up_tool_rounds_used = 0
         idle_cut_count = 0
 
@@ -1051,7 +1058,10 @@ class CoreLoop:
                 )
                 yield LoopEvent(
                     "budget_exhausted",
-                    {"kind": "rounds", "rounds": self._config.max_rounds},
+                    # "budget" not "kind": the sidecar wraps loop events as
+                    # {"kind": <event kind>, **data} — a data["kind"] would
+                    # clobber the envelope kind hosts dispatch on.
+                    {"budget": "rounds", "rounds": self._config.max_rounds},
                 )
                 narrate = await self._offer_narration(
                     "", round_index, had_tool_calls=True, ctx=ctx,
@@ -1060,6 +1070,7 @@ class CoreLoop:
                 if narrate is not None:
                     prompt, reason = narrate
                     completion_redos += 1
+                    wrap_up_terminal = decision
                     mark_wrap_up()
                     manager.append_fragment(NarrationRequest(prompt))
                     yield LoopEvent(
@@ -1362,7 +1373,7 @@ class CoreLoop:
                             if exhausted:
                                 yield LoopEvent(
                                     "budget_exhausted",
-                                    {"kind": "tokens", "used": budget_state.tokens_used},
+                                    {"budget": "tokens", "used": budget_state.tokens_used},
                                 )
                                 decision = CompletionDecision(
                                     status="budget_exhausted", reason="token budget exceeded"
@@ -1586,7 +1597,13 @@ class CoreLoop:
 
             # ── decide: no tool calls → terminal (unless a hook vetoes) ──
             if not tool_calls:
-                if content.strip():
+                if wrap_up_terminal is not None:
+                    # Budget-wall wrap-up: the narration summary is an interim
+                    # report, not a finished task. Restore the wall's terminal
+                    # (budget_exhausted) so the host auto-continues with a
+                    # fresh budget instead of stopping on a half-done task.
+                    decision = wrap_up_terminal
+                elif content.strip():
                     decision = CompletionDecision(
                         status="completed",
                         reason="assistant produced final response with no pending tools",

{steerable_agent_runtime-0.6.7 → steerable_agent_runtime-0.6.9}/src/steerable_agent_runtime.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steerable-agent-runtime
-Version: 0.6.7
+Version: 0.6.9
 Summary: Steerable agent runtime: LLM, tool, storage, and transport adapters.
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{steerable_agent_runtime-0.6.7 → steerable_agent_runtime-0.6.9}/tests/test_antihallucination.py

@@ -17,6 +17,7 @@ from steerable_agent_runtime import (
     AntiHallucinationConfig,
     AntiHallucinationHooks,
     CoreLoop,
+    LoopConfig,
     LoopEvent,
     RouterToolExecutor,
     ToolRouter,
@@ -521,6 +522,42 @@ async def test_narration_round_on_empty_terminal() -> None:
     )
 
 
+@pytest.mark.asyncio
+async def test_narration_at_max_rounds_wall_stays_budget_exhausted() -> None:
+    """The maxRounds wall interrupts work; the narration summary it triggers
+    is an interim report, not task completion. The terminal must keep
+    budget_exhausted so the host's auto-continue resumes with a fresh budget
+    (a completed status would silently stop a half-done task)."""
+    provider = make_provider(
+        [
+            {"content": "", "tool_calls": [tc("get_data", call_id="c1")]},
+            {"content": "", "tool_calls": [tc("get_data", {"source": "a"}, "c2")]},
+            {"content": "", "tool_calls": [tc("get_data", {"source": "b"}, "c3")]},
+            # narration wrap-up round (tools withheld): interim summary
+            {"content": "阶段性总结：已取数 3 次。"},
+        ]
+    )
+    hooks = AntiHallucinationHooks(provider, AntiHallucinationConfig())
+    loop = CoreLoop(
+        provider,
+        RouterToolExecutor(make_router_with_tool()),
+        LoopConfig(max_rounds=3),
+        hooks=hooks,
+    )
+    events = await collect(loop.run([LLMMessage.text_of("user", "取数")], tools=TOOLS))
+
+    final = final_completion(events)
+    assert final["status"] == "budget_exhausted"
+    assert "maxRounds" in final["reason"]
+    # The interim summary still rides the completion and the transcript.
+    assert final["textLength"] == len("阶段性总结：已取数 3 次。")
+    narrations = [
+        e for e in events
+        if e.kind == "hook_action" and e.data.get("action") == "narrate"
+    ]
+    assert len(narrations) == 1
+
+
 @pytest.mark.asyncio
 async def test_narration_second_chance_on_empty_wrap_up() -> None:
     """Real-data replay finding: the wrap-up round itself can come back empty

{steerable_agent_runtime-0.6.7 → steerable_agent_runtime-0.6.9}/tests/test_compaction.py

@@ -437,6 +437,88 @@ async def test_compaction_preserves_system_and_first_user_message() -> None:
         assert call[1].role == "user" and call[1].content_text == "the original goal"
 
 
+def tool_result(call_id: str) -> LLMMessage:
+    return LLMMessage.text_of("tool", "ok", name="emit", tool_call_id=call_id)
+
+
+@pytest.mark.asyncio
+async def test_summarize_middle_widens_the_tail_off_an_orphan_tool_result() -> None:
+    # A count-only tail cut can land inside a tool-call group: the issuing
+    # assistant goes into the summarized middle while its results stay in the
+    # tail, and the request opens on a `tool` message nothing answered.
+    # DeepSeek rejects that with HTTP 400 invalid_request.
+    calls = [
+        ToolCall(id="call_a", name="emit", arguments={}),
+        ToolCall(id="call_b", name="emit", arguments={}),
+    ]
+    transcript = [
+        LLMMessage.text_of("system", "you are helpful"),
+        LLMMessage.text_of("user", "make a deck"),
+        LLMMessage.text_of("assistant", "reading the skill files"),
+        LLMMessage.text_of("assistant", "", tool_calls=calls),
+        tool_result("call_a"),
+        # the read path interleaves image messages between tool results
+        LLMMessage.text_of("user", "slide.png:"),
+        tool_result("call_b"),
+        LLMMessage.text_of("assistant", "wrapping up"),
+    ]
+    hooks = CompactionHooks(max_context_tokens=1_000, keep_last_messages=3)
+
+    out = await hooks._summarize_middle(transcript)
+
+    assert CompactionHooks._orphan_tool_ids(out) == set()
+    assert any("[context compacted" in m.content_text for m in out)
+    # the group survived whole, in order, with its interleaved image message
+    assert [m.role for m in out[-5:]] == [
+        "assistant",
+        "tool",
+        "user",
+        "tool",
+        "assistant",
+    ]
+
+
+@pytest.mark.asyncio
+async def test_summarize_middle_still_compacts_an_already_orphaned_transcript() -> None:
+    # The issuer is missing from the input (a host resuming from a truncated
+    # log), so widening could never repair the tail. Compaction proceeds
+    # rather than widening to the head and going silent for the rest of the
+    # run — the alternative to the provider 400 is a context overflow.
+    transcript = [
+        LLMMessage.text_of("user", "make a deck"),
+        LLMMessage.text_of("assistant", "first"),
+        tool_result("call_gone_a"),
+        tool_result("call_gone_b"),
+        LLMMessage.text_of("assistant", "wrapping up"),
+    ]
+    hooks = CompactionHooks(max_context_tokens=1_000, keep_last_messages=2)
+
+    out = await hooks._summarize_middle(transcript)
+
+    assert len(out) < len(transcript)
+    assert any("[context compacted" in m.content_text for m in out)
+
+
+@pytest.mark.asyncio
+async def test_summarize_middle_keeps_an_aligned_tail_at_keep_last() -> None:
+    # No tool-call group is cut, so the tail stays exactly keep_last long —
+    # widening must not cost compaction on a clean boundary.
+    transcript = [
+        LLMMessage.text_of("system", "you are helpful"),
+        LLMMessage.text_of("user", "make a deck"),
+        LLMMessage.text_of("assistant", "first"),
+        LLMMessage.text_of("assistant", "second"),
+        LLMMessage.text_of("user", "keep going"),
+        LLMMessage.text_of("assistant", "third"),
+    ]
+    hooks = CompactionHooks(max_context_tokens=1_000, keep_last_messages=3)
+
+    out = await hooks._summarize_middle(transcript)
+
+    assert [m.content_text for m in out[-3:]] == ["second", "keep going", "third"]
+    assert len(out) == 6  # system + goal + summary + 3 kept
+
+
 @pytest.mark.asyncio
 async def test_micro_compact_trigger_schedule() -> None:
     """Periodic prune fires on interval multiples (never round 0), and an

{steerable_agent_runtime-0.6.7 → steerable_agent_runtime-0.6.9}/tests/test_loop.py

@@ -410,7 +410,7 @@ async def test_token_budget_exhausted() -> None:
     events = await collect(loop.run([LLMMessage.text_of("user", "hi")]))
     decision = final_completion(events)
     assert decision["status"] == "budget_exhausted"
-    assert any(e.kind == "budget_exhausted" and e.data["kind"] == "tokens" for e in events)
+    assert any(e.kind == "budget_exhausted" and e.data["budget"] == "tokens" for e in events)
 
 
 @pytest.mark.asyncio