feat(backend): add agent mode support to SmartDecisionMakerBlock with autonomous tool execution loops

[majdyz]

Summary

🚀 Major Feature: Agent Mode Support

Adds autonomous agent mode to SmartDecisionMakerBlock, enabling it to execute tools directly in loops until tasks are completed, rather than just yielding tool calls for external execution.

⭐ Key New Features

🤖 Agent Mode with Tool Execution Loops

• New agent_mode_max_iterations parameter controls execution behavior:
  • 0 = Traditional mode (single LLM call, yield tool calls)
  • 1+ = Agent mode with iteration limit
  • -1 = Infinite agent mode (loop until finished)

🔄 Autonomous Tool Execution

• Direct tool execution instead of yielding for external handling
• Multi-iteration loops with conversation state management
• Automatic completion detection when LLM stops making tool calls
• Iteration limit handling with graceful completion messages

🏗️ Proper Database Operations

• Replace manual execution ID generation with proper upsert_execution_input/upsert_execution_output
• Real NodeExecutionEntry objects from database results
• Proper execution status management: QUEUED → RUNNING → COMPLETED/FAILED

🔧 Enhanced Type Safety

• Pydantic models replace TypedDict: ToolInfo and ExecutionParams
• Runtime validation with better error messages
• Improved developer experience with IDE support

🔧 Technical Implementation

Agent Mode Flow:

# Agent mode enabled with iterations
if input_data.agent_mode_max_iterations != 0:
    async for result in self._execute_tools_agent_mode(...):
        yield result  # "conversations", "finished"
    return

# Traditional mode (existing behavior)  
# Single LLM call + yield tool calls for external execution

Tool Execution with Database Operations:

# Before: Manual execution IDs
tool_exec_id = f"{node_exec_id}_tool_{sink_node_id}_{len(input_data)}"

# After: Proper database operations
node_exec_result, final_input_data = await db_client.upsert_execution_input(
    node_id=sink_node_id,
    graph_exec_id=execution_params.graph_exec_id,
    input_name=input_name, 
    input_data=input_value,
)

Type Safety with Pydantic:

# Before: Dict access prone to errors
execution_params["user_id"]  

# After: Validated model access
execution_params.user_id  # Runtime validation + IDE support

🧪 Comprehensive Test Coverage

• Agent mode execution tests with multi-iteration scenarios
• Database operation verification
• Type safety validation
• Backward compatibility for traditional mode
• Enhanced dynamic fields tests

📊 Usage Examples

Traditional Mode (Existing Behavior):

SmartDecisionMakerBlock.Input(
    prompt="Search for keywords",
    agent_mode_max_iterations=0  # Default
)
# → Yields tool calls for external execution

Agent Mode (New Feature):

SmartDecisionMakerBlock.Input(
    prompt="Complete this task using available tools",
    agent_mode_max_iterations=5  # Max 5 iterations
)
# → Executes tools directly until task completion or iteration limit

Infinite Agent Mode:

SmartDecisionMakerBlock.Input(
    prompt="Analyze and process this data thoroughly", 
    agent_mode_max_iterations=-1  # No limit, run until finished
)
# → Executes tools autonomously until LLM indicates completion

✅ Backward Compatibility

• Zero breaking changes to existing functionality
• Traditional mode remains default (agent_mode_max_iterations=0)
• All existing tests pass
• Same API for tool definitions and execution

This transforms the SmartDecisionMakerBlock from a simple tool call generator into a powerful autonomous agent capable of complex multi-step task execution! 🎯

🤖 Generated with Claude Code

[coderabbitai]

Important

Review skipped

Auto reviews are disabled on this repository.

Please check the settings in the CodeRabbit UI or the .coderabbit.yaml file in this repository. To trigger a single review, invoke the @coderabbitai review command.

You can disable this status message by setting the reviews.review_status to false in the CodeRabbit configuration file.

✨ Finishing touches

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Post copyable unit tests in a comment
• Commit unit tests in branch feat/smart-decision-block-agent-mode

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

[netlify]

✅ Deploy Preview for auto-gpt-docs-dev canceled.

Name	Link
🔨 Latest commit	9c30908
🔍 Latest deploy log	https://app.netlify.com/projects/auto-gpt-docs-dev/deploys/6937cd97b6df3500086c835c

[netlify]

✅ Deploy Preview for auto-gpt-docs canceled.

Name	Link
🔨 Latest commit	9c30908
🔍 Latest deploy log	https://app.netlify.com/projects/auto-gpt-docs/deploys/6937cd979c566800083650fb

[qodo-code-review]

PR Reviewer Guide 🔍

Here are some key observations to aid the review process:

⏱️ Estimated effort to review: 4 🔵🔵🔵🔵⚪

🧪 PR contains tests

🔒 No security concerns identified

