Execução de Código

ADK-Rust fornece execução de código por meio de dois crates:

• adk-sandbox — Runtime de execução isolado com ProcessBackend (subprocesso) e WasmBackend (wasmtime)
• adk-code — Cadeia de ferramentas com suporte a linguagens com RustExecutor (pipeline de verificação, compilação e execução) e CodeTool

A separação é intencional: adk-sandbox cuida do isolamento, enquanto adk-code cuida da compilação e da lógica específica da linguagem.

Início Rápido

use adk_code::{CodeTool, RustExecutor, RustExecutorConfig};
use adk_sandbox::ProcessBackend;
use std::sync::Arc;

let backend = Arc::new(ProcessBackend::default());
let executor = RustExecutor::new(backend, RustExecutorConfig::default());
let tool = Arc::new(CodeTool::new(executor));

let agent = LlmAgentBuilder::new("code_agent")
    .instruction("Execute Rust code when asked to compute something.")
    .model(model)
    .tool(tool)
    .build()?;

Para execução direta em sandbox sem o pipeline de compilação Rust:

use adk_sandbox::{SandboxTool, ProcessBackend};
use std::sync::Arc;

let backend = Arc::new(ProcessBackend::default());
let tool = Arc::new(SandboxTool::new(backend));

Arquitetura

CodeTool adiciona um pipeline de compilação Rust (verifica erros, compila o binário e, em seguida, executa). SandboxTool executa o código diretamente pelo backend, sem compilação.

Matriz de Recursos dos Backends

ProcessBackend é transparente sobre o que não impõe. Use WasmBackend para sandboxing completo ou DockerExecutor para isolamento no nível do contêiner.

Ferramentas

CodeTool, SandboxTool e MontyPythonCodeTool seguem o padrão de erro como informação: os erros são retornados como JSON estruturado com um campo "status", nunca como ToolError. Isso permite que os agentes raciocinem sobre falhas. PythonCodeTool é a exceção — ele retorna um ToolError para um argumento code ausente e para falhas no nível do executor; somente falhas no nível do script são expostas como dados.

Para execução de Python no processo — modos de execução única e REPL, concessões de acesso ao sistema operacional e funções do host — consulte Execução de código Python.

Diagnósticos estruturados

CodeTool retorna diagnósticos analisados do compilador para erros de compilação do Rust:

{
  "status": "compile_error",
  "diagnostics": [
    {
      "level": "error",
      "message": "expected `;`",
      "code": "E0308",
      "spans": [{ "file_name": "main.rs", "line_start": 3, "column_start": 15 }]
    }
  ],
  "stderr": "error: expected `;`"
}

As respostas de sucesso incluem uma saída estruturada extraída do harness:

{
  "status": "success",
  "stdout": "",
  "output": { "greeting": "hello" },
  "exit_code": 0,
  "duration_ms": 42
}

Contrato de código Rust

O código do usuário deve fornecer fn run(input: serde_json::Value) -> serde_json::Value. O harness o encapsula com fn main(), análise de stdin e serialização de stdout. O código do usuário não deve definir fn main() nem usar atributos no nível do crate (#![...]).

Migração do API anterior

Os tipos adk-code anteriores (CodeExecutor, ExecutionRequest, RustSandboxExecutor) e o RustCodeTool de adk-tool foram removidos. Use os novos tipos:

Consulte adk_code::compat para obter o guia completo de migração.

Navegador JavaScript

A execução de páginas do navegador JavaScript via adk-browser é uma capacidade separada. Ela é executada dentro do contexto da página remota e não faz parte da infraestrutura de execução de código. Use as ferramentas adk-browser para automação da web e interação com páginas.

Integração com o Studio

O ADK Studio usa o mesmo pipeline de execução de código:

• Executor ao vivo: Executa Rust criado pelo usuário por meio de RustExecutor + ProcessBackend
• Geração de código: Incorpora o mesmo corpo Rust em projetos gerados
• Configurações do sandbox: Mapeiam para capacidades que podem ser aplicadas pelo back-end