agentbyte 0.53.0__tar.gz → 0.55.0__tar.gz

{agentbyte-0.53.0 → agentbyte-0.55.0}/CHANGELOG.md

@@ -6,6 +6,47 @@ The format follows Keep a Changelog principles and semantic versioning.
 
 ## [Unreleased]
 
+## [0.55.0] - 2026-10-12
+
+### Added
+
+- `AgentToolContextPolicy` (strategy enum plus `message_limit`) configures what a sub-agent tool
+  inherits from its caller via `context_policy` on `AgentAsTool` and `Agent.as_tool()`. Strategies:
+  `identity` (default), `last_task`, `recent`, `full`, or a callable. `session_id`/`user_id` are always
+  inherited. `BaseTool.accepts_context()` lets the agent loop forward its working context to opted-in tools.
+- `compaction.grouping.select_recent_messages()`: shared last-N window that never splits a tool exchange,
+  now used by both orchestration and agent tools.
+
+### Changed
+
+- The in-flight delegation call is excluded from seeded sub-agent history so it is always a valid sequence.
+- `AgentToolContextPolicy` rejects `message_limit` for any strategy other than `recent`.
+
+## [0.54.0] - 2026-10-12
+
+### Added
+
+- Anthropic/Bedrock prompt caching: `AnthropicConversionMixin` now tags the `system` block
+  with a `cache_control: {"type": "ephemeral"}` breakpoint whenever a `SystemMessage` is
+  present, so both `AnthropicChatCompletionClient` and `AnthropicBedrockChatCompletionClient`
+  get cache-read discounting through the same shared request-building code — no config flag,
+  no-op below the per-model minimum cacheable size. Added a matching
+  `examples/llm/anthropic_bedrock_prompt_caching_cost_smoke_test.py` alongside the existing
+  OpenAI/Azure smoke test.
+- `examples/agents/anthropic_agent_example.py`: Bedrock Claude injected via
+  `AnthropicBedrockChatCompletionClient.from_region()` driven through `Agent.run()`/
+  `Agent.run_stream()`. `examples/agents/cohere_bedrock_embedding_example.py`: raw
+  `CohereBedrockEmbeddingClient` calls, then the same client wrapped in `EmbeddingBatcher`,
+  then with `LoggingMiddleware` added — both live-verified end to end against real Bedrock.
+
+### Fixed
+
+- `PricingRegistry.ANTHROPIC_CHAT_PRICING` had no exact entry for `claude-sonnet-4-5` or
+  `claude-sonnet-4-6`; both resolved only through the generic `claude-sonnet-4` prefix
+  fallback, which happened to match current pricing ($3/$15 per MTok) but offered no
+  protection against a future divergent repricing (the same reasoning that already justified
+  separate `claude-opus-4-5`..`claude-opus-4-8` entries). Added explicit entries for both.
+
 ## [0.53.0] - 2026-10-10
 
 ### Added

