"""The in-sandbox judge proxy shim, shared by the Harbor verifier and theoffline rejudge path so judge calls go through one identical code patheverywhere. Stdlib-only and free of any `harbor`/`modal` imports on purpose: `verifier.py`imports these constants for the live in-sandbox install, and `rejudge.py` runsthe very same proxy in a plain container to re-grade stored runs. Keeping theshim here means there is exactly one implementation of the upstream fixups(Anthropic `response_format` stripping, `max_tokens` -> `max_completion_tokens`,the `ZED_JUDGE_MAX_TOKENS` floor) rather than a copy per call site.""" from __future__ import annotations # Stdlib-only OpenAI-protocol shim. The SWE-Atlas RF judge hardcodes# `response_format={"type": "json_object"}`, which Anthropic's OpenAI-compatible# endpoint rejects (400: "response_format.type: Input should be 'json_schema'").# The shim listens on 127.0.0.1:PORT and forwards to ZED_JUDGE_UPSTREAM, applying# upstream-specific fixups:#   - `response_format` is stripped ONLY for Anthropic (Baseten/OpenAI accept#     json_object, and the Kimi/DeepSeek judges rely on it);#   - `max_tokens` is renamed to `max_completion_tokens` (accepted by both#     Anthropic-compat and OpenAI, including GPT-5.x reasoning models that reject#     `max_tokens`) and raised to the ZED_JUDGE_MAX_TOKENS floor so the runtime#     judge matches the offline-calibrated token budget.# When ZED_JUDGE_AUTH_ENV is set, it replaces verifier auth with the named# sandbox env var; otherwise it passes auth headers through unchanged.JUDGE_PROXY_SCRIPT = """\import json, os, urllib.request, urllib.errorfrom http.server import BaseHTTPRequestHandler, ThreadingHTTPServer UPSTREAM = os.environ.get("ZED_JUDGE_UPSTREAM", "https://api.anthropic.com/v1").rstrip("/")PORT = int(os.environ.get("ZED_JUDGE_PROXY_PORT", "8089"))AUTH_ENV = os.environ.get("ZED_JUDGE_AUTH_ENV")MAX_TOKENS_FLOOR = int(os.environ.get("ZED_JUDGE_MAX_TOKENS", "0")) class Handler(BaseHTTPRequestHandler):    def do_POST(self):        length = int(self.headers.get("Content-Length", 0))        body = self.rfile.read(length)        try:            payload = json.loads(body)            if "anthropic" in UPSTREAM:                payload.pop("response_format", None)            sent = payload.pop("max_tokens", None)            current = sent if sent is not None else payload.get("max_completion_tokens")            if current is not None or MAX_TOKENS_FLOOR:                payload["max_completion_tokens"] = max(current or 0, MAX_TOKENS_FLOOR)            body = json.dumps(payload).encode()        except Exception as error:            print(f"proxy: passing body through unmodified: {error}", flush=True)        path = self.path        if path.startswith("/v1/"):            path = path[len("/v1"):]        request = urllib.request.Request(UPSTREAM + path, data=body, method="POST")        request.add_header("Content-Type", "application/json")        auth_value = os.environ.get(AUTH_ENV, "") if AUTH_ENV else ""        if auth_value:            request.add_header("Authorization", f"Bearer {auth_value}")        else:            for header in ("Authorization", "x-api-key"):                value = self.headers.get(header)                if value:                    request.add_header(header, value)        for header in ("anthropic-version",):            value = self.headers.get(header)            if value:                request.add_header(header, value)        try:            with urllib.request.urlopen(request, timeout=900) as response:                data = response.read()                status = response.status        except urllib.error.HTTPError as error:            data = error.read()            status = error.code        except Exception as error:            data = json.dumps({"error": {"message": str(error)}}).encode()            status = 502        self.send_response(status)        self.send_header("Content-Type", "application/json")        self.send_header("Content-Length", str(len(data)))        self.end_headers()        self.wfile.write(data)     def log_message(self, format, *args):        print("proxy: " + format % args, flush=True) if __name__ == "__main__":    print(f"judge proxy listening on 127.0.0.1:{PORT} -> {UPSTREAM}", flush=True)    ThreadingHTTPServer(("127.0.0.1", PORT), Handler).serve_forever()""" # Idempotent starter. Uses bash's /dev/tcp (pgrep isn't in every image) to check# the port; the daemon inherits ZED_JUDGE_UPSTREAM from the verifier setup exec# env. stdout/stderr/stdin are fully detached so the spawning exec doesn't hang# on open pipes.JUDGE_PROXY_ENSURE_SCRIPT = """\#!/bin/bashif ! (exec 3<>/dev/tcp/127.0.0.1/${ZED_JUDGE_PROXY_PORT:-8089}) 2>/dev/null; then    nohup python3 /usr/local/lib/zed_judge_proxy.py \\        >>/tmp/zed-judge-proxy.log 2>&1 </dev/null &    sleep 1fi"""