Download twinlab/settings.py from ZJUSCL/TwinLab-Bench: direct link, hf CLI and curl.
- Browser
- Download file 6.51 kB
-
https://huggingface.co/datasets/ZJUSCL/TwinLab-Bench/resolve/main/twinlab/settings.py
- Command line
-
hf download hf://datasets/ZJUSCL/TwinLab-Bench/twinlab/settings.py
-
curl -L -o settings.py https://huggingface.co/datasets/ZJUSCL/TwinLab-Bench/resolve/main/twinlab/settings.py
6.51 kB
| """Machine settings: where the agent CLIs live, which logged-in config they use, the proxy, and the sandbox. | |
| They are read from machine.yaml at the repository root. That file is not committed (it holds a proxy password and | |
| an API key); copy machine.example.yaml and fill it in. Nothing else in the package depends on the computer. | |
| """ | |
| from pathlib import Path | |
| import yaml | |
| ROOT = Path(__file__).resolve().parents[1] | |
| MACHINE_FILE = ROOT / "machine.yaml" | |
| assert MACHINE_FILE.is_file(), f"{MACHINE_FILE} is missing: copy machine.example.yaml to machine.yaml and fill it in" | |
| _m = yaml.safe_load(MACHINE_FILE.read_text()) | |
| def _path(p: str) -> Path: | |
| return Path(p).expanduser() | |
| HOME = Path.home() | |
| # ---- Claude Code: the environment agent and the judge always; the actor when --actor-agent claude-code ---- | |
| CLAUDE_BIN = _path(_m["claude"]["bin"]) | |
| CLAUDE_INSTALL_DIR = _path(_m["claude"]["install_dir"]) | |
| # A logged-in Claude Code config dir. The environment agent and the judge run on it directly; the actor gets a fresh | |
| # copy with only the login keys (see actors/claude_code.py), mounted at the same path inside its sandbox. | |
| CLAUDE_CONFIG_DIR = _path(_m["claude"]["config_dir"]) | |
| CLAUDE_LAUNCH_FLAGS = list(_m["claude"]["launch_flags"]) | |
| # zsh for Claude Code's Bash tool (env, judge, actor). A zsh whose loader prints a warning (anaconda's | |
| # libtinfow "no version information available") puts that line into every tool result the models read. | |
| SHELL_BIN = _path(_m["claude"]["shell"]) | |
| PROXY = _m["claude"]["proxy"] | |
| NO_PROXY = _m["claude"]["no_proxy"] | |
| # Non-Claude models run inside Claude Code through an Anthropic-compatible endpoint: model id -> base_url, | |
| # auth_token, proxy (null = direct), config_dir, cli_env (extra CLI variables, e.g. retries). Claude models (claude-*) need no entry and run on the logged-in | |
| # config above; any other model must have one (claude_cli.model_backend). | |
| # An entry with `endpoint: deepseek` takes base_url and auth_token from the environment (_deepseek_endpoint). | |
| # api_format: "openai" = an OpenAI-format endpoint behind the local LiteLLM proxy (scripts/llm_proxy.py), probed on | |
| # its /v1/chat/completions route; "anthropic" = Claude Code talks to the endpoint directly, probed on /v1/messages. | |
| DEEPSEEK_ANTHROPIC_DEFAULT = "https://api.deepseek.com/anthropic" | |
| def _deepseek_endpoint(model: str, b: dict) -> dict: | |
| """DEEPSEEK_BASE_URL_OPENAI set: that endpoint is reached through the local proxy (b["llm_proxy"]: url, | |
| master_key), which scripts/llm_proxy.py was configured with. Unset: Claude Code talks to DEEPSEEK_BASE_URL_ANTHROPIC | |
| (default DEEPSEEK_ANTHROPIC_DEFAULT) with DEEPSEEK_API_KEY.""" | |
| import os | |
| openai_base = os.environ.get("DEEPSEEK_BASE_URL_OPENAI") | |
| if openai_base: | |
| r = {"base_url": b["llm_proxy"]["url"], "auth_token": b["llm_proxy"]["master_key"], "api_format": "openai"} | |
| print(f"[settings] {model}: DEEPSEEK_BASE_URL_OPENAI={openai_base} -> through the local proxy {r['base_url']}", | |
| flush=True) | |
| else: | |
| r = {"base_url": os.environ.get("DEEPSEEK_BASE_URL_ANTHROPIC", DEEPSEEK_ANTHROPIC_DEFAULT), | |
| "auth_token": os.environ["DEEPSEEK_API_KEY"], "api_format": "anthropic"} | |
| print(f"[settings] {model}: Anthropic format, directly at {r['base_url']}", flush=True) | |
| return r | |
| def _backend(model: str, b: dict) -> dict: | |
| b = {**b, "config_dir": _path(b["config_dir"])} | |
| if b.get("endpoint") == "deepseek": | |
| return {**b, **_deepseek_endpoint(model, b)} | |
| assert "endpoint" not in b, f"machine.yaml model_backends.{model}: unknown endpoint {b['endpoint']!r}" | |
| return {"api_format": "openai", **b} # an explicit base_url: a LiteLLM proxy or gateway with an OpenAI route | |
| MODEL_BACKENDS = {m: _backend(m, b) for m, b in _m["model_backends"].items()} | |
| # ---- Codex: the actor when --actor-agent codex ---- | |
| CODEX_BIN = _path(_m["codex"]["bin"]) | |
| CODEX_PROVIDER = dict(_m["codex"]["provider"]) # one [model_providers.<name>] table of Codex's config.toml | |
| CODEX_API_KEY = _m["codex"]["api_key"] # exported to the actor as CODEX_PROVIDER["env_key"] | |
| CODEX_WEB_SEARCH = _m["codex"]["web_search"] # Codex config value: "live", "cached" or "disabled" | |
| CODEX_PROXY = _m["codex"]["proxy"] # null: the provider is reached directly | |
| # model metadata catalog (Codex model_catalog_json) for model names Codex does not know, e.g. the gateway's | |
| # azure_openai/<slug> (2026-11-05: without it Codex 0.141 sent no reasoning settings) | |
| CODEX_MODEL_CATALOG = _path(_m["codex"]["model_catalog"]) | |
| # ---- Actor reasoning effort ---- | |
| # the agent CLI's default effort per actor model (measured from its requests); used, passed explicitly and recorded | |
| # when no --actor-effort is given (every model's reasoning effort is recorded) | |
| ACTOR_DEFAULT_EFFORT = dict(_m["actor_default_effort"]) | |
| # ---- Actor sandbox (bubblewrap) ---- | |
| BWRAP = _path(_m["sandbox"]["bwrap"]) | |
| # read-only inside the sandbox: the agent binaries (sandbox.py adds the Python running the benchmark) | |
| SANDBOX_RO_BINDS = [_path(p) for p in _m["sandbox"]["ro_binds"]] | |
| # true: the actor gets its own PID namespace and /proc, so host command lines (case id, paths) are invisible. | |
| # false where bwrap cannot mount a new proc ("Can't mount proc on /newroot/proc", e.g. inside a Docker container); | |
| # the actor then sees host command lines, though not other processes' files (/proc/<pid>/cwd, environ). | |
| # Optional key: when absent, a one-line bwrap call decides (machine.yaml files from before 2026-11-11 have none). | |
| OWN_PROC_TEST = ["--unshare-pid", "--ro-bind", "/", "/", "--dev", "/dev", "--proc", "/proc", "true"] | |
| def _own_proc() -> bool: | |
| if "own_proc" in _m["sandbox"]: | |
| v = _m["sandbox"]["own_proc"] | |
| assert isinstance(v, bool), "machine.yaml sandbox.own_proc must be true or false" | |
| return v | |
| import subprocess | |
| p = subprocess.run([str(BWRAP), *OWN_PROC_TEST], capture_output=True, text=True) | |
| print(f"[settings] sandbox.own_proc not set; bwrap {'can' if p.returncode == 0 else 'cannot'} mount a new /proc " | |
| f"here -> own_proc {p.returncode == 0}{'' if p.returncode == 0 else ' (' + p.stderr.strip() + ')'}", | |
| flush=True) | |
| return p.returncode == 0 | |
| SANDBOX_OWN_PROC = _own_proc() | |
| for _p in (CLAUDE_BIN, CLAUDE_CONFIG_DIR, SHELL_BIN, BWRAP, *SANDBOX_RO_BINDS, | |
| *(b["config_dir"] for b in MODEL_BACKENDS.values())): # CODEX_BIN is checked when Codex runs | |
| assert _p.exists(), f"machine.yaml: {_p} does not exist" | |