fix: bug referencing wrong variable

Author: dbschmigelski

src/strands/tools/decorator.py

@@ -268,7 +268,7 @@ def validate_input(self, input_data: dict[str, Any]) -> dict[str, Any]:
             error_msg = str(e)
             raise ValueError(f"Validation failed for input parameters: {error_msg}") from e
 
-    def _inject_special_parameters(
+    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.
@@ -444,7 +444,7 @@ async def stream(self, tool_use: ToolUse, invocation_state: dict[str, Any], **kw
             validated_input = self._metadata.validate_input(tool_input)
 
             # Inject special framework-provided parameters
-            self._metadata._inject_special_parameters(validated_input, tool_use, invocation_state)
+            self._metadata.inject_special_parameters(validated_input, tool_use, invocation_state)
 
             # "Too few arguments" expected, hence the type ignore
             if inspect.iscoroutinefunction(self._tool_func):

tests/strands/tools/test_decorator.py

@@ -8,6 +8,7 @@
 import pytest
 
 import strands
+from strands import Agent
 from strands.types.tools import StrandsContext, ToolUse
 
 
@@ -1043,7 +1044,7 @@ 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:
+    def context_tool(message: str, agent: Agent, 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"]
@@ -1052,7 +1053,13 @@ def context_tool(message: str, strands_context: StrandsContext) -> dict:
         return {
             "status": "success",
             "content": [
-                {"text": f"Tool '{tool_name}' (ID: {tool_use_id}) with agent '{agent_info}' processed: {message}"}
+                {
+                    "text": f"""
+			Tool '{tool_name}' (ID: {tool_use_id}) 
+			with agent '{agent_info}' 
+                        and injected agent '{agent}' processed: {message}
+                     """
+                }
             ],
         }
 
@@ -1067,10 +1074,12 @@ def context_tool(message: str, strands_context: StrandsContext) -> dict:
     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 "and injected agent 'test-agent'" in result["content"][0]["text"]
     assert "processed: hello world" in result["content"][0]["text"]
 
-    # Verify strands_context is excluded from schema
+    # Verify strands_context and agent are excluded from schema
     tool_spec = context_tool.tool_spec
     schema_properties = tool_spec["inputSchema"]["json"].get("properties", {})
     assert "message" in schema_properties
     assert "strands_context" not in schema_properties
+    assert "agent" not in schema_properties

tests_integ/test_strands_context_integration.py

@@ -14,31 +14,91 @@
 @tool
 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}"}]}
+    try:
+        print(f"DEBUG: tool_with_context called with message='{message}'")
+        print(f"DEBUG: strands_context type: {type(strands_context)}")
+        print(f"DEBUG: strands_context contents: {strands_context}")
+
+        tool_use_id = strands_context["tool_use"]["toolUseId"]
+        print(f"DEBUG: Successfully extracted tool_use_id: {tool_use_id}")
+
+        result = {
+            "status": "success",
+            "content": [{"text": f"Context tool processed '{message}' with ID: {tool_use_id}"}],
+        }
+        print(f"DEBUG: Returning result: {result}")
+        return result
+
+    except Exception as e:
+        print(f"ERROR in tool_with_context: {type(e).__name__}: {e}")
+        print(f"ERROR: strands_context = {strands_context}")
+        import traceback
+
+        traceback.print_exc()
+        return {"status": "error", "content": [{"text": f"Error: {str(e)}"}]}
 
 
 @tool
-def tool_with_agent_and_context(message: str, agent, strands_context: StrandsContext) -> dict:
+def tool_with_agent_and_context(message: str, agent: 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")
-    return {
-        "status": "success",
-        "content": [{"text": f"Agent '{agent_name}' processed '{message}' with ID: {tool_use_id}"}],
-    }
+    try:
+        print(f"DEBUG: tool_with_agent_and_context called with message='{message}'")
+        print(f"DEBUG: agent type: {type(agent)}")
+        print(f"DEBUG: strands_context type: {type(strands_context)}")
+        print(f"DEBUG: strands_context contents: {strands_context}")
+
+        tool_use_id = strands_context["tool_use"]["toolUseId"]
+        print(f"DEBUG: Successfully extracted tool_use_id: {tool_use_id}")
+
+        agent_name = getattr(agent, "name", "unknown-agent")
+        print(f"DEBUG: Agent name: {agent_name}")
+
+        result = {
+            "status": "success",
+            "content": [{"text": f"Agent '{agent_name}' processed '{message}' with ID: {tool_use_id}"}],
+        }
+        print(f"DEBUG: Returning result: {result}")
+        return result
+
+    except Exception as e:
+        print(f"ERROR in tool_with_agent_and_context: {type(e).__name__}: {e}")
+        print(f"ERROR: agent = {agent}")
+        print(f"ERROR: strands_context = {strands_context}")
+        import traceback
+
+        traceback.print_exc()
+        return {"status": "error", "content": [{"text": f"Error: {str(e)}"}]}
 
 
 def test_strands_context_integration():
     """Test StrandsContext functionality with real agent interactions."""
+    try:
+        print("DEBUG: Starting test_strands_context_integration")
+
+        # Initialize agent with tools
+        print("DEBUG: Initializing agent with tools")
+        agent = Agent(tools=[tool_with_context, tool_with_agent_and_context])
+        print(f"DEBUG: Agent created: {agent}")
+
+        # Test tool with StrandsContext
+        print("DEBUG: Testing tool_with_context")
+        result1 = agent.tool.tool_with_context(message="hello world")
+        print(f"DEBUG: tool_with_context result: {result1}")
+        assert result1.get("status") == "success"
+        print("DEBUG: tool_with_context assertion passed")
+
+        # Test tool with both agent and StrandsContext
+        print("DEBUG: Testing tool_with_agent_and_context")
+        result = agent.tool.tool_with_agent_and_context(message="hello agent")
+        print(f"DEBUG: tool_with_agent_and_context result: {result}")
+        assert result.get("status") == "success"
+        print("DEBUG: tool_with_agent_and_context assertion passed")
 
-    # Initialize agent with tools
-    agent = Agent(tools=[tool_with_context, tool_with_agent_and_context])
+        print("DEBUG: All tests passed successfully")
 
-    # Test tool with StrandsContext
-    result1 = agent.tool.tool_with_context(message="hello world")
-    assert result1.get("status") == "success"
+    except Exception as e:
+        print(f"ERROR in test_strands_context_integration: {type(e).__name__}: {e}")
+        import traceback
 
-    # Test tool with both agent and StrandsContext
-    result = agent.tool.tool_with_agent_and_context(message="hello agent")
-    assert result.get("status") == "success"
+        traceback.print_exc()
+        raise