agno 2.2.13__py3-none-any.whl → 2.3.1__py3-none-any.whl

agno/models/anthropic/claude.py

@@ -4,7 +4,8 @@ from dataclasses import asdict, dataclass
 from os import getenv
 from typing import Any, Dict, List, Optional, Type, Union
 
-from pydantic import BaseModel
+import httpx
+from pydantic import BaseModel, ValidationError
 
 from agno.exceptions import ModelProviderError, ModelRateLimitError
 from agno.models.base import Model
@@ -12,6 +13,7 @@ from agno.models.message import Citations, DocumentCitation, Message, UrlCitatio
 from agno.models.metrics import Metrics
 from agno.models.response import ModelResponse
 from agno.run.agent import RunOutput
+from agno.utils.http import get_default_async_client, get_default_sync_client
 from agno.utils.log import log_debug, log_error, log_warning
 from agno.utils.models.claude import MCPServerConfiguration, format_messages, format_tools_for_model
 
@@ -25,6 +27,11 @@ try:
     from anthropic import (
         AsyncAnthropic as AsyncAnthropicClient,
     )
+    from anthropic.lib.streaming._beta_types import (
+        BetaRawContentBlockStartEvent,
+        ParsedBetaContentBlockStopEvent,
+        ParsedBetaMessageStopEvent,
+    )
     from anthropic.types import (
         CitationPageLocation,
         CitationsWebSearchResultLocation,
@@ -39,6 +46,7 @@ try:
     from anthropic.types import (
         Message as AnthropicMessage,
     )
+
 except ImportError as e:
     raise ImportError("`anthropic` not installed. Please install it with `pip install anthropic`") from e
 
@@ -72,6 +80,30 @@ class Claude(Model):
         "claude-3-5-haiku-latest",
     }
 
+    # Models that DO NOT support native structured outputs
+    # All future models are assumed to support structured outputs
+    NON_STRUCTURED_OUTPUT_MODELS = {
+        # Claude 3.x family (all versions)
+        "claude-3-opus-20240229",
+        "claude-3-sonnet-20240229",
+        "claude-3-haiku-20240307",
+        "claude-3-opus",
+        "claude-3-sonnet",
+        "claude-3-haiku",
+        # Claude 3.5 family (all versions except Sonnet 4.5)
+        "claude-3-5-sonnet-20240620",
+        "claude-3-5-sonnet-20241022",
+        "claude-3-5-sonnet",
+        "claude-3-5-haiku-20241022",
+        "claude-3-5-haiku-latest",
+        "claude-3-5-haiku",
+        # Claude Sonnet 4.x family (versions before 4.5)
+        "claude-sonnet-4-20250514",
+        "claude-sonnet-4",
+        # Claude Opus 4.x family (versions before 4.1)
+        # (Add any Opus 4.x models released before 4.1 if they exist)
+    }
+
     id: str = "claude-sonnet-4-5-20250929"
     name: str = "Claude"
     provider: str = "Anthropic"
@@ -99,6 +131,7 @@ class Claude(Model):
     api_key: Optional[str] = None
     default_headers: Optional[Dict[str, Any]] = None
     timeout: Optional[float] = None
+    http_client: Optional[Union[httpx.Client, httpx.AsyncClient]] = None
     client_params: Optional[Dict[str, Any]] = None
 
     client: Optional[AnthropicClient] = None
@@ -109,6 +142,9 @@ class Claude(Model):
         # Validate thinking support immediately at model creation
         if self.thinking:
             self._validate_thinking_support()
+        # Set structured outputs capability flag for supported models
+        if self._supports_structured_outputs():
+            self.supports_native_structured_outputs = True
         # Set up skills configuration if skills are enabled
         if self.skills:
             self._setup_skills_configuration()
@@ -132,13 +168,72 @@ class Claude(Model):
             client_params["default_headers"] = self.default_headers
         return client_params
 
