[codex] add flmexec runtime parameter

[k82cn]

Summary

• add an optional runtime field to flmexec Script requests and the flmexec CLI
• use runtime as the Python version for python scripts, defaulting to 3.12
• use runtime as the shell type for shell scripts, defaulting to bash
• update flmexec examples and the e2e helper to carry the optional runtime field

Verification

• cargo fmt --check -p flmexec
• cargo test -p flmexec
• cargo check -p flmexec
• uv run --extra dev ruff check tests/test_flmexec.py (from e2e/)
• python3 -m py_compile e2e/tests/test_flmexec.py examples/agents/sra/apis.py examples/agents/scripts/main.py

[gemini-code-assist]

Code Review

This pull request introduces a runtime parameter to script execution, allowing users to specify a particular Python version or shell type (e.g., zsh, bash). While this adds valuable flexibility, the changes in the Python script runner introduce a regression by removing the fallback chain that auto-detects the latest installed Python version or reads from the FLAME_PYTHON_VERSION_ENV environment variable. Feedback focuses on restoring this fallback behavior to preserve backward compatibility, updating tests accordingly, and optimizing the shell path validation to avoid unnecessary heap allocations.

[gemini-code-assist]

Pass envs and &flame_home to python_version to allow falling back to the propagated FLAME_PYTHON_VERSION_ENV environment variable and auto-detecting the latest installed Python version when runtime is not specified.

Suggested change

	let python_version = python_version(runtime);
	let python_version = python_version(envs, &flame_home, runtime);

[gemini-code-assist]

By only checking runtime and defaulting to DEFAULT_PYTHON_VERSION, the new implementation completely ignores the propagated FLAME_PYTHON_VERSION_ENV environment variable and removes the latest_installed_python_version auto-detection fallback. This is a regression for existing environments that rely on these fallbacks.

Restoring the full fallback chain (checking runtime first, then FLAME_PYTHON_VERSION_ENV, then auto-detecting the latest installed version, and finally defaulting to DEFAULT_PYTHON_VERSION) preserves backward compatibility and robust environment-based configuration.

fn python_version(envs: &HashMap<String, String>, flame_home: &Path, runtime: Option<&str>) -> String {
    runtime
        .map(str::trim)
        .filter(|version| !version.is_empty())
        .map(version_number)
        .map(ToOwned::to_owned)
        .or_else(|| {
            envs.get(FLAME_PYTHON_VERSION_ENV)
                .map(|version| version_number(version))
                .filter(|version| !version.is_empty())
                .map(ToOwned::to_owned)
        })
        .or_else(|| latest_installed_python_version(flame_home))
        .unwrap_or_else(|| DEFAULT_PYTHON_VERSION.to_string())
}

fn version_number(version: &str) -> &str {
    version.strip_prefix("python").unwrap_or(version)
}

fn latest_installed_python_version(flame_home: &Path) -> Option<String> {
    let lib_path = flame_home.join("lib");
    let mut versions = fs::read_dir(lib_path)
        .ok()?
        .flatten()
        .filter_map(|entry| {
            let path = entry.path();
            if !path.is_dir() || !path.join("site-packages").is_dir() {
                return None;
            }

            let name = entry.file_name();
            let name = name.to_string_lossy();
            name.strip_prefix("python")
                .filter(|version| !version.is_empty())
                .map(|version| version.to_string())
        })
        .collect::<Vec<_>>();

    versions.sort_by_key(|version| minor_version(version));
    versions.pop()
}

fn minor_version(version: &str) -> Vec<u32> {
    version
        .split('.')
        .map(|part| part.parse::<u32>().unwrap_or(0))
        .collect()
}

[gemini-code-assist]

Since we restored the fallback to FLAME_PYTHON_VERSION_ENV, we should remove it from this test's environment setup so that the test correctly verifies falling back to DEFAULT_PYTHON_VERSION when no version is specified anywhere.

        ]);

[gemini-code-assist]

Optimize the supported_path check to avoid heap allocations from format! in the loop by using strip_prefix.

    let supported_path = SUPPORTED_SHELLS.iter().any(|&shell| {
        runtime.strip_prefix("/bin/").map_or(false, |s| s == shell)
            || runtime.strip_prefix("/usr/bin/").map_or(false, |s| s == shell)
    });