motif64

m64_0f5b8210b0a4 / cli_shim.py

427 lines, 17.8 KBraw
1"""CLI shim — gives a command-line agent harness a small HTTP API, from inside2its sandbox.34opencode ships an HTTP server; hermes, pi and openclaw are driven here through5their own non-interactive CLI instead, one process per prompt. That keeps each6session in its own working directory and home, relies only on each tool's most7stable interface (the documented one-shot mode + its "continue" flag), and needs8nothing but the Python stdlib.910Copied from gx10 ~/code/vlmtest/agents/shim/cli_shim.py. In the m64 capsule it listens on11$SHIM_HOST:$SHIM_PORT (127.0.0.1:4096): only the agent gateway in the same container calls it.1213  GET    /health14  POST   /sessions                 {id, directory}   create home + harness config15  GET    /sessions/{id}            {busy}16  DELETE /sessions/{id}17  POST   /sessions/{id}/prompt     {text}            blocks; {text, tools, exit_code, ...}18  GET    /sessions/{id}/messages   transcript19  GET    /sessions/{id}/events     SSE: raw harness output lines + turn start/end20  POST   /sessions/{id}/abort      kill the running turn21"""22import json23import os24import queue25import shutil26import signal27import subprocess28import threading29import time30from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer31from pathlib import Path3233HARNESS = os.environ["AGENT_HARNESS"]34MODEL = os.environ["AGENT_MODEL"]35LLM_BASE = os.environ.get("LLM_BASE_URL", "http://llm:9000/v1")36HOST = os.environ.get("SHIM_HOST", "127.0.0.1")37PORT = int(os.environ.get("SHIM_PORT", "4096"))38HOMES = Path(os.environ.get("SHIM_HOMES", "/work/.homes"))39# 0 = no limit: a turn runs until the harness finishes it (the caller can still40# POST /sessions/{id}/abort). Long agentic tasks outlast any fixed cap.41TURN_TIMEOUT = int(os.environ.get("TURN_TIMEOUT", "0"))42# The LLM's max-model-len; harnesses budget their context against it.43CONTEXT = int(os.environ.get("AGENT_CONTEXT", "131072"))44# The reply cap and pi's compaction match the airbench checkup harness (agent-checkup-benchmark45# checkup.py output_cap / compaction_reserve): at 262144 tokens, 32768 out and a 65536-token reserve,46# so one picture cannot overflow the window.47MAX_OUT = int(os.environ.get("AGENT_MAX_OUT", min(16384, CONTEXT // 8)))48COMPACTION_RESERVE = int(os.environ.get("AGENT_COMPACTION_RESERVE", "0"))49# Every agent LLM is a vision model; a harness told "text" only refuses to pass50# images on even though the server takes them.51INPUT = ["text", "image"] if os.environ.get("AGENT_VISION", "1") == "1" else ["text"]525354# ── Harness adapters ──────────────────────────────────────────────────────────55# Each: setup(home, directory) writes config; command(...) -> (argv, env);56# parse(lines) -> (text, tools).5758class Pi:59    binary = "pi"6061    def setup(self, home: Path, directory: str) -> None:62        agent_dir = home / "pi-agent"63        agent_dir.mkdir(parents=True, exist_ok=True)64        (agent_dir / "models.json").write_text(json.dumps({"providers": {"gx10": {65            "baseUrl": LLM_BASE, "api": "openai-completions", "apiKey": "sk-local",66            # vLLM rejects the `developer` role and reasoning_effort (the same compat as the checkup harness).67            "compat": {"supportsDeveloperRole": False, "supportsReasoningEffort": False},68            "models": [{"id": MODEL, "reasoning": True, "input": INPUT, "contextWindow": CONTEXT,69                        "maxTokens": MAX_OUT}]}}}, indent=2))70        (agent_dir / "settings.json").write_text(json.dumps(71            {"defaultProvider": "gx10", "defaultModel": MODEL, "quietStartup": True,72             **({"compaction": {"enabled": True, "reserveTokens": COMPACTION_RESERVE, "keepRecentTokens": 20000}}73                if COMPACTION_RESERVE else {})}))7475    def command(self, home: Path, directory: str, text: str, first: bool, sid: str):76        argv = ["pi", "-p", "--mode", "json", "--provider", "gx10", "--model", MODEL]77        if not first:78            argv.append("--continue")79        argv.append(text)80        env = {"PI_CODING_AGENT_DIR": str(home / "pi-agent"), "PI_OFFLINE": "1",81               "PI_TELEMETRY": "0"}82        return argv, env8384    def parse(self, lines: list[str]):85        text, tools, open_calls = "", [], {}86        for line in lines:87            try:88                ev = json.loads(line)89            except ValueError:90                continue91            t = ev.get("type")92            if t == "tool_execution_start":93                call = {"tool": ev.get("toolName"), "status": "running", "input": ev.get("args"),94                        "output": ""}95                open_calls[ev.get("toolCallId")] = call96                tools.append(call)97            elif t == "tool_execution_end":98                call = open_calls.get(ev.get("toolCallId"))99                if call:100                    call["status"] = "error" if ev.get("isError") else "completed"101                    call["output"] = _content_text(ev.get("result"))[:4000]102            elif t == "message_end" and (ev.get("message") or {}).get("role") == "assistant":103                t_ = _content_text((ev["message"] or {}).get("content"))104                if t_.strip():105                    text = t_106        return text, tools107108109class Hermes:110    binary = "hermes"111112    def setup(self, home: Path, directory: str) -> None:113        h = home / "hermes"114        h.mkdir(parents=True, exist_ok=True)115        (h / "config.yaml").write_text(116            "model:\n"117            f'  default: "{MODEL}"\n'118            '  provider: "custom"\n'119            f'  base_url: "{LLM_BASE}"\n'120            '  api_key: "sk-local"\n'121            '  api_mode: "chat_completions"\n'122            # Its terminal tool otherwise starts in HOME, not the session directory.123            "terminal:\n"124            f'  cwd: "{directory}"\n')125126    def command(self, home: Path, directory: str, text: str, first: bool, sid: str):127        argv = ["hermes", "-z", text, "--provider", "custom", "-m", MODEL, "--yolo",128                "--in", directory]129        if not first:130            argv.append("--continue")131        return argv, {"HERMES_HOME": str(home / "hermes")}132133    def parse(self, lines: list[str]):134        # -z prints only the final response.135        return "\n".join(lines).strip(), []136137138class OpenClaw:139    binary = "openclaw"140141    def setup(self, home: Path, directory: str) -> None:142        state = home / "openclaw"143        state.mkdir(parents=True, exist_ok=True)144        (state / "openclaw.json").write_text(json.dumps({145            "models": {"providers": {"vllm": {146                "baseUrl": LLM_BASE, "apiKey": "sk-local", "api": "openai-completions",147                "timeoutSeconds": 900,148                "models": [{"id": MODEL, "name": MODEL, "reasoning": True, "input": INPUT,149                            "cost": {"input": 0, "output": 0, "cacheRead": 0, "cacheWrite": 0},150                            "contextWindow": CONTEXT, "maxTokens": MAX_OUT}]}}},151            "agents": {"defaults": {"model": {"primary": f"vllm/{MODEL}"},152                                    "workspace": directory}},153            **json.loads(os.environ.get("OPENCLAW_EXTRA_CONFIG", "{}")),154        }, indent=2))155156    def command(self, home: Path, directory: str, text: str, first: bool, sid: str):157        state = home / "openclaw"158        argv = ["openclaw", "agent", "--local", "--session-id", sid, "--message", text, "--json"]159        return argv, {"OPENCLAW_STATE_DIR": str(state),160                      "OPENCLAW_CONFIG_PATH": str(state / "openclaw.json")}161162    def parse(self, lines: list[str]):163        raw = "\n".join(lines)164        start = raw.find("{")165        try:166            doc = json.loads(raw[start:]) if start >= 0 else {}167        except ValueError:168            return raw.strip(), []169        payloads = doc.get("payloads") or (doc.get("result") or {}).get("payloads") or []170        text = "\n".join(p.get("text", "") for p in payloads if isinstance(p, dict)).strip()171        return text or raw.strip(), []172173174class Dsh:175    """DeepSeek Harness (`dsh --profile headless`). The LLM route is a --patch overlay176    on the shipped headless profile: one pi-ai openai-completions provider at the177    gateway, set as the default model. Approvals off via DSH_PERMISSION_MODE (the178    container is the sandbox). Everything else stays the profile's own default."""179    binary = "dsh"180181    def setup(self, home: Path, directory: str) -> None:182        d = home / "dsh"183        d.mkdir(parents=True, exist_ok=True)184        (d / "gx10.patch.yml").write_text(185            "- id: llm-pi-ai\n"186            "  config:\n"187            "    providers:\n"188            "      gx10:\n"189            "        api: openai-completions\n"190            f"        baseURL: {LLM_BASE}\n"191            "        apiKeyEnv: GX10_LLM_KEY\n"192            "        models:\n"193            f"          - id: {MODEL}\n"194            f"            contextWindow: {CONTEXT}\n"195            f"            input: [{', '.join(INPUT)}]\n"196            "- id: agent-default-model\n"197            "  config:\n"198            "    provider: gx10\n"199            f"    model: {MODEL}\n")200201    def command(self, home: Path, directory: str, text: str, first: bool, sid: str):202        d = home / "dsh"203        argv = ["dsh", "--profile", "headless", "--patch", str(d / "gx10.patch.yml"), "--json"]204        if not first:205            # Follow-ups adopt this session's persisted dsh Session (newest under DSH_HOME).206            ids = sorted((p for p in (d / "home" / "sessions").rglob("session-*")),207                         key=lambda p: p.stat().st_mtime)208            if ids:209                argv += ["--session-id", ids[-1].name.split(".")[0]]210        argv.append(text)211        # The gateway holds any real key; the route only needs a non-empty credential.212        return argv, {"DSH_HOME": str(d / "home"), "GX10_LLM_KEY": "sk-local",213                      "DSH_PERMISSION_MODE": "danger-full-access"}214215    def parse(self, lines: list[str]):216        text, tools, calls = "", [], {}217        for line in lines:218            try:219                ev = json.loads(line)220            except ValueError:221                continue222            t = ev.get("type")223            if t == "tool_call":224                call = {"tool": ev.get("tool"), "status": "running", "input": ev.get("input"), "output": ""}225                calls[ev.get("callId")] = call226                tools.append(call)227            elif t == "tool_result":228                call = calls.get(ev.get("callId"))229                if call:230                    r = ev.get("result")231                    call["status"] = ev.get("status") or "completed"232                    call["output"] = (r if isinstance(r, str) else _content_text(r))[:4000]233            elif t == "final":234                text = ev.get("text") or text235        return text, tools236237238ADAPTERS = {"pi": Pi, "hermes": Hermes, "openclaw": OpenClaw, "dsh": Dsh}239adapter = ADAPTERS[HARNESS]()240241242def _content_text(content) -> str:243    if isinstance(content, str):244        return content245    if isinstance(content, dict):246        return _content_text(content.get("content"))247    if isinstance(content, list):248        return "".join(c.get("text", "") for c in content if isinstance(c, dict)249                       and c.get("type") in (None, "text"))250    return ""251252253# ── Sessions ──────────────────────────────────────────────────────────────────254255class Session:256    def __init__(self, sid: str, directory: str):257        self.id, self.directory = sid, directory258        self.home = HOMES / sid259        self.proc: subprocess.Popen | None = None260        self.turns = 0261        self.subscribers: list[queue.Queue] = []262        self.lock = threading.Lock()263        self.transcript_path = self.home / "transcript.json"264265    def emit(self, ev: dict) -> None:266        for q in list(self.subscribers):267            q.put(ev)268269    def transcript(self) -> list:270        try:271            return json.loads(self.transcript_path.read_text())272        except Exception:273            return []274275    def record(self, entry: dict) -> None:276        t = self.transcript()277        t.append(entry)278        self.transcript_path.write_text(json.dumps(t, indent=1))279280    def prompt(self, text: str) -> dict:281        if not self.lock.acquire(blocking=False):282            return {"error": "session busy", "status": 409}283        try:284            argv, extra_env = adapter.command(self.home, self.directory, text,285                                              self.turns == 0, self.id)286            env = {**os.environ, "HOME": str(self.home), **extra_env}287            self.record({"role": "user", "text": text, "time": time.time()})288            self.emit({"type": "turn.start", "text": text})289            t0 = time.time()290            self.proc = subprocess.Popen(argv, cwd=self.directory, env=env, text=True,291                                         stdout=subprocess.PIPE, stderr=subprocess.PIPE,292                                         start_new_session=True)293            err_lines: list[str] = []294            threading.Thread(target=lambda: err_lines.extend(self.proc.stderr), daemon=True).start()295            lines = []296            timer = threading.Timer(TURN_TIMEOUT, self.abort) if TURN_TIMEOUT > 0 else None297            if timer:298                timer.start()299            for line in self.proc.stdout:300                line = line.rstrip("\n")301                lines.append(line)302                self.emit({"type": "output", "line": line})303            code = self.proc.wait()304            if timer:305                timer.cancel()306            reply, tools = adapter.parse(lines)307            out = {"role": "assistant", "text": reply, "tools": tools, "exit_code": code,308                   "elapsed_s": round(time.time() - t0, 1), "time": time.time()}309            if code != 0:310                out["error"] = "".join(err_lines)[-2000:] or f"exit {code}"311            self.turns += 1312            self.record(out)313            self.emit({"type": "turn.end", **out})314            return out315        finally:316            self.proc = None317            self.lock.release()318319    def abort(self) -> None:320        p = self.proc321        if p and p.poll() is None:322            os.killpg(p.pid, signal.SIGTERM)323324325SESSIONS: dict[str, Session] = {}326327328class H(BaseHTTPRequestHandler):329    protocol_version = "HTTP/1.1"330331    def log_message(self, *a):332        pass333334    def _send(self, code: int, obj) -> None:335        body = json.dumps(obj).encode()336        self.send_response(code)337        self.send_header("Content-Type", "application/json")338        self.send_header("Content-Length", str(len(body)))339        self.end_headers()340        self.wfile.write(body)341342    def _body(self) -> dict:343        n = int(self.headers.get("Content-Length") or 0)344        return json.loads(self.rfile.read(n) or b"{}") if n else {}345346    def _session(self, sid: str) -> Session | None:347        s = SESSIONS.get(sid)348        if not s:349            self._send(404, {"error": f"unknown session {sid}"})350        return s351352    def do_GET(self):353        parts = self.path.split("?")[0].strip("/").split("/")354        if parts == ["health"]:355            ok = shutil.which(adapter.binary) is not None356            return self._send(200 if ok else 503, {"ok": ok, "harness": HARNESS})357        if len(parts) >= 2 and parts[0] == "sessions":358            s = self._session(parts[1])359            if not s:360                return361            if len(parts) == 2:362                return self._send(200, {"id": s.id, "busy": s.proc is not None, "turns": s.turns})363            if parts[2] == "messages":364                return self._send(200, {"messages": s.transcript()})365            if parts[2] == "events":366                return self._events(s)367        self._send(404, {"error": "not found"})368369    def _events(self, s: Session) -> None:370        q: queue.Queue = queue.Queue()371        s.subscribers.append(q)372        self.send_response(200)373        self.send_header("Content-Type", "text/event-stream")374        self.send_header("Cache-Control", "no-cache")375        self.end_headers()376        try:377            self.wfile.write(b'data: {"type": "server.connected"}\n\n')378            self.wfile.flush()379            while True:380                try:381                    ev = q.get(timeout=15)382                    self.wfile.write(f"data: {json.dumps(ev)}\n\n".encode())383                except queue.Empty:384                    self.wfile.write(b": keepalive\n\n")385                self.wfile.flush()386        except (BrokenPipeError, ConnectionResetError):387            pass388        finally:389            s.subscribers.remove(q)390391    def do_POST(self):392        parts = self.path.split("?")[0].strip("/").split("/")393        body = self._body()394        if parts == ["sessions"]:395            sid, directory = body["id"], body["directory"]396            s = Session(sid, directory)397            s.home.mkdir(parents=True, exist_ok=True)398            adapter.setup(s.home, directory)399            SESSIONS[sid] = s400            return self._send(201, {"id": sid})401        if len(parts) == 3 and parts[0] == "sessions":402            s = self._session(parts[1])403            if not s:404                return405            if parts[2] == "prompt":406                out = s.prompt(body.get("text", ""))407                return self._send(out.pop("status", 200) if "status" in out else 200, out)408            if parts[2] == "abort":409                s.abort()410                return self._send(200, {"aborted": s.id})411        self._send(404, {"error": "not found"})412413    def do_DELETE(self):414        parts = self.path.strip("/").split("/")415        if len(parts) == 2 and parts[0] == "sessions":416            s = SESSIONS.pop(parts[1], None)417            if s:418                s.abort()419                shutil.rmtree(s.home, ignore_errors=True)420            return self._send(200, {"deleted": parts[1]})421        self._send(404, {"error": "not found"})422423424if __name__ == "__main__":425    HOMES.mkdir(parents=True, exist_ok=True)426    print(f"[cli-shim] {HARNESS} ({MODEL}) on {HOST}:{PORT}", flush=True)427    ThreadingHTTPServer((HOST, PORT), H).serve_forever()