-    def _has_beta_features(self) -> bool:
+    def _supports_structured_outputs(self) -> bool:
+        """
+        Check if the current model supports native structured outputs.
+
+        Returns:
+            bool: True if model supports structured outputs
+        """
+        # If model is in blacklist, it doesn't support structured outputs
+        if self.id in self.NON_STRUCTURED_OUTPUT_MODELS:
+            log_warning(
+                f"Model '{self.id}' does not support structured outputs. "
+                "Structured output features will not be available for this model."
+            )
+            return False
+
+        # Check for legacy model patterns that don't support structured outputs
+        if self.id.startswith("claude-3-"):
+            return False
+        if self.id.startswith("claude-sonnet-4-") and not self.id.startswith("claude-sonnet-4-5"):
+            return False
+        if self.id.startswith("claude-opus-4-") and not self.id.startswith("claude-opus-4-1"):
+            return False
+
+        return True
+
+    def _using_structured_outputs(
+        self,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> bool:
+        """
+        Check if structured outputs are being used in this request.
+
+        Args:
+            response_format: Response format parameter
+            tools: Tools list to check for strict mode
+
+        Returns:
+            bool: True if structured outputs are in use
+        """
+        # Check for output_format usage
+        if response_format is not None and self._supports_structured_outputs():
+            return True
+
+        # Check for strict tools
+        if tools:
+            for tool in tools:
+                if tool.get("type") == "function":
+                    func_def = tool.get("function", {})
+                    if func_def.get("strict") is True:
+                        return True
+
+        return False
+
+    def _has_beta_features(
+        self,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> bool:
         """Check if the model has any Anthropic beta features enabled."""
         return (
             self.mcp_servers is not None
             or self.context_management is not None
             or self.skills is not None
             or self.betas is not None
+            or self._using_structured_outputs(response_format, tools)
         )
 
     def get_client(self) -> AnthropicClient:
@@ -149,6 +244,16 @@ class Claude(Model):
             return self.client
 
         _client_params = self._get_client_params()
+        if self.http_client:
+            if isinstance(self.http_client, httpx.Client):
+                _client_params["http_client"] = self.http_client
+            else:
+                log_warning("http_client is not an instance of httpx.Client. Using default global httpx.Client.")
+                # Use global sync client when user http_client is invalid
+                _client_params["http_client"] = get_default_sync_client()
+        else:
+            # Use global sync client when no custom http_client is provided
+            _client_params["http_client"] = get_default_sync_client()
         self.client = AnthropicClient(**_client_params)
         return self.client
 
@@ -160,6 +265,18 @@ class Claude(Model):
             return self.async_client
 
         _client_params = self._get_client_params()
+        if self.http_client:
+            if isinstance(self.http_client, httpx.AsyncClient):
+                _client_params["http_client"] = self.http_client
+            else:
+                log_warning(
+                    "http_client is not an instance of httpx.AsyncClient. Using default global httpx.AsyncClient."
+                )
+                # Use global async client when user http_client is invalid
+                _client_params["http_client"] = get_default_async_client()
+        else:
+            # Use global async client when no custom http_client is provided
+            _client_params["http_client"] = get_default_async_client()
         self.async_client = AsyncAnthropicClient(**_client_params)
         return self.async_client
 
@@ -199,7 +316,70 @@ class Claude(Model):
                 if beta not in self.betas:
                     self.betas.append(beta)
 
-    def get_request_params(self) -> Dict[str, Any]:
+    def _ensure_additional_properties_false(self, schema: Dict[str, Any]) -> None:
+        """
+        Recursively ensure all object types have additionalProperties: false.
+        """
+        if isinstance(schema, dict):
+            if schema.get("type") == "object":
+                schema["additionalProperties"] = False
+
+            # Recursively process nested schemas
+            for key, value in schema.items():
+                if key in ["properties", "items", "allOf", "anyOf", "oneOf"]:
+                    if isinstance(value, dict):
+                        self._ensure_additional_properties_false(value)
+                    elif isinstance(value, list):
+                        for item in value:
+                            if isinstance(item, dict):
+                                self._ensure_additional_properties_false(item)
+
+    def _build_output_format(self, response_format: Optional[Union[Dict, Type[BaseModel]]]) -> Optional[Dict[str, Any]]:
+        """
+        Build Anthropic output_format parameter from response_format.
+
+        Args:
+            response_format: Pydantic model or dict format
+
+        Returns:
+            Dict with output_format structure or None
+        """
+        if response_format is None:
+            return None
+
+        if not self._supports_structured_outputs():
+            return None
+
+        # Handle Pydantic BaseModel
+        if isinstance(response_format, type) and issubclass(response_format, BaseModel):
+            try:
+                # Try to use Anthropic SDK's transform_schema helper if available
+                from anthropic import transform_schema
+
+                schema = transform_schema(response_format.model_json_schema())
+            except (ImportError, AttributeError):
+                # Fallback to direct schema conversion
+                schema = response_format.model_json_schema()
+                # Ensure additionalProperties is False
+                if isinstance(schema, dict):
+                    if "additionalProperties" not in schema:
+                        schema["additionalProperties"] = False
+                    # Recursively ensure all object types have additionalProperties: false
+                    self._ensure_additional_properties_false(schema)
+
+            return {"type": "json_schema", "schema": schema}
+
+        # Handle dict format (already in correct structure)
+        elif isinstance(response_format, dict):
+            return response_format
+
+        return None
+
+    def get_request_params(
+        self,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Dict[str, Any]:
         """
         Generate keyword arguments for API requests.
         """
@@ -220,8 +400,20 @@ class Claude(Model):
             _request_params["top_p"] = self.top_p
         if self.top_k:
             _request_params["top_k"] = self.top_k
-        if self.betas:
-            _request_params["betas"] = self.betas
+
+        # Build betas list - include existing betas and add new one if needed
+        betas_list = list(self.betas) if self.betas else []
+
+        # Add structured outputs beta header if using structured outputs
+        if self._using_structured_outputs(response_format, tools):
+            beta_header = "structured-outputs-2025-11-13"
+            if beta_header not in betas_list:
+                betas_list.append(beta_header)
+
+        # Include betas if any are present
+        if betas_list:
+            _request_params["betas"] = betas_list
+
         if self.context_management:
             _request_params["context_management"] = self.context_management
         if self.mcp_servers:
@@ -229,26 +421,51 @@ class Claude(Model):
                 {k: v for k, v in asdict(server).items() if v is not None} for server in self.mcp_servers
             ]
         if self.skills:
-            _request_params["betas"] = self.betas
             _request_params["container"] = {"skills": self.skills}
         if self.request_params:
             _request_params.update(self.request_params)
 
         return _request_params
 
+    def _validate_structured_outputs_usage(
+        self,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> None:
+        """
+        Validate that structured outputs are only used with supported models.
+
+        Raises:
+            ValueError: If structured outputs are used with unsupported model
+        """
+        if not self._using_structured_outputs(response_format, tools):
+            return
+
+        if not self._supports_structured_outputs():
+            raise ValueError(f"Model '{self.id}' does not support structured outputs.\n\n")
+
     def _prepare_request_kwargs(
-        self, system_message: str, tools: Optional[List[Dict[str, Any]]] = None
+        self,
+        system_message: str,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
     ) -> Dict[str, Any]:
         """
         Prepare the request keyword arguments for the API call.
 
         Args:
             system_message (str): The concatenated system messages.
+            tools: Optional list of tools
+            response_format: Optional response format (Pydantic model or dict)
 
         Returns:
             Dict[str, Any]: The request keyword arguments.
         """
-        request_kwargs = self.get_request_params().copy()
+        # Validate structured outputs usage
+        self._validate_structured_outputs_usage(response_format, tools)
+
+        # Pass response_format and tools to get_request_params for beta header handling
+        request_kwargs = self.get_request_params(response_format=response_format, tools=tools).copy()
         if system_message:
             if self.cache_system_prompt:
                 cache_control = (
@@ -269,9 +486,15 @@ class Claude(Model):
             else:
                 tools = [code_execution_tool]
 
+        # Format tools (this will handle strict mode)
         if tools:
             request_kwargs["tools"] = format_tools_for_model(tools)
 
+        # Build output_format if response_format is provided
+        output_format = self._build_output_format(response_format)
+        if output_format:
+            request_kwargs["output_format"] = output_format
+
         if request_kwargs:
             log_debug(f"Calling {self.provider} with request parameters: {request_kwargs}", log_level=2)
         return request_kwargs
@@ -293,9 +516,9 @@ class Claude(Model):
                 run_response.metrics.set_time_to_first_token()
 
             chat_messages, system_message = format_messages(messages)
-            request_kwargs = self._prepare_request_kwargs(system_message, tools)
+            request_kwargs = self._prepare_request_kwargs(system_message, tools=tools, response_format=response_format)
 
-            if self._has_beta_features():
+            if self._has_beta_features(response_format=response_format, tools=tools):
                 assistant_message.metrics.start_timer()
                 provider_response = self.get_client().beta.messages.create(
                     model=self.id,
@@ -356,14 +579,14 @@ class Claude(Model):
             APIStatusError: For other API-related errors
         """
         chat_messages, system_message = format_messages(messages)
-        request_kwargs = self._prepare_request_kwargs(system_message, tools)
+        request_kwargs = self._prepare_request_kwargs(system_message, tools=tools, response_format=response_format)
 
         try:
             if run_response and run_response.metrics:
                 run_response.metrics.set_time_to_first_token()
 
             # Beta features
-            if self._has_beta_features():
+            if self._has_beta_features(response_format=response_format, tools=tools):
                 assistant_message.metrics.start_timer()
                 with self.get_client().beta.messages.stream(
                     model=self.id,
@@ -371,7 +594,7 @@ class Claude(Model):
                     **request_kwargs,
                 ) as stream:
                     for chunk in stream:
-                        yield self._parse_provider_response_delta(chunk)  # type: ignore
+                        yield self._parse_provider_response_delta(chunk, response_format=response_format)  # type: ignore
             else:
                 assistant_message.metrics.start_timer()
                 with self.get_client().messages.stream(
@@ -380,7 +603,7 @@ class Claude(Model):
                     **request_kwargs,
                 ) as stream:
                     for chunk in stream:  # type: ignore
-                        yield self._parse_provider_response_delta(chunk)  # type: ignore
+                        yield self._parse_provider_response_delta(chunk, response_format=response_format)  # type: ignore
 
             assistant_message.metrics.stop_timer()
 
@@ -416,10 +639,10 @@ class Claude(Model):
                 run_response.metrics.set_time_to_first_token()
 
             chat_messages, system_message = format_messages(messages)
-            request_kwargs = self._prepare_request_kwargs(system_message, tools)
+            request_kwargs = self._prepare_request_kwargs(system_message, tools=tools, response_format=response_format)
 
             # Beta features
-            if self._has_beta_features():
+            if self._has_beta_features(response_format=response_format, tools=tools):
                 assistant_message.metrics.start_timer()
                 provider_response = await self.get_async_client().beta.messages.create(
                     model=self.id,
@@ -481,9 +704,9 @@ class Claude(Model):
                 run_response.metrics.set_time_to_first_token()
 
             chat_messages, system_message = format_messages(messages)
-            request_kwargs = self._prepare_request_kwargs(system_message, tools)
+            request_kwargs = self._prepare_request_kwargs(system_message, tools=tools, response_format=response_format)
 
-            if self._has_beta_features():
+            if self._has_beta_features(response_format=response_format, tools=tools):
                 assistant_message.metrics.start_timer()
                 async with self.get_async_client().beta.messages.stream(
                     model=self.id,
@@ -491,7 +714,7 @@ class Claude(Model):
                     **request_kwargs,
                 ) as stream:
                     async for chunk in stream:
-                        yield self._parse_provider_response_delta(chunk)  # type: ignore
+                        yield self._parse_provider_response_delta(chunk, response_format=response_format)  # type: ignore
             else:
                 assistant_message.metrics.start_timer()
                 async with self.get_async_client().messages.stream(
@@ -500,7 +723,7 @@ class Claude(Model):
                     **request_kwargs,
                 ) as stream:
                     async for chunk in stream:  # type: ignore
-                        yield self._parse_provider_response_delta(chunk)  # type: ignore
+                        yield self._parse_provider_response_delta(chunk, response_format=response_format)  # type: ignore
 
             assistant_message.metrics.stop_timer()
 
@@ -525,12 +748,18 @@ class Claude(Model):
             return tool_call_prompt
         return None
 
-    def _parse_provider_response(self, response: Union[AnthropicMessage, BetaMessage], **kwargs) -> ModelResponse:
+    def _parse_provider_response(
+        self,
+        response: Union[AnthropicMessage, BetaMessage],
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        **kwargs,
+    ) -> ModelResponse:
         """
         Parse the Claude response into a ModelResponse.
 
         Args:
             response: Raw response from Anthropic
+            response_format: Optional response format for structured output parsing
 
         Returns:
             ModelResponse: Parsed response data
@@ -543,10 +772,32 @@ class Claude(Model):
         if response.content:
             for block in response.content:
                 if block.type == "text":
+                    text_content = block.text
+
                     if model_response.content is None:
-                        model_response.content = block.text
+                        model_response.content = text_content
                     else:
-                        model_response.content += block.text
+                        model_response.content += text_content
+
+                    # Handle structured outputs (JSON outputs)
+                    if (
+                        response_format is not None
+                        and isinstance(response_format, type)
+                        and issubclass(response_format, BaseModel)
+                    ):
+                        if text_content:
+                            try:
+                                # Parse JSON from text content
+                                parsed_data = json.loads(text_content)
+                                # Validate against Pydantic model
+                                model_response.parsed = response_format.model_validate(parsed_data)
+                                log_debug(f"Successfully parsed structured output: {model_response.parsed}")
+                            except json.JSONDecodeError as e:
+                                log_warning(f"Failed to parse JSON from structured output: {e}")
+                            except ValidationError as e:
+                                log_warning(f"Failed to validate structured output against schema: {e}")
+                            except Exception as e:
+                                log_warning(f"Unexpected error parsing structured output: {e}")
 
                     # Capture citations from the response
                     if block.citations is not None:
@@ -634,24 +885,29 @@ class Claude(Model):
             ContentBlockStopEvent,
             MessageStopEvent,
             BetaRawContentBlockDeltaEvent,
+            BetaRawContentBlockStartEvent,
+            ParsedBetaContentBlockStopEvent,
+            ParsedBetaMessageStopEvent,
         ],
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
     ) -> ModelResponse:
         """
         Parse the Claude streaming response into ModelProviderResponse objects.
 
         Args:
             response: Raw response chunk from Anthropic
+            response_format: Optional response format for structured output parsing
 
         Returns:
             ModelResponse: Iterator of parsed response data
         """
         model_response = ModelResponse()
 
-        if isinstance(response, ContentBlockStartEvent):
+        if isinstance(response, (ContentBlockStartEvent, BetaRawContentBlockStartEvent)):
             if response.content_block.type == "redacted_reasoning_content":
                 model_response.redacted_reasoning_content = response.content_block.data
 
-        if isinstance(response, ContentBlockDeltaEvent):
+        if isinstance(response, (ContentBlockDeltaEvent, BetaRawContentBlockDeltaEvent)):
             # Handle text content
             if response.delta.type == "text_delta":
                 model_response.content = response.delta.text
@@ -663,7 +919,7 @@ class Claude(Model):
                     "signature": response.delta.signature,
                 }
 
-        elif isinstance(response, ContentBlockStopEvent):
+        elif isinstance(response, (ContentBlockStopEvent, ParsedBetaContentBlockStopEvent)):
             if response.content_block.type == "tool_use":  # type: ignore
                 tool_use = response.content_block  # type: ignore
                 tool_name = tool_use.name
@@ -683,11 +939,24 @@ class Claude(Model):
                     }
                 ]
 
