fix(backend): Add dynamic input pin support for Smart Decision Maker Block (#11082)

## Summary

- Centralize dynamic field delimiters and helpers in
backend/data/dynamic_fields.py.
- Refactor SmartDecisionMaker: build function signatures with
dynamic-field mapping and re-map tool outputs back to original dynamic
names.
- Deterministic retry loop with retry-only feedback to avoid polluting
final conversation history.
- Update executor/utils.py and data/graph.py to use centralized
utilities.
- Update and extend tests: dynamic-field E2E flow, mapping verification,
output yielding, and retry validation; switch mocked llm_call to
AsyncMock; align tool-name expectations.
- Add a single-tool fallback in schema lookup to support mocked
scenarios.

## Validation

- Full backend test suite: 1125 passed, 88 skipped, 53 warnings (local).
- Backend lint/format pass.

## Scope

- Minimal and localized to SmartDecisionMaker and dynamic-field
utilities; unrelated pyright warnings remain unchanged.

## Risks/Mitigations

- Behavior is backward-compatible; dynamic-field constants are
centralized and reused.
- Output re-mapping only affects SmartDecisionMaker tool outputs and
matches existing link naming conventions.

## Checklist

- [x] Formatted and linted
- [x] All updated tests pass locally
- [x] No secrets introduced

---------

Co-authored-by: Claude <[email protected]>

Author: majdyz

autogpt_platform/backend/backend/blocks/smart_decision_maker.py

@@ -216,8 +216,17 @@ async def test_smart_decision_maker_tracks_llm_stats():
     }
 
     # Mock the _create_function_signature method to avoid database calls
-    with patch("backend.blocks.llm.llm_call", return_value=mock_response), patch.object(
-        SmartDecisionMakerBlock, "_create_function_signature", return_value=[]
+    from unittest.mock import AsyncMock
+
+    with patch(
+        "backend.blocks.llm.llm_call",
+        new_callable=AsyncMock,
+        return_value=mock_response,
+    ), patch.object(
+        SmartDecisionMakerBlock,
+        "_create_function_signature",
+        new_callable=AsyncMock,
+        return_value=[],
     ):
 
         # Create test input
@@ -301,11 +310,16 @@ async def test_smart_decision_maker_parameter_validation():
     mock_response_with_typo.reasoning = None
     mock_response_with_typo.raw_response = {"role": "assistant", "content": None}
 
+    from unittest.mock import AsyncMock
+
     with patch(
-        "backend.blocks.llm.llm_call", return_value=mock_response_with_typo
+        "backend.blocks.llm.llm_call",
+        new_callable=AsyncMock,
+        return_value=mock_response_with_typo,
     ) as mock_llm_call, patch.object(
         SmartDecisionMakerBlock,
         "_create_function_signature",
+        new_callable=AsyncMock,
         return_value=mock_tool_functions,
     ):
 
@@ -332,7 +346,7 @@ async def test_smart_decision_maker_parameter_validation():
 
         # Verify error message contains details about the typo
         error_msg = str(exc_info.value)
-        assert "Tool call validation failed" in error_msg
+        assert "Tool call 'search_keywords' has parameter errors" in error_msg
         assert "Unknown parameters: ['maximum_keyword_difficulty']" in error_msg
 
         # Verify that LLM was called the expected number of times (retries)
@@ -353,11 +367,16 @@ async def test_smart_decision_maker_parameter_validation():
     mock_response_missing_required.reasoning = None
     mock_response_missing_required.raw_response = {"role": "assistant", "content": None}
 
+    from unittest.mock import AsyncMock
+
     with patch(
-        "backend.blocks.llm.llm_call", return_value=mock_response_missing_required
+        "backend.blocks.llm.llm_call",
+        new_callable=AsyncMock,
+        return_value=mock_response_missing_required,
     ), patch.object(
         SmartDecisionMakerBlock,
         "_create_function_signature",
+        new_callable=AsyncMock,
         return_value=mock_tool_functions,
     ):
 
@@ -398,11 +417,16 @@ async def test_smart_decision_maker_parameter_validation():
     mock_response_valid.reasoning = None
     mock_response_valid.raw_response = {"role": "assistant", "content": None}
 
+    from unittest.mock import AsyncMock
+
     with patch(
-        "backend.blocks.llm.llm_call", return_value=mock_response_valid
+        "backend.blocks.llm.llm_call",
+        new_callable=AsyncMock,
+        return_value=mock_response_valid,
     ), patch.object(
         SmartDecisionMakerBlock,
         "_create_function_signature",
+        new_callable=AsyncMock,
         return_value=mock_tool_functions,
     ):
 
@@ -447,11 +471,16 @@ async def test_smart_decision_maker_parameter_validation():
     mock_response_all_params.reasoning = None
     mock_response_all_params.raw_response = {"role": "assistant", "content": None}
 
+    from unittest.mock import AsyncMock
+
     with patch(
-        "backend.blocks.llm.llm_call", return_value=mock_response_all_params
+        "backend.blocks.llm.llm_call",
+        new_callable=AsyncMock,
+        return_value=mock_response_all_params,
     ), patch.object(
         SmartDecisionMakerBlock,
         "_create_function_signature",
+        new_callable=AsyncMock,
         return_value=mock_tool_functions,
     ):
 
@@ -553,9 +582,14 @@ def __init__(self, role, content, tool_calls=None):
     )
 
     # Mock llm_call to return different responses on different calls