{agentbyte-0.53.0 → agentbyte-0.55.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentbyte
-Version: 0.53.0
+Version: 0.55.0
 Summary: A toolkit for designing multiagent systems
 Author-email: MrDataPsycho <mr.data.psycho@gmail.com>
 License-Expression: LicenseRef-Proprietary
@@ -90,7 +90,7 @@ Description-Content-Type: text/markdown
 
 Agentbyte is an observability-first agentic AI framework for building and studying multiagent systems with a learning-first, implementation-oriented workflow.
 
-Current release: **0.53.0**
+Current release: **0.55.0**
 
 ## Building an Agent
 

{agentbyte-0.53.0 → agentbyte-0.55.0}/README.md

@@ -2,7 +2,7 @@
 
 Agentbyte is an observability-first agentic AI framework for building and studying multiagent systems with a learning-first, implementation-oriented workflow.
 
-Current release: **0.53.0**
+Current release: **0.55.0**
 
 ## Building an Agent
 

agentbyte-0.55.0/src/agentbyte/__about__.py

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

{agentbyte-0.53.0 → agentbyte-0.55.0}/src/agentbyte/agents/__init__.py

@@ -3,7 +3,7 @@ Agent implementations and abstractions.
 """
 
 from .agent import Agent
-from .agent_as_tool import AgentAsTool
+from .agent_as_tool import AgentAsTool, AgentToolContextPolicy, ContextStrategy
 from .base import (
     AgentConfigurationError,
     AgentError,
@@ -35,6 +35,8 @@ __all__ = [
     "BaseAgent",
     "Agent",
     "AgentAsTool",
+    "ContextStrategy",
+    "AgentToolContextPolicy",
     "AgentError",
     "AgentConfigurationError",
     "AgentExecutionError",

{agentbyte-0.53.0 → agentbyte-0.55.0}/src/agentbyte/agents/agent.py

@@ -188,10 +188,19 @@ class Agent(BaseAgent):
                             "tool_call payload parameters must be a dictionary"
                         )
 
-                    async for item in tool.execute_stream(
-                        tool_parameters,
-                        cancellation_token,
-                    ):
+                    if tool.accepts_context():
+                        stream = tool.execute_stream(
+                            tool_parameters,
+                            agent_context=working_context,
+                            cancellation_token=cancellation_token,
+                        )
+                    else:
+                        stream = tool.execute_stream(
+                            tool_parameters,
+                            cancellation_token=cancellation_token,
+                        )
+
+                    async for item in stream:
                         yield item
 
                 streamed_result: object | None = None
@@ -280,6 +289,10 @@ class Agent(BaseAgent):
                     raise ValueError(
                         "tool_call payload parameters must be a dictionary"
                     )
+                if tool.accepts_context():
+                    return await tool.execute(
+                        tool_parameters, agent_context=working_context
+                    )
                 return await tool.execute(tool_parameters)
 
             result: object | None = None

agentbyte-0.55.0/src/agentbyte/agents/agent_as_tool.py

@@ -0,0 +1,366 @@
+"""
+Wrap agents as tools for hierarchical agent composition.
+"""
+
+from collections.abc import AsyncGenerator, Callable
+from enum import StrEnum
+from typing import Any, Dict, List, Optional, Protocol, Union, runtime_checkable
+
+from pydantic import BaseModel, ConfigDict, StrictInt, model_validator
+
+from agentbyte.cancellation_token import CancellationToken
+from agentbyte.compaction.grouping import select_recent_messages
+from agentbyte.context import AgentContext
+from agentbyte.llm.types import ChatCompletionChunk
+from agentbyte.messages import AssistantMessage, Message, ToolMessage, UserMessage
+from agentbyte.tools.base import BaseTool
+from agentbyte.types import ToolResult
+
+from .types import AgentEvent, AgentResponse
+
+ResultStrategy = Union[str, Callable[[List[Message]], str]]
+
+
+class ContextStrategy(StrEnum):
+    """Which slice of the caller's conversation a sub-agent inherits.
+
+    Identity (``session_id``/``user_id``) is always inherited so sub-agent usage
+    aggregates under the parent; each strategy adds messages on top of it. The
+    recent window mirrors the orchestrator's ``HistoryWindow`` vocabulary and
+    reuses its whole-tool-exchange windowing (spec 0064).
+    """
+
+    IDENTITY = "identity"
+    """Identity only — no messages (default, no context bloat)."""
+    LAST_TASK = "last_task"
+    """Identity plus the caller's most recent user task."""
+    RECENT = "recent"
+    """Identity plus the last ``message_limit`` messages (never splitting a tool
+    exchange)."""
+    FULL = "full"
+    """Identity plus the whole caller conversation."""
+
+
+class AgentToolContextPolicy(BaseModel):
+    """How much of the caller's conversation a sub-agent tool inherits."""
+
+    model_config = ConfigDict(extra="forbid", frozen=True)
+
+    strategy: ContextStrategy = ContextStrategy.IDENTITY
+    """Which messages to seed. Plain strings are accepted."""
+    message_limit: Optional[StrictInt] = None
+    """Minimum messages for ``recent``; more are kept to preserve whole tool
+    exchanges. Required (>= 1) for ``recent`` and rejected otherwise."""
+
+    @model_validator(mode="after")
+    def validate_limit(self) -> "AgentToolContextPolicy":
+        """Require a limit for the recent strategy and reject it elsewhere."""
+        if self.strategy is ContextStrategy.RECENT:
+            if self.message_limit is None or self.message_limit < 1:
+                raise ValueError(
+                    "message_limit must be >= 1 when strategy='recent'"
+                )
+        elif self.message_limit is not None:
+            raise ValueError("message_limit is only valid when strategy='recent'")
+        return self
+
+
+# A callable selector is the escape hatch for fully custom curation.
+ContextPolicyInput = Union[
+    AgentToolContextPolicy, Callable[[AgentContext], List[Message]]
+]
+
+
+@runtime_checkable
+class AgentToolCompatible(Protocol):
+    name: str
+    description: str
+
+    async def run(
+        self,
+        task: Optional[Union[str, UserMessage, List[Message]]] = None,
+        context: Optional[AgentContext] = None,
+        cancellation_token: Optional[CancellationToken] = None,
+    ) -> AgentResponse: ...
+
+    def run_stream(
+        self,
+        task: Optional[Union[str, UserMessage, List[Message]]] = None,
+        context: Optional[AgentContext] = None,
+        cancellation_token: Optional[CancellationToken] = None,
+        verbose: bool = False,
+        stream_tokens: bool = False,
+    ) -> AsyncGenerator[
+        Union[Message, AgentEvent, AgentResponse, ChatCompletionChunk], None
+    ]: ...
+
+
+class AgentAsTool(BaseTool):
+    """Expose any BaseAgent as a BaseTool."""
+
+    def __init__(
+        self,
+        agent: AgentToolCompatible,
+        task_parameter_name: str = "task",
+        result_strategy: ResultStrategy = "last",
+        context_policy: Optional[ContextPolicyInput] = None,
+    ) -> None:
+        if not isinstance(agent, AgentToolCompatible):
+            raise TypeError("agent must implement the agent tool interface")
+
+        super().__init__(name=agent.name, description=agent.description)
+
+        self.agent = agent
+        self.task_parameter_name = task_parameter_name
+        self.result_strategy = result_strategy
+        if context_policy is None:
+            context_policy = AgentToolContextPolicy()
+        if not callable(context_policy) and not isinstance(
+            context_policy, AgentToolContextPolicy
+        ):
+            raise TypeError(
+                "context_policy must be an AgentToolContextPolicy or callable"
+            )
+        self.context_policy = context_policy
+        self._validate_result_strategy()
+
+    def _validate_result_strategy(self) -> None:
+        if callable(self.result_strategy):
+            return
+
+        if not isinstance(self.result_strategy, str):
+            raise TypeError("result_strategy must be a string or callable")
+
+        if self.result_strategy in {"last", "all"}:
+            return
+
+        if self.result_strategy.startswith("last:"):
+            try:
+                count = int(self.result_strategy.split(":", maxsplit=1)[1])
+            except ValueError as exc:
+                raise ValueError(
+                    "Invalid result_strategy format, expected 'last:N'",
+                ) from exc
+
+            if count <= 0:
+                raise ValueError("N must be positive in 'last:N' strategy")
+            return
+
+        raise ValueError(
+            "Unknown result_strategy. Use 'last', 'last:N', 'all', or callable.",
+        )
+
+    def _select_inherited_messages(
+        self, agent_context: AgentContext
+    ) -> List[Message]:
+        """Pick which caller messages to seed into the sub-agent.
+
+        Built-in strategies operate on the caller's resolved history (its live
+        in-flight delegation call excluded) and always yield a valid sequence:
+        ``identity`` carries none, ``last_task`` the most recent user task,
+        ``recent`` the last ``message_limit`` messages (whole tool exchanges, via
+        the shared :func:`select_recent_messages`), and ``full`` the entire
+        history. A callable returns a fully custom selection and owns its own
+        validity.
+        """
+        policy = self.context_policy
+        if not isinstance(policy, AgentToolContextPolicy):
+            return list(policy(agent_context))
+
+        strategy = policy.strategy
+        if strategy is ContextStrategy.IDENTITY:
+            return []
+
+        history = self._resolved_history(agent_context.messages)
+
+        if strategy is ContextStrategy.LAST_TASK:
+            for message in reversed(history):
+                if isinstance(message, UserMessage):
+                    return [message]
+            return []
+
+        if strategy is ContextStrategy.FULL:
+            return history
+
+        # RECENT — the policy guarantees message_limit >= 1.
+        assert policy.message_limit is not None
+        return select_recent_messages(history, policy.message_limit)
+
+    @staticmethod
+    def _resolved_history(messages: List[Message]) -> List[Message]:
+        """Return the caller's history with its in-flight delegation call removed.
+
+        ``AgentAsTool`` runs inside the caller's live working context, whose last
+        assistant message is the tool call that triggered this sub-agent — its
+        result does not exist yet. That trailing exchange is pending (it would
+        fail grouping), so exclude it before windowing; earlier turns are already
+        complete.
+        """
+        resolved = list(messages)
+        trailing_results: List[Message] = []
+        while resolved and isinstance(resolved[-1], ToolMessage):
+            trailing_results.append(resolved.pop())
+
+        if (
+            resolved
+            and isinstance(resolved[-1], AssistantMessage)
+            and resolved[-1].tool_calls
+        ):
+            answered = {m.tool_call_id for m in trailing_results}
+            if not all(tc.call_id in answered for tc in resolved[-1].tool_calls):
+                resolved.pop()  # unresolved in-flight delegation batch
+                return resolved
+
+        # Tail is a complete exchange (or no tool exchange) — keep everything.
+        return list(messages)
+
+    def _extract_result(self, messages: List[Message]) -> str:
+        if not messages:
+            return ""
+
+        if callable(self.result_strategy):
+            return self.result_strategy(messages)
+
+        if self.result_strategy == "last":
+            return messages[-1].content
+
+        if self.result_strategy == "all":
+            return "\n".join(message.content for message in messages)
+
+        count = int(self.result_strategy.split(":", maxsplit=1)[1])
+        selected = messages[-count:]
+        return "\n".join(message.content for message in selected)
+
+    @property
+    def parameters(self) -> Dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                self.task_parameter_name: {
+                    "type": "string",
+                    "description": f"Task for {self.agent.name} to complete",
+                },
+            },
+            "required": [self.task_parameter_name],
+        }
+
+    def accepts_context(self) -> bool:
+        """Opt in to receiving the calling agent's context for identity reuse."""
+        return True
+
+    def _resolve_context(
+        self,
+        context: Optional[AgentContext],
+        agent_context: Optional[AgentContext],
+    ) -> Optional[AgentContext]:
+        """Resolve the context the sub-agent should run with.
+
+        An explicit ``context`` (passed by a direct caller) is used as-is. When
+        the agent loop forwards its ``agent_context`` instead, the sub-agent runs
+        in a fresh, isolated context that inherits identity — ``session_id`` and
+        ``user_id`` — so its usage records aggregate under the parent
+        session/user without polluting the parent conversation. The sub-run keeps
+        its own ``run_id`` because it is a distinct agent invocation.
+
+        ``context_policy`` optionally seeds a slice of the parent conversation
+        into that fresh context (default ``identity`` seeds none), letting the
+        sub-agent see recent turns without copying the full history.
+        """
+        if context is not None:
+            return context
+        if agent_context is None:
+            return None
+
+        child = AgentContext(
+            session_id=agent_context.session_id,
+            user_id=agent_context.user_id,
+        )
+        for message in self._select_inherited_messages(agent_context):
+            child.add_message(message)
+        return child
+
+    async def execute(
+        self,
+        parameters: Dict[str, Any],
+        context: Optional[AgentContext] = None,
+        agent_context: Optional[AgentContext] = None,
+    ) -> ToolResult:
+        task_str = parameters.get(self.task_parameter_name, "")
+        task = UserMessage(content=task_str, source="user")
+        run_context = self._resolve_context(context, agent_context)
+
+        try:
+            response = await self.agent.run(task=task, context=run_context)
+            final_content = self._extract_result(response.messages)
+            return ToolResult(
+                success=True,
+                result=final_content,
+                metadata={
+                    "agent_name": self.agent.name,
+                    "message_count": len(response.messages),
+                    "usage": response.usage.model_dump() if response.usage else None,
+                    "finish_reason": response.finish_reason,
+                },
+            )
+        except Exception as exc:
+            return ToolResult(
+                success=False,
+                result="",
+                error=f"Agent execution failed: {exc}",
+                metadata={"agent_name": self.agent.name},
+            )
+
+    async def execute_stream(
+        self,
+        parameters: Dict[str, Any],
+        context: Optional[AgentContext] = None,
+        cancellation_token: Optional[CancellationToken] = None,
+        agent_context: Optional[AgentContext] = None,
+    ) -> AsyncGenerator[Union[Message, AgentEvent, ToolResult], None]:
+        task_str = parameters.get(self.task_parameter_name, "")
+        task = UserMessage(content=task_str, source="user")
+        run_context = self._resolve_context(context, agent_context)
+        final_response: Optional[AgentResponse] = None
+
+        try:
+            async for item in self.agent.run_stream(
+                task=task,
+                context=run_context,
+                cancellation_token=cancellation_token,
+                verbose=True,
+                stream_tokens=False,
+            ):
+                if isinstance(item, AgentResponse):
+                    final_response = item
+                else:
+                    yield item
+
+            result_content = ""
+            metadata: Dict[str, Any] = {"agent_name": self.agent.name}
+
+            if final_response is not None:
+                result_content = self._extract_result(final_response.messages)
+                metadata["message_count"] = len(final_response.messages)
+                metadata["usage"] = (
+                    final_response.usage.model_dump() if final_response.usage else None
+                )
+                metadata["finish_reason"] = final_response.finish_reason
+
+            yield ToolResult(success=True, result=result_content, metadata=metadata)
+        except Exception as exc:
+            yield ToolResult(
+                success=False,
+                result="",
+                error=f"Agent execution failed: {exc}",
+                metadata={"agent_name": self.agent.name},
+            )
+
+
+__all__ = [
+    "AgentAsTool",
+    "ResultStrategy",
+    "ContextStrategy",
+    "AgentToolContextPolicy",
+    "ContextPolicyInput",
+    "AgentToolCompatible",
+]

