"""CLI shim — gives a command-line agent harness a small HTTP API, from inside its sandbox. opencode ships an HTTP server; hermes, pi and openclaw are driven here through their own non-interactive CLI instead, one process per prompt. That keeps each session in its own working directory and home, relies only on each tool's most stable interface (the documented one-shot mode + its "continue" flag), and needs nothing but the Python stdlib. Copied from gx10 ~/code/vlmtest/agents/shim/cli_shim.py. In the m64 capsule it listens on $SHIM_HOST:$SHIM_PORT (127.0.0.1:4096): only the agent gateway in the same container calls it. GET /health POST /sessions {id, directory} create home + harness config GET /sessions/{id} {busy} DELETE /sessions/{id} POST /sessions/{id}/prompt {text} blocks; {text, tools, exit_code, ...} GET /sessions/{id}/messages transcript GET /sessions/{id}/events SSE: raw harness output lines + turn start/end POST /sessions/{id}/abort kill the running turn """ import json import os import queue import shutil import signal import subprocess import threading import time from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer from pathlib import Path HARNESS = os.environ["AGENT_HARNESS"] MODEL = os.environ["AGENT_MODEL"] LLM_BASE = os.environ.get("LLM_BASE_URL", "http://llm:9000/v1") HOST = os.environ.get("SHIM_HOST", "127.0.0.1") PORT = int(os.environ.get("SHIM_PORT", "4096")) HOMES = Path(os.environ.get("SHIM_HOMES", "/work/.homes")) # 0 = no limit: a turn runs until the harness finishes it (the caller can still # POST /sessions/{id}/abort). Long agentic tasks outlast any fixed cap. TURN_TIMEOUT = int(os.environ.get("TURN_TIMEOUT", "0")) # The LLM's max-model-len; harnesses budget their context against it. CONTEXT = int(os.environ.get("AGENT_CONTEXT", "131072")) # The reply cap and pi's compaction match the airbench checkup harness (agent-checkup-benchmark # checkup.py output_cap / compaction_reserve): at 262144 tokens, 32768 out and a 65536-token reserve, # so one picture cannot overflow the window. MAX_OUT = int(os.environ.get("AGENT_MAX_OUT", min(16384, CONTEXT // 8))) COMPACTION_RESERVE = int(os.environ.get("AGENT_COMPACTION_RESERVE", "0")) # Every agent LLM is a vision model; a harness told "text" only refuses to pass # images on even though the server takes them. INPUT = ["text", "image"] if os.environ.get("AGENT_VISION", "1") == "1" else ["text"] # ── Harness adapters ────────────────────────────────────────────────────────── # Each: setup(home, directory) writes config; command(...) -> (argv, env); # parse(lines) -> (text, tools). class Pi: binary = "pi" def setup(self, home: Path, directory: str) -> None: agent_dir = home / "pi-agent" agent_dir.mkdir(parents=True, exist_ok=True) (agent_dir / "models.json").write_text(json.dumps({"providers": {"gx10": { "baseUrl": LLM_BASE, "api": "openai-completions", "apiKey": "sk-local", # vLLM rejects the `developer` role and reasoning_effort (the same compat as the checkup harness). "compat": {"supportsDeveloperRole": False, "supportsReasoningEffort": False}, "models": [{"id": MODEL, "reasoning": True, "input": INPUT, "contextWindow": CONTEXT, "maxTokens": MAX_OUT}]}}}, indent=2)) (agent_dir / "settings.json").write_text(json.dumps( {"defaultProvider": "gx10", "defaultModel": MODEL, "quietStartup": True, **({"compaction": {"enabled": True, "reserveTokens": COMPACTION_RESERVE, "keepRecentTokens": 20000}} if COMPACTION_RESERVE else {})})) def command(self, home: Path, directory: str, text: str, first: bool, sid: str): argv = ["pi", "-p", "--mode", "json", "--provider", "gx10", "--model", MODEL] if not first: argv.append("--continue") argv.append(text) env = {"PI_CODING_AGENT_DIR": str(home / "pi-agent"), "PI_OFFLINE": "1", "PI_TELEMETRY": "0"} return argv, env def parse(self, lines: list[str]): text, tools, open_calls = "", [], {} for line in lines: try: ev = json.loads(line) except ValueError: continue t = ev.get("type") if t == "tool_execution_start": call = {"tool": ev.get("toolName"), "status": "running", "input": ev.get("args"), "output": ""} open_calls[ev.get("toolCallId")] = call tools.append(call) elif t == "tool_execution_end": call = open_calls.get(ev.get("toolCallId")) if call: call["status"] = "error" if ev.get("isError") else "completed" call["output"] = _content_text(ev.get("result"))[:4000] elif t == "message_end" and (ev.get("message") or {}).get("role") == "assistant": t_ = _content_text((ev["message"] or {}).get("content")) if t_.strip(): text = t_ return text, tools class Hermes: binary = "hermes" def setup(self, home: Path, directory: str) -> None: h = home / "hermes" h.mkdir(parents=True, exist_ok=True) (h / "config.yaml").write_text( "model:\n" f' default: "{MODEL}"\n' ' provider: "custom"\n' f' base_url: "{LLM_BASE}"\n' ' api_key: "sk-local"\n' ' api_mode: "chat_completions"\n' # Its terminal tool otherwise starts in HOME, not the session directory. "terminal:\n" f' cwd: "{directory}"\n') def command(self, home: Path, directory: str, text: str, first: bool, sid: str): argv = ["hermes", "-z", text, "--provider", "custom", "-m", MODEL, "--yolo", "--in", directory] if not first: argv.append("--continue") return argv, {"HERMES_HOME": str(home / "hermes")} def parse(self, lines: list[str]): # -z prints only the final response. return "\n".join(lines).strip(), [] class OpenClaw: binary = "openclaw" def setup(self, home: Path, directory: str) -> None: state = home / "openclaw" state.mkdir(parents=True, exist_ok=True) (state / "openclaw.json").write_text(json.dumps({ "models": {"providers": {"vllm": { "baseUrl": LLM_BASE, "apiKey": "sk-local", "api": "openai-completions", "timeoutSeconds": 900, "models": [{"id": MODEL, "name": MODEL, "reasoning": True, "input": INPUT, "cost": {"input": 0, "output": 0, "cacheRead": 0, "cacheWrite": 0}, "contextWindow": CONTEXT, "maxTokens": MAX_OUT}]}}}, "agents": {"defaults": {"model": {"primary": f"vllm/{MODEL}"}, "workspace": directory}}, **json.loads(os.environ.get("OPENCLAW_EXTRA_CONFIG", "{}")), }, indent=2)) def command(self, home: Path, directory: str, text: str, first: bool, sid: str): state = home / "openclaw" argv = ["openclaw", "agent", "--local", "--session-id", sid, "--message", text, "--json"] return argv, {"OPENCLAW_STATE_DIR": str(state), "OPENCLAW_CONFIG_PATH": str(state / "openclaw.json")} def parse(self, lines: list[str]): raw = "\n".join(lines) start = raw.find("{") try: doc = json.loads(raw[start:]) if start >= 0 else {} except ValueError: return raw.strip(), [] payloads = doc.get("payloads") or (doc.get("result") or {}).get("payloads") or [] text = "\n".join(p.get("text", "") for p in payloads if isinstance(p, dict)).strip() return text or raw.strip(), [] class Dsh: """DeepSeek Harness (`dsh --profile headless`). The LLM route is a --patch overlay on the shipped headless profile: one pi-ai openai-completions provider at the gateway, set as the default model. Approvals off via DSH_PERMISSION_MODE (the container is the sandbox). Everything else stays the profile's own default.""" binary = "dsh" def setup(self, home: Path, directory: str) -> None: d = home / "dsh" d.mkdir(parents=True, exist_ok=True) (d / "gx10.patch.yml").write_text( "- id: llm-pi-ai\n" " config:\n" " providers:\n" " gx10:\n" " api: openai-completions\n" f" baseURL: {LLM_BASE}\n" " apiKeyEnv: GX10_LLM_KEY\n" " models:\n" f" - id: {MODEL}\n" f" contextWindow: {CONTEXT}\n" f" input: [{', '.join(INPUT)}]\n" "- id: agent-default-model\n" " config:\n" " provider: gx10\n" f" model: {MODEL}\n") def command(self, home: Path, directory: str, text: str, first: bool, sid: str): d = home / "dsh" argv = ["dsh", "--profile", "headless", "--patch", str(d / "gx10.patch.yml"), "--json"] if not first: # Follow-ups adopt this session's persisted dsh Session (newest under DSH_HOME). ids = sorted((p for p in (d / "home" / "sessions").rglob("session-*")), key=lambda p: p.stat().st_mtime) if ids: argv += ["--session-id", ids[-1].name.split(".")[0]] argv.append(text) # The gateway holds any real key; the route only needs a non-empty credential. return argv, {"DSH_HOME": str(d / "home"), "GX10_LLM_KEY": "sk-local", "DSH_PERMISSION_MODE": "danger-full-access"} def parse(self, lines: list[str]): text, tools, calls = "", [], {} for line in lines: try: ev = json.loads(line) except ValueError: continue t = ev.get("type") if t == "tool_call": call = {"tool": ev.get("tool"), "status": "running", "input": ev.get("input"), "output": ""} calls[ev.get("callId")] = call tools.append(call) elif t == "tool_result": call = calls.get(ev.get("callId")) if call: r = ev.get("result") call["status"] = ev.get("status") or "completed" call["output"] = (r if isinstance(r, str) else _content_text(r))[:4000] elif t == "final": text = ev.get("text") or text return text, tools ADAPTERS = {"pi": Pi, "hermes": Hermes, "openclaw": OpenClaw, "dsh": Dsh} adapter = ADAPTERS[HARNESS]() def _content_text(content) -> str: if isinstance(content, str): return content if isinstance(content, dict): return _content_text(content.get("content")) if isinstance(content, list): return "".join(c.get("text", "") for c in content if isinstance(c, dict) and c.get("type") in (None, "text")) return "" # ── Sessions ────────────────────────────────────────────────────────────────── class Session: def __init__(self, sid: str, directory: str): self.id, self.directory = sid, directory self.home = HOMES / sid self.proc: subprocess.Popen | None = None self.turns = 0 self.subscribers: list[queue.Queue] = [] self.lock = threading.Lock() self.transcript_path = self.home / "transcript.json" def emit(self, ev: dict) -> None: for q in list(self.subscribers): q.put(ev) def transcript(self) -> list: try: return json.loads(self.transcript_path.read_text()) except Exception: return [] def record(self, entry: dict) -> None: t = self.transcript() t.append(entry) self.transcript_path.write_text(json.dumps(t, indent=1)) def prompt(self, text: str) -> dict: if not self.lock.acquire(blocking=False): return {"error": "session busy", "status": 409} try: argv, extra_env = adapter.command(self.home, self.directory, text, self.turns == 0, self.id) env = {**os.environ, "HOME": str(self.home), **extra_env} self.record({"role": "user", "text": text, "time": time.time()}) self.emit({"type": "turn.start", "text": text}) t0 = time.time() self.proc = subprocess.Popen(argv, cwd=self.directory, env=env, text=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, start_new_session=True) err_lines: list[str] = [] threading.Thread(target=lambda: err_lines.extend(self.proc.stderr), daemon=True).start() lines = [] timer = threading.Timer(TURN_TIMEOUT, self.abort) if TURN_TIMEOUT > 0 else None if timer: timer.start() for line in self.proc.stdout: line = line.rstrip("\n") lines.append(line) self.emit({"type": "output", "line": line}) code = self.proc.wait() if timer: timer.cancel() reply, tools = adapter.parse(lines) out = {"role": "assistant", "text": reply, "tools": tools, "exit_code": code, "elapsed_s": round(time.time() - t0, 1), "time": time.time()} if code != 0: out["error"] = "".join(err_lines)[-2000:] or f"exit {code}" self.turns += 1 self.record(out) self.emit({"type": "turn.end", **out}) return out finally: self.proc = None self.lock.release() def abort(self) -> None: p = self.proc if p and p.poll() is None: os.killpg(p.pid, signal.SIGTERM) SESSIONS: dict[str, Session] = {} class H(BaseHTTPRequestHandler): protocol_version = "HTTP/1.1" def log_message(self, *a): pass def _send(self, code: int, obj) -> None: body = json.dumps(obj).encode() self.send_response(code) self.send_header("Content-Type", "application/json") self.send_header("Content-Length", str(len(body))) self.end_headers() self.wfile.write(body) def _body(self) -> dict: n = int(self.headers.get("Content-Length") or 0) return json.loads(self.rfile.read(n) or b"{}") if n else {} def _session(self, sid: str) -> Session | None: s = SESSIONS.get(sid) if not s: self._send(404, {"error": f"unknown session {sid}"}) return s def do_GET(self): parts = self.path.split("?")[0].strip("/").split("/") if parts == ["health"]: ok = shutil.which(adapter.binary) is not None return self._send(200 if ok else 503, {"ok": ok, "harness": HARNESS}) if len(parts) >= 2 and parts[0] == "sessions": s = self._session(parts[1]) if not s: return if len(parts) == 2: return self._send(200, {"id": s.id, "busy": s.proc is not None, "turns": s.turns}) if parts[2] == "messages": return self._send(200, {"messages": s.transcript()}) if parts[2] == "events": return self._events(s) self._send(404, {"error": "not found"}) def _events(self, s: Session) -> None: q: queue.Queue = queue.Queue() s.subscribers.append(q) self.send_response(200) self.send_header("Content-Type", "text/event-stream") self.send_header("Cache-Control", "no-cache") self.end_headers() try: self.wfile.write(b'data: {"type": "server.connected"}\n\n') self.wfile.flush() while True: try: ev = q.get(timeout=15) self.wfile.write(f"data: {json.dumps(ev)}\n\n".encode()) except queue.Empty: self.wfile.write(b": keepalive\n\n") self.wfile.flush() except (BrokenPipeError, ConnectionResetError): pass finally: s.subscribers.remove(q) def do_POST(self): parts = self.path.split("?")[0].strip("/").split("/") body = self._body() if parts == ["sessions"]: sid, directory = body["id"], body["directory"] s = Session(sid, directory) s.home.mkdir(parents=True, exist_ok=True) adapter.setup(s.home, directory) SESSIONS[sid] = s return self._send(201, {"id": sid}) if len(parts) == 3 and parts[0] == "sessions": s = self._session(parts[1]) if not s: return if parts[2] == "prompt": out = s.prompt(body.get("text", "")) return self._send(out.pop("status", 200) if "status" in out else 200, out) if parts[2] == "abort": s.abort() return self._send(200, {"aborted": s.id}) self._send(404, {"error": "not found"}) def do_DELETE(self): parts = self.path.strip("/").split("/") if len(parts) == 2 and parts[0] == "sessions": s = SESSIONS.pop(parts[1], None) if s: s.abort() shutil.rmtree(s.home, ignore_errors=True) return self._send(200, {"deleted": parts[1]}) self._send(404, {"error": "not found"}) if __name__ == "__main__": HOMES.mkdir(parents=True, exist_ok=True) print(f"[cli-shim] {HARNESS} ({MODEL}) on {HOST}:{PORT}", flush=True) ThreadingHTTPServer((HOST, PORT), H).serve_forever()