Download twinlab/actors/codex.py from ZJUSCL/TwinLab-Bench: direct link, hf CLI and curl.
- Browser
- Download file 10.6 kB
-
https://huggingface.co/datasets/ZJUSCL/TwinLab-Bench/resolve/main/twinlab/actors/codex.py
- Command line
-
hf download hf://datasets/ZJUSCL/TwinLab-Bench/twinlab/actors/codex.py
-
curl -L -o codex.py https://huggingface.co/datasets/ZJUSCL/TwinLab-Bench/resolve/main/twinlab/actors/codex.py
10.6 kB
| """Codex CLI as the actor (`codex exec --json`), inside the same sandbox as Claude Code (sandbox.py). | |
| - CODEX_HOME is a per-run dir mounted at ~/.codex inside the sandbox. Its config.toml holds only the model provider | |
| of machine.yaml, the web-search setting, and the `lab` MCP server; nothing of the user's own Codex config. | |
| - The provider's API key is passed as the environment variable named by the provider's env_key. | |
| - config.toml points model_catalog_json at a copy of machine.yaml codex.model_catalog: official model metadata | |
| (reasoning defaults, context window, encrypted reasoning) for names Codex does not know, e.g. the gateway's | |
| azure_openai/<slug>; without it Codex falls back to metadata that sends no reasoning settings (2026-11-05). | |
| - Codex's own sandbox is off (--dangerously-bypass-approvals-and-sandbox): bubblewrap is the sandbox. | |
| - guard_hook.py (guard.py installs it, needles stored only as hashes; CODEX_HOME/hooks.json, same payload as Claude | |
| Code: tool_name "Bash", tool_input.command): PreToolUse denies shell commands that name the source record, | |
| PostToolUse withholds shell output that contains a blocklisted string. Codex runs hooks only after their trust is | |
| persisted, so every invocation passes --dangerously-bypass-hook-trust (the hook is ours). The hosted web_search tool | |
| does not go through hooks (probe 2026-11-05); since 2026-11-06 Codex talks to | |
| the provider through websearch_relay.py (one per run, base_url overridden per invocation), which drops answers | |
| whose web searches reached the source and adds a protocol notice instead. Runs prepared before that have no | |
| websearch_guard.json and resume without the relay; their leaks are caught by the contamination audit. | |
| - stream_idle_timeout_ms is raised (STREAM_IDLE_TIMEOUT_MS) because the relay hands Codex an answer only once it is | |
| complete. | |
| - The event stream does not say which model answered, so the served model is not checked (REPORTS_SERVED_MODEL). | |
| - Codex assigns the session id (thread_id of the first event); later invocations use `codex exec resume <id>`. | |
| """ | |
| import json | |
| import os | |
| import re | |
| import shutil | |
| import sys | |
| from .. import settings | |
| from . import guard, websearch_relay | |
| from .base import ActorAgent | |
| from .sandbox import actor_env, bwrap_prefix | |
| SANDBOX_CODEX_HOME = settings.HOME / ".codex" | |
| MODEL_CATALOG_NAME = "model_catalog.json" # copy of settings.CODEX_MODEL_CATALOG in the per-run CODEX_HOME | |
| # One lab call waits for the environment agent (minutes, or hours if the environment's claude.ai quota runs out | |
| # and is waited out); Codex must not give up on the tool call before that. | |
| MCP_TOOL_TIMEOUT_S = 24 * 3600 | |
| MCP_STARTUP_TIMEOUT_S = 60 | |
| # the url line of [mcp_servers.lab] in config.toml, as prepare() writes it or as command() last set it | |
| MCP_URL_LINE = re.compile(r'^url = "http://127\.0\.0\.1:\d+/mcp[^"]*".*$', re.M) | |
| STRIP_ENV_PREFIXES = ("CLAUDE", "ANTHROPIC", "CTX_", "OPENAI", "CODEX") | |
| STRIP_ENV_PROXY = ("http_proxy", "https_proxy", "no_proxy", "all_proxy") | |
| # item types of `codex exec --json` that are not tool use | |
| NON_TOOL_ITEMS = {"agent_message", "reasoning", "todo_list", "error"} | |
| # provider errors that every later request of the session repeats: the run ends and is judged as it stands | |
| # (Azure allows 50 images per request; 058-02 luna got 51 lab images) | |
| TERMINAL_API_ERRORS = {"Exceeded maximum number of images": "max_images_per_request"} | |
| STREAM_IDLE_TIMEOUT_MS = 3600 * 1000 # Codex default 300000; the relay sends nothing until the answer is complete | |
| def toml_value(v) -> str: | |
| if isinstance(v, bool): | |
| return "true" if v else "false" | |
| if isinstance(v, (int, float)): | |
| return str(v) | |
| assert isinstance(v, str), f"unsupported TOML value {v!r}" | |
| return json.dumps(v) # a JSON string is a valid TOML basic string | |
| class CodexActor(ActorAgent): | |
| name = "codex" | |
| REPORTS_SERVED_MODEL = False | |
| relay = None # websearch_relay.Relay, started at the first invocation of this process | |
| def relay_args(self): | |
| if not (self.run_dir / websearch_relay.STATE_FILE).exists(): | |
| print(f"[ws-relay] {self.run_dir} was prepared before the web-search relay: Codex talks to the " | |
| f"provider directly", flush=True) | |
| return [] | |
| assert settings.CODEX_PROXY is None, "the web-search relay connects to the provider directly" | |
| if self.relay is None: | |
| self.relay = websearch_relay.Relay(self.run_dir, settings.CODEX_PROVIDER["base_url"]) | |
| name = settings.CODEX_PROVIDER["name"] | |
| return ["-c", f"model_providers.{name}.base_url=" | |
| f"{json.dumps(self.relay.base_url(settings.CODEX_PROVIDER['base_url']))}", | |
| "-c", f"model_providers.{name}.stream_idle_timeout_ms={STREAM_IDLE_TIMEOUT_MS}"] | |
| def prepare(self, case, model): | |
| assert settings.CODEX_BIN.exists(), f"machine.yaml codex.bin: {settings.CODEX_BIN} does not exist" | |
| self.cfg.mkdir(parents=True) | |
| p = settings.CODEX_PROVIDER | |
| shutil.copyfile(settings.CODEX_MODEL_CATALOG, self.cfg / MODEL_CATALOG_NAME) # visible inside the sandbox | |
| lines = [f"model_provider = {toml_value(p['name'])}", | |
| f"web_search = {toml_value(settings.CODEX_WEB_SEARCH)}", | |
| f"model_catalog_json = {toml_value(str(SANDBOX_CODEX_HOME / MODEL_CATALOG_NAME))}", | |
| "", | |
| f"[model_providers.{p['name']}]", | |
| *(f"{k} = {toml_value(v)}" for k, v in p.items()), | |
| "", | |
| "[mcp_servers.lab]", | |
| 'url = "http://127.0.0.1:0/mcp"', # replaced on every invocation (command()) | |
| f"tool_timeout_sec = {MCP_TOOL_TIMEOUT_S}", | |
| f"startup_timeout_sec = {MCP_STARTUP_TIMEOUT_S}"] | |
| (self.cfg / "config.toml").write_text("\n".join(lines) + "\n") | |
| guard.install(self.cfg / "hooks", case) | |
| hook = [{"type": "command", # path inside the sandbox | |
| "command": f"{sys.executable} {SANDBOX_CODEX_HOME}/hooks/{guard.HOOK_FILE}"}] | |
| (self.cfg / "hooks.json").write_text(json.dumps({"hooks": { | |
| "PreToolUse": [{"matcher": "Bash", "hooks": hook}], | |
| "PostToolUse": [{"matcher": "Bash", "hooks": hook}]}}, indent=1)) | |
| websearch_relay.write_state(self.run_dir, case.guard_needles) | |
| case.write_actor_workspace(self.ws) | |
| def new_session_id(self): | |
| return None | |
| def command(self, message, model, mcp_url, session_id, new_session): | |
| # effort None: runs started before 2026-11-05 recorded none and keep the catalog default on resume | |
| effort = [] if self.effort is None else ["-c", f"model_reasoning_effort={json.dumps(self.effort)}"] | |
| # the hook and hooks.json, read-only (hooks/guard.log stays writable for the hook) | |
| protected = [(self.cfg / rel, SANDBOX_CODEX_HOME / rel) for rel in | |
| ("hooks.json", f"hooks/{guard.HOOK_FILE}", f"hooks/{guard.NEEDLES_FILE}")] | |
| # the lab url (with the run's token) goes into config.toml, not argv: without own_proc, other runs' actors | |
| # can read every host command line | |
| cfg_toml = self.cfg / "config.toml" | |
| text, n = MCP_URL_LINE.subn(f"url = {json.dumps(mcp_url)}", cfg_toml.read_text()) | |
| assert n == 1, f"{cfg_toml}: expected one [mcp_servers.lab] url line, found {n}" | |
| cfg_toml.write_text(text) | |
| return bwrap_prefix([(self.cfg, SANDBOX_CODEX_HOME)], self.ws, protected) + [ | |
| str(settings.CODEX_BIN), "exec", *([] if new_session else ["resume", session_id]), | |
| "--json", "--skip-git-repo-check", "--dangerously-bypass-approvals-and-sandbox", | |
| "--dangerously-bypass-hook-trust", "-m", model, *effort, *self.relay_args(), message, | |
| ] | |
| def env(self): | |
| env = {k: v for k, v in os.environ.items() | |
| if not k.startswith(STRIP_ENV_PREFIXES) and k.lower() not in STRIP_ENV_PROXY} | |
| env["CODEX_HOME"] = str(SANDBOX_CODEX_HOME) | |
| env[settings.CODEX_PROVIDER["env_key"]] = settings.CODEX_API_KEY | |
| if settings.CODEX_PROXY is not None: | |
| env.update(HTTP_PROXY=settings.CODEX_PROXY, HTTPS_PROXY=settings.CODEX_PROXY) | |
| return actor_env(env, (settings.CODEX_PROVIDER["env_key"],)) | |
| def session_id_from_stream(self, stream): | |
| first = json.loads(stream.read_text().splitlines()[0]) | |
| assert first["type"] == "thread.started", f"codex stream does not start with thread.started: {first}" | |
| return first["thread_id"] | |
| def served_models(self, stream): | |
| raise AssertionError("codex streams do not report the served model") | |
| def usage_limit_hit(self, stream_tail): | |
| return False # API-key billing: no subscription usage limit to wait out | |
| def wait_for_usage_reset(self, stream_tail): | |
| raise AssertionError("codex has no usage limit to wait for") | |
| def terminal_api_error(self, stream_tail): | |
| for needle, label in TERMINAL_API_ERRORS.items(): | |
| if needle in stream_tail: | |
| return label | |
| return None | |
| def tool_events(stream): | |
| events = [] | |
| for line in stream.read_text().splitlines(): | |
| m = json.loads(line) | |
| if m["type"] != "item.completed": | |
| continue | |
| it = m["item"] | |
| t = it["type"] | |
| if t in NON_TOOL_ITEMS: | |
| continue | |
| if t == "command_execution": | |
| events.append({"kind": "call", "name": "shell", "input": {"command": it["command"]}}) | |
| events.append({"kind": "result", "text": it["aggregated_output"], "lab": False}) | |
| elif t == "mcp_tool_call": | |
| lab = it["server"] == "lab" | |
| events.append({"kind": "call", "name": f"mcp__{it['server']}__{it['tool']}", | |
| "input": it["arguments"]}) | |
| if it["error"] is not None: | |
| text = f"ERROR: {it['error']}" | |
| else: | |
| text = " ".join(x.get("text", f"<{x['type']}>") for x in it["result"]["content"]) | |
| events.append({"kind": "result", "text": text, "lab": lab}) | |
| elif t == "web_search": | |
| events.append({"kind": "call", "name": "web_search", "input": {"query": it["query"]}}) | |
| elif t == "file_change": | |
| events.append({"kind": "call", "name": "file_change", "input": it["changes"]}) | |
| else: | |
| raise AssertionError(f"unknown codex item type {t!r} in {stream}: {line[:300]}") | |
| return events | |