{agentbyte-0.53.0 → agentbyte-0.55.0}/src/agentbyte/agents/base.py

@@ -6,7 +6,10 @@ import json
 import warnings
 from abc import ABC, abstractmethod
 from collections.abc import AsyncGenerator, Callable
-from typing import Any, Dict, List, Optional, Type, Union
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Type, Union
+
+if TYPE_CHECKING:
+    from .agent_as_tool import ContextPolicyInput
 
 from pydantic import BaseModel
 
@@ -309,14 +312,24 @@ class BaseAgent(ABC):
         self,
         task_parameter_name: str = "task",
         result_strategy: Union[str, Callable[[List[Message]], str]] = "last",
+        context_policy: Optional["ContextPolicyInput"] = None,
     ) -> BaseTool:
-        """Wrap this agent as a tool for hierarchical composition."""
+        """Wrap this agent as a tool for hierarchical composition.
+
+        ``context_policy`` controls how much of the calling agent's conversation
+        the sub-agent inherits: an :class:`AgentToolContextPolicy` (default
+        ``identity`` seeds no messages; ``last_task``, ``recent`` with
+        ``message_limit``, and ``full`` seed more) or a callable for a custom
+        selection. ``session_id`` and ``user_id`` are always inherited so
+        sub-agent usage aggregates under the parent session/user.
+        """
         from .agent_as_tool import AgentAsTool
 
         return AgentAsTool(
             agent=self,
             task_parameter_name=task_parameter_name,
             result_strategy=result_strategy,
+            context_policy=context_policy,
         )
 
     @abstractmethod