-        # Capture citations from the final response
-        elif isinstance(response, MessageStopEvent):
+        # Capture citations from the final response and handle structured outputs
+        elif isinstance(response, (MessageStopEvent, ParsedBetaMessageStopEvent)):
+            # In streaming mode, content has already been emitted via ContentBlockDeltaEvent chunks
+            # Setting content here would cause duplication since _populate_stream_data accumulates with +=
+            # Keep content empty to avoid duplication
             model_response.content = ""
             model_response.citations = Citations(raw=[], urls=[], documents=[])
+
+            # Accumulate text content for structured output parsing (but don't set model_response.content)
+            # The text was already streamed via ContentBlockDeltaEvent chunks
+            accumulated_text = ""
+
             for block in response.message.content:  # type: ignore
+                # Handle text blocks for structured output parsing
+                if block.type == "text":
+                    accumulated_text += block.text
+
+                # Handle citations
                 citations = getattr(block, "citations", None)
                 if not citations:
                     continue
@@ -702,6 +971,28 @@ class Claude(Model):
                             DocumentCitation(document_title=citation.document_title, cited_text=citation.cited_text)
                         )
 
+            # Handle structured outputs (JSON outputs) from accumulated text
+            # Note: We parse from accumulated_text but don't set model_response.content to avoid duplication
+            # The content was already streamed via ContentBlockDeltaEvent chunks
+            if (
+                response_format is not None
+                and isinstance(response_format, type)
+                and issubclass(response_format, BaseModel)
+            ):
+                if accumulated_text:
+                    try:
+                        # Parse JSON from accumulated text content
+                        parsed_data = json.loads(accumulated_text)
+                        # Validate against Pydantic model
+                        model_response.parsed = response_format.model_validate(parsed_data)
+                        log_debug(f"Successfully parsed structured output from stream: {model_response.parsed}")
+                    except json.JSONDecodeError as e:
+                        log_warning(f"Failed to parse JSON from structured output in stream: {e}")
+                    except ValidationError as e:
+                        log_warning(f"Failed to validate structured output against schema in stream: {e}")
+                    except Exception as e:
+                        log_warning(f"Unexpected error parsing structured output in stream: {e}")
+
             # Capture context management information if present
             if self.context_management is not None and hasattr(response.message, "context_management"):  # type: ignore
                 context_mgmt = response.message.context_management  # type: ignore

