feat: add Bedrock AgentCore Code Interpreter tool

[dbschmigelski]

Description

This pull request introduces a Code Interpreter tool that provides secure, isolated sandbox environments for executing code in multiple programming languages
including Python, JavaScript, and TypeScript. The implementation follows a modular architecture with clear separation of concerns between the tool interface, platform abstraction, and underlying execution engines.

The core design centers around a wrapper class pattern that encapsulates platform lifecycle management while exposing a clean tool interface through the Strands @tool decorator. This wrapper approach was chosen to provide stateful tool functionality, allowing the tool to maintain persistent sessions and manage platform resources
automatically:

class CodeInterpreter(ABC):

    @tool
    def code_interpreter(self, code_interpreter_input: CodeInterpreterInput) -> Dict[str, Any]:
        # Route to appropriate platform method based on action type

The CodeInterpreter class handles initialization, cleanup, and auto-start functionality, ensuring that users don't need to manually manage platform lifecycle while still providing explicit control when needed.

The implementation leverages Pydantic models extensively for input validation and type safety. Rather than using a single schema with numerous optional fields that would require complex runtime validation logic, we opted for discriminated unions with specific action models:

Instead of this complex approach with runtime validation:

class CodeInterpreterInput(BaseModel):
    action_type: str
    session_name: Optional[str] = None
    code: Optional[str] = None
    language: Optional[str] = None
    # ... many optional fields requiring validation logic

We use discriminated unions with specific models:

class ExecuteCodeAction(BaseModel):
    type: Literal["executeCode"]
    session_name: str  # Required
    code: str         # Required
    language: LanguageType  # Required enum
    clear_context: Optional[bool] = False

This approach provides several key benefits: type checking ensures correctness, each action type has clearly defined required and optional fields, validation errors are specific and actionable, and the code is self-documenting through the type system. The Pydantic approach eliminates the need for manual validation code that would be error-prone and difficult to maintain.

Platform abstraction is achieved through the CodeInterpreter base class, which defines a consistent interface that any execution backend must implement. This modular design enables seamless integration of different execution environments. The current implementation include an AgentCoreCodeInterpreter for AWS-based sandbox execution, but the architecture readily supports additional platforms. A local platform could be implemented using Docker containers or virtual environments, while third-party platforms like CodeSandbox.io or custom Kubernetes-based solutions could be integrated by simply implementing the platform protocol.

Related Issues

[Link to related issues using #issue-number format]

Documentation PR

[Link to related associated PR in the agent-docs repo]

Type of Change

• New Tool

Testing

[How have you tested the change?]

• hatch fmt --linter
• hatch fmt --formatter
• hatch test --all

Checklist

• I have read the CONTRIBUTING document

• I have added tests that prove my fix is effective or my feature works

• I have updated the documentation accordingly

• I have added an appropriate example to the documentation to outline the feature

• My changes generate no new warnings

• Any dependent changes have been merged and published

• By submitting this pull request, I confirm that you can use, modify, copy, and redistribute this contribution, under the terms of your choice.