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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steerable-agent-runtime
-Version: 0.6.7
+Version: 0.6.8
 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.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "steerable-agent-runtime"
-version = "0.6.7"
+version = "0.6.8"
 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.8}/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.8}/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.8
 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.8}/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