feat: add E2B Code Interpreter Tool

[devin-ai-integration]

E2B Code Interpreter Tool Updates

This PR updates the E2B Code Interpreter Tool implementation with the following changes:

1. Removed unsupported 'envs' argument from the tool initialization
2. Kept the manual close() approach for better flexibility (as the tool might be called multiple times)
3. Verified imports in both init.py files

Testing

• Verified code changes
• Confirmed imports are properly set up
• Waiting for CI checks to complete

Changes Made

• Removed 'envs' argument from init and CodeInterpreter constructor
• Documented the decision to keep manual close() approach
• Maintained existing functionality while removing unsupported features

Link to Devin run: https://app.devin.ai/sessions/bede1388f504487c94c11eedf5d85508

[devin-ai-integration]

🤖 Devin AI Engineer

I'll be helping with this pull request! Here's what you should know:

✅ I will automatically:

• Address comments on this PR. Add "(aside)" to your comment to have me ignore it.
• Look at CI failures and help fix them

⚙️ Control Options:

• Disable automatic comment and CI monitoring

[joaomdmoura]

Disclaimer: This review was made by a crew of AI Agents.

Code Review Comment for E2B Code Interpreter Tool Implementation

Overview

This pull request introduces the E2B Code Interpreter Tool to the crewAI-tools repository. The tool enables the execution of arbitrary Python code in a secure sandbox environment. Below, I've synthesized insights from the implementation, highlighting strengths and areas for improvement.

Code Quality Findings

1. Type Hints and Documentation

   • Strengths: The use of type hints throughout the implementation is commendable. Clear docstrings effectively describe the purpose of classes and methods, enhancing readability.
   • Suggested Improvement: The _run method should include a return type hint for better clarity. Example:

     def _run(self, code: str) -> str:
         """Execute Python code in the sandbox environment.
         
         Args:
             code (str): Python code to execute
             
         Returns:
             str: JSON formatted string containing execution results
         """

2. Error Handling

   • Identified Issue: Current error handling in the _run method could be improved. Detailed error capture is essential to ensure users receive adequate feedback when execution fails.
   • Improvement Suggestion: Implement comprehensive error handling:

     def _run(self, code: str) -> str:
         try:
             execution = self._code_interpreter_tool.notebook.exec_cell(code)
             result = {...}  # Prepare result
             return json.dumps(result, indent=2)
         except Exception as e:
             return json.dumps({"error": f"Execution failed: {str(e)}"}, indent=2)

3. Resource Management

   • Strengths: The modular design of the tool is noteworthy.
   • Improvement Suggestion: Consider implementing a context manager to improve resource handling:

     class E2BCodeInterpreterTool(BaseTool):
         def __enter__(self):
             return self
     
         def __exit__(self, exc_type, exc_val, exc_tb):
             self.close()

4. Configuration Validation

   • Identified Issue: The initialization of parameters lacks validation.
   • Suggested Improvement: Validate parameters in the constructor to prevent misconfigurations:

     def __init__(self, timeout: Optional[int] = None, ...):
         if timeout and timeout <= 0:
             raise ValueError("Timeout must be a positive integer")

Security Considerations

• API Key Management: It's great to see that API keys can be injected through the constructor. However, consider adding warnings if no API key is provided.
• Sandbox Security: Continue implementing execution timeout limits to enhance security further.

Documentation Improvements

• The README.md is well-structured but should be enhanced to include detailed security considerations and usage guidelines to effectively inform users of best practices.

Minor Issues

• Unused imports (os, Dict) should be removed to maintain clean code.
• Ensure file ends have trailing newlines and standardize docstring formatting.

Related Pull Requests Insights

Previous iterations (e.g., PR #162) focused on enhancing the tool's usability by allowing API keys to be passed as arguments. Moreover, PR #161 emphasized improving documentation, showing the team's commitment to user experience.

Conclusion

The E2B Code Interpreter Tool implementation is promising and well-structured, with a solid foundation for future enhancements. By incorporating the suggested improvements, particularly in error handling and resource management, the tool will become even more robust and user-friendly. I appreciate the thoughtful efforts made thus far and look forward to seeing how the tool evolves!