OpenAI Agents SDK +
Sandbox Platform

# sandbox_tools.py
import os
import httpx

SANDBOX_URL = os.environ.get("SANDBOX_URL", "https://sandbox.dev.ab0t.com")
SANDBOX_API_KEY = os.environ["SANDBOX_API_KEY"]

client = httpx.Client(
    base_url=SANDBOX_URL,
    headers={"Authorization": f"Bearer {SANDBOX_API_KEY}"},
    timeout=120.0,
)

# Track the active sandbox
_active_sandbox_id: str | None = None

from agents import function_tool

@function_tool
def create_sandbox(name: str, instance_type: str = "ab0t.medium") -> str:
    """Create an isolated Linux sandbox for code execution.
    Use ab0t.micro for light tasks, ab0t.medium for builds and tests,
    ab0t.gpu for GPU workloads. Returns the sandbox ID."""
    global _active_sandbox_id
    resp = client.post("/api/sandboxes", json={
        "name": name,
        "instance_type": instance_type,
        "auto_stop_minutes": 60,
    })
    resp.raise_for_status()
    data = resp.json()
    _active_sandbox_id = data["sandbox_id"]
    return (
        f"Sandbox created: {data['sandbox_id']}\n"
        f"Status: {data['status']}\n"
        f"Cost: ${data.get('hourly_cost', '0.04')}/hr\n"
        f"Ready for commands."
    )

@function_tool
def execute_command(command: str) -> str:
    """Execute a shell command in the active sandbox.
    Use for: installing packages, running tests, git operations,
    building projects, running scripts. Returns stdout, stderr, and exit code."""
    if not _active_sandbox_id:
        return "No active sandbox. Call create_sandbox first."
    resp = client.post(
        f"/api/sandboxes/{_active_sandbox_id}/execute",
        json={"command": command},
    )
    resp.raise_for_status()
    data = resp.json()
    parts = []
    if data.get("stdout"):
        parts.append(data["stdout"])
    if data.get("stderr"):
        parts.append(f"STDERR:\n{data['stderr']}")
    parts.append(f"Exit code: {data.get('exit_code', 0)}")
    if data.get("execution_time_ms"):
        parts.append(f"Time: {data['execution_time_ms']}ms")
    return "\n".join(parts)

@function_tool
def launch_browser(url: str = "", browser_type: str = "chrome") -> str:
    """Launch a cloud browser for web automation.
    Returns a CDP URL for connecting with Playwright or Puppeteer,
    plus an access URL for viewing the browser in your own browser.
    Use for: web research, form filling, scraping, testing."""
    resp = client.post("/api/browsers", json={
        "browser_type": browser_type,
        "homepage_url": url,
    })
    resp.raise_for_status()
    data = resp.json()
    return (
        f"Browser launched: {data['container_id']}\n"
        f"CDP URL: {data.get('cdp_url', 'pending...')}\n"
        f"View URL: {data.get('access_url', 'pending...')}\n"
        f"Connect: browser = await pw.chromium.connect_over_cdp(cdp_url)"
    )

@function_tool
def save_file(filename: str, content: str) -> str:
    """Save a file to the sandbox's /workspace directory.
    Use for: writing scripts, config files, test fixtures."""
    if not _active_sandbox_id:
        return "No active sandbox."
    resp = client.post(
        f"/api/sandboxes/{_active_sandbox_id}/files",
        json={"filename": filename, "content": content},
    )
    resp.raise_for_status()
    return f"Saved: /workspace/{filename}"

@function_tool
def stop_sandbox() -> str:
    """Stop the active sandbox. Preserves data. Stops billing."""
    global _active_sandbox_id
    if _active_sandbox_id:
        client.post(f"/api/sandboxes/{_active_sandbox_id}/stop")
        sid = _active_sandbox_id
        _active_sandbox_id = None
        return f"Sandbox {sid} stopped. Billing paused."
    return "No active sandbox."

# agent.py
from agents import Agent, Runner
from sandbox_tools import (
    create_sandbox, execute_command, launch_browser, save_file, stop_sandbox
)

