fix: linting

Author: dbschmigelski

src/strands/tools/decorator.py

@@ -61,7 +61,7 @@ def my_tool(param1: str, param2: int = 42) -> dict:
 from pydantic import BaseModel, Field, create_model
 from typing_extensions import override
 
-from ..types.tools import AgentTool, JSONSchema, ToolGenerator, ToolSpec, ToolUse, StrandsContext
+from ..types.tools import AgentTool, JSONSchema, StrandsContext, ToolGenerator, ToolSpec, ToolUse
 
 logger = logging.getLogger(__name__)
 
@@ -107,22 +107,6 @@ def __init__(self, func: Callable[..., Any]) -> None:
         # Create a Pydantic model for validation
         self.input_model = self._create_input_model()
 
-    def _is_special_parameter(self, param_name: str) -> bool:
-        """Check if a parameter should be automatically injected by the framework.
-        
-        Special parameters include:
-        - Standard Python parameters: self, cls
-        - Framework-provided context parameters: agent, strands_context
-        
-        Args:
-            param_name: The name of the parameter to check.
-            
-        Returns:
-            True if the parameter should be excluded from input validation and 
-            automatically injected during tool execution.
-        """
-        return param_name in {"self", "cls", "agent", "strands_context"}
-
     def _create_input_model(self) -> Type[BaseModel]:
         """Create a Pydantic model from function signature for input validation.
 
@@ -159,6 +143,22 @@ def _create_input_model(self) -> Type[BaseModel]:
             # Handle case with no parameters
             return create_model(model_name)
 
+    def _is_special_parameter(self, param_name: str) -> bool:
+        """Check if a parameter should be automatically injected by the framework.
+
+        Special parameters include:
+        - Standard Python parameters: self, cls
+        - Framework-provided context parameters: agent, strands_context
+
+        Args:
+            param_name: The name of the parameter to check.
+
+        Returns:
+            True if the parameter should be excluded from input validation and
+            automatically injected during tool execution.
+        """
+        return param_name in {"self", "cls", "agent", "strands_context"}
+
     def extract_metadata(self) -> ToolSpec:
         """Extract metadata from the function to create a tool specification.
 
@@ -272,10 +272,10 @@ def _inject_special_parameters(
         self, validated_input: dict[str, Any], tool_use: ToolUse, invocation_state: dict[str, Any]
     ) -> None:
         """Inject special framework-provided parameters into the validated input.
-        
+
         This method automatically provides framework-level context to tools that request it
         through their function signature.
-        
+
         Args:
             validated_input: The validated input parameters (modified in place).
             tool_use: The tool use request containing tool invocation details.
@@ -288,7 +288,7 @@ def _inject_special_parameters(
                 "invocation_state": invocation_state,
             }
             validated_input["strands_context"] = strands_context
-            
+
         # Inject agent if requested (backward compatibility)
         if "agent" in self.signature.parameters and "agent" in invocation_state:
             validated_input["agent"] = invocation_state["agent"]

src/strands/types/tools.py

@@ -119,15 +119,15 @@ class ToolChoiceTool(TypedDict):
 
 class StrandsContext(TypedDict, total=False):
     """Context object containing framework-provided data for decorated tools.
-    
+
     This object provides access to framework-level information that may be useful
     for tool implementations. All fields are optional to maintain backward compatibility.