{agentbyte-0.53.0 → agentbyte-0.55.0}/src/agentbyte/compaction/grouping.py

@@ -119,3 +119,27 @@ def group_messages(messages: list[Any]) -> list[MessageGroup]:
         index += 1
 
     return groups
+
+
+def select_recent_messages(messages: list[Any], message_limit: int) -> list[Any]:
+    """Return the last *message_limit* messages without splitting a tool exchange.
+
+    Groups the conversation with :func:`group_messages` and keeps whole groups
+    from the newest end until at least *message_limit* messages are covered. The
+    limit is a floor rather than an exact count: a tool exchange is kept whole
+    rather than cut between a tool-calling ``AssistantMessage`` and its results,
+    which would otherwise leave an orphaned tool result (spec 0064).
+
+    *messages* must already be a valid sequence (no pending or orphaned tool
+    exchanges); see :func:`group_messages` for the raised errors otherwise.
+    """
+    groups = group_messages(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]

{agentbyte-0.53.0 → agentbyte-0.55.0}/src/agentbyte/llm/anthropic/_conversion.py

@@ -94,7 +94,15 @@ class AnthropicConversionMixin:
 
         system = self._extract_system(messages)
         if system is not None:
-            api_kwargs["system"] = system
+            # A single `cache_control` breakpoint on the system block marks it
+            # as a cache candidate for Anthropic's Messages API (no beta header
+            # needed as of anthropic==1.13.0's non-beta `TextBlockParam`). This
+            # is a no-op below the per-model minimum cacheable size and strictly
+            # beneficial above it, so there's no config flag for it -- shared
+            # here means both direct Anthropic and Bedrock transports get it.
+            api_kwargs["system"] = [
+                {"type": "text", "text": system, "cache_control": {"type": "ephemeral"}}
+            ]
 
         api_messages = self._convert_messages_to_api_format(messages)
         api_tools = self._convert_tools(tools)
