agentbyte 0.40.0__tar.gz → 0.41.0__tar.gz

{agentbyte-0.40.0 → agentbyte-0.41.0}/CHANGELOG.md

@@ -6,6 +6,30 @@ The format follows Keep a Changelog principles and semantic versioning.
 
 ## [Unreleased]
 
+## [0.41.0] - 2026-10-04
+
+### Fixed
+
+- Tool-call-pair-safe recent history window (spec 0064). `BaseOrchestrator._select_history_messages`
+  implemented `AgentHistoryPolicy(window="recent")` as a blind `shared_messages[-message_limit:]`
+  slice, which could cut between a tool-calling `AssistantMessage` and its `ToolMessage` reply once
+  enough turns accumulated (a multi-step plan, or a step-retry loop), handing the next agent a
+  transcript that opens on an orphaned tool result and gets rejected by the provider. The `"recent"`
+  branch now reuses `agentbyte.compaction.grouping.group_messages` (spec 0049) to keep each tool
+  exchange whole, growing the window left by the few messages needed rather than splitting it.
+  `message_limit` is therefore a floor, not an exact count, only when a tool exchange would
+  otherwise be split; histories with no tool calls are unaffected. Lives in `BaseOrchestrator`, so
+  every pattern (`PlanBasedOrchestrator`, `AIOrchestrator`, `RoundRobinOrchestrator`,
+  `HandoffOrchestrator`) is covered by the one change.
+
+### Added
+
+- New optim usecase notebook `notebooks/usecases/optim/02-optim-it-helpdesk-triage.ipynb`: a
+  `PlanBasedOrchestrator` supervisor over three structured-output specialists (`hardware`,
+  `software`, `access-control`, each with a `lookup_asset` tool) plus a `synthesizer`, optimized
+  with `ReflectiveOptimizer` against a routing-correctness judge. Introduces a `DescriptionTunable`
+  (the planner routes off each member's `description`, which the built-in tunables did not expose).
+
 ## [0.40.0] - 2026-10-02
 
 ### Added

{agentbyte-0.40.0 → agentbyte-0.41.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentbyte
-Version: 0.40.0
+Version: 0.41.0
 Summary: A toolkit for designing multiagent systems
 Author-email: MrDataPsycho <mr.data.psycho@gmail.com>
 License-Expression: LicenseRef-Proprietary

agentbyte-0.41.0/src/agentbyte/__about__.py

@@ -0,0 +1,2 @@
+__version__ = "0.41.0"
+VERSION = __version__

{agentbyte-0.40.0 → agentbyte-0.41.0}/src/agentbyte/orchestration/base.py

@@ -16,6 +16,7 @@ from agentbyte.agents.types import AgentResponse, Usage
 from agentbyte.execution_trace import trace_stream
 from agentbyte.execution_trace.collector import capture_agent_stream, normalize_status
 from agentbyte.cancellation_token import CancellationToken
+from agentbyte.compaction.grouping import MessageGroup, group_messages
 from agentbyte.context import AgentContext
 from agentbyte.messages import Message, UserMessage
 from agentbyte.termination import BaseTermination
@@ -827,9 +828,32 @@ class BaseOrchestrator(ABC):
     def _select_history_messages(self, policy: AgentHistoryPolicy) -> list[Message]:
         """Return the relevant shared-message slice for a history policy."""
         if policy.window == "recent" and policy.message_limit is not None:
-            return list(self.shared_messages[-policy.message_limit :])
+            return self._select_recent_messages(policy.message_limit)
         return list(self.shared_messages)
 
+    def _select_recent_messages(self, message_limit: int) -> list[Message]:
+        """Last `message_limit` messages, never splitting a tool-call exchange.
+
+        A plain ``shared_messages[-message_limit:]`` slice can cut between a
+        tool-calling ``AssistantMessage`` and its ``ToolMessage`` reply once enough
+        turns accumulate, leaving the next agent a transcript that opens on an
+        orphaned tool result (spec 0064). ``group_messages`` (spec 0049) already
+        groups each exchange into one indivisible unit; keep whole groups from the
+        newest end until at least ``message_limit`` messages are covered, so the
+        limit becomes a floor rather than an exact count when a tool exchange
+        would otherwise be split.
+        """
+        groups = group_messages(self.shared_messages)
+        kept: list[MessageGroup] = []
+        count = 0
+        for group in reversed(groups):
+            kept.append(group)
+            count += len(group.messages)
+            if count >= message_limit:
+                break
+        kept.reverse()
+        return [message for group in kept for message in group.messages]
+
     def _build_agent_context_from_history(
         self, agent: BaseAgent
     ) -> UserMessage | list[Message]:

agentbyte-0.41.0/tests/orchestration/test_history_tool_call_pairing.py

@@ -0,0 +1,162 @@
+from __future__ import annotations
+
+from collections.abc import AsyncGenerator
+from typing import Any, Optional, Union
+
+import pytest
+
+from agentbyte.agents.base import BaseAgent
+from agentbyte.agents.types import AgentResponse, Usage
+from agentbyte.cancellation_token import CancellationToken
+from agentbyte.context import AgentContext
+from agentbyte.messages import (
+    AssistantMessage,
+    Message,
+    ToolCallRequest,
+    ToolMessage,
+    UserMessage,
+)
+from agentbyte.orchestration import AgentHistoryPolicy, HistoryContextPolicy
+from agentbyte.orchestration.round_robin import RoundRobinOrchestrator
+from agentbyte.termination.max_message import MaxMessageTermination
+
+
+class MockAgent(BaseAgent):
+    """Minimal BaseAgent stub -- these tests only exercise history selection,
+    never the orchestration run loop, so responses are fixed and unused."""
+
+    def __init__(self, name: str):
+        self.name = name
+        self.description = f"Description of {name}"
+        self.tools = []
+
+    async def run(
+        self,
+        task: Optional[Union[UserMessage, list[Message]]] = None,
+        context: Optional[AgentContext] = None,
+        cancellation_token: Optional[CancellationToken] = None,
+    ) -> AgentResponse:
+        del cancellation_token
+        ctx = context or AgentContext()
+        if task and not ctx.messages:
+            if isinstance(task, UserMessage):
+                ctx.messages.append(task)
+            else:
+                ctx.messages.extend(task)
+        msg = AssistantMessage(content="ok", source=self.name)
+        ctx.messages.append(msg)
+        return AgentResponse(source=self.name, context=ctx, finish_reason="stop")
+
+    async def run_stream(
+        self,
+        task: Optional[Union[UserMessage, list[Message]]] = None,
+        context: Optional[AgentContext] = None,
+        cancellation_token: Optional[CancellationToken] = None,
+        verbose: bool = False,
+        stream_tokens: bool = False,
+    ) -> AsyncGenerator[Union[Message, Any, AgentResponse], None]:
+        del cancellation_token, verbose, stream_tokens
+        ctx = context or AgentContext()
+        if task:
+            if isinstance(task, UserMessage):
+                yield task
+                if not ctx.messages:
+                    ctx.messages.append(task)
+            else:
+                for message in task:
+                    yield message
+                    if not ctx.messages:
+                        ctx.messages.append(message)
+        msg = AssistantMessage(content="ok", source=self.name)
+        yield msg
+        ctx.messages.append(msg)
+        yield AgentResponse(
+            source=self.name, context=ctx, usage=Usage(), finish_reason="stop"
+        )
+
+
+def _recent(limit: int) -> HistoryContextPolicy:
+    return HistoryContextPolicy(
+        default=AgentHistoryPolicy(window="recent", message_limit=limit, format="messages")
+    )
+
+
+@pytest.mark.asyncio
+class TestToolCallPairSafety:
+    async def test_naive_cut_between_pair_grows_window_left(self):
+        a1 = MockAgent("a1")
+        orchestrator = RoundRobinOrchestrator(
+            [a1], MaxMessageTermination(2), history_policy=_recent(2)
+        )
+        orchestrator.shared_messages = [
+            UserMessage(content="task", source="user"),
+            AssistantMessage(
+                content="",
+                source="a1",
+                tool_calls=[ToolCallRequest(tool_name="lookup", parameters={}, call_id="c1")],
+            ),
+            ToolMessage(
+                content="result", tool_call_id="c1", tool_name="lookup", source="a1", success=True
+            ),
+        ]
+
+        # A naive shared_messages[-2:] would return [AssistantMessage(tool_calls), ToolMessage] --
+        # that one is actually still paired. Force the cut one message later so the naive slice
+        # would be [ToolMessage] alone, with its issuing AssistantMessage left out.
+        orchestrator.shared_messages.append(AssistantMessage(content="final", source="a1"))
+
+        context = await orchestrator.prepare_context_for_agent(a1)
+
+        assert isinstance(context, list)
+        # The orphaned ToolMessage's issuing AssistantMessage must be present, and it must come
+        # immediately before the ToolMessage -- never open on a bare 'tool' message.
+        roles = [type(m).__name__ for m in context]
+        tool_index = roles.index("ToolMessage")
+        assert roles[tool_index - 1] == "AssistantMessage"
+        assert context[tool_index - 1].tool_calls is not None
+
+    async def test_cut_on_group_boundary_is_unchanged(self):
+        """No tool calls: behavior is byte-identical to the pre-fix raw slice."""
+        a1 = MockAgent("a1")
+        orchestrator = RoundRobinOrchestrator(
+            [a1], MaxMessageTermination(2), history_policy=_recent(2)
+        )
+        orchestrator.shared_messages = [
+            UserMessage(content="one", source="user"),
+            AssistantMessage(content="two", source="a1"),
+            AssistantMessage(content="three", source="a1"),
+        ]
+
+        context = await orchestrator.prepare_context_for_agent(a1)
+
+        assert isinstance(context, list)
+        assert [message.content for message in context] == ["two", "three"]
+
+    async def test_multi_call_batch_is_kept_whole(self):
+        a1 = MockAgent("a1")
+        orchestrator = RoundRobinOrchestrator(
+            [a1], MaxMessageTermination(2), history_policy=_recent(1)
+        )
+        orchestrator.shared_messages = [
+            UserMessage(content="task", source="user"),
+            AssistantMessage(
+                content="",
+                source="a1",
+                tool_calls=[
+                    ToolCallRequest(tool_name="lookup", parameters={}, call_id="c1"),
+                    ToolCallRequest(tool_name="lookup", parameters={}, call_id="c2"),
+                ],
+            ),
+            ToolMessage(
+                content="r1", tool_call_id="c1", tool_name="lookup", source="a1", success=True
+            ),
+            ToolMessage(
+                content="r2", tool_call_id="c2", tool_name="lookup", source="a1", success=True
+            ),
+        ]
+
+        context = await orchestrator.prepare_context_for_agent(a1)
+
+        assert isinstance(context, list)
+        roles = [type(m).__name__ for m in context]
+        assert roles == ["AssistantMessage", "ToolMessage", "ToolMessage"]

agentbyte-0.40.0/src/agentbyte/__about__.py

@@ -1,2 +0,0 @@
-__version__ = "0.40.0"
-VERSION = __version__