/**
 * Execução de código em sandbox: o isolamento que o `execute_code` exigia.
 *
 * Programmatic tool calling colapsa uma sequência de chamadas de tool num
 * script só, e economiza round-trips de inferência. O bloqueio nunca foi o
 * colapso: era o isolamento. Rodar código gerado por modelo no mesmo processo
 * do runtime dá a ele o filesystem inteiro, as variáveis de ambiente com as
 * chaves de API, e a capacidade de abrir processos.
 *
 * Aqui o isolamento é do RUNTIME, não de checagem de string sobre o código —
 * varredura de `import` é evasível e dá falsa sensação de segurança. O script
 * roda num processo Node separado com o Permission Model ligado.
 *
 * ## O que está isolado (verificado, não presumido)
 *
 *   filesystem     : só o diretório de trabalho da própria execução. Ler fora
 *                    dele falha com ERR_ACCESS_DENIED, imposto pelo Node.
 *   subprocessos   : `child_process` falha com ERR_ACCESS_DENIED.
 *   worker threads : bloqueados. Addons nativos e WASI também.
 *   ambiente       : env montado do zero. Nenhuma variável do processo pai
 *                    atravessa, então nenhuma chave de API atravessa.
 *   tempo          : timeout com kill.
 *   saída          : teto de bytes, com truncamento declarado.
 *
 * ## O que NÃO está isolado
 *
 *   rede : o Permission Model do Node não cobre rede (medido: `fetch` funciona
 *          com `--permission` ligado). Um script pode fazer requisição de
 *          saída. Isolar isso exigiria container ou firewall de processo, que
 *          é outra ordem de dependência.
 *
 * Por isso a tool exige permissão `shell` no contrato, e a `PolicyEngine` já
 * nega `shell` para trust tier `generated` e `community`: na prática, só código
 * partindo do próprio framework ou do dono do processo executa. Este limite
 * está declarado aqui, no README e no SYSTEM.md — não é para ser descoberto
 * depois.
 */
export declare const DEFAULT_TIMEOUT_MS = 15000;
export declare const DEFAULT_MAX_OUTPUT_BYTES: number;
export interface SandboxRequest {
    /** Código ESM a executar. Roda como módulo: `await` de topo é permitido. */
    code: string;
    /** Raiz do projeto. O diretório de trabalho é criado DENTRO dela. */
    baseDir: string;
    timeoutMs?: number;
    maxOutputBytes?: number;
    /**
     * Concede leitura (nunca escrita) da raiz do projeto. Falso por padrão:
     * um script que precisa do repositório inteiro para rodar provavelmente não
     * deveria ser um script gerado.
     */
    allowProjectRead?: boolean;
}
export interface SandboxResult {
    ok: boolean;
    stdout: string;
    stderr: string;
    exitCode: number | null;
    timedOut: boolean;
    /** Saída cortada pelo teto de bytes. */
    truncated: boolean;
    durationMs: number;
    /** Diretório de trabalho da execução (já removido quando `cleaned`). */
    workDir: string;
    error?: string;
}
/** Isolamento disponível neste runtime, ou a razão de não estar. */
export declare function sandboxAvailability(): {
    available: boolean;
    reason?: string;
};
/**
 * Executa o código em processo isolado. Nunca lança: erro de spawn, timeout e
 * saída não-zero voltam como resultado, porque quem chamou precisa decidir o
 * que fazer com a falha — não ser interrompido por ela.
 */
export declare function runInSandbox(request: SandboxRequest): Promise<SandboxResult>;
//# sourceMappingURL=code-sandbox.d.ts.map