agno/models/aws/claude.py

@@ -2,6 +2,7 @@ from dataclasses import dataclass
 from os import getenv
 from typing import Any, AsyncIterator, Dict, Iterator, List, Optional, Type, Union
 
+import httpx
 from pydantic import BaseModel
 
 from agno.exceptions import ModelProviderError, ModelRateLimitError
@@ -9,6 +10,7 @@ from agno.models.anthropic import Claude as AnthropicClaude
 from agno.models.message import Message
 from agno.models.response import ModelResponse
 from agno.run.agent import RunOutput
+from agno.utils.http import get_default_async_client, get_default_sync_client
 from agno.utils.log import log_debug, log_error, log_warning
 from agno.utils.models.claude import format_messages
 
@@ -99,9 +101,23 @@ class Claude(AnthropicClaude):
                 "aws_region": self.aws_region,
             }
 
+        if self.timeout is not None:
+            client_params["timeout"] = self.timeout
+
         if self.client_params:
             client_params.update(self.client_params)
 
+        if self.http_client:
+            if isinstance(self.http_client, httpx.Client):
+                client_params["http_client"] = self.http_client
+            else:
+                log_warning("http_client is not an instance of httpx.Client. Using default global httpx.Client.")
+                # Use global sync client when user http_client is invalid
+                client_params["http_client"] = get_default_sync_client()
+        else:
+            # Use global sync client when no custom http_client is provided
+            client_params["http_client"] = get_default_sync_client()
+
         self.client = AnthropicBedrock(
             **client_params,  # type: ignore
         )
@@ -132,9 +148,25 @@ class Claude(AnthropicClaude):
                 "aws_region": self.aws_region,
             }
 
+        if self.timeout is not None:
+            client_params["timeout"] = self.timeout
+
         if self.client_params:
             client_params.update(self.client_params)
 
+        if self.http_client:
+            if isinstance(self.http_client, httpx.AsyncClient):
+                client_params["http_client"] = self.http_client
+            else:
+                log_warning(
+                    "http_client is not an instance of httpx.AsyncClient. Using default global httpx.AsyncClient."
+                )
+                # Use global async client when user http_client is invalid
+                client_params["http_client"] = get_default_async_client()
+        else:
+            # Use global async client when no custom http_client is provided
+            client_params["http_client"] = get_default_async_client()
+
         self.async_client = AsyncAnthropicBedrock(
             **client_params,  # type: ignore
         )