Aligning Python implementation with TS

Author: leandrodamascena

aws_lambda_powertools/event_handler/bedrock_agent_function.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import inspect
+import logging
 import warnings
 from collections.abc import Callable
 from typing import Any, Literal, TypeVar
@@ -11,6 +12,8 @@
 # Define a generic type for the function
 T = TypeVar("T", bound=Callable[..., Any])
 
+logger = logging.getLogger(__name__)
+
 
 class BedrockFunctionResponse:
     """Response class for Bedrock Agent Functions.
@@ -156,6 +159,9 @@ def tool(
 
         def decorator(func: T) -> T:
             function_name = name or func.__name__
+
+            logger.debug(f"Registering {function_name} tool")
+
             if function_name in self._tools:
                 warnings.warn(
                     f"Tool '{function_name}' already registered. Overwriting with new definition.",
@@ -186,9 +192,32 @@ def _resolve(self) -> dict[str, Any]:
 
         function_name = self.current_event.function
 
+        logger.debug(f"Resolving {function_name} tool")
+
         try:
+            parameters: dict[str, Any] = {}
             # Extract parameters from the event
-            parameters = {param.name: param.value for param in getattr(self.current_event, "parameters", [])}
+            for param in getattr(self.current_event, "parameters", []):
+                param_type = getattr(param, "type", None)
+                if param_type == "string":
+                    parameters[param.name] = str(param.value)
+                elif param_type == "integer":
+                    try:
+                        parameters[param.name] = int(param.value)
+                    except (ValueError, TypeError):
+                        parameters[param.name] = param.value
+                elif param_type == "number":
+                    try:
+                        parameters[param.name] = float(param.value)
+                    except (ValueError, TypeError):
+                        parameters[param.name] = param.value
+                elif param_type == "boolean":
+                    if isinstance(param.value, str):
+                        parameters[param.name] = param.value.lower() == "true"
+                    else:
+                        parameters[param.name] = bool(param.value)
+                else:  # "array" or any other type
+                    parameters[param.name] = param.value
 
             func = self._tools[function_name]["function"]
             # Filter parameters to only include those expected by the function
@@ -204,7 +233,8 @@ def _resolve(self) -> dict[str, Any]:
             return BedrockFunctionsResponseBuilder(result).build(self.current_event)
         except Exception as error:
             # Return a formatted error response
-            error_response = BedrockFunctionResponse(body=f"Error: {str(error)}", response_state="FAILURE")
+            logger.error(f"Error processing function: {function_name}", exc_info=True)
+            error_response = BedrockFunctionResponse(body=f"Error: {error.__class__.__name__}: {str(error)}")
             return BedrockFunctionsResponseBuilder(error_response).build(self.current_event)
 
     def append_context(self, **additional_context):

tests/functional/event_handler/required_dependencies/test_bedrock_agent_functions.py

@@ -281,7 +281,6 @@ def strict_function(required_param):
 
     # Function should raise a TypeError due to missing required parameter
     assert "Error:" in result["response"]["functionResponse"]["responseBody"]["TEXT"]["body"]
-    assert result["response"]["functionResponse"]["responseState"] == "FAILURE"
 
 
 def test_bedrock_agent_function_with_complex_return_type():
@@ -359,3 +358,67 @@ def test_resolve_with_no_current_event():
     # THEN a ValueError should be raised
     with pytest.raises(ValueError, match="No event to process"):
         app._resolve()
+
+
+def test_bedrock_agent_function_with_parameters_casting():
+    # GIVEN a Bedrock Agent Function resolver
+    app = BedrockAgentFunctionResolver()
+
+    @app.tool(description="Function that accepts parameters")
+    def vacation_request(month: int, payment: float, approved: bool):
+        # Store received parameters for assertion
+        assert isinstance(month, int)
+        assert isinstance(payment, float)
+        assert isinstance(approved, bool)
+        return "Vacation request"
+
+    # WHEN calling the event handler with parameters
+    raw_event = load_event("bedrockAgentFunctionEvent.json")
+    raw_event["function"] = "vacation_request"
+    raw_event["parameters"] = [
+        {"name": "month", "value": "3", "type": "integer"},
+        {"name": "payment", "value": "1000.5", "type": "number"},
+        {"name": "approved", "value": False, "type": "boolean"},
+    ]
+    result = app.resolve(raw_event, {})
+
+    # THEN parameters should be correctly passed to the function
+    assert "Vacation request" == result["response"]["functionResponse"]["responseBody"]["TEXT"]["body"]
+
+
+def test_bedrock_agent_function_with_parameters_casting_errors():
+    # GIVEN a Bedrock Agent Function resolver
+    app = BedrockAgentFunctionResolver()
+
+    @app.tool(description="Function that handles parameter casting errors")
+    def process_data(id_product: str, quantity: int, price: float, available: bool, items: list):
+        # Check that invalid values maintain their original types
+        assert isinstance(id_product, str)
+        # For invalid integer, the original string should be preserved
+        assert quantity == "invalid_number"
+        # For invalid float, the original string should be preserved
+        assert price == "not_a_price"
+        # For invalid boolean, should evaluate based on Python's bool rules
+        assert isinstance(available, bool)
+        assert not available
+        # Arrays should remain as is
+        assert isinstance(items, list)
+        return "Processed with casting errors handled"
+
+    # WHEN calling the event handler with parameters that cause casting errors
+    raw_event = load_event("bedrockAgentFunctionEvent.json")
+    raw_event["function"] = "process_data"
+    raw_event["parameters"] = [
+        {"name": "id_product", "value": 12345, "type": "string"},  # Integer to string (should work)
+        {"name": "quantity", "value": "invalid_number", "type": "integer"},  # Will cause ValueError
+        {"name": "price", "value": "not_a_price", "type": "number"},  # Will cause ValueError
+        {"name": "available", "value": "invalid_bool", "type": "boolean"},  # Not "true"/"false"
+        {"name": "items", "value": ["item1", "item2"], "type": "array"},  # Array should remain as is
+    ]
+    result = app.resolve(raw_event, {})
+
+    # THEN parameters should be handled properly despite casting errors
+    assert (
+        "Processed with casting errors handled"
+        == result["response"]["functionResponse"]["responseBody"]["TEXT"]["body"]
+    )