⚡ Recommended focus areas for review Error Handling In agent mode, tool execution exceptions are caught and converted to tool error responses, but upstream execution status updates rely on external functions; ensure failures propagate correctly to calling systems and that partial outputs don't mask fatal errors when multiple tools are called. for tool_info in processed_tools: try: tool_response = await self._execute_single_tool( tool_info, execution_params ) tool_outputs.append(tool_response) except Exception as e: logger.error(f"Tool execution failed: {e}") # Create error response for the tool error_response = _create_tool_response( tool_info.tool_call.id, f"Error: {str(e)}" ) tool_outputs.append(error_response) # Update conversation with response and tool outputs self._update_conversation(current_prompt, response, tool_outputs) Conversation Growth Agent mode continuously appends reasoning, raw responses, and tool outputs to the prompt; validate that token growth is bounded or summarized across iterations to prevent runaway context size, especially for infinite mode (-1). def _update_conversation( self, prompt: list[dict], response, tool_outputs: list | None = None ): """Update conversation history with response and tool outputs.""" if response.reasoning: prompt.append( {"role": "assistant", "content": f"[Reasoning]: {response.reasoning}"} ) prompt.append(_convert_raw_response_to_dict(response.raw_response)) if tool_outputs: prompt.extend(tool_outputs) async def _execute_single_tool( self, tool_info: ToolInfo, execution_params: ExecutionParams ) -> dict: """Execute a single tool with proper execution events and status updates.""" # Lazy imports to avoid circular dependencies from backend.data.execution import ExecutionStatus Input Validation _execute_single_tool rejects empty input_data and always includes None values; confirm this aligns with downstream node validation and does not inadvertently create executions that always fail or pollute stats when tools omit optional args. # Add all inputs to the execution (including None values) # upsert_execution_input accumulates inputs for the same node_id/graph_exec_id if not raw_input_data: # If truly no input data, fail with clear error raise ValueError(f"Tool call has no input data: {tool_call}") for input_name, input_value in raw_input_data.items(): # Include all inputs, even None ones - let the target node handle validation node_exec_result, final_input_data = await db_client.upsert_execution_input( node_id=sink_node_id, graph_exec_id=execution_params.graph_exec_id, input_name=input_name, input_data=input_value, ) # Create NodeExecutionEntry from the result

[deepsource-io]

Here's the code health analysis summary for commits c1e21d0..9c30908. View details on DeepSource ↗.

Analysis Summary

Analyzer	Status	Summary	Link
JavaScript	✅ Success		View Check ↗
Python	✅ Success	❗ 15 occurences introduced 🎯 10 occurences resolved	View Check ↗

---

💡 If you’re a repository administrator, you can configure the quality gates from the settings.

[AutoGPT-Agent]

Thanks for your comprehensive PR implementing agent mode support for the SmartDecisionMakerBlock!

Overall Feedback

You've done excellent work creating autonomous tool execution loops for the SmartDecisionMakerBlock. The implementation is well-designed with proper database operations, type safety improvements, and comprehensive test coverage.

Your PR description is extremely detailed and clearly explains the changes, which is greatly appreciated.

Required Changes

However, according to our contribution standards, we need you to add the standard checklist to your PR description and check off the relevant items. Since this is a code change, please include:

• The standard checklist with items checked off
• Your test plan explicitly listed in the checklist section

If you could update your PR description to include the checklist format from our template and check off the relevant items, we'll be able to proceed with the review process.

Technical Implementation

The technical implementation looks solid with:

• Well-structured agent mode execution flow
• Proper database operations replacing manual ID generation
• Pydantic models for better type safety
• Comprehensive test coverage

Once you add the required checklist to your PR description, this looks ready for further review.

[AutoGPT-Agent]

Thank you for this comprehensive PR adding agent mode to the SmartDecisionMakerBlock. The code implementation looks solid and the feature will be a valuable addition to the platform.

However, there are a couple of issues that need to be addressed before this can be merged:

1. Missing Checklist: Your PR description is missing the required checklist. For code changes, we need to see that you've:

   • Clearly listed changes (you've done this well)
   • Made a test plan
   • Tested your changes according to that plan

2. Security Concern: The new function get_execution_outputs_by_node_exec_id in backend/data/execution.py doesn't appear to include user_id validation. This could potentially allow unauthorized access to execution outputs. Please either:

   • Add user_id validation to this function
   • Or explain why this function is safe without user_id checks (e.g., if it's only called in contexts where authorization is already handled)

The code implementation itself looks excellent - you've included thorough tests and the agent mode functionality is well-designed. Once the checklist and security concern are addressed, this should be ready to merge.

[AutoGPT-Agent]

Thanks for this comprehensive PR that adds agent mode to SmartDecisionMakerBlock! The feature looks well-designed with thoughtful consideration for backward compatibility.

A few things to address before merging:

1. Missing Checklist: The PR description is missing the required checklist. Please add the standard checklist and check off all applicable items, particularly the testing section. Since this is a significant feature addition, we need clear documentation of how you've tested it.

2. Test Coverage: While you've added tests for the new functionality, please ensure your test plan includes:

   • Testing with varying iteration limits
   • Edge cases like error handling during tool execution
   • Performance implications of long-running agent loops

3. Documentation: Consider adding docstrings to the new methods like _execute_tools_agent_mode, _process_tool_calls, etc. for better developer experience.

4. Configuration: Are there any environment variable or configuration changes needed to support this feature? If so, please document them.

The implementation looks solid with good use of Pydantic for type safety and proper database operations. I particularly like how you've maintained backward compatibility with the default agent_mode_max_iterations=0 setting.

Once you add the checklist and address these minor points, this PR should be ready for merging.

[github-actions]

This pull request has conflicts with the base branch, please resolve those so we can evaluate the pull request.

[github-actions]

Conflicts have been resolved! 🎉 A maintainer will review the pull request shortly.

[ntindle]

Okay two things

I think this is really cool but should maybe be its own block

raised by SmartDecisionMakerBlock with message: LLM call failed in agent mode iteration 2: Anthropic API error: Error code: 400 - {'type': 'error', 'error': {'type': 'invalid_request_error', 'message': 'messages.2.content.1: unexpected `tool_use_id` found in `tool_result` blocks: toolu_01MKTmC796yXvy3QSZaF4YZk. Each `tool_result` block must have a corresponding `tool_use` block in the previous message.'}, 'request_id': 'req_011CVwXdgUvaosWgBiwsFDEa'}. block_id: 3b191d9f-356f-482d-8238-ba04b6d18381