LangChain Agent with
Browser and Terminal

# Install dependencies
pip install langchain langchain-openai langchain-anthropic httpx

# Set your keys
export OPENAI_API_KEY="sk-..."          # or ANTHROPIC_API_KEY for Claude
export SANDBOX_API_KEY="ab0t_sk_live_..."
export SANDBOX_URL="https://sandbox.dev.ab0t.com"

# sandbox_tools.py
import os, httpx
from langchain_core.tools import tool

_URL = os.environ.get("SANDBOX_URL", "https://sandbox.dev.ab0t.com")
_KEY = os.environ["SANDBOX_API_KEY"]
_client = httpx.Client(base_url=_URL, headers={"Authorization": f"Bearer {_KEY}"}, timeout=120)
_sandbox_id: str | None = None

@tool
def create_sandbox(name: str, instance_type: str = "ab0t.medium") -> str:
    """Create an isolated Linux VM for code execution. Must be called before
    execute_command or save_file. Use ab0t.micro for light tasks, ab0t.medium
    for builds, ab0t.gpu for GPU. Returns sandbox ID when ready."""
    global _sandbox_id
    r = _client.post("/api/sandboxes", json={
        "name": name, "instance_type": instance_type, "auto_stop_minutes": 60
    })
    r.raise_for_status()
    d = r.json()
    _sandbox_id = d["sandbox_id"]
    return f"Sandbox {_sandbox_id} created ({d['status']}). Cost: ${d.get('hourly_cost','0.04')}/hr."

@tool
def execute_command(command: str) -> str:
    """Run a shell command in the active sandbox. Use for git, pip, npm, pytest,
    any CLI tool. Returns stdout, stderr, exit code. Install packages as needed."""
    if not _sandbox_id: return "No sandbox. Call create_sandbox first."
    r = _client.post(f"/api/sandboxes/{_sandbox_id}/execute", json={"command": command})
    r.raise_for_status()
    d = r.json()
    out = d.get("stdout", "")
    err = d.get("stderr", "")
    code = d.get("exit_code", 0)
    return f"{out}\n{err}\nExit: {code}".strip()

@tool
def launch_browser(url: str = "") -> str:
    """Launch a cloud Chrome browser. Returns a CDP URL for programmatic control
    and an access URL for visual viewing. Use for web research, scraping, testing."""
    r = _client.post("/api/browsers", json={"browser_type": "chrome", "homepage_url": url})
    r.raise_for_status()
    d = r.json()
    return f"Browser {d['container_id']} launched.\nCDP: {d.get('cdp_url','pending')}\nView: {d.get('access_url','pending')}"

@tool
def save_file(filename: str, content: str) -> str:
    """Write a file to the sandbox workspace. Use for scripts, configs, data."""
    if not _sandbox_id: return "No sandbox."
    _client.post(f"/api/sandboxes/{_sandbox_id}/files", json={"filename": filename, "content": content})
    return f"Saved /workspace/{filename}"

@tool
def stop_sandbox() -> str:
    """Stop the sandbox. Data persists. Billing stops."""
    global _sandbox_id
    if _sandbox_id:
        _client.post(f"/api/sandboxes/{_sandbox_id}/stop")
        sid = _sandbox_id; _sandbox_id = None
        return f"Sandbox {sid} stopped."
    return "No active sandbox."

ALL_TOOLS = [create_sandbox, execute_command, launch_browser, save_file, stop_sandbox]

# agent.py
from langchain_openai import ChatOpenAI
from langchain.agents import create_react_agent, AgentExecutor
from langchain_core.prompts import ChatPromptTemplate
from sandbox_tools import ALL_TOOLS

llm = ChatOpenAI(model="gpt-4.1", temperature=0)
# Or: from langchain_anthropic import ChatAnthropic
# llm = ChatAnthropic(model="claude-sonnet-4-6")

prompt = ChatPromptTemplate.from_messages([
    ("system", """You are a developer with access to cloud sandboxes.

RULES:
1. Always create_sandbox before running commands.
2. Use execute_command for shell operations (git, pip, tests, builds).
3. Use launch_browser for web research, scraping, UI testing.
4. Use save_file to write code or data.
5. Always stop_sandbox when the task is done.

You have full root access on the sandbox. Install anything you need."""),
    ("human", "{input}"),
    ("placeholder", "{agent_scratchpad}"),
])

agent = create_react_agent(llm, ALL_TOOLS, prompt)
executor = AgentExecutor(agent=agent, tools=ALL_TOOLS, verbose=True, max_iterations=25)

# run.py
result = executor.invoke({
    "input": """
    1. Create a sandbox.
    2. Launch a browser and research the top 5 Python web frameworks in 2026.
       Visit their official sites and GitHub repos. Note star counts and key features.
    3. In the sandbox terminal, write a Python script that generates a comparison
       table as a Markdown file, using the data you collected.
    4. Run the script and show me the output.
    5. Stop the sandbox.
    """
})
print(result["output"])

from langgraph.graph import StateGraph, MessagesState
from langgraph.prebuilt import ToolNode
from sandbox_tools import ALL_TOOLS

# Bind tools to the model
model_with_tools = llm.bind_tools(ALL_TOOLS)

def agent_node(state: MessagesState):
    return {"messages": [model_with_tools.invoke(state["messages"])]}

def should_continue(state: MessagesState):
    last = state["messages"][-1]
    if last.tool_calls:
        return "tools"
    return "end"

# Build the graph
graph = StateGraph(MessagesState)
graph.add_node("agent", agent_node)
graph.add_node("tools", ToolNode(ALL_TOOLS))
graph.set_entry_point("agent")
graph.add_conditional_edges("agent", should_continue, {"tools": "tools", "end": "__end__"})
graph.add_edge("tools", "agent")

app = graph.compile()

# Run it
result = app.invoke({
    "messages": [("human", "Create a sandbox, clone fastapi, run tests, report failures.")]
})
print(result["messages"][-1].content)