langchain - 💡(How to fix) Fix feat(community): Add exec-sandbox integration -- self-hosted hardware-isolated code execution (QEMU microVMs) [2 comments, 3 participants]

from langchain_core.tools import BaseTool
from pydantic import BaseModel, Field
from exec_sandbox import ExecutionResult, Scheduler, SchedulerConfig


class ExecSandboxInput(BaseModel):
    code: str = Field(..., description="The code to execute.")
    language: str = Field(default="python", description="'python', 'javascript', or 'raw' (shell).")
    packages: list[str] = Field(default_factory=list, description="Packages to install (e.g., ['pandas==2.2.0']).")


class ExecSandboxTool(BaseTool):
    """Execute code in a hardware-isolated QEMU microVM."""

    name: str = "exec_sandbox"
    description: str = (
        "Execute code in a secure, hardware-isolated sandbox (QEMU microVM). "
        "Supports Python, JavaScript/TypeScript, and shell commands. "
        "Returns stdout, stderr, and exit code."
    )
    args_schema: type[BaseModel] = ExecSandboxInput

    async def _arun(self, code: str, language: str = "python", packages: list[str] | None = None, **kwargs) -> str:
        scheduler = await self._ensure_scheduler()
        result = await scheduler.run(code=code, language=language, packages=packages or [],
                                     allow_network=self.allow_network, timeout_seconds=self.timeout_seconds)
        return _format_result(result)

---

from langchain.chat_models import init_chat_model
from langgraph.prebuilt import create_react_agent

model = init_chat_model("claude-sonnet-4-20250514", model_provider="anthropic")
tool = ExecSandboxTool(timeout_seconds=60, memory_mb=512)
agent = create_react_agent(model, [tool])

result = await agent.ainvoke({
    "messages": [{"role": "user", "content": "Calculate the first 20 Fibonacci numbers"}]
})

---

from deepagents.backends.protocol import ExecuteResponse, SandboxBackendProtocol
from exec_sandbox import Scheduler, SchedulerConfig, Session


class ExecSandboxBackend(SandboxBackendProtocol):
    """Self-hosted QEMU microVM sandbox for Deep Agents."""

    @property
    def id(self) -> str:
        return "exec-sandbox"

    async def aexecute(self, command: str, *, timeout: int | None = None) -> ExecuteResponse:
        session = await self._ensure_session()
        result = await session.exec(code=command, timeout_seconds=timeout or self._timeout_seconds)
        return ExecuteResponse(output=result.stdout or "", exit_code=result.exit_code, truncated=False)

---

from deepagents import create_deep_agent
from langchain.chat_models import init_chat_model
from langchain_exec_sandbox import ExecSandboxBackend

model = init_chat_model("claude-sonnet-4-20250514", model_provider="anthropic")
backend = ExecSandboxBackend(memory_mb=512, allow_network=True, allowed_domains=["api.github.com"])

agent = create_deep_agent(
    model=model,
    backend=backend,
    system_prompt="You are a software engineer. Use the sandbox to write, test, and debug code.",
)

---

from exec_sandbox import Scheduler

def create_exec_sandbox_eval(scheduler: Scheduler, timeout_seconds: int = 30) -> callable:
    """Create a CodeAct-compatible eval function backed by exec-sandbox."""
    def eval_fn(code: str, _locals: dict) -> tuple[str, dict]:
        result = asyncio.get_event_loop().run_until_complete(
            scheduler.run(code=code, language="python", timeout_seconds=timeout_seconds)
        )
        output = result.stdout or ""
        if result.stderr:
            output += f"\n[stderr] {result.stderr}"
        return output, {}
    return eval_fn

---

from exec_sandbox import Scheduler
from langgraph_codeact import create_codeact

async with Scheduler() as scheduler:
    eval_fn = create_exec_sandbox_eval(scheduler, timeout_seconds=60)
    agent = create_codeact(model, tools=[], eval_fn=eval_fn)