| |
| |
| |
| |
| @@ -20,8 +20,18 @@ pip install --no-deps -e <vggt-omega checkout> # optional; gated weights, FAIR |
| pytest -q |
| ``` |
| |
| -Generation also needs Docker, the agent CLIs logged in on the host (Claude Code at `~/.local/bin/claude`, Codex CLI, |
| -OpenCode's login in `~/.local/share/opencode/auth.json`) and the two images: |
| +Generation also needs Docker and host logins (Claude Code at `~/.local/bin/claude`, Codex's login in |
| +`~/.codex/auth.json`, OpenCode V2's active account via `opencode auth export <provider>`, or a legacy |
| +`~/.local/share/opencode/auth.json`). The runner converts V2 credentials into a private temporary V1 login for |
| +the container; it does not require or create a host `auth.json`, or copy the host database. Credential refreshes |
| +use `opencode auth import`, preserving a concurrent user login or account switch. |
| +Codex 0.167.0 and OpenCode 1.19.5 |
| +are installed inside both images; a host Codex executable is not mounted or required. |
| +The images target Linux AMD64. On Apple Silicon, build with `--platform linux/amd64`; Docker Desktop must share |
| +the repository and run directories. MuJoCo generation can use emulation. Isaac Sim requires a supported NVIDIA GPU |
| +host and NVIDIA Container Toolkit; building its image on a Mac does not verify GPU simulation. |
| +Claude Code still mounts the host executable and therefore requires a compatible Linux binary. |
| +Build the two images: |
| |
| ```bash |
| docker build -t simready-generation:latest -f src/simready/generation/runtime/Dockerfile src/simready/generation/runtime |
| |
| |
| |
| |
| @@ -58,12 +58,18 @@ from; do not read authentication files. |
| |
| - **Claude Code** (host `~/.local/bin/claude`, mounted read-only): every tool but `WebFetch`; `WebSearch` runs on |
| Anthropic's side. `--claude-config-dir` picks the login folder (default `~/.claude`, e.g. `~/.claude-huan`). |
| -- **Codex CLI** (host `codex`, mounted read-only): `web_search="live"`, browser features off. Model `gpt-6.1-sol` |
| - (`codex debug models`). |
| +- **Codex CLI** 0.167.0 (Linux x64, installed in both images, pinned by archive and binary sha256 in |
| + `runtime/install_codex.sh`): `web_search="live"`, browser features off. Model `gpt-6.1-sol`. |
| + The runner copies only the host login (`~/.codex/auth.json`) into the session state, not the host executable. |
| - **OpenCode** 1.19.5 (in both images, pinned by sha256 with the ripgrep its glob and grep tools need): |
| `opencode run --pure --auto --format json -m opencode-go/<model>`; `webfetch` denied by its permission config, so not |
| offered; `websearch` (Exa or Parallel) on. Its config, cache, login and session database live in the session's state |
| folder (`XDG_*`); updates, the models.dev fetch, plugins, project config and Claude Code compatibility are off. |
| + On a V2 host, the runner exports only the model provider's active account with `opencode auth export <provider>`. |
| + It converts V2 API-key credentials into the V1 schema in the private temporary state folder. The host needs no |
| + `auth.json`; its database is neither mounted nor copied. Rotated credentials return through `opencode auth import` |
| + only if the exported account and credentials still match the initial login. A V1 host can still use its existing |
| + `~/.local/share/opencode/auth.json`. CLI credential output is captured and excluded from errors and run logs. |
| - **Isolation.** Read-only input and tools, writable output and scratch, the login copied into a private state folder and |
| saved back when it rotates (a backup first; a login changed meanwhile by someone else is kept). Every 20 s a running |
| session exchanges rotated tokens with the saved login, so sessions sharing a login do not invalidate each other. |
| @@ -77,14 +83,18 @@ from; do not read authentication files. |
| |
| | Image | Dockerfile | Contents | |
| |---|---|---| |
| -| `simready-generation:latest` | `runtime/Dockerfile` | Python 3.12, MuJoCo 4.0.0, NumPy, SciPy, Pillow, imageio-ffmpeg, ffmpeg, Blender 5.2.3, OpenCode 1.19.5 + ripgrep 15.1.0, `runtime/requirements-tools.txt` (trimesh, Open3D, OpenCV, scikit-image, PyMeshLab, manifold3d, usd-core, shapely, pandas, matplotlib, scikit-learn, networkx, pygltflib, rtree) | |
| -| `simready-isaac-generation:latest` | `runtime/Dockerfile.isaac` | `nvcr.io/nvidia/isaac-sim:6.2.0` plus the same Blender and OpenCode; the host ffmpeg is mounted | |
| +| `simready-generation:latest` | `runtime/Dockerfile` | Python 3.12, MuJoCo 4.0.0, NumPy, SciPy, Pillow, imageio-ffmpeg, ffmpeg, Blender 5.2.3, Codex 0.167.0, OpenCode 1.19.5 + ripgrep 15.1.0, `runtime/requirements-tools.txt` (trimesh, Open3D, OpenCV, scikit-image, PyMeshLab, manifold3d, usd-core, shapely, pandas, matplotlib, scikit-learn, networkx, pygltflib, rtree) | |
| +| `simready-isaac-generation:latest` | `runtime/Dockerfile.isaac` | `nvcr.io/nvidia/isaac-sim:6.2.0` plus the same Blender, Codex and OpenCode; the host ffmpeg is mounted | |
| |
| ```bash |
| docker build -t simready-generation:latest -f src/simready/generation/runtime/Dockerfile src/simready/generation/runtime |
| docker build -t simready-isaac-generation:latest -f src/simready/generation/runtime/Dockerfile.isaac src/simready/generation/runtime |
| ``` |
| |
| +Both images target Linux AMD64; add `--platform linux/amd64` when building on Apple Silicon. Docker Desktop must |
| +share the repository and run directories. Codex and OpenCode use image binaries; Claude Code still needs a compatible |
| +Linux host executable. Isaac Sim also requires a supported NVIDIA GPU host with NVIDIA Container Toolkit. |
| + |
| An Isaac session needs its CLI's shader-cache volume warmed once (`data/runtime/isaac/smoke_<cli>/smoke.json`): |
| |
| ```bash |
| @@ -98,6 +108,35 @@ docker run --rm --gpus device=GPU-... --user 1234:1234 --entrypoint bash -e ACCE |
| |
| ## Commands |
| |
| +Campaigns can enforce subscription reserves with an optional top-level `quota` object: |
| + |
| +```json |
| +"quota": { |
| + "codex_weekly_remaining_percent": 30, |
| + "poll_seconds": 30, |
| + "opencode_pause_on_limit": true |
| +} |
| +``` |
| + |
| +The host's Codex app-server `account/rateLimits/read` supplies the weekly window (10080 minutes). |
| +At or below the configured reserve, the runner stops dispatching Codex jobs and stops active Codex containers |
| +at their next monitoring check (at most 20 seconds after detection). With a positive reserve, missing or invalid quota data also pause Codex. |
| +Polling and provider reporting delays mean this is not an exact account-wide billing cap; other sessions also use |
| +the account. No reset credits are consumed. Set the reserve to `0` to use the full weekly allowance. Quota policy edits |
| +reload into the existing guard. A reserve-threshold pause otherwise stays paused for this invocation; another CLI |
| +may continue. With a positive reserve, a quota-query failure pauses spending while quota remains unknown. With a |
| +zero reserve, unavailable quota reporting leaves exhaustion enforcement to the provider. Queries retry at the configured |
| +poll interval; a fresh valid reading above the reserve releases only the query-failure pause and its partial job. |
| +OpenCode HTTP 402/429 errors pause its login without retrying the same rejected job. These responses can indicate |
| +either exhausted allowance or a temporary provider rate limit; they do not establish a remaining balance. |
| +Partial quota-stopped runs are retained as `quota_paused`, skipped by evaluation, and never counted as generated. |
| +An explicit restart retries these jobs from the beginning while retaining the partial attempts as provenance. |
| +Completed runs are kept. Existing saved adaptive concurrency cannot exceed the configured `per_cli_max`. |
| +Only one `campaign run` process can hold a campaign's `.run.lock` at once. |
| + |
| +For unattended local runs, redirect stdout/stderr to a persistent log and detach stdin; a closed terminal pipe must |
| +not be the process's output destination. Keep Docker, network connectivity and the workstation available. |
| + |
| ```bash |
| simready generate --track scenes --engine mujoco --id 41159420 --cli codex --model gpt-6.1-sol --budget 900 1800 |
| simready generate --track objects --engine mujoco --id input_2d_001 --cli claude --claude-config-dir ~/.claude-huan --model claude-opus-5-5 |
| |
| |
| |
| |
| @@ -10,6 +10,7 @@ each other's rotated tokens in step (Session.sync_login). The config format is i |
| simready campaign status configs/campaigns/example.json |
| """ |
| import os |
| +import fcntl |
| from pathlib import Path |
| import queue |
| import subprocess |
| @@ -22,6 +23,7 @@ from ..common.gpu import MINIMUM_FREE_MIB, driver_busy, free_mib |
| from ..common.io import DATA, read_json, write_json |
| from .session import Session, shown |
| from .stage import frozen_protocol |
| +from .quota import QuotaGuard |
| |
| LOAD_PAUSE_SECONDS = 600 |
| LOGIN_START_GAP_SECONDS = 60 # a session refreshing an expired login rotates its refresh token; one starting beside it then fails |
| @@ -58,7 +60,7 @@ def recover(state): |
| for run in job["runs"]: |
| if run["evaluation"] in {"running", "failed"}: |
| run["evaluation"] = "pending" |
| - if job["state"] in {"running", "failed"}: |
| + if job["state"] in {"running", "failed"} or any(r.get("status") == "quota_paused" for r in job["runs"]): |
| job["attempts_abandoned"] = job.get("attempts_abandoned", []) + [r["run"] for r in job["runs"]] |
| job.update(state="pending", runs=[]) |
| job.pop("error", None) |
| @@ -131,6 +133,10 @@ def settle(job, held): |
| """A finished session's outcome. A CLI crash well into a session starts over once; a session failed by a rate limit |
| goes back to the queue (the login's limit is lowered elsewhere), and so does a first early failure; an early failure |
| that repeats looks like a lost login, so that login takes no more sessions.""" |
| + if any(r["status"] == "quota_paused" for r in job["runs"]): |
| + job["state"] = "pending" |
| + held[login(job)] = job["id"] |
| + return |
| failure = next((r for r in job["runs"] if r["status"] == "cli_failed"), None) |
| if not job["runs"]: |
| job["state"] = "failed" |
| @@ -180,6 +186,8 @@ class Campaign: |
| self.state = recover(read_json(self.path)) if self.path.is_file() else {"jobs": [], "held": {}} |
| self.merge_jobs() |
| self.state.setdefault("login_limits", {}) |
| + self.quota_guard = QuotaGuard(self.config.get("quota", {})) |
| + self.state["quota"] = self.quota_guard.snapshot() |
| if self.config.get("evaluate", True): # results generated with evaluation off (e.g. on another machine) are evaluated now |
| for entry in (r for j in self.state["jobs"] for r in j["runs"] if r["evaluation"] == "skipped"): |
| entry["evaluation"] = "pending" |
| @@ -223,6 +231,8 @@ class Campaign: |
| return |
| old, self.config_stamp = self.config["limits"], stamp |
| self.config = {**read_json(self.config_path), "name": self.config["name"]} |
| + if self.quota_guard.config != self.config.get("quota", {}): |
| + self.quota_guard.update_policy(self.config.get("quota", {})) |
| self.merge_jobs() |
| self.tune_pools() |
| for key, cap in (("isaac_sessions", "sessions"), ("isaac_evaluations", "evaluations")): |
| @@ -261,7 +271,11 @@ class Campaign: |
| self.isaac_changed = now |
| |
| def allowed(self, job): |
| - return self.state["login_limits"].get(login(job), limit(self.config["limits"], job)) |
| + configured = limit(self.config["limits"], job) |
| + current = self.state["login_limits"].get(login(job), configured) |
| + if current == 0 and configured > 0: |
| + current = configured |
| + return min(current, limit(self.config["limits"], job, "per_cli_max", current)) |
| |
| def rate_limited(self, job): |
| """A rate limit: halve the login's session limit and pause it.""" |
| @@ -283,7 +297,8 @@ class Campaign: |
| entry = {"run": str(shown(run)), "status": record["status"], "budget_seconds": record["budget_seconds"], |
| "elapsed_seconds": record["elapsed_seconds"], "stage_seconds": record.get("stage_seconds", record["elapsed_seconds"]), |
| "api_retries": record["api_retries"], "rate_limit_events": record["rate_limit_events"], |
| - "usd": (record.get("cost") or {}).get("usd"), "evaluation": "pending" if self.config.get("evaluate", True) else "skipped"} |
| + "usd": (record.get("cost") or {}).get("usd"), |
| + "evaluation": "pending" if self.config.get("evaluate", True) and record["status"] != "quota_paused" else "skipped"} |
| with self.lock: |
| job["runs"].append(entry) |
| if entry["rate_limit_events"]: |
| @@ -292,8 +307,10 @@ class Campaign: |
| if entry["evaluation"] == "pending": |
| (self.isaac if job["engine"] == "isaac" else self.mujoco).put((job, entry, run)) |
| try: |
| - Session(job["track"], job["engine"], job["item"], job["cli"], job["model"], job.get("effort"), job.get("gpu"), |
| - job.get("claude_config_dir"), campaign=self.config["name"]).run(job["budgets"], on_result) |
| + session = Session(job["track"], job["engine"], job["item"], job["cli"], job["model"], job.get("effort"), job.get("gpu"), |
| + job.get("claude_config_dir"), campaign=self.config["name"]) |
| + session.quota_guard = getattr(self, "quota_guard", None) |
| + session.run(job["budgets"], on_result) |
| with self.lock: |
| settle(job, self.state["held"]) |
| if job["state"] == "pending": # requeued: it may have been taken out of the config meanwhile |
| @@ -330,7 +347,18 @@ class Campaign: |
| def finished(self): |
| jobs = self.state["jobs"] |
| return (all(j["state"] != "running" for j in jobs) and all(r["evaluation"] in {"done", "failed", "skipped"} for j in jobs for r in j["runs"]) |
| - and all(j["state"] != "pending" or login(j) in self.state["held"] for j in jobs)) |
| + and all(j["state"] != "pending" or login(j) in self.state["held"] |
| + or j["cli"] in self.quota_guard.blocked() for j in jobs)) |
| + |
| + def release_revalidated_quota_holds(self, blocked): |
| + """Release only partial quota-stopped jobs after a fresh successful quota check.""" |
| + for job in self.state["jobs"]: |
| + name = login(job) |
| + if (job["cli"] not in blocked and self.state["held"].get(name) == job["id"] |
| + and job["state"] == "pending" and any(r.get("status") == "quota_paused" for r in job["runs"])): |
| + job["attempts_abandoned"] = job.get("attempts_abandoned", []) + [r["run"] for r in job["runs"]] |
| + job["runs"] = [] |
| + del self.state["held"][name] |
| |
| def run(self): |
| from ..common.io import REPO_ROOT |
| @@ -351,6 +379,13 @@ class Campaign: |
| threading.Thread(target=self.evaluator, args=(self.mujoco, False), daemon=True).start() |
| loaded_since, started = None, {} |
| while not self.finished(): |
| + quota_blocked = self.quota_guard.blocked() |
| + quota = self.quota_guard.snapshot() |
| + if quota != self.state.get("quota"): |
| + with self.lock: |
| + self.release_revalidated_quota_holds(quota_blocked) |
| + self.state["quota"] = quota |
| + self.save() |
| ceiling = self.config["limits"].get("pause_new_jobs_above_load") |
| loaded_since = (loaded_since or time.monotonic()) if ceiling and os.getloadavg()[0] > ceiling else None |
| paused = loaded_since is not None and time.monotonic() - loaded_since >= LOAD_PAUSE_SECONDS # a shared host: others' work comes first |
| @@ -360,6 +395,7 @@ class Campaign: |
| now = time.monotonic() |
| blocked = {name for name, at in started.items() if now - at < LOGIN_START_GAP_SECONDS} |
| blocked |= {name for name, at in self.cooling.items() if now - at < COOL_SECONDS} |
| + blocked |= quota_blocked |
| self.tune_isaac() |
| limits = {**self.config["limits"], "isaac_sessions": self.isaac_caps()["sessions"]} |
| job = None if paused else next_job(self.state["jobs"], limits, self.state["held"], |
| @@ -375,6 +411,8 @@ class Campaign: |
| time.sleep(2) |
| else: |
| time.sleep(5) |
| + self.state["quota"] = self.quota_guard.snapshot() |
| + self.save() |
| print(summary(self.state), flush=True) |
| |
| |
| @@ -389,6 +427,10 @@ def summary(state): |
| f"throttled results {sum(bool(r['api_retries'] or r['rate_limit_events']) for r in runs)}, " |
| f"list price so far ${sum(r['usd'] or 0 for j in jobs for r in j['runs'][-1:]):.2f}"] |
| lines += [f"HELD {name}: {job}" for name, job in state["held"].items()] |
| + quota = state.get("quota", {}) |
| + if quota.get("codex_weekly"): |
| + lines += [f"Codex weekly quota remaining {quota['codex_weekly']['remaining_percent']}% (last check)"] |
| + lines += [f"QUOTA PAUSED {cli}: {reason}" for cli, reason in quota.get("paused", {}).items()] |
| lines += [f"FAILED {j['id']}: {(j.get('error') or '').strip().splitlines()[-1:]}" for j in jobs if j["state"] == "failed"] |
| lines += [f"EVALUATION FAILED {r['run']}" for r in runs if r["evaluation"] == "failed"] |
| return "\n".join(lines) |
| @@ -401,5 +443,12 @@ def status(config_path): |
| |
| def main_run(config, generation_gpus="", evaluation_gpus="", render_gpu=None): |
| split = lambda value: [g for g in (value or "").split(",") if g] |
| - Campaign(config, split(generation_gpus), split(evaluation_gpus), render_gpu).run() |
| + directory = CAMPAIGNS / read_json(config)["name"] |
| + directory.mkdir(parents=True, exist_ok=True) |
| + with (directory / ".run.lock").open("a") as lock: |
| + try: |
| + fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB) |
| + except BlockingIOError: |
| + raise SystemExit("This campaign is already running.") from None |
| + Campaign(config, split(generation_gpus), split(evaluation_gpus), render_gpu).run() |
| |
| |
| |
| |
| |
| @@ -10,7 +10,6 @@ import hashlib |
| import json |
| from pathlib import Path |
| import re |
| -import shutil |
| import subprocess |
| |
| from ..common.io import BENCHMARK |
| @@ -33,18 +32,19 @@ BLENDER_VERSION = "5.2.3" |
| OPENCODE_HOSTS = ("opencode.ai", "mcp.exa.ai", "search.parallel.ai") |
| EGRESS_HOSTS = ("api.anthropic.com", "platform.claude.com", "chatgpt.com", "auth.openai.com") + OPENCODE_HOSTS |
| |
| -# The agent CLIs. Claude Code and Codex are the host's binaries, mounted read-only (their version is read at each run); |
| -# OpenCode is installed in both generation images, pinned by version and sha256 (runtime/install_opencode.sh). |
| +# Claude Code is mounted from the host. Codex and OpenCode are installed in both images, |
| +# pinned by version and sha256 (runtime/install_codex.sh and runtime/install_opencode.sh). |
| CLIS = { |
| "claude": {"name": "Claude Code", "binary": "host ~/.local/bin/claude, mounted read-only", |
| "login": "<config dir>/.credentials.json (default ~/.claude; --claude-config-dir)", |
| "tools": "every tool but WebFetch (--disallowedTools WebFetch); WebSearch runs on Anthropic's side", |
| "hosts": ["api.anthropic.com", "platform.claude.com"]}, |
| - "codex": {"name": "Codex CLI", "binary": "host codex, mounted read-only", "login": "~/.codex/auth.json", |
| + "codex": {"name": "Codex CLI", "version": "0.167.0", "binary": "/opt/codex/bin/codex in both generation images", |
| + "binary_sha256": "cdcb45aaa01d0f14e298985e09465aebccd47f64ecd298aea44814af7b62bbda", "login": "~/.codex/auth.json", |
| "tools": 'every tool, web_search="live", browser features off', "hosts": ["chatgpt.com", "auth.openai.com"]}, |
| "opencode": {"name": "OpenCode", "version": "1.19.5", "binary": "/opt/opencode/bin/opencode in both generation images", |
| "binary_sha256": "7df4e4136301f16589b0f30bf91a61380fca5f8ef22dd36570f5ebe1d4ec802c", |
| - "login": "~/.local/share/opencode/auth.json", "billing": "subscription (OpenCode Go)", |
| + "login": "host OpenCode V2 auth export/import API, or legacy ~/.local/share/opencode/auth.json", "billing": "subscription (OpenCode Go)", |
| "tools": "every tool but webfetch (denied by its permission config, so not offered); websearch on (Exa or Parallel)", |
| "hosts": list(OPENCODE_HOSTS)}, |
| } |
| @@ -218,7 +218,7 @@ def cli_version(cli): |
| """The installed version of a host-mounted CLI, or the pinned one.""" |
| if "version" in CLIS[cli]: |
| return CLIS[cli]["version"] |
| - binary = shutil.which("codex") if cli == "codex" else str(Path.home() / ".local/bin/claude") |
| + binary = str(Path.home() / ".local/bin/claude") |
| try: |
| return subprocess.run([binary, "--version"], capture_output=True, text=True, timeout=30).stdout.strip() or None |
| except (OSError, TypeError, subprocess.SubprocessError): |
| |
| |
| |
| |
| @@ -1,5 +1,5 @@ |
| # simready-generation:latest, the MuJoCo agents' runtime: MuJoCo, headless Blender (install_blender.sh), the geometry and |
| -# vision packages of requirements-tools.txt and the pinned OpenCode CLI with ripgrep (install_opencode.sh). |
| +# vision packages of requirements-tools.txt, pinned Codex (install_codex.sh) and OpenCode with ripgrep (install_opencode.sh). |
| # docker build -t simready-generation:latest -f src/simready/generation/runtime/Dockerfile src/simready/generation/runtime |
| FROM python:3.12-slim-bookworm |
| RUN apt-get update && apt-get install -y --no-install-recommends \ |
| @@ -14,6 +14,8 @@ COPY requirements-tools.txt /tmp/requirements-tools.txt |
| RUN pip install --no-cache-dir -r /tmp/requirements-tools.txt numpy==2.4.4 && rm /tmp/requirements-tools.txt |
| COPY install_opencode.sh /tmp/install_opencode.sh |
| RUN bash /tmp/install_opencode.sh && rm /tmp/install_opencode.sh && rm -rf /root/.local /root/.cache /root/.config |
| +COPY install_codex.sh /tmp/install_codex.sh |
| +RUN bash /tmp/install_codex.sh && rm /tmp/install_codex.sh |
| # No network but the CLI API (session.EGRESS_HOSTS): every package an agent may use is installed here. |
| ENV MUJOCO_GL=osmesa PYTHONUNBUFFERED=1 PIP_DISABLE_PIP_VERSION_CHECK=1 PATH=/tmp/agent-home/.local/bin:$PATH |
| WORKDIR /work |
| |
| |
| |
| |
| @@ -1,5 +1,5 @@ |
| # simready-isaac-generation:latest, the Isaac Sim agents' runtime: Isaac Sim plus the same pinned headless Blender and |
| -# OpenCode CLI as simready-generation:latest. Isaac evaluation keeps the plain nvcr image. |
| +# Codex and OpenCode CLIs as simready-generation:latest. Isaac evaluation keeps the plain nvcr image. |
| # docker build -t simready-isaac-generation:latest -f src/simready/generation/runtime/Dockerfile.isaac src/simready/generation/runtime |
| FROM nvcr.io/nvidia/isaac-sim:6.2.0 |
| USER root |
| @@ -9,5 +9,7 @@ COPY install_blender.sh /tmp/install_blender.sh |
| RUN bash /tmp/install_blender.sh && rm /tmp/install_blender.sh |
| COPY install_opencode.sh /tmp/install_opencode.sh |
| RUN bash /tmp/install_opencode.sh && rm /tmp/install_opencode.sh && rm -rf /root/.local /root/.cache /root/.config |
| +COPY install_codex.sh /tmp/install_codex.sh |
| +RUN bash /tmp/install_codex.sh && rm /tmp/install_codex.sh |
| ENV PIP_DISABLE_PIP_VERSION_CHECK=1 |
| USER isaac-sim |
| |
| |
| |
| |
| @@ -29,6 +29,8 @@ from . import contracts |
| from .contracts import EGRESS_HOSTS, IMAGES |
| from .cost import combine_costs, events, keep_codex_usage, keep_opencode_usage, run_cost |
| from .stage import contract_for, frozen_protocol, item_input, stage |
| +from .opencode_auth import OpenCodeLogin |
| +from .quota import opencode_limit |
| |
| MUJOCO_IMAGE, ISAAC_IMAGE = IMAGES["mujoco"], IMAGES["isaac"] |
| RUNS, RUNTIME = DATA / "runs", DATA / "runtime" |
| @@ -157,8 +159,13 @@ def throttling(log): |
| retries = limited = 0 |
| for event in events(log): |
| retries += event.get("subtype") == "api_retry" |
| - limited += (event.get("type") == "rate_limit_event" and (event.get("rate_limit_info") or {}).get("status") not in {"allowed", "allowed_warning"} |
| - or event.get("type") == "error") |
| + if event.get("type") == "rate_limit_event": |
| + limited += (event.get("rate_limit_info") or {}).get("status") not in {"allowed", "allowed_warning"} |
| + elif event.get("type") == "error": |
| + error = event.get("error") or {} |
| + if isinstance(error, dict): |
| + data = error.get("data") or {} |
| + limited += isinstance(data, dict) and data.get("statusCode") == 429 |
| return {"api_retries": retries, "rate_limit_events": limited} |
| |
| |
| @@ -214,7 +221,13 @@ class Session: |
| self.contract = contract_for(track, engine, item) |
| if contracts.missing_files(self.contract): |
| raise SystemExit(f"{self.contract} stages {', '.join(contracts.missing_files(self.contract))}, not present yet.") |
| - if not (self.login / self.auth_name).is_file(): |
| + if cli == "opencode": |
| + self.opencode_login = OpenCodeLogin(self.login, model.split("/", 1)[0]) |
| + try: |
| + self.read_login() |
| + except (OSError, RuntimeError) as error: |
| + raise SystemExit(f"OpenCode login is unavailable: {error}") from None |
| + elif not (self.login / self.auth_name).is_file(): |
| raise SystemExit(f"The {cli} login is unavailable ({self.login / self.auth_name}).") |
| if self.isaac and not gpu: |
| raise SystemExit("Isaac generation needs a GPU (--gpu UUID).") |
| @@ -229,9 +242,16 @@ class Session: |
| def persist(self, original, state, initial): |
| """Save a refreshed login from the state folder back to the CLI's own login.""" |
| if self.cli == "opencode": |
| + login = getattr(self, "opencode_login", None) |
| + if login is not None and login.v2: |
| + return login.persist(state / self.held, initial) |
| return persist_opencode(original, state / OPENCODE_DATA, initial) |
| return (persist_codex if self.cli == "codex" else persist_claude)(original, state, initial) |
| |
| + def read_login(self): |
| + login = getattr(self, "opencode_login", None) |
| + return login.read() if login is not None else (self.login / self.auth_name).read_bytes() |
| + |
| def agent(self): |
| if self.cli == "opencode": |
| variant = ["--variant", self.effort] if self.effort != "default" else [] |
| @@ -261,9 +281,7 @@ class Session: |
| if self.cli == "opencode": # the binary is the image's own (pinned); its config, cache and sessions live in the state folder |
| command += [part for key, value in OPENCODE_ENV.items() for part in ("-e", f"{key}={value}")] |
| elif self.cli == "codex": |
| - binary = Path(shutil.which("codex")).resolve() |
| - command += ["-e", "CODEX_HOME=/auth", "-e", "PATH=/opt/codex/bin:/usr/local/bin:/usr/local/sbin:/usr/sbin:/usr/bin:/sbin:/bin", |
| - "--mount", f"type=bind,src={binary.parent},dst=/opt/codex/bin,readonly"] |
| + command += ["-e", "CODEX_HOME=/auth", "-e", "PATH=/opt/codex/bin:/usr/local/bin:/usr/local/sbin:/usr/sbin:/usr/bin:/sbin:/bin"] |
| else: |
| binary = (Path.home() / ".local/bin/claude").resolve() |
| command += ["-e", "CLAUDE_CONFIG_DIR=/auth", "-e", "DISABLE_AUTOUPDATER=1", "--mount", f"type=bind,src={binary},dst=/usr/local/bin/claude,readonly"] |
| @@ -276,27 +294,27 @@ class Session: |
| Returns what both now hold.""" |
| try: |
| held = subprocess.run(["docker", "exec", name, "cat", "/auth/" + self.held], capture_output=True, timeout=15, check=True).stdout |
| - saved = (self.login / self.auth_name).read_bytes() |
| + saved = self.read_login() |
| if held and held != known: |
| with tempfile.TemporaryDirectory() as directory: |
| fresh = Path(directory) |
| (fresh / self.held).parent.mkdir(parents=True, exist_ok=True) |
| (fresh / self.held).write_bytes(held) |
| (fresh / self.held).chmod(0o600) |
| - self.persist(self.login, fresh, saved) |
| - return (self.login / self.auth_name).read_bytes() |
| + self.persist(self.login, fresh, known) |
| + return self.read_login() |
| if saved != known: |
| subprocess.run(["docker", "exec", "-i", name, "sh", "-c", f"cat > /auth/{self.held}.new && mv /auth/{self.held}.new /auth/{self.held}"], |
| input=saved, capture_output=True, timeout=15, check=True) |
| return saved |
| - except (subprocess.SubprocessError, OSError, ValueError): |
| + except (subprocess.SubprocessError, OSError, ValueError, RuntimeError): |
| pass # the end of the stage saves it anyway |
| return known |
| |
| def stage(self, run, record, prompt, seconds, state, scratch): |
| """One timed container. Stopping at the budget is normal; the agent's session survives in `state`.""" |
| public, output, log = run / "input", run / "output", run / "generation.jsonl" |
| - initial = (self.login / self.auth_name).read_bytes() |
| + initial = self.read_login() |
| (state / self.held).parent.mkdir(mode=0o700, exist_ok=True) |
| (state / self.held).write_bytes(initial) |
| (state / self.held).chmod(0o600) |
| @@ -312,6 +330,16 @@ class Session: |
| started = time.monotonic() |
| record.update(status="running", started_at=datetime.now(timezone.utc).isoformat()) |
| save_record(run / "run.json", record) |
| + guard = getattr(self, "quota_guard", None) |
| + if guard: |
| + reason = guard.reason(self.cli) |
| + if reason: |
| + log.touch() |
| + record.update(status="quota_paused", quota_pause_reason=reason, |
| + api_retries=0, rate_limit_events=0, exit_code=None, |
| + credential_refresh_persistence="unchanged", cli_session_id=self.session_id, |
| + finished_at=datetime.now(timezone.utc).isoformat()) |
| + return 0. |
| try: |
| with log.open("w") as stream: |
| ensure_egress() |
| @@ -325,6 +353,14 @@ class Session: |
| process.wait(timeout=min(LOGIN_SYNC_SECONDS, max(seconds - (time.monotonic() - started), .1))) |
| break |
| except subprocess.TimeoutExpired: |
| + reason = guard.reason(self.cli) if guard else None |
| + if guard and self.cli == "opencode" and guard.config.get("opencode_pause_on_limit"): |
| + reason = reason or opencode_limit(log) |
| + if reason: |
| + guard.pause(self.cli, reason) |
| + if reason: |
| + record["quota_pause_reason"] = reason |
| + raise |
| if time.monotonic() - started >= seconds: |
| raise |
| if not record.get("model_answered"): |
| @@ -341,7 +377,8 @@ class Session: |
| except subprocess.TimeoutExpired: |
| process.kill() |
| process.wait() |
| - record.update(status="cli_failed" if record.get("stalled") else "budget_expired", exit_code=process.returncode) |
| + record.update(status="quota_paused" if record.get("quota_pause_reason") else |
| + "cli_failed" if record.get("stalled") else "budget_expired", exit_code=process.returncode) |
| finally: |
| subprocess.run(["docker", "rm", "-f", name], capture_output=True) |
| if self.isaac: |
| @@ -352,6 +389,11 @@ class Session: |
| self.session_id = self.session_id or session_identity(self.cli, log) |
| record["cli_session_id"] = self.session_id |
| record.update(throttling(log)) |
| + if guard and self.cli == "opencode" and guard.config.get("opencode_pause_on_limit"): |
| + reason = opencode_limit(log) |
| + if reason: |
| + guard.pause(self.cli, reason) |
| + record.update(status="quota_paused", quota_pause_reason=reason) |
| if record.get("stalled"): # no answer at all: a refused login (rate or usage limit), not the agent's work |
| record["rate_limit_events"] = max(1, record["rate_limit_events"]) |
| return time.monotonic() - started |
| @@ -410,7 +452,7 @@ class Session: |
| previous = run |
| if on_result: |
| on_result(run, record) |
| - if record["status"] == "cli_failed" or not self.session_id: |
| + if record["status"] in {"cli_failed", "quota_paused"} or not self.session_id: |
| break |
| finally: |
| if self.isaac: |
|
|