-    
+
     Attributes:
         tool_use: The complete ToolUse object containing tool invocation details.
         invocation_state: Context for the tool invocation, including agent state.
     """
-    
+
     tool_use: ToolUse
     invocation_state: dict[str, Any]
 

tests/strands/tools/test_decorator.py

@@ -8,7 +8,7 @@
 import pytest
 
 import strands
-from strands.types.tools import ToolUse, StrandsContext
+from strands.types.tools import StrandsContext, ToolUse
 
 
 @pytest.fixture(scope="module")
@@ -1041,36 +1041,34 @@ def complex_schema_tool(union_param: Union[List[int], Dict[str, Any], str, None]
 @pytest.mark.asyncio
 async def test_strands_context_injection(alist):
     """Test that StrandsContext is properly injected into tools that request it."""
-    
+
     @strands.tool
     def context_tool(message: str, strands_context: StrandsContext) -> dict:
         """Tool that uses StrandsContext to access tool_use_id."""
         tool_use_id = strands_context["tool_use"]["toolUseId"]
         tool_name = strands_context["tool_use"]["name"]
         agent_info = strands_context["invocation_state"].get("agent", "no-agent")
-        
+
         return {
             "status": "success",
-            "content": [{"text": f"Tool '{tool_name}' (ID: {tool_use_id}) with agent '{agent_info}' processed: {message}"}]
+            "content": [
+                {"text": f"Tool '{tool_name}' (ID: {tool_use_id}) with agent '{agent_info}' processed: {message}"}
+            ],
         }
-    
+
     # Test tool use with context injection
-    tool_use = {
-        "toolUseId": "test-context-123",
-        "name": "context_tool", 
-        "input": {"message": "hello world"}
-    }
+    tool_use = {"toolUseId": "test-context-123", "name": "context_tool", "input": {"message": "hello world"}}
     invocation_state = {"agent": "test-agent"}
-    
+
     stream = context_tool.stream(tool_use, invocation_state)
     result = (await alist(stream))[-1]
-    
+
     assert result["status"] == "success"
     assert result["toolUseId"] == "test-context-123"
     assert "Tool 'context_tool' (ID: test-context-123)" in result["content"][0]["text"]
     assert "with agent 'test-agent'" in result["content"][0]["text"]
     assert "processed: hello world" in result["content"][0]["text"]
-    
+
     # Verify strands_context is excluded from schema
     tool_spec = context_tool.tool_spec
     schema_properties = tool_spec["inputSchema"]["json"].get("properties", {})

tests_integ/test_strands_context_integration.py

@@ -4,7 +4,8 @@
 """
 
 import logging
-from strands import Agent, tool, StrandsContext
+
+from strands import Agent, StrandsContext, tool
 
 logging.getLogger("strands").setLevel(logging.DEBUG)
 logging.basicConfig(format="%(levelname)s | %(name)s | %(message)s", handlers=[logging.StreamHandler()])
@@ -14,33 +15,30 @@
 def tool_with_context(message: str, strands_context: StrandsContext) -> dict:
     """Tool that uses StrandsContext to access tool_use_id."""
     tool_use_id = strands_context["tool_use"]["toolUseId"]
-    return {
-        "status": "success",
-        "content": [{"text": f"Context tool processed '{message}' with ID: {tool_use_id}"}]
-    }
+    return {"status": "success", "content": [{"text": f"Context tool processed '{message}' with ID: {tool_use_id}"}]}
 
 
 @tool
 def tool_with_agent_and_context(message: str, agent, strands_context: StrandsContext) -> dict:
     """Tool that uses both agent and StrandsContext."""
     tool_use_id = strands_context["tool_use"]["toolUseId"]
-    agent_name = getattr(agent, 'name', 'unknown-agent')
+    agent_name = getattr(agent, "name", "unknown-agent")
     return {
-        "status": "success", 
-        "content": [{"text": f"Agent '{agent_name}' processed '{message}' with ID: {tool_use_id}"}]
+        "status": "success",
+        "content": [{"text": f"Agent '{agent_name}' processed '{message}' with ID: {tool_use_id}"}],
     }
 
 
 def test_strands_context_integration():
     """Test StrandsContext functionality with real agent interactions."""
-    
+
     # Initialize agent with tools
     agent = Agent(tools=[tool_with_context, tool_with_agent_and_context])
-    
+
     # Test tool with StrandsContext
     result1 = agent.tool.tool_with_context(message="hello world")
     assert result1.get("status") == "success"
-    
+
     # Test tool with both agent and StrandsContext
     result = agent.tool.tool_with_agent_and_context(message="hello agent")
     assert result.get("status") == "success"