agentbyte 0.51.0__tar.gz → 0.52.0__tar.gz

{agentbyte-0.51.0 → agentbyte-0.52.0}/CHANGELOG.md

@@ -6,6 +6,40 @@ The format follows Keep a Changelog principles and semantic versioning.
 
 ## [Unreleased]
 
+## [0.52.0] - 2026-10-10
+
+### Added
+
+- `AnthropicChatCompletionClient`: direct Anthropic Claude chat client (`agentbyte[anthropic]`),
+  matching the existing `OpenAIChatCompletionClient` construction/DI/retry/pricing/error-mapping
+  contract (`from_api_key()`, `_to_config`/`_from_config` without persisting secrets, tool-use,
+  streaming).
+- `AnthropicBedrockChatCompletionClient`: the same Claude Messages API client transported through
+  AWS Bedrock (`agentbyte[bedrock]`) via `AsyncAnthropicBedrock` (SigV4, boto3 credential chain),
+  constructed with `from_region()`. Shares conversion/parsing logic with the direct client through
+  `AnthropicConversionMixin`.
+- `CohereBedrockEmbeddingClient`: Cohere Embed v3 (English/Multilingual) and v4 embeddings via AWS
+  Bedrock Runtime (`agentbyte[aws]`, `aioboto3`), with `CohereInputType`/`CohereTruncate` options
+  and the same injected-or-fresh-client pattern as `dataset/s3.py`'s `s3_client()`.
+- `build_chat_client` auto-detects `anthropic` (`ANTHROPIC_API_KEY`) and `anthropic-bedrock`
+  (`AWS_REGION` + `ANTHROPIC_BEDROCK_MODEL`) alongside the existing OpenAI/Azure detection.
+- Pricing for Claude 5.5 (`claude-opus-5-5`, `claude-haiku-5-5`), Cohere Embed v3 (English/
+  Multilingual, estimate), and Cohere Embed v4 (verified against AWS Bedrock's own pricing page).
+
+### Fixed
+
+- `AnthropicBedrockChatCompletionClient` was built on `AsyncAnthropicBedrockMantle`, a Bedrock
+  access path authenticated by a bearer token (`AWS_BEARER_TOKEN_BEDROCK`), not AWS IAM
+  credentials — every call 404'd with a misleading "model does not exist" error against a real
+  account. Caught by live smoke-testing against real Bedrock, invisible to the mocked unit tests.
+  Swapped to `AsyncAnthropicBedrock`, the real SigV4/boto3-credential-chain transport.
+- The Bedrock Claude pricing normalizer didn't strip cross-region inference-profile prefixes
+  (`eu.`/`global.`, required for on-demand invoke on most accounts), silently falling back to
+  default pricing for real Bedrock calls.
+- `CohereBedrockEmbeddingClient` read billed tokens from a response-body field that doesn't exist
+  on real Bedrock responses, so `tokens_input`/`cost_estimate` were silently always zero despite
+  successful calls. Now reads the real `x-amzn-bedrock-input-token-count` response header.
+
 ## [0.51.0] - 2026-10-09
 
 ### Added

{agentbyte-0.51.0 → agentbyte-0.52.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentbyte
-Version: 0.51.0
+Version: 0.52.0
 Summary: A toolkit for designing multiagent systems
 Author-email: MrDataPsycho <mr.data.psycho@gmail.com>
 License-Expression: LicenseRef-Proprietary
@@ -17,6 +17,8 @@ Requires-Dist: uvicorn[standard]>=0.44.0; extra == 'a2a'
 Provides-Extra: all
 Requires-Dist: aioboto3>=15.5.0; extra == 'all'
 Requires-Dist: aiosqlite>=0.22.1; extra == 'all'
+Requires-Dist: anthropic>=1.13.0; extra == 'all'
+Requires-Dist: anthropic[bedrock]>=1.13.0; extra == 'all'
 Requires-Dist: arxiv>=2.1; extra == 'all'
 Requires-Dist: asyncpg>=0.31.0; extra == 'all'
 Requires-Dist: azure-identity>=1.25.1; extra == 'all'
@@ -35,11 +37,15 @@ Requires-Dist: sqlmodel>=0.0.38; extra == 'all'
 Requires-Dist: tiktoken>=0.9.0; extra == 'all'
 Requires-Dist: uvicorn[standard]>=0.44.0; extra == 'all'
 Requires-Dist: youtube-transcript-api>=0.6; extra == 'all'
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=1.13.0; extra == 'anthropic'
 Provides-Extra: aws
 Requires-Dist: aioboto3>=15.5.0; extra == 'aws'
 Provides-Extra: azureopenai
 Requires-Dist: azure-identity>=1.25.1; extra == 'azureopenai'
 Requires-Dist: openai>=1.107.1; extra == 'azureopenai'
+Provides-Extra: bedrock
+Requires-Dist: anthropic[bedrock]>=1.13.0; extra == 'bedrock'
 Provides-Extra: gunicorn
 Requires-Dist: fastapi>=0.135.2; extra == 'gunicorn'
 Requires-Dist: gunicorn>=23.0.0; extra == 'gunicorn'
@@ -333,7 +339,9 @@ uv add "agentbyte[openai,sqlite]"
 | --- | --- | --- |
 | `openai` | `openai` | `OpenAIChatCompletionClient`, `OpenAIEmbeddingClient` |
 | `azureopenai` | `openai`, `azure-identity` | Azure OpenAI clients and Entra ID credentials |
-| `aws` | `aioboto3` | S3 dataset sources, writers and publishers |
+| `anthropic` | `anthropic` | Direct Anthropic Claude chat client |
+| `bedrock` | `anthropic[bedrock]` | Anthropic Claude chat through AWS Bedrock |
+| `aws` | `aioboto3` | S3 dataset I/O and Cohere Bedrock embedding client |
 | `otel` | OpenTelemetry API, SDK, OTLP exporter | OpenTelemetry tracing and metrics |
 | `webui` | `fastapi`, `uvicorn` | `agentbyte webui` |
 | `gunicorn` | `webui` + `gunicorn` | Production single-worker serving (`gunicorn -k uvicorn.workers.UvicornWorker -w 1`) |

{agentbyte-0.51.0 → agentbyte-0.52.0}/README.md

@@ -251,7 +251,9 @@ uv add "agentbyte[openai,sqlite]"
 | --- | --- | --- |
 | `openai` | `openai` | `OpenAIChatCompletionClient`, `OpenAIEmbeddingClient` |
 | `azureopenai` | `openai`, `azure-identity` | Azure OpenAI clients and Entra ID credentials |
-| `aws` | `aioboto3` | S3 dataset sources, writers and publishers |
+| `anthropic` | `anthropic` | Direct Anthropic Claude chat client |
+| `bedrock` | `anthropic[bedrock]` | Anthropic Claude chat through AWS Bedrock |
+| `aws` | `aioboto3` | S3 dataset I/O and Cohere Bedrock embedding client |
 | `otel` | OpenTelemetry API, SDK, OTLP exporter | OpenTelemetry tracing and metrics |
 | `webui` | `fastapi`, `uvicorn` | `agentbyte webui` |
 | `gunicorn` | `webui` + `gunicorn` | Production single-worker serving (`gunicorn -k uvicorn.workers.UvicornWorker -w 1`) |

{agentbyte-0.51.0 → agentbyte-0.52.0}/pyproject.toml

@@ -24,6 +24,16 @@ azureopenai = [
     "openai>=1.107.1",
     "azure-identity>=1.25.1",
 ]
+anthropic = [
+    "anthropic>=1.13.0",
+]
+# anthropic[bedrock] does its own AWS SigV4 signing via AnthropicBedrock*; deliberately
+# not named "aws" (that extra is aioboto3, which this one does not need).
+bedrock = [
+    "anthropic[bedrock]>=1.13.0",
+]
+# aioboto3 for AWS I/O: S3 dataset access (dataset/s3.py) and Bedrock Runtime
+# (llm/bedrock/, e.g. CohereBedrockEmbeddingClient).
 aws = [
     "aioboto3>=15.5.0",
 ]
@@ -76,7 +86,7 @@ a2a = [
     "agentbyte[webui]",
 ]
 all = [
-    "agentbyte[openai,azureopenai,aws,otel,webui,gunicorn,sql,tiktoken,optim,viz,research]",
+    "agentbyte[openai,azureopenai,anthropic,bedrock,aws,otel,webui,gunicorn,sql,tiktoken,optim,viz,research]",
 ]
 
 

agentbyte-0.52.0/src/agentbyte/__about__.py

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

{agentbyte-0.51.0 → agentbyte-0.52.0}/src/agentbyte/llm/__init__.py

@@ -69,6 +69,8 @@ __all__ = [
     "AzureOpenAIChatCompletionClientConfig",
     "AzureOpenAIEmbeddingClient",
     "AzureOpenAIEmbeddingClientConfig",
+    "AnthropicChatCompletionClient",
+    "AnthropicChatCompletionClientConfig",
     # Authentication utilities
     "get_default_token_provider",
     "get_certificate_token_provider",
@@ -77,6 +79,12 @@ __all__ = [
     "OpenAISettings",
     "AzureOpenAISettings",
     "AzureServicePrincipalSettings",
+    "AnthropicSettings",
+    "AnthropicBedrockChatCompletionClient",
+    "AnthropicBedrockChatCompletionClientConfig",
+    "CohereBedrockEmbeddingClient",
+    "CohereBedrockEmbeddingClientConfig",
+    "BedrockSettings",
     # Retry policy
     "RetryPolicy",
     # Exception types
@@ -123,9 +131,22 @@ if TYPE_CHECKING:  # editors and type checkers see the provider classes eagerly
         OpenAIEmbeddingClientConfig,
         OpenAISettings,
     )
+    from .anthropic import (
+        AnthropicChatCompletionClient,
+        AnthropicChatCompletionClientConfig,
+        AnthropicSettings,
+    )
+    from .bedrock import (
+        AnthropicBedrockChatCompletionClient,
+        AnthropicBedrockChatCompletionClientConfig,
+        BedrockSettings,
+        CohereBedrockEmbeddingClient,
+        CohereBedrockEmbeddingClientConfig,
+    )
 
-# Provider clients need optional extras (``openai``, ``azureopenai``); they are
-# imported on first access so ``import agentbyte`` works with core dependencies only.
+# Provider clients need optional extras (``openai``, ``azureopenai``, ``anthropic``);
+# they are imported on first access so ``import agentbyte`` works with core
+# dependencies only.
 _PROVIDER_EXPORTS = {
     "OpenAIChatCompletionClient": ".openai",
     "OpenAIChatCompletionClientConfig": ".openai",
@@ -141,6 +162,25 @@ _PROVIDER_EXPORTS = {
     "create_token_provider_from_string": ".azure",
     "AzureOpenAISettings": ".azure",
     "AzureServicePrincipalSettings": ".azure",
+    "AnthropicChatCompletionClient": ".anthropic",
+    "AnthropicChatCompletionClientConfig": ".anthropic",
+    "AnthropicSettings": ".anthropic",
+    "AnthropicBedrockChatCompletionClient": ".bedrock",
+    "AnthropicBedrockChatCompletionClientConfig": ".bedrock",
+    "CohereBedrockEmbeddingClient": ".bedrock",
+    "CohereBedrockEmbeddingClientConfig": ".bedrock",
+    "BedrockSettings": ".bedrock",
+}
+
+_PROVIDER_EXTRAS = {
+    ".openai": ("openai", "openai"),
+    ".azure": ("openai", "azureopenai"),
+    ".anthropic": ("anthropic", "anthropic"),
+    # `.bedrock` is intentionally absent: its two clients need different extras
+    # (`anthropic[bedrock]` vs. `aioboto3`/`aws`), so `llm/bedrock/__init__.py`
+    # does its own fine-grained, per-symbol `require()` check instead -- a
+    # single module-level check here would wrongly demand both extras for
+    # either client.
 }
 
 
@@ -150,9 +190,12 @@ def __getattr__(name: str):
         raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
     from importlib import import_module
 
-    from agentbyte._optional import require
+    extra_spec = _PROVIDER_EXTRAS.get(module_name)
+    if extra_spec is not None:
+        from agentbyte._optional import require
 
-    require("openai", extra="openai" if module_name == ".openai" else "azureopenai", feature=name)
+        required_module, extra = extra_spec
+        require(required_module, extra=extra, feature=name)
     value = getattr(import_module(module_name, __name__), name)
     globals()[name] = value
     return value

agentbyte-0.52.0/src/agentbyte/llm/anthropic/__init__.py

@@ -0,0 +1,10 @@
+"""Anthropic provider package."""
+
+from .chat import AnthropicChatCompletionClient, AnthropicChatCompletionClientConfig
+from .settings import AnthropicSettings
+
+__all__ = [
+    "AnthropicChatCompletionClient",
+    "AnthropicChatCompletionClientConfig",
+    "AnthropicSettings",
+]

agentbyte-0.52.0/src/agentbyte/llm/anthropic/_conversion.py

@@ -0,0 +1,439 @@
+"""
+Shared Anthropic Messages API conversion/parsing logic.
+
+Both `AnthropicChatCompletionClient` (direct API) and
+`AnthropicBedrockChatCompletionClient` (Bedrock transport via
+`AsyncAnthropicBedrock`) ride the identical wire format -- same
+`.messages.create()`/`.messages.create(stream=True)` surface, same `Message`,
+`Usage`, and stream-event shapes. This mixin owns everything that depends only
+on that wire format, not on how the client authenticates or which SDK class is
+injected. Transport-specific concerns (`__init__`, `from_*` construction,
+`_estimate_cost`, `_to_config`/`_from_config`) stay on each concrete client.
+
+A consuming class must also provide: `self.client` (an object exposing
+`.messages.create()`), `self.model`, `self.config`, `self._estimate_cost(...)`,
+and (via `RetryMixin`) `self._retry_with_backoff`/`self._retry_stream_with_backoff`.
+"""
+
+import logging
+import time
+from collections.abc import AsyncGenerator
+from typing import Any, Dict, List, Optional
+
+from agentbyte.messages import (
+    AssistantMessage,
+    Message,
+    MultiModalMessage,
+    SystemMessage,
+    ToolCallRequest,
+    ToolMessage,
+)
+
+from .._retry_observability import build_retry_summary
+from ..types import (
+    ChatCompletionChunk,
+    ChatCompletionResult,
+    ModelClientError,
+    Usage,
+)
+from ..base import AuthenticationError, InvalidRequestError, RateLimitError
+
+logger = logging.getLogger(__name__)
+
+# The Messages API requires max_tokens; OpenAI's Chat Completions API does not.
+DEFAULT_MAX_TOKENS = 4096
+
+
+class AnthropicConversionMixin:
+    """Messages API request/response conversion shared by both Claude transports."""
+
+    async def create(
+        self,
+        messages: List[Message],
+        tools: Optional[List[Dict[str, Any]]] = None,
+        output_format: Optional[type] = None,
+        **kwargs: Any,
+    ) -> ChatCompletionResult:
+        """Make a single Anthropic Messages API call."""
+        retry_history: List = []
+        try:
+            result = await self._retry_with_backoff(
+                self._create_internal,
+                messages,
+                tools,
+                output_format,
+                _retry_history=retry_history,
+                **kwargs,
+            )
+            if retry_history:
+                result.metadata["retry_observability"] = {
+                    "history": retry_history,
+                    "latest": build_retry_summary(retry_history),
+                }
+            return result
+        except Exception as e:
+            if retry_history:
+                logger.warning(
+                    "LLM call failed after retries for model=%s: %s",
+                    self.model,
+                    build_retry_summary(retry_history),
+                )
+            self._handle_error(e)
+
+    async def _create_internal(
+        self,
+        messages: List[Message],
+        tools: Optional[List[Dict[str, Any]]] = None,
+        output_format: Optional[type] = None,
+        **kwargs: Any,
+    ) -> ChatCompletionResult:
+        """Internal create implementation (retried by wrapper)."""
+        api_kwargs = {**self.config, **kwargs}
+        api_kwargs.setdefault("max_tokens", DEFAULT_MAX_TOKENS)
+
+        system = self._extract_system(messages)
+        if system is not None:
+            api_kwargs["system"] = system
+
+        api_messages = self._convert_messages_to_api_format(messages)
+        api_tools = self._convert_tools(tools)
+        if api_tools:
+            api_kwargs["tools"] = api_tools
+
+        start_time = time.perf_counter()
+        response = await self.client.messages.create(
+            model=self.model,
+            messages=api_messages,
+            **api_kwargs,
+        )
+        duration_ms = int((time.perf_counter() - start_time) * 1000)
+
+        message_content, tool_calls = self._split_content_blocks(response.content)
+
+        structured_output = None
+        if output_format and message_content:
+            try:
+                structured_output = output_format.model_validate_json(message_content)
+            except Exception as e:
+                logger.warning(f"Failed to parse structured output: {e}. Using raw content.")
+
+        cached_tokens = response.usage.cache_read_input_tokens or 0
+
+        return ChatCompletionResult(
+            message=AssistantMessage(
+                content=message_content,
+                source=self.model,
+                tool_calls=tool_calls,
+            ),
+            usage=Usage(
+                duration_ms=duration_ms,
+                llm_calls=1,
+                tokens_input=response.usage.input_tokens,
+                tokens_output=response.usage.output_tokens,
+                tokens_cached=cached_tokens,
+                tool_calls=len(tool_calls) if tool_calls else 0,
+                cost_estimate=self._estimate_cost(
+                    response.usage.input_tokens,
+                    response.usage.output_tokens,
+                    cached_tokens,
+                ),
+            ),
+            model=response.model,
+            metadata={"finish_reason": response.stop_reason},
+            finish_reason=response.stop_reason,
+            structured_output=structured_output,
+        )
+
+    async def create_stream(
+        self,
+        messages: List[Message],
+        tools: Optional[List[Dict[str, Any]]] = None,
+        output_format: Optional[type] = None,
+        stream_options: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> AsyncGenerator[ChatCompletionChunk, None]:
+        """Make a streaming Anthropic Messages API call."""
+        try:
+            async for chunk in self._retry_stream_with_backoff(
+                self._create_stream_internal,
+                messages,
+                tools,
+                output_format,
+                stream_options,
+                **kwargs,
+            ):
+                yield chunk
+        except Exception as e:
+            self._handle_error(e)
+
+    async def _create_stream_internal(
+        self,
+        messages: List[Message],
+        tools: Optional[List[Dict[str, Any]]] = None,
+        output_format: Optional[type] = None,
+        stream_options: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> AsyncGenerator[ChatCompletionChunk, None]:
+        """Internal streaming implementation (retried by wrapper)."""
+        api_kwargs = {**self.config, **kwargs}
+        api_kwargs.pop("stream_options", None)
+        api_kwargs.setdefault("max_tokens", DEFAULT_MAX_TOKENS)
+
+        system = self._extract_system(messages)
+        if system is not None:
+            api_kwargs["system"] = system
+
+        api_messages = self._convert_messages_to_api_format(messages)
+        api_tools = self._convert_tools(tools)
+        if api_tools:
+            api_kwargs["tools"] = api_tools
+
+        start_time = time.perf_counter()
+        stream = await self.client.messages.create(
+            model=self.model,
+            messages=api_messages,
+            stream=True,
+            **api_kwargs,
+        )
+
+        model_name = self.model
+        # Anthropic's input_json_delta streams raw JSON-fragment text per
+        # content-block index, the same accumulator shape openai/chat.py uses
+        # for streamed tool-call arguments.
+        tool_call_chunks: Dict[int, Dict[str, Any]] = {}
+
+        async for event in stream:
+            if event.type == "message_start":
+                model_name = event.message.model
+                continue
+
+            if event.type == "content_block_start":
+                if event.content_block.type == "tool_use":
+                    tool_call_chunks[event.index] = {
+                        "id": event.content_block.id,
+                        "function": {"name": event.content_block.name, "arguments": ""},
+                    }
+                    yield ChatCompletionChunk(
+                        content="",
+                        model=model_name,
+                        is_complete=False,
+                        tool_call_chunk=tool_call_chunks[event.index],
+                        usage=None,
+                        metadata={},
+                    )
+                continue
+
+            if event.type == "content_block_delta":
+                if event.delta.type == "text_delta":
+                    yield ChatCompletionChunk(
+                        content=event.delta.text,
+                        model=model_name,
+                        is_complete=False,
+                        tool_call_chunk=None,
+                        usage=None,
+                        metadata={},
+                    )
+                elif event.delta.type == "input_json_delta":
+                    chunk_state = tool_call_chunks.get(event.index)
+                    if chunk_state is not None:
+                        chunk_state["function"]["arguments"] += event.delta.partial_json
+                        yield ChatCompletionChunk(
+                            content="",
+                            model=model_name,
+                            is_complete=False,
+                            tool_call_chunk=chunk_state,
+                            usage=None,
+                            metadata={},
+                        )
+                continue
+
+            if event.type == "message_delta":
+                duration_ms = int((time.perf_counter() - start_time) * 1000)
+                input_tokens = event.usage.input_tokens or 0
+                output_tokens = event.usage.output_tokens or 0
+                cached_tokens = event.usage.cache_read_input_tokens or 0
+                usage = Usage(
+                    duration_ms=duration_ms,
+                    llm_calls=1,
+                    tokens_input=input_tokens,
+                    tokens_output=output_tokens,
+                    tokens_cached=cached_tokens,
+                    cost_estimate=self._estimate_cost(input_tokens, output_tokens, cached_tokens),
+                )
+                yield ChatCompletionChunk(
+                    content="",
+                    model=model_name,
+                    is_complete=True,
+                    tool_call_chunk=None,
+                    usage=usage,
+                    metadata={"finish_reason": event.delta.stop_reason},
+                )
+                continue
+
+    @staticmethod
+    def _extract_system(messages: List[Message]) -> Optional[str]:
+        """Pull SystemMessages out as Anthropic's top-level `system` param."""
+        system_parts = [m.content for m in messages if isinstance(m, SystemMessage)]
+        return "\n\n".join(system_parts) if system_parts else None
+
+    def _convert_messages_to_api_format(self, messages: List[Message]) -> List[Dict[str, Any]]:
+        """
+        Convert Agentbyte messages to Anthropic's role/content-block format.
+
+        SystemMessages are excluded here (pulled out via `_extract_system`).
+        Adjacent same-role entries are merged into one message, because a turn
+        with multiple tool calls produces one ToolMessage per call and Anthropic
+        requires them as content blocks on a single "user" message, not several
+        consecutive "user" messages.
+        """
+        api_messages: List[Dict[str, Any]] = []
+        for message in messages:
+            if isinstance(message, SystemMessage):
+                continue
+            role, blocks = self._message_to_blocks(message)
+            if api_messages and api_messages[-1]["role"] == role:
+                api_messages[-1]["content"].extend(blocks)
+            else:
+                api_messages.append({"role": role, "content": blocks})
+        return api_messages
+
+    @staticmethod
+    def _message_to_blocks(message: Message) -> "tuple[str, List[Dict[str, Any]]]":
+        """Convert one Agentbyte message into (role, content_blocks)."""
+        if isinstance(message, ToolMessage):
+            # Tool results are a "user" turn in the Messages API, not a "tool" role.
+            return "user", [
+                {
+                    "type": "tool_result",
+                    "tool_use_id": message.tool_call_id,
+                    "content": message.content,
+                }
+            ]
+
+        role = message.role.value if hasattr(message.role, "value") else message.role
+
+        if isinstance(message, MultiModalMessage):
+            blocks: List[Dict[str, Any]] = []
+            if message.content:
+                blocks.append({"type": "text", "text": message.content})
+            if message.is_image():
+                if message.media_url:
+                    blocks.append(
+                        {"type": "image", "source": {"type": "url", "url": message.media_url}}
+                    )
+                elif message.data is not None:
+                    base64_data = message.to_base64()
+                    if base64_data:
+                        blocks.append(
+                            {
+                                "type": "image",
+                                "source": {
+                                    "type": "base64",
+                                    "media_type": message.mime_type,
+                                    "data": base64_data,
+                                },
+                            }
+                        )
+            elif message.is_text() and message.data is not None:
+                data_text = (
+                    message.data.decode("utf-8", errors="ignore")
+                    if isinstance(message.data, bytes)
+                    else message.data
+                )
+                if data_text and data_text != message.content:
+                    blocks.append({"type": "text", "text": data_text})
+            return role, blocks or [{"type": "text", "text": message.content or ""}]
+
+        if isinstance(message, AssistantMessage) and message.tool_calls:
+            blocks = []
+            if message.content:
+                blocks.append({"type": "text", "text": message.content})
+            blocks.extend(
+                {
+                    "type": "tool_use",
+                    "id": tc.call_id,
+                    "name": tc.tool_name,
+                    "input": tc.parameters,
+                }
+                for tc in message.tool_calls
+            )
+            return role, blocks
+
+        return role, [{"type": "text", "text": message.content or ""}]
+
+    @staticmethod
+    def _convert_tools(
+        tools: Optional[List[Dict[str, Any]]],
+    ) -> Optional[List[Dict[str, Any]]]:
+        """Convert OpenAI-shaped tool schemas to Anthropic's flat tool shape."""
+        if not tools:
+            return None
+        converted = []
+        for tool in tools:
+            function = tool.get("function", tool)
+            converted.append(
+                {
+                    "name": function["name"],
+                    "description": function.get("description", ""),
+                    "input_schema": function.get(
+                        "parameters", {"type": "object", "properties": {}}
+                    ),
+                }
+            )
+        return converted
+
+    @staticmethod
+    def _split_content_blocks(
+        content_blocks: Any,
+    ) -> "tuple[str, Optional[List[ToolCallRequest]]]":
+        """Split a Messages API response's content blocks into (text, tool_calls)."""
+        text_parts: List[str] = []
+        tool_calls: List[ToolCallRequest] = []
+        for block in content_blocks:
+            if block.type == "text":
+                text_parts.append(block.text)
+            elif block.type == "tool_use":
+                tool_calls.append(
+                    ToolCallRequest(
+                        call_id=block.id,
+                        tool_name=block.name,
+                        parameters=block.input,
+                    )
+                )
+        return "".join(text_parts), (tool_calls or None)
+
+    def _handle_error(self, error: Exception) -> None:
+        """Convert Anthropic exceptions to the unified error hierarchy.
+
+        Shared by both transports: Bedrock's `AsyncAnthropicBedrock` client is
+        a thin SigV4 transport swap over the same SDK, and still raises the
+        same typed `anthropic.*Error` classes as the direct client.
+        """
+        try:
+            from anthropic import (
+                RateLimitError as AnthropicRateLimitError,
+                AuthenticationError as AnthropicAuthenticationError,
+                BadRequestError,
+                APIError,
+            )
+        except ImportError:
+            raise ModelClientError(f"Anthropic error: {str(error)}") from error
+
+        error_msg = str(error)
+        error_type = type(error).__name__
+
+        if isinstance(error, AnthropicRateLimitError):
+            raise RateLimitError(f"Anthropic rate limit exceeded: {error_msg}") from error
+        elif isinstance(error, AnthropicAuthenticationError):
+            raise AuthenticationError(f"Anthropic authentication failed: {error_msg}") from error
+        elif isinstance(error, BadRequestError):
+            raise InvalidRequestError(f"Anthropic request invalid: {error_msg}") from error
+        elif isinstance(error, APIError):
+            raise ModelClientError(f"Anthropic API error ({error_type}): {error_msg}") from error
+        else:
+            raise ModelClientError(
+                f"Unexpected error from Anthropic ({error_type}): {error_msg}"
+            ) from error
+
+
+__all__ = ["AnthropicConversionMixin", "DEFAULT_MAX_TOKENS"]