/**
 * Polyglot code executor — run snippets of Python, Node, TypeScript, or Bash
 * inside a `SandboxPolicy`. The runner is the missing primitive that turns
 * the harness into a "Claude Code" style agent loop: rather than ask the
 * model to author whole files for every task, hand it a small `run_code`
 * tool and let it batch primitive operations in its native language.
 *
 * Design goals
 * ------------
 * - **Polyglot**: TS harness can launch `python3 -c …` or `node -e …`
 *   without the agent author having to know which interpreter is on $PATH.
 *   Auto-detect each language once on first use.
 * - **Sandboxed**: every spawn inherits the workspace cwd from
 *   `SandboxPolicy.workspace`, refuses to start when `allowShell === false`,
 *   and caps stdout/stderr at `sandbox.maxOutputBytes`.
 * - **Stateless**: no persistent REPL state between calls (this is *not*
 *   Jupyter). For session-scoped state the agent should write to a file.
 *   Stateless executors are easier to reason about and trivial to
 *   parallelize across forks.
 * - **Tool-shaped**: `executor.tools()` returns one LLM-callable
 *   `run_code({ language, source })` tool plus a thin `which_languages()`
 *   capability probe so the model can branch on what's installed.
 *
 * Why this is the right shape
 * ---------------------------
 * Claude Code conflates "shell" and "code execution" inside its single
 * `BashTool`. That works for an interactive engineer running mostly bash,
 * but it forces every Python snippet through `python3 -c "$(cat <<EOF …`
 * heredoc gymnastics. Splitting code execution into its own tool means:
 *
 * 1. The model can pass *raw* source — no shell-escaping Easter eggs.
 * 2. The model gets per-language hints (Python sees a `repr()`-friendly
 *    error trace, Node sees a `console.error` stack).
 * 3. The harness author can swap interpreters (e.g. `uv run python` vs
 *    `python3`, `bun` vs `node`) by pointing at a different binary in
 *    `CodeExecutorOptions.interpreters`.
 *
 * Pair this with `H.codingAgent(...)` for the full reduce-ceremony preset.
 */
import { type SandboxPolicy } from "./sandbox.js";
import { type HarnessTool } from "./types.js";
export type CodeLanguage = "python" | "node" | "typescript" | "bash" | "shell";
export interface CodeExecutorOptions {
    /**
     * Override the binary used for each language. Useful when the host has
     * multiple Python versions, or when the user prefers `bun` to `node`.
     *
     * Each entry can be a single binary name (`"python3.12"`) or a full
     * argv prefix (`["uv", "run", "python"]`).
     */
    interpreters?: Partial<Record<CodeLanguage, string | string[]>>;
    /** Default per-call wall clock in milliseconds. */
    defaultTimeoutMs?: number;
    /** Languages that should NOT be exposed even if their interpreter exists. */
    disable?: CodeLanguage[];
    /** Optional streaming sink for live stdout. */
    onOutput?: (chunk: string) => void;
}
export interface CodeRunResult {
    language: CodeLanguage;
    stdout: string;
    stderr: string;
    exitCode: number;
    truncated: boolean;
    durationMs: number;
}
/**
 * Polyglot code runner. Holds a `SandboxPolicy` reference and an
 * interpreter table; calling `.run(...)` shells out to the right binary.
 */
export declare class CodeExecutor {
    readonly sandbox: SandboxPolicy;
    readonly defaultTimeoutMs: number;
    private readonly interpreters;
    private readonly disabled;
    private readonly onOutput?;
    private detectedCache?;
    constructor(sandbox: SandboxPolicy, opts?: CodeExecutorOptions);
    /** Run `source` under the chosen language; returns captured streams. */
    run(language: CodeLanguage, source: string, opts?: {
        timeoutMs?: number;
        stdin?: string;
    }): Promise<CodeRunResult>;
    /** Probe interpreters once and cache. Used by `which_languages` tool. */
    detect(): Promise<Record<CodeLanguage, boolean>>;
    /** Build LLM-callable tools that wrap this executor. */
    tools(): HarnessTool[];
    private materialize;
}
//# sourceMappingURL=code-executor.d.ts.map