coding_agent = Agent(
    name="Sandbox Developer",
    model="gpt-4.1",
    instructions="""You are a software developer with access to a cloud sandbox.

You can create isolated Linux environments, execute shell commands,
launch browsers for web tasks, and save files.

WORKFLOW:
1. Always create_sandbox first before executing commands.
2. Use execute_command for: git, pip, npm, pytest, build commands.
3. Use launch_browser for: web research, scraping, testing web UIs.
4. Use save_file to write code, scripts, or config files.
5. Always stop_sandbox when the task is complete to stop billing.

The sandbox is a fresh Ubuntu VM. Install any packages you need.
You have root access via sudo.""",
    tools=[create_sandbox, execute_command, launch_browser, save_file, stop_sandbox],
)

# run_agent.py
import asyncio
from agents import Agent, Runner
from sandbox_tools import (
    create_sandbox, execute_command, launch_browser, save_file, stop_sandbox
)

agent = Agent(
    name="Code Reviewer",
    model="gpt-4.1",
    instructions="""You review code repositories. For each task:
1. Create a sandbox
2. Clone the repo
3. Install dependencies
4. Run the test suite
5. Analyze failures and suggest fixes
6. Stop the sandbox when done

Be thorough. Read test output carefully. If tests fail,
look at the relevant source code to understand why.""",
    tools=[create_sandbox, execute_command, save_file, stop_sandbox],
)

async def main():
    result = await Runner.run(
        agent,
        input="Review https://github.com/fastapi/fastapi — clone it, "
              "run the tests, and report which ones fail and why.",
    )
    print("\n=== Agent Output ===")
    print(result.final_output)

asyncio.run(main())

async def main_streamed():
    result = Runner.run_streamed(
        agent,
        input="Clone the repo, run tests, fix any failures, run tests again.",
    )
    async for event in result.stream_events():
        if event.type == "tool_call":
            print(f"  Tool: {event.tool_call.name}({event.tool_call.arguments})")
        elif event.type == "tool_output":
            output = event.output[:200]  # Truncate for display
            print(f"  Result: {output}...")
        elif event.type == "text_delta":
            print(event.text, end="", flush=True)

    print(f"\n\nFinal: {result.final_output}")

# Each agent manages its own sandbox via separate tool instances
from agents import Agent, Runner

# Research agent uses browsers
researcher = Agent(
    name="Researcher",
    model="gpt-4.1",
    instructions="You research topics using web browsers. "
                  "Launch a browser, navigate to relevant pages, "
                  "and extract key findings.",
    tools=[create_sandbox, launch_browser, execute_command, stop_sandbox],
)

# Coding agent uses terminals
developer = Agent(
    name="Developer",
    model="gpt-4.1",
    instructions="You write and test code in a sandbox. "
                  "Create a sandbox, write code, run tests, iterate.",
    tools=[create_sandbox, execute_command, save_file, stop_sandbox],
)

# Orchestrator hands off between them
orchestrator = Agent(
    name="Project Lead",
    model="gpt-4.1",
    instructions="You manage a research project. First, hand off to "
                  "Researcher to gather information. Then hand off to "
                  "Developer to implement the findings as code.",
    handoffs=[researcher, developer],
)

async def main():
    result = await Runner.run(
        orchestrator,
        input="Research the top 5 Python testing frameworks in 2026, "
              "then write a comparison script that benchmarks each one "
              "against a sample project.",
    )
    print(result.final_output)

# Create a sandbox
SANDBOX=$(curl -s -X POST "$SANDBOX_URL/api/sandboxes" \
  -H "Authorization: Bearer $SANDBOX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name":"codex-dev","instance_type":"ab0t.medium","auto_stop_minutes":120}')

# SSH in
ssh ubuntu@$(echo $SANDBOX | jq -r '.instance_ip')

# Inside the sandbox:
npm install -g @openai/codex
export OPENAI_API_KEY="sk-YOUR_KEY"

# Run Codex in Full Auto mode
cd /home/ubuntu/workspace
git clone https://github.com/your-org/your-project.git
cd your-project
codex --approval-mode full-auto "Run the tests and fix any failures"