fix: formatting and linting

Author: dbschmigelski

src/strands/models/bedrock.py

@@ -136,18 +136,11 @@ def __init__(
             else:
                 new_user_agent = "strands-agents"
 
-            client_config = boto_client_config.merge(
-                BotocoreConfig(user_agent_extra=new_user_agent)
-            )
+            client_config = boto_client_config.merge(BotocoreConfig(user_agent_extra=new_user_agent))
         else:
             client_config = BotocoreConfig(user_agent_extra="strands-agents")
 
-        resolved_region = (
-            region_name
-            or session.region_name
-            or os.environ.get("AWS_REGION")
-            or DEFAULT_BEDROCK_REGION
-        )
+        resolved_region = region_name or session.region_name or os.environ.get("AWS_REGION") or DEFAULT_BEDROCK_REGION
 
         self.client = session.client(
             service_name="bedrock-runtime",
@@ -156,9 +149,7 @@ def __init__(
             region_name=resolved_region,
         )
 
-        logger.debug(
-            "region=<%s> | bedrock client created", self.client.meta.region_name
-        )
+        logger.debug("region=<%s> | bedrock client created", self.client.meta.region_name)
 
     @override
     def update_config(self, **model_config: Unpack[BedrockConfig]) -> None:  # type: ignore
@@ -199,11 +190,7 @@ def format_request(
             "messages": self._format_bedrock_messages(messages),
             "system": [
                 *([{"text": system_prompt}] if system_prompt else []),
-                *(
-                    [{"cachePoint": {"type": self.config["cache_prompt"]}}]
-                    if self.config.get("cache_prompt")
-                    else []
-                ),
+                *([{"cachePoint": {"type": self.config["cache_prompt"]}}] if self.config.get("cache_prompt") else []),
             ],
             **(
                 {
@@ -223,20 +210,12 @@ def format_request(
                 else {}
             ),
             **(
-                {
-                    "additionalModelRequestFields": self.config[
-                        "additional_request_fields"
-                    ]
-                }
+                {"additionalModelRequestFields": self.config["additional_request_fields"]}
                 if self.config.get("additional_request_fields")
                 else {}
             ),
             **(
-                {
-                    "additionalModelResponseFieldPaths": self.config[
-                        "additional_response_field_paths"
-                    ]
-                }
+                {"additionalModelResponseFieldPaths": self.config["additional_response_field_paths"]}
                 if self.config.get("additional_response_field_paths")
                 else {}
             ),
@@ -247,18 +226,13 @@ def format_request(
                         "guardrailVersion": self.config["guardrail_version"],
                         "trace": self.config.get("guardrail_trace", "enabled"),
                         **(
-                            {
-                                "streamProcessingMode": self.config.get(
-                                    "guardrail_stream_processing_mode"
-                                )
-                            }
+                            {"streamProcessingMode": self.config.get("guardrail_stream_processing_mode")}
                             if self.config.get("guardrail_stream_processing_mode")
                             else {}
                         ),
                     }
                 }
-                if self.config.get("guardrail_id")
-                and self.config.get("guardrail_version")
+                if self.config.get("guardrail_id") and self.config.get("guardrail_version")
                 else {}
             ),
             "inferenceConfig": {
@@ -273,14 +247,11 @@ def format_request(
             },
             **(
                 self.config["additional_args"]
-                if "additional_args" in self.config
-                and self.config["additional_args"] is not None
+                if "additional_args" in self.config and self.config["additional_args"] is not None
                 else {}
             ),
         }
 
-
-
     def _format_bedrock_messages(self, messages: Messages) -> Messages:
         """Format messages for Bedrock API compatibility.
 
@@ -312,7 +283,7 @@ def _format_bedrock_messages(self, messages: Messages) -> Messages:
                 # DeepSeek models have issues with reasoningContent
                 if is_deepseek and "reasoningContent" in content_block:
                     continue
-                    
+
                 if "toolResult" in content_block:
                     # Create a new content block with only the cleaned toolResult
                     tool_result: ToolResult = content_block["toolResult"]
@@ -332,9 +303,7 @@ def _format_bedrock_messages(self, messages: Messages) -> Messages:
 
             # Create new message with cleaned content (skip if empty for DeepSeek)
             if cleaned_content:
-                cleaned_message: Message = Message(
-                    content=cleaned_content, role=message["role"]
-                )
+                cleaned_message: Message = Message(content=cleaned_content, role=message["role"])
                 cleaned_messages.append(cleaned_message)
 
         return cleaned_messages
@@ -352,17 +321,11 @@ def _has_blocked_guardrail(self, guardrail_data: dict[str, Any]) -> bool:
         output_assessments = guardrail_data.get("outputAssessments", {})
 
         # Check input assessments
-        if any(
-            self._find_detected_and_blocked_policy(assessment)
-            for assessment in input_assessment.values()
-        ):
+        if any(self._find_detected_and_blocked_policy(assessment) for assessment in input_assessment.values()):
             return True
 
         # Check output assessments
-        if any(
-            self._find_detected_and_blocked_policy(assessment)
-            for assessment in output_assessments.values()
-        ):
+        if any(self._find_detected_and_blocked_policy(assessment) for assessment in output_assessments.values()):
             return True
 
         return False
@@ -437,9 +400,7 @@ def callback(event: Optional[StreamEvent] = None) -> None:
         loop = asyncio.get_event_loop()
         queue: asyncio.Queue[Optional[StreamEvent]] = asyncio.Queue()
 
-        thread = asyncio.to_thread(
-            self._stream, callback, messages, tool_specs, system_prompt
-        )
+        thread = asyncio.to_thread(self._stream, callback, messages, tool_specs, system_prompt)
         task = asyncio.create_task(thread)
 
         while True:
@@ -451,8 +412,6 @@ def callback(event: Optional[StreamEvent] = None) -> None:
 
         await task
 
-
-
     def _stream(
         self,
         callback: Callable[..., None],
@@ -538,10 +497,7 @@ def _stream(
             if e.response["Error"]["Code"] == "ThrottlingException":
                 raise ModelThrottledException(error_message) from e
 
-            if any(
-                overflow_message in error_message
-                for overflow_message in BEDROCK_CONTEXT_WINDOW_OVERFLOW_MESSAGES
-            ):
+            if any(overflow_message in error_message for overflow_message in BEDROCK_CONTEXT_WINDOW_OVERFLOW_MESSAGES):
                 logger.warning("bedrock threw context window overflow error")
                 raise ContextWindowOverflowException(e) from e
 
@@ -577,9 +533,7 @@ def _stream(
             callback()
             logger.debug("finished streaming response from model")
 
-    def _convert_non_streaming_to_streaming(
-        self, response: dict[str, Any]
-    ) -> Iterable[StreamEvent]:
+    def _convert_non_streaming_to_streaming(self, response: dict[str, Any]) -> Iterable[StreamEvent]:
         """Convert a non-streaming response to the streaming format.
 
         Args:
@@ -609,9 +563,7 @@ def _convert_non_streaming_to_streaming(
                 # For tool use, we need to yield the input as a delta
                 input_value = json.dumps(content["toolUse"]["input"])
 
-                yield {
-                    "contentBlockDelta": {"delta": {"toolUse": {"input": input_value}}}
-                }
+                yield {"contentBlockDelta": {"delta": {"toolUse": {"input": input_value}}}}
             elif "text" in content:
                 # Then yield the text as a delta
                 yield {
@@ -623,13 +575,7 @@ def _convert_non_streaming_to_streaming(
                 # Then yield the reasoning content as a delta
                 yield {
                     "contentBlockDelta": {
-                        "delta": {
-                            "reasoningContent": {
-                                "text": content["reasoningContent"]["reasoningText"][
-                                    "text"
-                                ]
-                            }
-                        }
+                        "delta": {"reasoningContent": {"text": content["reasoningContent"]["reasoningText"]["text"]}}
                     }
                 }
 
@@ -638,9 +584,7 @@ def _convert_non_streaming_to_streaming(
                         "contentBlockDelta": {
                             "delta": {
                                 "reasoningContent": {
-                                    "signature": content["reasoningContent"][
-                                        "reasoningText"
-                                    ]["signature"]
+                                    "signature": content["reasoningContent"]["reasoningText"]["signature"]
                                 }
                             }
                         }
@@ -707,11 +651,7 @@ def _find_detected_and_blocked_policy(self, input: Any) -> bool:
         # Check if input is a dictionary
         if isinstance(input, dict):
             # Check if current dictionary has action: BLOCKED and detected: true
-            if (
-                input.get("action") == "BLOCKED"
-                and input.get("detected")
-                and isinstance(input.get("detected"), bool)
-            ):
+            if input.get("action") == "BLOCKED" and input.get("detected") and isinstance(input.get("detected"), bool):
                 return True
 
             # Recursively check all values in the dictionary
@@ -762,9 +702,7 @@ async def structured_output(
         stop_reason, messages, _, _ = event["stop"]
 
         if stop_reason != "tool_use":
-            raise ValueError(
-                f'Model returned stop_reason: {stop_reason} instead of "tool_use".'
-            )
+            raise ValueError(f'Model returned stop_reason: {stop_reason} instead of "tool_use".')
 
         content = messages["content"]
         output_response: dict[str, Any] | None = None
@@ -777,8 +715,6 @@ async def structured_output(
                 continue
 
         if output_response is None:
-            raise ValueError(
-                "No valid tool use or tool use input was found in the Bedrock response."
-            )
+            raise ValueError("No valid tool use or tool use input was found in the Bedrock response.")
 
         yield {"output": output_model(**output_response)}

src/strands/tools/registry.py

@@ -192,9 +192,9 @@ def register_tool(self, tool: AgentTool) -> None:
 
         # Check duplicate tool name, throw on duplicate tool names except if hot_reloading is enabled
         if tool.tool_name in self.registry and not tool.supports_hot_reload:
-                raise ValueError(
-                    f"Tool name '{tool.tool_name}' already exists. Cannot register tools with exact same name."
-                )
+            raise ValueError(
+                f"Tool name '{tool.tool_name}' already exists. Cannot register tools with exact same name."
+            )
 
         # Check for normalized name conflicts (- vs _)
         if self.registry.get(tool.tool_name) is None:

tests/strands/models/test_bedrock.py

@@ -1307,63 +1307,50 @@ def test_format_request_cleans_tool_result_content_blocks(model, model_id):
 async def test_stream_deepseek_filters_reasoning_content(bedrock_client, alist):
     """Test that DeepSeek models filter reasoningContent from messages during streaming."""
     model = BedrockModel(model_id="us.deepseek.r1-v1:0")
-    
+
     messages = [
+        {"role": "user", "content": [{"text": "Hello"}]},
         {
-            "role": "user",
-            "content": [{"text": "Hello"}]
-        },
-        {
-            "role": "assistant", 
+            "role": "assistant",
             "content": [
                 {"text": "Response"},
                 {"reasoningContent": {"reasoningText": {"text": "Thinking..."}}},
-            ]
-        }
+            ],
+        },
     ]
-    
+
     bedrock_client.converse_stream.return_value = {"stream": []}
-    
+
     await alist(model.stream(messages))
-    
+
     # Verify the request was made with filtered messages (no reasoningContent)
     call_args = bedrock_client.converse_stream.call_args[1]
     sent_messages = call_args["messages"]
-    
+
     assert len(sent_messages) == 2
     assert sent_messages[0]["content"] == [{"text": "Hello"}]
     assert sent_messages[1]["content"] == [{"text": "Response"}]
 
+
 @pytest.mark.asyncio
 async def test_stream_deepseek_skips_empty_messages(bedrock_client, alist):
     """Test that DeepSeek models skip messages that would be empty after filtering reasoningContent."""
     model = BedrockModel(model_id="us.deepseek.r1-v1:0")
-    
+
     messages = [
-        {
-            "role": "user",
-            "content": [{"text": "Hello"}]
-        },
-        {
-            "role": "assistant", 
-            "content": [
-                {"reasoningContent": {"reasoningText": {"text": "Only reasoning..."}}}
-            ]
-        },
-        {
-            "role": "user",
-            "content": [{"text": "Follow up"}]
-        }
+        {"role": "user", "content": [{"text": "Hello"}]},
+        {"role": "assistant", "content": [{"reasoningContent": {"reasoningText": {"text": "Only reasoning..."}}}]},
+        {"role": "user", "content": [{"text": "Follow up"}]},
     ]
-    
+
     bedrock_client.converse_stream.return_value = {"stream": []}
-    
+
     await alist(model.stream(messages))
-    
+
     # Verify the request was made with only non-empty messages
     call_args = bedrock_client.converse_stream.call_args[1]
     sent_messages = call_args["messages"]
-    
+
     assert len(sent_messages) == 2
     assert sent_messages[0]["content"] == [{"text": "Hello"}]
-    assert sent_messages[1]["content"] == [{"text": "Follow up"}]
+    assert sent_messages[1]["content"] == [{"text": "Follow up"}]