@@ -182,7 +190,15 @@ class AnthropicConversionMixin:
 
         system = self._extract_system(messages)
         if system is not None:
-            api_kwargs["system"] = system
+            # A single `cache_control` breakpoint on the system block marks it
+            # as a cache candidate for Anthropic's Messages API (no beta header
+            # needed as of anthropic==1.13.0's non-beta `TextBlockParam`). This
+            # is a no-op below the per-model minimum cacheable size and strictly
+            # beneficial above it, so there's no config flag for it -- shared
+            # here means both direct Anthropic and Bedrock transports get it.
+            api_kwargs["system"] = [
+                {"type": "text", "text": system, "cache_control": {"type": "ephemeral"}}
+            ]
 
         api_messages = self._convert_messages_to_api_format(messages)
         api_tools = self._convert_tools(tools)

{agentbyte-0.53.0 → agentbyte-0.55.0}/src/agentbyte/llm/pricing.py

@@ -456,6 +456,13 @@ class PricingRegistry:
         "claude-opus-4-5": ModelPricing(input_per_1m=5.0, output_per_1m=25.0),
         "claude-opus-4": ModelPricing(input_per_1m=15.0, output_per_1m=75.0),
         "claude-sonnet-5": ModelPricing(input_per_1m=2.0, output_per_1m=10.0),
