agentbyte 0.54.0__tar.gz → 0.56.0__tar.gz

{agentbyte-0.54.0 → agentbyte-0.56.0}/.gitignore

@@ -84,3 +84,7 @@ optim-reports/
 
 # marimo local session cache
 __marimo__/
+
+# Local Claude worktrees and machine-specific permissions
+.claude/worktrees/
+.claude/settings.local.json

{agentbyte-0.54.0 → agentbyte-0.56.0}/CHANGELOG.md

@@ -6,6 +6,44 @@ The format follows Keep a Changelog principles and semantic versioning.
 
 ## [Unreleased]
 
+## [0.56.0] - 2026-10-23
+
+### Added
+
+- `pricing_model=` on OpenAI chat/embedding, Anthropic direct/Bedrock chat, and Cohere Bedrock
+  embedding constructors and factories, matching Azure pricing aliases. Component configs preserve
+  the alias; manual `model_pricing` takes precedence while transport model IDs remain unchanged.
+- Standard short-context catalog entries for `gpt-6.1-sol`, `gpt-6-astra`, and `gpt-6-luna`,
+  including cached-input and 30-minute cache-write metadata.
+
+### Changed
+
+- Consolidated 19 AgentByte coding skills into one topic router with references loaded on demand;
+  removed the WebUI smoke-test skill and repaired migration-guide links.
+- Added proposed spec 0077 for OpenAI models on Bedrock over SigV4 and updated the spec index.
+
+### Fixed
+
+- Exact Claude Sonnet 5.5, Fable 5.1, Mythos 5, and Mythos 5.1 pricing prevents sibling fallback.
+  Claude 5-series rates now include cache reads and 5-minute cache-write metadata, including
+  Haiku 5.5 below the 100K prompt threshold.
+
+## [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

{agentbyte-0.54.0 → agentbyte-0.56.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentbyte
-Version: 0.54.0
+Version: 0.56.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.54.0**
+Current release: **0.56.0**
 
 ## Building an Agent
 

{agentbyte-0.54.0 → agentbyte-0.56.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.54.0**
+Current release: **0.56.0**
 
 ## Building an Agent
 

agentbyte-0.56.0/src/agentbyte/__about__.py

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

{agentbyte-0.54.0 → agentbyte-0.56.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.54.0 → agentbyte-0.56.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.56.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.54.0 → agentbyte-0.56.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.54.0 → agentbyte-0.56.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.54.0 → agentbyte-0.56.0}/src/agentbyte/llm/anthropic/chat.py

@@ -19,6 +19,7 @@ from ._conversion import AnthropicConversionMixin
 class AnthropicChatCompletionClientConfig(BaseChatCompletionClientConfig):
     """Configuration for AnthropicChatCompletionClient serialization."""
 
+    pricing_model: str | None = None
     retry_policy: RetryPolicy = RetryPolicy()
     key_env_var: str = "ANTHROPIC_API_KEY"
 
@@ -46,9 +47,11 @@ class AnthropicChatCompletionClient(
         max_retry_delay: float = 60.0,
         retry_policy: Optional[RetryPolicy] = None,
         middlewares: Optional[List[ClientMiddleware]] = None,
+        pricing_model: str | None = None,
     ):
         super().__init__(model, client, config, middlewares=middlewares)
         self.model_pricing = model_pricing
+        self.pricing_model = pricing_model
         if retry_policy is not None:
             self.retry_policy = retry_policy
         else:
@@ -83,6 +86,7 @@ class AnthropicChatCompletionClient(
         max_retry_delay: float = 60.0,
         retry_policy: Optional[RetryPolicy] = None,
         middlewares: Optional[List[ClientMiddleware]] = None,
+        pricing_model: str | None = None,
     ) -> "AnthropicChatCompletionClient":
         """Create a client from an explicit or env-backed API key."""
         from pydantic import ValidationError
@@ -109,6 +113,7 @@ class AnthropicChatCompletionClient(
             client=anthropic_client,
             config=config,
             model_pricing=model_pricing,
+            pricing_model=pricing_model,
             max_retries=max_retries,
             initial_retry_delay=initial_retry_delay,
             max_retry_delay=max_retry_delay,
@@ -126,13 +131,14 @@ class AnthropicChatCompletionClient(
         if self.model_pricing is not None:
             pricing = self.model_pricing
         else:
-            pricing = PricingRegistry.resolve_anthropic_chat_pricing(self.model)
+            pricing = PricingRegistry.resolve_anthropic_chat_pricing(self.pricing_model or self.model)
         return pricing.calculate_cost(input_tokens, output_tokens, cached_tokens)
 
     def _to_config(self) -> AnthropicChatCompletionClientConfig:
         """Serialize to config without persisting secrets."""
         return AnthropicChatCompletionClientConfig(
             model=self.model,
+            pricing_model=self.pricing_model,
             config=self.config.copy(),
             retry_policy=self.retry_policy,
             key_env_var=getattr(self, "_key_env_var", "ANTHROPIC_API_KEY"),
@@ -153,6 +159,7 @@ class AnthropicChatCompletionClient(
             )
         instance = cls.from_api_key(
             model=config.model,
+            pricing_model=config.pricing_model,
             api_key=api_key,
             config=config.config or None,
             retry_policy=config.retry_policy,