-    with patch("backend.blocks.llm.llm_call") as mock_llm_call, patch.object(
+    from unittest.mock import AsyncMock
+
+    with patch(
+        "backend.blocks.llm.llm_call", new_callable=AsyncMock
+    ) as mock_llm_call, patch.object(
         SmartDecisionMakerBlock,
         "_create_function_signature",
+        new_callable=AsyncMock,
         return_value=mock_tool_functions,
     ):
         # First call returns response that will trigger retry due to validation error
@@ -614,11 +648,16 @@ def __init__(self, role, content, tool_calls=None):
         "I'll help you with that."  # Ollama returns string
     )
 
+    from unittest.mock import AsyncMock
+
     with patch(
-        "backend.blocks.llm.llm_call", return_value=mock_response_ollama
+        "backend.blocks.llm.llm_call",
+        new_callable=AsyncMock,
+        return_value=mock_response_ollama,
     ), patch.object(
         SmartDecisionMakerBlock,
         "_create_function_signature",
+        new_callable=AsyncMock,
         return_value=[],  # No tools for this test
     ):
         input_data = SmartDecisionMakerBlock.Input(
@@ -655,11 +694,16 @@ def __init__(self, role, content, tool_calls=None):
         "content": "Test response",
     }  # Dict format
 
+    from unittest.mock import AsyncMock
+
     with patch(
-        "backend.blocks.llm.llm_call", return_value=mock_response_dict
+        "backend.blocks.llm.llm_call",
+        new_callable=AsyncMock,
+        return_value=mock_response_dict,
     ), patch.object(
         SmartDecisionMakerBlock,
         "_create_function_signature",
+        new_callable=AsyncMock,
         return_value=[],
     ):
         input_data = SmartDecisionMakerBlock.Input(

autogpt_platform/backend/backend/blocks/test/test_smart_decision_maker.py

@@ -48,16 +48,24 @@ async def test_smart_decision_maker_handles_dynamic_dict_fields():
     assert "parameters" in signature["function"]
     assert "properties" in signature["function"]["parameters"]
 
-    # Check that dynamic fields are handled
+    # Check that dynamic fields are handled with original names
     properties = signature["function"]["parameters"]["properties"]
     assert len(properties) == 3  # Should have all three fields
 
-    # Each dynamic field should have proper schema
-    for prop_value in properties.values():
+    # Check that field names are cleaned (for Anthropic API compatibility)
+    assert "values___name" in properties
+    assert "values___age" in properties
+    assert "values___city" in properties
+
+    # Each dynamic field should have proper schema with descriptive text
+    for field_name, prop_value in properties.items():
         assert "type" in prop_value
         assert prop_value["type"] == "string"  # Dynamic fields get string type
         assert "description" in prop_value
-        assert "Dynamic value for" in prop_value["description"]
+        # Check that descriptions properly explain the dynamic field
+        if field_name == "values___name":
+            assert "Dictionary field 'name'" in prop_value["description"]
+            assert "values['name']" in prop_value["description"]
 
 
 @pytest.mark.asyncio
@@ -96,10 +104,18 @@ async def test_smart_decision_maker_handles_dynamic_list_fields():
     properties = signature["function"]["parameters"]["properties"]
     assert len(properties) == 2  # Should have both list items
 
-    # Each dynamic field should have proper schema
-    for prop_value in properties.values():
+    # Check that field names are cleaned (for Anthropic API compatibility)
+    assert "entries___0" in properties
+    assert "entries___1" in properties
+
+    # Each dynamic field should have proper schema with descriptive text
+    for field_name, prop_value in properties.items():
         assert prop_value["type"] == "string"
-        assert "Dynamic value for" in prop_value["description"]
+        assert "description" in prop_value
+        # Check that descriptions properly explain the list field
+        if field_name == "entries___0":
+            assert "List item 0" in prop_value["description"]
+            assert "entries[0]" in prop_value["description"]
 
 
 @pytest.mark.asyncio