File size: 20,065 Bytes
eeaa10a | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 | """Launch Claude Code processes: the environment of a process, one-shot JSON calls, and claude.ai usage limits.
The environment agent, the judge, and the memorization probe call `claude -p ... --output-format json` through
run_claude_json(). The Claude Code actor builds its own command (actors/claude_code.py) but uses claude_env().
"""
import datetime as dt
import json
import os
import re
import subprocess
import time
from pathlib import Path
import jsonschema
from . import settings
# Inherited variables with these prefixes are dropped so that a harness started from inside a Claude Code session
# does not leak its child-session state (CLAUDE_CODE_CHILD_SESSION etc.) into the processes it starts.
# CTX_: the user's shell alias also sets CTX_HOOKS_ON (context hooks); harness sessions run without them.
STRIP_ENV_PREFIXES = ("CLAUDE", "ANTHROPIC", "CTX_")
STRIP_ENV_LOWER = ("http_proxy", "https_proxy", "no_proxy", "all_proxy")
LIMIT_RE = re.compile(r"hit your [a-z ]*limit", re.I)
RESET_RE = re.compile(r"resets\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)\s*\(UTC\)", re.I)
LIMIT_MARGIN_S = 90
def claude_env(config_dir: Path) -> dict:
"""os.environ minus inherited Claude/proxy variables, plus the variables of the user's interactive launch
(config dir, locale, proxy, zsh as SHELL)."""
env = {k: v for k, v in os.environ.items()
if not k.startswith(STRIP_ENV_PREFIXES) and k.lower() not in STRIP_ENV_LOWER}
env.update(
CLAUDE_CONFIG_DIR=str(config_dir),
TZ="",
LANG="en_US.UTF-8",
LC_ALL="",
HTTP_PROXY=settings.PROXY,
HTTPS_PROXY=settings.PROXY,
no_proxy=settings.NO_PROXY,
SHELL=str(settings.SHELL_BIN),
)
return env
# Claude Code model slots that a non-Claude backend fills with the same model, so that no helper or subagent call
# (haiku helper, sonnet/opus aliases of the Task tool) goes to another model.
BACKEND_MODEL_VARS = ("ANTHROPIC_MODEL", "ANTHROPIC_SMALL_FAST_MODEL", "ANTHROPIC_DEFAULT_HAIKU_MODEL",
"ANTHROPIC_DEFAULT_SONNET_MODEL", "ANTHROPIC_DEFAULT_OPUS_MODEL", "CLAUDE_CODE_SUBAGENT_MODEL")
def model_backend(model: str):
"""None for a Claude model (logged-in config, unchanged); the machine.yaml model_backends entry otherwise."""
if model.startswith("claude-"):
assert model not in settings.MODEL_BACKENDS, f"{model}: Claude models run on the logged-in config"
return None
assert model in settings.MODEL_BACKENDS, f"model {model} has no model_backends entry in machine.yaml"
return settings.MODEL_BACKENDS[model]
def config_dir_for(model: str) -> Path:
"""Config dir of env and judge sessions of this model (where their transcripts are written)."""
b = model_backend(model)
return settings.CLAUDE_CONFIG_DIR if b is None else b["config_dir"]
def claude_env_for(model: str, config_dir: Path) -> dict:
"""claude_env for a call of `model`. A non-Claude model gets its backend's endpoint, token and proxy, and every
model slot of the CLI set to it."""
env = claude_env(config_dir)
b = model_backend(model)
if b is None:
return env
del env["HTTP_PROXY"], env["HTTPS_PROXY"]
if b["proxy"] is not None:
env.update(HTTP_PROXY=b["proxy"], HTTPS_PROXY=b["proxy"])
env.update(ANTHROPIC_BASE_URL=b["base_url"], ANTHROPIC_AUTH_TOKEN=b["auth_token"], ANTHROPIC_API_KEY="",
NO_PROXY=settings.NO_PROXY, **{k: model for k in BACKEND_MODEL_VARS}, **b["cli_env"])
return env
def backend_record(model: str):
"""What run_config.json records about a model's backend (never the token); None for a Claude model."""
b = model_backend(model)
if b is None:
return None
return {"base_url": b["base_url"], "api_format": b["api_format"], "proxy": b["proxy"],
"config_dir": str(b["config_dir"]), "cli_env": b["cli_env"], "served": served_model(model, b)}
PROBE_MAX_TOKENS = 5
def served_model(model: str, b: dict) -> dict:
"""What the endpoint serves under this name right now, from a 5-token call (record before each run).
api_format openai: the proxy's OpenAI route, upstream model id and system_fingerprint (deepseek-flash gave
fingerprint bc19ba97cbe016479903222bb1578db6 on 11-05). anthropic: /v1/messages, the model id it answers with
(this format has no fingerprint)."""
import urllib.request
handlers = [urllib.request.ProxyHandler({"http": b["proxy"], "https": b["proxy"]} if b["proxy"] else {})]
body = {"model": model, "messages": [{"role": "user", "content": "hi"}], "max_tokens": PROBE_MAX_TOKENS}
if b["api_format"] == "openai":
route = "/v1/chat/completions"
headers = {"Content-Type": "application/json", "Authorization": f"Bearer {b['auth_token']}"}
else:
assert b["api_format"] == "anthropic", f"{model}: unknown api_format {b['api_format']!r}"
route = "/v1/messages"
headers = {"Content-Type": "application/json", "x-api-key": b["auth_token"], "anthropic-version": "2023-06-01"}
req = urllib.request.Request(b["base_url"].rstrip("/") + route, json.dumps(body).encode(), headers)
d = json.loads(urllib.request.build_opener(*handlers).open(req, timeout=120).read())
rec = {"model": d["model"], "system_fingerprint": d.get("system_fingerprint"), "at": time.strftime("%Y-%m-%d %H:%M:%S")}
print(f"[backend] {model} served as {rec}", flush=True)
return rec
def private_tmp_prefix(tmp_dir: Path, cwd: Path) -> list:
"""bwrap prefix that keeps the whole filesystem but gives the process its own /tmp (tmp_dir on the host): the
environment writes scratch files such as /tmp/w.txt, which collided between parallel runs (redundancy audit
2026-10-26). bwrap does not keep the working directory by itself, hence --chdir; cwd must not be under the host
/tmp. A cwd inside tmp_dir is entered as /tmp/<rel>, so the process does not see the host path (the memorization
probe's cwd must not name the case, 071 probe 2026-10-26)."""
assert not cwd.resolve().is_relative_to("/tmp"), f"cwd {cwd} is under /tmp, which the call gets as its own"
tmp_dir.mkdir(exist_ok=True)
inner = cwd.resolve()
if inner.is_relative_to(tmp_dir.resolve()):
inner = Path("/tmp") / inner.relative_to(tmp_dir.resolve())
return [str(settings.BWRAP), "--die-with-parent", "--bind", "/", "/", "--dev", "/dev",
"--bind", str(tmp_dir), "/tmp", "--chdir", str(inner)]
def run_claude_json(args: list, cwd: Path, timeout_s: int, log_path: Path, tmp_dir: Path) -> dict:
"""Run `claude -p ... --output-format json` on the logged-in config (--safe-mode is the caller's job), with
tmp_dir as its /tmp. Appends the raw call record to log_path and fails fast on any error."""
return run_claude_json_env(args, cwd, timeout_s, log_path, tmp_dir, {})
def run_claude_json_env(args: list, cwd: Path, timeout_s: int, log_path: Path, tmp_dir: Path,
extra_env: dict) -> dict:
"""run_claude_json with extra process variables on top of claude_env (the env agent's guarded PATH,
twinlab/calc_guard.py)."""
# the prompt goes through stdin: judge prompts exceed the per-argument limit of execve (~128 KB)
i = args.index("-p")
prompt = args[i + 1]
cmd = [*private_tmp_prefix(tmp_dir, cwd), str(settings.CLAUDE_BIN), *args[:i + 1], *args[i + 2:]]
asked = args[args.index("--model") + 1]
config_dir = config_dir_for(asked)
structured = "--json-schema" in args
if structured: # StructuredOutput rejections are counted from the lines this call appends to the transcript
sid = session_id_of(args)
before = session_transcripts(sid, config_dir)
assert len(before) <= 1, before
n_before = len(jsonl_lines(before[0])) if before else 0
while True: # a claude.ai usage limit is waited out, then the same call is retried
t0 = time.time()
p = subprocess.run(cmd, cwd=cwd, env={**claude_env_for(asked, config_dir), **extra_env}, input=prompt,
capture_output=True, text=True, timeout=timeout_s)
if (p.returncode != 0 or '"is_error":true' in p.stdout) and limit_hit(p.stdout + p.stderr):
wait_for_reset(p.stdout + p.stderr, f"claude call in {cwd.name}")
continue
break
rec = {"cmd": [a if len(a) < 400 else a[:400] + "...<truncated>" for a in cmd], "cwd": str(cwd),
"rc": p.returncode, "secs": round(time.time() - t0, 1), "stdout": p.stdout, "stderr": p.stderr[-4000:]}
rejections = None
if structured and p.returncode == 0: # a crashed call is reported by the assert below, uncounted
after = session_transcripts(sid, config_dir)
assert len(after) == 1, f"session {sid}: expected 1 transcript, found {after}"
new_lines = jsonl_lines(after[0])[n_before:]
rejections = structured_output_rejections(new_lines)
rec["structured_output_rejections"] = len(rejections)
rec["structured_output_rejection_errors"] = rejections
rec["compactions"] = sum(COMPACT_MARK in line for line in new_lines)
# replies cut at the output cap (thinking counts; 2026-11-04 deepseek-flash judges); logged, not fatal
rec["max_tokens_stops"] = len({json.loads(line)["message"]["id"] for line in new_lines
if MAX_TOKENS_MARK in line and '"type":"assistant"' in line})
if rec["max_tokens_stops"]:
print(f"[claude] WARNING {rec['max_tokens_stops']} replies stopped at max_tokens", flush=True)
with open(log_path, "a", encoding="utf-8") as f:
f.write(json.dumps(rec, ensure_ascii=False) + "\n")
assert p.returncode == 0, f"claude exited {p.returncode}; see {log_path}\nstderr: {p.stderr[-2000:]}\nstdout: {p.stdout[-2000:]}"
# an auto-compacted env or judge works from a summary of the case instead of the case (5 of 10 deepseek-flash
# judges, 2026-11-04, before the backend's CLAUDE_CODE_MAX_CONTEXT_TOKENS); none of 702 Claude env sessions did
assert not rec.get("compactions"), f"session auto-compacted {rec['compactions']}x; see {log_path}"
out = json.loads(p.stdout)
assert not out["is_error"], f"claude returned is_error: {out.get('result')}; see {log_path}"
# a safety stop silently re-serves the call with another model (kquiz-009 2026-10-19: claude-opus-5 answered
# with safety_stops 2); haiku is the CLI's own helper model and does not answer the prompt
served = [m for m in out["modelUsage"] if "haiku" not in m]
assert served == [asked], f"asked {asked}, served {served} (safety_stops={out.get('safety_stops')}); see {log_path}"
print(f"[claude] {rec['secs']}s cost=${out.get('total_cost_usd')} turns={out.get('num_turns')}", flush=True)
if structured:
print(f"[claude] StructuredOutput rejections={len(rejections)}"
+ "".join(f"\n[claude] rejected: {r[:300]}" for r in rejections), flush=True)
return out
# ---- JSON answers through --json-schema (StructuredOutput tool) ----
# The CLI offers the model a StructuredOutput tool whose input is validated against the schema; a rejected input
# comes back as an is_error tool_result and the model corrects it in the same call; the accepted object is in
# out["structured_output"]. The extra turn the CLI logs after it is a <synthetic> message with 0 tokens (study
# removed 10-26 on a wrong cost reason, restored
# 10-30). Every object in the schemas is closed (additionalProperties false): extra keys are rejected, not ignored.
STRUCTURED_ANSWER_MARK = "# ANSWER SUBMISSION"
COMPACT_MARK = '"subtype":"compact_boundary"' # the transcript line Claude Code writes when it auto-compacts
MAX_TOKENS_MARK = '"stop_reason":"max_tokens"'
def close_objects(schema):
"""Copy of a JSON schema with additionalProperties false on every object that lists properties."""
if isinstance(schema, list):
return [close_objects(x) for x in schema]
if not isinstance(schema, dict):
return schema
out = {k: (v if k in ("required", "enum", "properties") else close_objects(v)) for k, v in schema.items()}
if "properties" in out:
out["properties"] = {k: close_objects(v) for k, v in schema["properties"].items()}
out["additionalProperties"] = False
return out
def structured_answer_instructions() -> str:
return (f"\n\n{STRUCTURED_ANSWER_MARK}\nEnd every turn by calling the StructuredOutput tool once with your answer; "
"its input schema lists the keys and what each holds. Text outside that tool call is not read. If the "
"tool rejects the input, correct what the error names and call it again.\n")
def session_id_of(args: list) -> str:
for flag in ("--session-id", "--resume"):
if flag in args:
return args[args.index(flag) + 1]
raise AssertionError(f"--json-schema call without --session-id/--resume (rejections are read from its transcript): {args[:3]}")
def jsonl_lines(path: Path) -> list:
"""Records of a jsonl file split on newline only: str.splitlines() also splits on characters JSON leaves raw
inside strings (form feed, U+2028, ...), e.g. PDF text in a judge's Read result (072-02 mimo 20261105-131105)."""
return [x for x in path.read_text(encoding="utf-8").split("\n") if x]
def session_transcripts(sid: str, config_dir: Path) -> list:
return list((config_dir / "projects").glob(f"*/{sid}.jsonl"))
def structured_output_rejections(lines: list) -> list:
"""Error texts of the StructuredOutput calls the CLI rejected, from transcript lines (each tool_use id once)."""
so_ids, errs = set(), {}
for line in lines:
msg = json.loads(line).get("message")
if not isinstance(msg, dict) or not isinstance(msg.get("content"), list):
continue
for c in msg["content"]:
if c.get("type") == "tool_use" and c.get("name") == "StructuredOutput":
so_ids.add(c["id"])
elif c.get("type") == "tool_result" and c.get("is_error"):
errs[c["tool_use_id"]] = c["content"] if isinstance(c["content"], str) else json.dumps(c["content"])
return [e for tid, e in errs.items() if tid in so_ids]
def structured_answer(out: dict, schema: dict, log_path: Path) -> dict:
"""The object the CLI accepted through StructuredOutput, validated again here (fail fast)."""
assert out.get("structured_output") is not None, \
f"no structured_output in the CLI result; see {log_path}\nresult: {str(out.get('result'))[:2000]}"
obj = out["structured_output"]
try:
jsonschema.validate(obj, schema)
except jsonschema.ValidationError as e:
raise AssertionError(f"structured_output does not match the schema: {e.message} at "
f"{list(e.absolute_path)}; see {log_path}")
return obj
# ---- LEGACY: JSON answers as final text (runs started 2026-10-26..10-30) ----
# From 793eb461 (10-26) to the restore of --json-schema (10-30) the schema went into the system prompt under
# "# ANSWER FORMAT" and the harness parsed the final message. Env sessions of those runs keep this path on resume
# (EnvAgent detects the marker); new runs never use it.
FENCED_JSON_RE = re.compile(r"```(?:json)?\s*\n(.*)\n```", re.S)
STRAY_TAIL_RE = re.compile(r"[\s}\]]*(?:```[\s}\]]*)?")
def json_answer_instructions(schema: dict) -> str:
return ("\n\n# ANSWER FORMAT\nEnd every turn with exactly one JSON object that validates against the schema "
"below and nothing else: no text before or after it, no code fence. Anything meant for the actor (for "
"example that no figure is attached) goes inside the object, never in front of it.\n```json\n"
f"{json.dumps(schema, indent=1)}\n```\n")
def parse_json_answer(out: dict, schema: dict, log_path: Path) -> dict:
text = out["result"].strip()
# the whole message may be one ```json fenced block (070 replay, 2026-10-26: Sonnet env fenced its first answer
# despite the instruction); anything besides that one block still fails
m = FENCED_JSON_RE.fullmatch(text)
if m:
print(f"[claude] answer was one fenced JSON block; fence removed", flush=True)
text = m.group(1)
# one sentence of prose, then the object (001-01 Opus runs 20261027-041148 #11 and 20261027-043031 #1: Sonnet env
# wrote "The calculator printed no gel figure ..." before the JSON, twice in a day once --json-schema was gone).
# Accepted only as plain text without "{" followed by one object that ends the message; the prose is printed.
# prose, then one fenced block that ends the message (069-02 Opus run 20261029-180354 #1: "Nothing in your request
# could be done. ..." then ```json ... ```); the prose must not contain "{" and is printed, the fence is removed.
j = text.find("```")
if j > 0 and "{" not in text[:j]:
m = FENCED_JSON_RE.fullmatch(text[j:])
if m:
print(f"[claude] PROSE BEFORE FENCED JSON dropped ({j} chars): {text[:j].strip()[:300]!r}", flush=True)
text = m.group(1)
i = text.find("{")
# complete object, then only stray closing braces/brackets or a closing fence (003-03 Opus run 20261029-204001:
# judge wrote a valid object plus one extra "}"); the tail is cut and printed, any other tail still fails below.
if i >= 0:
try:
_, end = json.JSONDecoder().raw_decode(text, i)
except json.JSONDecodeError:
end = len(text)
if text[end:].strip() and STRAY_TAIL_RE.fullmatch(text[end:]):
print(f"[claude] STRAY TAIL AFTER JSON dropped: {text[end:]!r}", flush=True)
text = text[:end]
if i > 0 and not text.startswith("{"):
try:
obj, end = json.JSONDecoder().raw_decode(text, i)
except json.JSONDecodeError:
end = -1
if end == len(text):
print(f"[claude] PROSE BEFORE JSON dropped ({i} chars): {text[:i].strip()[:300]!r}", flush=True)
text = text[i:]
try:
obj = json.loads(text)
except json.JSONDecodeError as e:
# the end of the message goes on the first line: the discard note a resumed env reads is built from this line
# (lab.Lab.restore); 001-03 run 20261029-202451 ended with '","}' twice and the env never saw that tail
raise AssertionError(f"final message is not one JSON object ({e}); it ends with {text[-80:]!r}; "
f"see {log_path}\n{text[:2000]}")
try:
jsonschema.validate(obj, schema)
except jsonschema.ValidationError as e:
raise AssertionError(f"final message does not match the schema: {e.message} at "
f"{list(e.absolute_path)}; see {log_path}")
return obj
# ---- claude.ai usage limits: "You've hit your session limit · resets 6:10pm (UTC)" ----
# Runs sleep until the reset (plus a margin) and then continue on their own.
def limit_hit(text: str) -> bool:
return bool(LIMIT_RE.search(text))
def seconds_until_reset(text: str) -> float:
m = RESET_RE.search(text)
assert m, f"usage limit hit but no parsable reset time in: {text[-300:]}"
h, mi, ap = int(m.group(1)), int(m.group(2) or 0), m.group(3).lower()
h = h % 12 + (12 if ap == "pm" else 0)
now = dt.datetime.now(dt.timezone.utc)
reset = now.replace(hour=h, minute=mi, second=0, microsecond=0)
if reset <= now:
if now - reset < dt.timedelta(hours=3): # the reset just passed (clock skew / late message)
return LIMIT_MARGIN_S
reset += dt.timedelta(days=1)
return (reset - now).total_seconds() + LIMIT_MARGIN_S
def wait_for_reset(text: str, who: str) -> float:
"""Sleep until the quota resets; returns the seconds slept."""
s = seconds_until_reset(text)
print(f"[quota] {who}: usage limit hit; sleeping {s / 60:.1f} min until the reset", flush=True)
time.sleep(s)
print(f"[quota] {who}: resuming after the reset", flush=True)
return s
|