+        # claude-sonnet-4-6/-4-5 currently price identically to claude-sonnet-4 ($3/$15,
+        # verified against platform.claude.com/docs/en/about-claude/pricing), so the
+        # prefix fallback already resolved them correctly -- listed explicitly anyway so a
+        # future divergent repricing (as happened for claude-opus-4-5 vs. claude-opus-4)
+        # doesn't silently fall through to the wrong rate.
+        "claude-sonnet-4-6": ModelPricing(input_per_1m=3.0, output_per_1m=15.0),
+        "claude-sonnet-4-5": ModelPricing(input_per_1m=3.0, output_per_1m=15.0),
         "claude-sonnet-4": ModelPricing(input_per_1m=3.0, output_per_1m=15.0),
         "claude-haiku-5-5": ModelPricing(
             input_per_1m=0.10,

{agentbyte-0.53.0 → agentbyte-0.55.0}/src/agentbyte/orchestration/base.py

@@ -16,7 +16,7 @@ from agentbyte.agents.types import AgentErrorDetail, AgentResponse, Usage
 from agentbyte.execution_trace import SpanKind, 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.compaction.grouping import select_recent_messages
 from agentbyte.context import AgentContext
 from agentbyte.messages import AssistantMessage, Message, UserMessage
 from agentbyte.agents.types import BaseEvent
@@ -1323,25 +1323,11 @@ class BaseOrchestrator(ABC):
     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.
+        Delegates to :func:`agentbyte.compaction.grouping.select_recent_messages`
+        so orchestrators and ``AgentAsTool`` share one recent-window
+        implementation (floor semantics, whole tool exchanges; spec 0064).
         """
-        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]
+        return select_recent_messages(self.shared_messages, message_limit)
 
     def _build_agent_context_from_history(
         self, agent: BaseAgent