Sandbox Fallback Execution

Overview

When

execute_code_sandbox

fails due to e2b initialization errors or sandbox unavailability, use this fallback pattern to execute Python code by writing it to disk and running it via

run_shell

. This approach is particularly useful for PDF generation, data processing, and other Python-intensive tasks.

When to Use

Use this skill when you encounter errors like:

• e2b initialization error

• sandbox not available

• execute_code_sandbox

  timeout or connection failures
• Any sandbox execution that consistently fails

Step-by-Step Instructions

Step 1: Attempt Sandbox Execution First

Always try

execute_code_sandbox

first, as it provides isolation and artifact handling:

execute_code_sandbox(code="your_python_code_here")

Step 2: Detect Failure and Switch to Fallback

When sandbox execution fails with initialization errors, switch to the fallback pattern:

1. Write the Python script to disk using

   write_file

   :
   • Choose a descriptive filename (e.g.,

     generate_pdf.py

     ,

     process_data.py

     )
   • Include the complete Python code with all necessary imports

2. Execute via shell using

   run_shell

   :
   • Run the script with

     python

     or

     python3

   • Capture stdout/stderr for verification

Step 3: Example Implementation

# Write the script to disk
write_file(
    path="generate_pdf.py",
    content="""
from reportlab.lib.pagesizes import letter
from reportlab.pdfgen import canvas

def create_pdf(filename, content):
    c = canvas.Canvas(filename, pagesize=letter)
    c.drawString(100, 750, content)
    c.save()

create_pdf('output.pdf', 'Hello World')
"""
)

# Execute the script via shell
run_shell(command="python generate_pdf.py")

Step 4: Handle Dependencies

If the script requires external packages:

# Install dependencies first
run_shell(command="pip install reportlab pillow")

# Then execute the script
run_shell(command="python generate_pdf.py")

Step 5: Verify Output

After execution, verify the output was created:

# Check if file was created
run_shell(command="ls -la output.pdf")

# Optionally read the file to confirm
read_file(file_path="output.pdf", filetype="pdf")

Best Practices

1. Keep scripts self-contained: Include all imports and logic in the written file
2. Use descriptive filenames: Make it clear what each script does
3. Clean up when done: Remove temporary scripts if not needed for debugging
4. Capture errors: Always check stdout/stderr from

   run_shell

   for debugging
5. Handle paths carefully: Use relative paths or absolute paths consistently

Complete Example Pattern

# Primary: Try sandbox execution
try:
    result = execute_code_sandbox(code=python_code)
except Exception as e:
    if "e2b" in str(e).lower() or "sandbox" in str(e).lower():
        # Fallback: Write to disk and execute via shell
        script_path = "task_script.py"
        
        write_file(
            path=script_path,
            content=python_code
        )
        
        # Install any required dependencies
        run_shell(command="pip install -q reportlab")
        
        # Execute the script
        result = run_shell(command=f"python {script_path}")
        
        # Verify output
        run_shell(command="ls -la")

Applicable Use Cases

• PDF generation (reportlab, fpdf, etc.)
• Image processing (PIL, OpenCV)
• Data analysis (pandas, numpy)
• File manipulation tasks
• Any Python script that doesn't require special sandbox features