MACE-Bench / code /agmem /llm.py
tirtho149's picture
Add retriever study (code, predictions, one-pager), refresh response cache
874eec2 verified
Raw History Blame Contribute Delete
7.96 kB
"""Claude via the Claude Code CLI in headless mode, with a content-addressed cache, a cost ledger and a hard budget.
Locked down for cost and isolation: no tools, a replaced system prompt, no user/project settings or MCP servers,
prompt caching disabled. Images go inline as base64 blocks. Cost per call is the CLI's `total_cost_usd`, a
list-price estimate. Identical requests are served from the cache at zero cost.
"""
from __future__ import annotations
import base64
import contextlib
import hashlib
import io
import json
import os
import subprocess
import threading
import time
from pathlib import Path
from . import config as C
_lock = threading.Lock()
_spent_lock = threading.Lock()
_tl = threading.local() # per-thread diagnosis model override; unset means C.MODEL, so existing cache keys do not change
_budget = {"usd": 0.0}
LEDGER = C.RUNS / "cost_ledger.jsonl"
def active_model() -> str:
return getattr(_tl, "model", None) or C.MODEL
@contextlib.contextmanager
def use_model(model: str | None):
"""Run the calls of this thread on another model. Cache keys carry the model, so replies never mix across models."""
prev = getattr(_tl, "model", None); _tl.model = model
try:
yield
finally:
_tl.model = prev
class BudgetExceeded(RuntimeError):
pass
class CallFailed(RuntimeError):
"""The CLI answered with an error (for example the account's usage-limit message). Never cached."""
_reserved = {"usd": 0.0}
_spent_cache = {"off": 0, "sum": 0.0}
LIMIT_MARKERS = ("usage limit", "limit reached", "rate limit", "hit your limit", "out of extra usage", "credit balance")
def looks_failed(text: str, is_error) -> bool:
t = (text or "").lower()
return bool(is_error) or (len(t) < 400 and any(m in t for m in LIMIT_MARKERS))
def sha(obj) -> str:
s = obj if isinstance(obj, (bytes, str)) else json.dumps(obj, sort_keys=True)
return hashlib.sha256(s.encode() if isinstance(s, str) else s).hexdigest()
def set_budget(total_usd: float) -> None:
"""Absolute ceiling on the ledger total (all paid calls ever made from this codebase)."""
_budget["usd"] = float(total_usd)
def spent() -> float:
"""Ledger total of paid calls, read incrementally (the ledger is append-only)."""
if not LEDGER.exists():
return 0.0
with _spent_lock: # threads share the read offset; without the lock two readers can seek into the middle of a line
with LEDGER.open() as f:
f.seek(_spent_cache["off"])
for line in f:
if not line.endswith("\n"):
break
r = json.loads(line); _spent_cache["off"] += len(line.encode())
if not r["cache_hit"]:
_spent_cache["sum"] += r["cost_usd"] or 0.0
return _spent_cache["sum"]
def reserve(usd: float) -> None:
"""Reserve a conservative maximum charge before dispatch; raise if spent + reserved would pass the budget."""
with _lock:
if spent() + _reserved["usd"] + usd > _budget["usd"]:
raise BudgetExceeded(f"spent {spent():.2f} + reserved {_reserved['usd']:.2f} + {usd:.2f} > budget {_budget['usd']:.2f}")
_reserved["usd"] += usd
def release(usd: float) -> None:
with _lock:
_reserved["usd"] = max(0.0, _reserved["usd"] - usd)
def image_block(path: str | Path, max_side: int = C.IMAGE_MAX_SIDE) -> dict:
from PIL import Image
p = C.CACHE / "img" / (sha(f"{Path(path).resolve()}|{max_side}") + ".jpg")
if not p.exists():
p.parent.mkdir(parents=True, exist_ok=True)
im = Image.open(path).convert("RGB"); im.thumbnail((max_side, max_side))
buf = io.BytesIO(); im.save(buf, "JPEG", quality=85); p.write_bytes(buf.getvalue())
return {"type": "image", "source": {"type": "base64", "media_type": "image/jpeg", "data": base64.b64encode(p.read_bytes()).decode()}}
def _cli(system: str, content: list[dict]) -> dict:
cmd = ["claude", "-p", "--model", active_model(), "--input-format", "stream-json", "--output-format", "stream-json", "--verbose",
"--no-session-persistence", "--tools", "", "--strict-mcp-config", "--setting-sources", "", "--system-prompt", system]
env = {k: v for k, v in os.environ.items() if not k.startswith(("CLAUDE", "CURSOR", "MCP_CONNECTION", "VSCODE", "ELECTRON"))}
env["DISABLE_PROMPT_CACHING"] = "1"
C.CACHE.mkdir(parents=True, exist_ok=True); t0 = time.time()
msg = {"type": "user", "message": {"role": "user", "content": content}}
proc = subprocess.run(cmd, input=json.dumps(msg).encode(), capture_output=True, env=env, timeout=300, cwd=str(C.CACHE))
res = {}
for line in proc.stdout.decode(errors="replace").splitlines():
try:
ev = json.loads(line)
except json.JSONDecodeError:
continue
if ev.get("type") == "result":
res = ev
if not res:
raise RuntimeError(f"no result event; rc={proc.returncode} {proc.stderr.decode()[:300]}")
u = res.get("usage", {})
return {"text": res.get("result", ""), "cost_usd": float(res.get("total_cost_usd") or 0.0),
"input_tokens": u.get("input_tokens", 0), "output_tokens": u.get("output_tokens", 0),
"model_ids": list((res.get("modelUsage") or {}).keys()), "is_error": res.get("is_error"),
"elapsed_s": round(time.time() - t0, 2)}
RUNNER = _cli # tests replace this with a fake
def _ledger(row: dict) -> None:
LEDGER.parent.mkdir(parents=True, exist_ok=True)
with _lock, LEDGER.open("a") as f:
f.write(json.dumps(row) + "\n")
def call(system: str, content: list[dict], *, stage: str, tag: str = "", retries: int = 1, reserve_usd: float = 0.05) -> dict:
"""Cached call. Error and usage-limit answers are never cached; at most `retries` retries; each attempt is
reserved against the budget before dispatch, and failed attempts that were charged are written to the ledger."""
key = sha({"m": active_model(), "s": system, "c": content})
cp = C.CACHE / "llm" / f"{key}.json"
if cp.exists():
out = json.loads(cp.read_text())
if not looks_failed(out.get("text"), out.get("is_error")):
out["cache_hit"] = True
_ledger({"key": key, "stage": stage, "tag": tag, "cache_hit": True, "cost_usd": 0.0, "t": time.time()})
return out
err = None
for attempt in range(retries + 1):
reserve(reserve_usd)
try:
out = RUNNER(system, content)
except Exception as e: # transient CLI or network failure
err = e; release(reserve_usd); time.sleep(2 * (attempt + 1)); continue
release(reserve_usd)
if looks_failed(out.get("text"), out.get("is_error")):
_ledger({"key": key, "stage": stage, "tag": tag, "cache_hit": False, "failed": True, "cost_usd": out.get("cost_usd") or 0.0,
"elapsed_s": out.get("elapsed_s"), "text": (out.get("text") or "")[:200], "t": time.time()})
err = CallFailed(out.get("text")); time.sleep(5 * (attempt + 1)); continue
break
else:
raise err if isinstance(err, CallFailed) else RuntimeError(f"call failed after {retries + 1} attempts: {err}")
out["parsed"] = parse_json(out["text"])
cp.parent.mkdir(parents=True, exist_ok=True); cp.write_text(json.dumps(out))
_ledger({"key": key, "stage": stage, "tag": tag, "cache_hit": False,
**{k: out.get(k) for k in ("cost_usd", "input_tokens", "output_tokens", "elapsed_s", "model_ids")}, "t": time.time()})
out["cache_hit"] = False
return out
def parse_json(text: str):
t = (text or "").strip()
if "```" in t:
t = next((s[4:] if s.startswith("json") else s for s in t.split("```") if "{" in s), t)
i, j = t.find("{"), t.rfind("}")
if i != -1 and j > i:
try:
return json.loads(t[i:j + 1])
except json.JSONDecodeError:
return None
return None