axnwork-cli 0.2.0__py3-none-any.whl

axnwork_cli-0.2.0.dist-info/METADATA

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: axnwork-cli
+Version: 0.2.0
+Summary: Axon mining CLI for the Proof of Useful Work platform
+Requires-Python: >=3.11
+Requires-Dist: typer>=0.15.0
+Requires-Dist: httpx>=0.28.0
+Requires-Dist: litellm>=1.60.0
+Requires-Dist: rich>=13.9.0
+Requires-Dist: eth-account>=0.13.0
+Requires-Dist: simple-term-menu>=1.6.0
+Provides-Extra: test
+Requires-Dist: pytest>=8.0; extra == "test"

axnwork_cli-0.2.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+axon/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+axon/api.py,sha256=jYtTEMy41Il8KOcUDxgtdUjHx_yE77nkV8sKiImQFl0,2654
+axon/cli.py,sha256=a4y0TzJ2XUaqK2QuMukh0aDUHPbKnm0d_PhggUPh6nI,22314
+axon/config.py,sha256=ggyGAKgrHvWIvW4gtP9YVJtKdF2Dft6lPfWmTKu8JyE,1613
+axon/display.py,sha256=8LYSNXA1lza8hzcCIqBxAP91ZNrzhtle_7_98drbg2I,14524
+axon/history.py,sha256=01ci1lR3wjFKibXzrizVi9YZwazc3wputtx5XtAIyaI,4546
+axon/llm.py,sha256=d59C_trHn8q226s6oHZluosZy67i5IDuC1-Tk5Frt7M,10757
+axon/log.py,sha256=-d0UvJFwyrTIFrtFDsLoOB9nExlvzEfefAh3qBpJNmY,1413
+axon/mining.py,sha256=7lTOVYCVv1kW530bpHxLDuOWukTEKqedYbIxu3zzd2M,30873
+axon/providers.py,sha256=Un5XPzrE2E0RWOJ897ZVbS_8S5vRHf-sDPQY4Mf_12A,2130
+axon/session.py,sha256=Jfw_1x4Gyod5XBPo0b7PCVI5QI3gEhQgjTiw7SiPsQ4,643
+axon/wallet.py,sha256=7ycCxPynUJM81TQL6DxoKjEepxw0-0FplvzypnPpLWY,1338
+axon/backends/__init__.py,sha256=G4O08tKQSJKQ7a2BkNwhHvqo3CmpXMHVPiXWpnPIKiE,269
+axon/backends/base.py,sha256=dsYvf43Qmpsa-XEtohkF2b3Oscn68nS0iJc8US6p2W8,665
+axon/backends/claude_cli.py,sha256=LuPe3yBDNAn5acNgyXnYratycWA9gvwUAYio08ziplo,10378
+axon/backends/codex_cli.py,sha256=zFJoyk32cLNXVXF8wzEFVqLnd_17f9ZO6kDYfGe16zY,7295
+axon/backends/litellm_backend.py,sha256=jggn6vC676UApLUV-nOQOeUS-jFz5Zz8eC3lIGJu7c0,1636
+axon/backends/registry.py,sha256=H-eaZdVKtowktXv9AB67O9hb55mwYMsrb1YGN1ZE2oc,1648
+axnwork_cli-0.2.0.dist-info/METADATA,sha256=jca0xsyONsiOqA-rvGdxFSlhIC-how1YoSfI43hpTIM,398
+axnwork_cli-0.2.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+axnwork_cli-0.2.0.dist-info/entry_points.txt,sha256=PvVxY7m3doaRsgAFAWnCXdkZsdzvMtT9Rdx53_Mzvpg,38
+axnwork_cli-0.2.0.dist-info/top_level.txt,sha256=vRkPFUYD0GspqpZfeuY7c2fzJmpHIpgjOY_nnOHNwVc,5
+axnwork_cli-0.2.0.dist-info/RECORD,,

axnwork_cli-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

axnwork_cli-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+axon = axon.cli:app

axnwork_cli-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+axon

axon/api.py

@@ -0,0 +1,83 @@
+"""Backend HTTP client with automatic wallet auth."""
+import httpx
+from axon.config import load_config, get_token, save_config
+
+
+def _ensure_auth():
+    """Auto-authenticate with wallet if no valid token."""
+    transport = httpx.HTTPTransport(proxy=None)
+
+    token = get_token()
+    if token:
+        config = load_config()
+        try:
+            with httpx.Client(base_url=config["server_url"], timeout=5, transport=transport) as c:
+                resp = c.get("/api/auth/me", headers={"Authorization": f"Bearer {token}"})
+            if resp.status_code == 200:
+                return  # Token still valid
+        except httpx.ConnectError:
+            raise
+        except Exception:
+            pass  # Token expired or invalid, try re-auth below
+
+    # Token missing or expired — re-auth with wallet
+    from axon.wallet import load_wallet, sign_message
+    wallet = load_wallet()
+    if not wallet:
+        return
+
+    config = load_config()
+    with httpx.Client(base_url=config["server_url"], timeout=10, transport=transport) as c:
+        # Get nonce
+        resp = c.get(f"/api/auth/nonce?address={wallet['address']}")
+        if resp.status_code != 200:
+            return
+        nonce_data = resp.json()
+
+        # Sign
+        signature = sign_message(nonce_data["message"], wallet["private_key"])
+
+        # Verify
+        resp = c.post("/api/auth/verify", json={
+            "address": wallet["address"],
+            "signature": signature,
+        })
+        if resp.status_code == 200:
+            save_config({"auth_token": resp.json()["access_token"]})
+
+
+def _client(auth: bool = True, timeout: int = 120) -> httpx.Client:
+    if auth:
+        _ensure_auth()
+    config = load_config()
+    headers = {"Content-Type": "application/json"}
+    token = get_token()
+    if auth and token:
+        headers["Authorization"] = f"Bearer {token}"
+    return httpx.Client(
+        base_url=config["server_url"],
+        headers=headers,
+        timeout=timeout,
+        transport=httpx.HTTPTransport(proxy=None),
+    )
+
+
+def api_get(path: str, auth: bool = True) -> dict | list:
+    with _client(auth=auth) as c:
+        resp = c.get(path)
+        resp.raise_for_status()
+        return resp.json()
+
+
+def api_post(path: str, body: dict, auth: bool = True) -> dict:
+    with _client(auth=auth) as c:
+        resp = c.post(path, json=body)
+        resp.raise_for_status()
+        return resp.json()
+
+
+def api_patch(path: str, body: dict | None = None, auth: bool = True) -> dict:
+    with _client(auth=auth) as c:
+        resp = c.patch(path, json=body) if body else c.patch(path)
+        resp.raise_for_status()
+        return resp.json()

axon/backends/__init__.py

@@ -0,0 +1,5 @@
+"""Axon mining backends — litellm, claude-cli, codex-cli."""
+from axon.backends.base import Backend, BackendResult
+from axon.backends.registry import auto_detect_backend, create_backend
+
+__all__ = ["Backend", "BackendResult", "auto_detect_backend", "create_backend"]

axon/backends/base.py

@@ -0,0 +1,23 @@
+"""Backend protocol and result type for mining LLM calls."""
+from __future__ import annotations
+
+from typing import Protocol, TypedDict, runtime_checkable
+
+
+class BackendResult(TypedDict):
+    thinking: str
+    answer: str
+    usage: dict  # {billing_mode, tokens, cost_usd, total_tokens, prompt_tokens, completion_tokens, cost}
+
+
+@runtime_checkable
+class Backend(Protocol):
+    name: str
+
+    def call(self, prompt: str, task: dict) -> BackendResult:
+        """Call the backend with a prompt and task context. Returns structured result."""
+        ...
+
+    def display_name(self) -> str:
+        """Human-readable name for display in status lines."""
+        ...

axon/backends/claude_cli.py

@@ -0,0 +1,290 @@
+"""Claude Code CLI backend — runs `claude -p` as subprocess."""
+from __future__ import annotations
+
+import json
+import logging
+import os
+import re
+import shlex
+import signal
+import subprocess
+import time
+from datetime import datetime
+
+from axon.backends.base import BackendResult
+from axon.backends.registry import register
+from axon.config import resolve_cli_timeout
+
+log = logging.getLogger("axon.backend.claude")
+_STREAM_SAMPLE_LIMIT = 20
+_STREAM_SAMPLE_BYTES = 240
+_SUBSCRIPTION_USAGE = {
+    "billing_mode": "subscription",
+    "tokens": None,
+    "cost_usd": None,
+    "total_tokens": None,
+    "prompt_tokens": None,
+    "completion_tokens": None,
+    "cost": None,
+}
+
+
+def _now_iso() -> str:
+    return datetime.now().astimezone().isoformat(timespec="seconds")
+
+
+def _normalize_output(output: str | bytes | None) -> str:
+    if output is None:
+        return ""
+    if isinstance(output, bytes):
+        return output.decode("utf-8", errors="replace")
+    return output
+
+
+def _log_output_sample(stream_name: str, output: str):
+    if not output:
+        return
+    lines = output.splitlines()
+    for line_count, line in enumerate(lines[:_STREAM_SAMPLE_LIMIT], start=1):
+        log.info("Claude CLI %s[%d]: %s", stream_name, line_count, line[:_STREAM_SAMPLE_BYTES])
+    if len(lines) > _STREAM_SAMPLE_LIMIT:
+        log.info("Claude CLI %s: further output truncated after %d lines", stream_name, _STREAM_SAMPLE_LIMIT)
+
+# Tool sets by eval_type
+_TOOLS_BY_EVAL_TYPE = {
+    "code_output": "Bash,Read,Write,Grep,Glob",
+    "llm_judge": "Read,WebSearch,WebFetch,Grep,Glob",
+}
+_DEFAULT_TOOLS = "Read,WebSearch,Grep,Glob"
+
+# System prompts include output format instructions (no --json-schema, which
+# conflicts with agentic multi-turn tool use and can cause infinite retries).
+_SYSTEM_PROMPTS = {
+    "code_output": (
+        "You are solving a coding task. Write executable code that produces the correct output. "
+        "Use Bash to test your code before submitting your final answer. "
+        "Iterate until tests pass.\n\n"
+        "YOUR FINAL MESSAGE must contain ONLY raw executable Python code.\n"
+        "Do NOT wrap it in <answer> tags. Do NOT use markdown fences. Do NOT add explanation.\n"
+        "The evaluator writes your submission directly to solution.py and executes it."
+    ),
+    "llm_judge": (
+        "You are solving a research/reasoning task. Use WebSearch and WebFetch to find "
+        "accurate information. Verify facts before submitting. "
+        "Provide a thorough, well-reasoned answer in your final message."
+    ),
+}
+_DEFAULT_SYSTEM = (
+    "You are solving a task. Use available tools to research and verify your answer. "
+    "Be thorough and accurate. Put your final answer in your last message."
+)
+
+
+@register("claude-cli")
+class ClaudeCLIBackend:
+    name = "claude-cli"
+
+    def __init__(self, config: dict):
+        self._timeout = resolve_cli_timeout(config)
+        self._model = config.get("claude_cli_model", "")
+
+    def call(self, prompt: str, task: dict) -> BackendResult:
+        eval_type = task.get("eval_type", "")
+        tools = _TOOLS_BY_EVAL_TYPE.get(eval_type, _DEFAULT_TOOLS)
+        system_prompt = _SYSTEM_PROMPTS.get(eval_type, _DEFAULT_SYSTEM)
+
+        # Prompt is passed via stdin (no positional arg) to avoid OS arg-length limits.
+        # No --json-schema: it conflicts with agentic tool-use and causes hangs.
+        cmd = [
+            "claude", "-p",
+            "--output-format", "json",
+            "--allowedTools", tools,
+            "--system-prompt", system_prompt,
+            "--dangerously-skip-permissions",
+        ]
+        if self._model:
+            cmd.extend(["--model", self._model])
+
+        started_at = _now_iso()
+        started_mono = time.monotonic()
+        timeout_label = "none" if self._timeout is None else f"{self._timeout}s"
+        log.info(
+            "Claude CLI start started_at=%s eval_type=%s tools=%s timeout=%s prompt_chars=%d cmd=%s",
+            started_at,
+            eval_type,
+            tools,
+            timeout_label,
+            len(prompt),
+            shlex.join(cmd),
+        )
+
+        # Clear env vars that make Claude CLI refuse to run inside another session
+        _blocked_env = {"CLAUDECODE", "CLAUDE_CODE_ENTRYPOINT"}
+        env = {k: v for k, v in os.environ.items() if k not in _blocked_env}
+
+        # start_new_session creates a process group so we can kill all children
+        proc = subprocess.Popen(
+            cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+            text=True, start_new_session=True, env=env,
+        )
+        try:
+            stdout, stderr = proc.communicate(input=prompt, timeout=self._timeout)
+        except subprocess.TimeoutExpired as exc:
+            stdout = _normalize_output(exc.stdout)
+            stderr = _normalize_output(exc.stderr)
+            _kill_process_group(proc)
+            _log_output_sample("stdout", stdout)
+            _log_output_sample("stderr", stderr)
+            log.error(
+                "Claude CLI timeout started_at=%s finished_at=%s duration_s=%.2f cmd=%s",
+                started_at,
+                _now_iso(),
+                time.monotonic() - started_mono,
+                shlex.join(cmd),
+            )
+            raise TimeoutError(f"Claude CLI timed out after {self._timeout}s") from None
+
+        _log_output_sample("stdout", stdout)
+        _log_output_sample("stderr", stderr)
+        if proc.returncode != 0:
+            log.error(
+                "Claude CLI failed started_at=%s finished_at=%s duration_s=%.2f returncode=%s cmd=%s stderr=%s",
+                started_at,
+                _now_iso(),
+                time.monotonic() - started_mono,
+                proc.returncode,
+                shlex.join(cmd),
+                stderr[:1000],
+            )
+            raise RuntimeError(f"Claude CLI exited with code {proc.returncode}: {stderr[:500]}")
+
+        if stderr:
+            log.debug("Claude CLI stderr: %s", stderr[:500])
+
+        log.info(
+            "Claude CLI finished started_at=%s finished_at=%s duration_s=%.2f returncode=%s stdout_chars=%d stderr_chars=%d",
+            started_at,
+            _now_iso(),
+            time.monotonic() - started_mono,
+            proc.returncode,
+            len(stdout),
+            len(stderr),
+        )
+
+        return _parse_response(stdout)
+
+    def display_name(self) -> str:
+        return f"claude-cli{f' ({self._model})' if self._model else ''}"
+
+
+def _kill_process_group(proc: subprocess.Popen):
+    """Kill the process and its entire process group."""
+    try:
+        pgid = os.getpgid(proc.pid)
+        os.killpg(pgid, signal.SIGTERM)
+    except (ProcessLookupError, OSError):
+        try:
+            proc.kill()
+        except OSError:
+            pass
+    try:
+        proc.wait(timeout=5)
+    except subprocess.TimeoutExpired:
+        try:
+            pgid = os.getpgid(proc.pid)
+            os.killpg(pgid, signal.SIGKILL)
+        except (ProcessLookupError, OSError):
+            try:
+                proc.kill()
+            except OSError:
+                pass
+        try:
+            proc.wait(timeout=3)
+        except subprocess.TimeoutExpired:
+            log.warning("Process %d did not exit after SIGKILL", proc.pid)
+
+
+def _parse_response(stdout: str) -> BackendResult:
+    """Parse Claude CLI JSON output.
+
+    `claude -p --output-format json` returns a single JSON object:
+      {type: "result", result: "...", total_cost_usd: ..., usage: {...}}
+    """
+    stdout = stdout.strip()
+    if not stdout:
+        raise RuntimeError("Claude CLI returned empty output")
+
+    data = json.loads(stdout)
+
+    # Extract the result text and usage from the response envelope
+    if isinstance(data, dict) and data.get("type") == "result":
+        content = data.get("result", "")
+        usage = _extract_usage(data)
+    elif isinstance(data, list):
+        # Fallback: older array format [{type:"system",...}, {type:"result",...}]
+        result_block = None
+        for block in data:
+            if isinstance(block, dict) and block.get("type") == "result":
+                result_block = block
+                break
+        if result_block is None:
+            raise RuntimeError("No result block found in Claude CLI output")
+        content = result_block.get("result", "")
+        usage = _extract_usage(result_block)
+    elif isinstance(data, dict):
+        # Direct dict with thinking/answer keys
+        return BackendResult(
+            thinking=data.get("thinking", ""),
+            answer=data.get("answer", str(data)),
+            usage=dict(_SUBSCRIPTION_USAGE),
+        )
+    else:
+        raise RuntimeError(f"Unexpected Claude CLI output type: {type(data)}")
+
+    return _extract_answer(content, usage)
+
+
+def _extract_usage(envelope: dict) -> dict:
+    """Return subscription usage — Claude CLI is subscription-based, not metered."""
+    return dict(_SUBSCRIPTION_USAGE)
+
+
+def _extract_answer(content, usage: dict) -> BackendResult:
+    """Parse the result field into thinking + answer."""
+    # If content is already a dict, extract fields
+    if isinstance(content, dict):
+        return BackendResult(
+            thinking=content.get("thinking", ""),
+            answer=content.get("answer", str(content)),
+            usage=usage,
+        )
+
+    text = str(content).strip()
+
+    # Try 1: Parse as JSON object with thinking/answer
+    try:
+        parsed = json.loads(text)
+        if isinstance(parsed, dict) and "answer" in parsed:
+            return BackendResult(
+                thinking=parsed.get("thinking", ""),
+                answer=parsed["answer"],
+                usage=usage,
+            )
+    except (json.JSONDecodeError, TypeError):
+        pass
+
+    # Try 2: Extract <thinking> and <answer> XML tags
+    think_match = re.search(r"<thinking>(.*?)</thinking>", text, re.DOTALL)
+    answer_match = re.search(r"<answer>(.*?)</answer>", text, re.DOTALL)
+    if answer_match:
+        return BackendResult(
+            thinking=think_match.group(1).strip() if think_match else "",
+            answer=answer_match.group(1).strip(),
+            usage=usage,
+        )
+
+    # Try 3: Strip markdown fences (common in code responses)
+    cleaned = re.sub(r"^```[\w]*\s*\n?", "", text)
+    cleaned = re.sub(r"\n?\s*```\s*$", "", cleaned)
+
+    return BackendResult(thinking="", answer=cleaned.strip(), usage=usage)

axon/backends/codex_cli.py

@@ -0,0 +1,223 @@
+"""OpenAI Codex CLI backend — runs `codex exec` as subprocess."""
+from __future__ import annotations
+
+import json
+import logging
+import os
+import re
+import shlex
+import signal
+import subprocess
+import time
+from datetime import datetime
+
+from axon.backends.base import BackendResult
+from axon.backends.registry import register
+from axon.config import resolve_cli_timeout
+
+log = logging.getLogger("axon.backend.codex")
+_STREAM_SAMPLE_LIMIT = 20
+_STREAM_SAMPLE_BYTES = 240
+_SUBSCRIPTION_USAGE = {
+    "billing_mode": "subscription",
+    "tokens": None,
+    "cost_usd": None,
+    "total_tokens": None,
+    "prompt_tokens": None,
+    "completion_tokens": None,
+    "cost": None,
+}
+
+
+def _now_iso() -> str:
+    return datetime.now().astimezone().isoformat(timespec="seconds")
+
+
+def _normalize_output(output: str | bytes | None) -> str:
+    if output is None:
+        return ""
+    if isinstance(output, bytes):
+        return output.decode("utf-8", errors="replace")
+    return output
+
+
+def _log_output_sample(stream_name: str, output: str):
+    if not output:
+        return
+    lines = output.splitlines()
+    for line_count, line in enumerate(lines[:_STREAM_SAMPLE_LIMIT], start=1):
+        log.info("Codex CLI %s[%d]: %s", stream_name, line_count, line[:_STREAM_SAMPLE_BYTES])
+    if len(lines) > _STREAM_SAMPLE_LIMIT:
+        log.info("Codex CLI %s: further output truncated after %d lines", stream_name, _STREAM_SAMPLE_LIMIT)
+
+# Codex doesn't support --json-schema, so we embed format instructions in the prompt
+_FORMAT_WRAPPER = """
+{prompt}
+
+## OUTPUT FORMAT
+You MUST output your response as valid JSON with exactly this structure:
+{{"thinking": "your step-by-step reasoning", "answer": "your final answer"}}
+
+If the task expects code, the "answer" field must contain ONLY raw executable Python code.
+Do NOT include XML tags, markdown fences, or prose in the "answer" field.
+
+Output ONLY the JSON object, nothing else.
+"""
+
+
+@register("codex-cli")
+class CodexCLIBackend:
+    name = "codex-cli"
+
+    def __init__(self, config: dict):
+        self._timeout = resolve_cli_timeout(config)
+        self._model = config.get("codex_cli_model", "")
+
+    def call(self, prompt: str, task: dict) -> BackendResult:
+        wrapped_prompt = _FORMAT_WRAPPER.format(prompt=prompt).strip()
+
+        # Prompt passed via stdin ("-" flag) to avoid OS arg-length limits
+        cmd = ["codex", "exec", "-", "--full-auto"]
+        if self._model:
+            cmd.extend(["--model", self._model])
+
+        started_at = _now_iso()
+        started_mono = time.monotonic()
+        timeout_label = "none" if self._timeout is None else f"{self._timeout}s"
+        log.info(
+            "Codex CLI start started_at=%s timeout=%s prompt_chars=%d cmd=%s",
+            started_at,
+            timeout_label,
+            len(wrapped_prompt),
+            shlex.join(cmd),
+        )
+
+        # start_new_session creates a process group so we can kill all children
+        proc = subprocess.Popen(
+            cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+            text=True, start_new_session=True,
+        )
+        try:
+            stdout, stderr = proc.communicate(input=wrapped_prompt, timeout=self._timeout)
+        except subprocess.TimeoutExpired as exc:
+            stdout = _normalize_output(exc.stdout)
+            stderr = _normalize_output(exc.stderr)
+            _kill_process_group(proc)
+            _log_output_sample("stdout", stdout)
+            _log_output_sample("stderr", stderr)
+            log.error(
+                "Codex CLI timeout started_at=%s finished_at=%s duration_s=%.2f cmd=%s",
+                started_at,
+                _now_iso(),
+                time.monotonic() - started_mono,
+                shlex.join(cmd),
+            )
+            raise TimeoutError(f"Codex CLI timed out after {self._timeout}s")
+
+        _log_output_sample("stdout", stdout)
+        _log_output_sample("stderr", stderr)
+        if proc.returncode != 0:
+            log.error(
+                "Codex CLI failed started_at=%s finished_at=%s duration_s=%.2f returncode=%s cmd=%s stderr=%s",
+                started_at,
+                _now_iso(),
+                time.monotonic() - started_mono,
+                proc.returncode,
+                shlex.join(cmd),
+                stderr[:1000],
+            )
+            raise RuntimeError(f"Codex CLI exited with code {proc.returncode}: {stderr[:500]}")
+
+        if stderr:
+            log.debug("Codex CLI stderr: %s", stderr[:500])
+
+        log.info(
+            "Codex CLI finished started_at=%s finished_at=%s duration_s=%.2f returncode=%s stdout_chars=%d stderr_chars=%d",
+            started_at,
+            _now_iso(),
+            time.monotonic() - started_mono,
+            proc.returncode,
+            len(stdout),
+            len(stderr),
+        )
+
+        return _parse_response(stdout)
+
+    def display_name(self) -> str:
+        return f"codex-cli{f' ({self._model})' if self._model else ''}"
+
+
+def _kill_process_group(proc: subprocess.Popen):
+    """Kill the process and its entire process group."""
+    try:
+        pgid = os.getpgid(proc.pid)
+        os.killpg(pgid, signal.SIGTERM)
+    except (ProcessLookupError, OSError):
+        try:
+            proc.kill()
+        except OSError:
+            pass
+    try:
+        proc.wait(timeout=5)
+    except subprocess.TimeoutExpired:
+        try:
+            pgid = os.getpgid(proc.pid)
+            os.killpg(pgid, signal.SIGKILL)
+        except (ProcessLookupError, OSError):
+            try:
+                proc.kill()
+            except OSError:
+                pass
+        proc.wait(timeout=3)
+
+
+def _parse_response(stdout: str) -> BackendResult:
+    """Parse Codex CLI output. Tries to extract JSON {thinking, answer}."""
+    stdout = stdout.strip()
+    if not stdout:
+        raise RuntimeError("Codex CLI returned empty output")
+
+    # Try to parse as JSON directly
+    try:
+        data = json.loads(stdout)
+        if isinstance(data, dict) and "answer" in data:
+            return BackendResult(
+                thinking=data.get("thinking", ""),
+                answer=data["answer"],
+                usage=dict(_SUBSCRIPTION_USAGE),
+            )
+    except json.JSONDecodeError:
+        pass
+
+    # Try to find JSON object within the output
+    match = re.search(r'\{[^{}]*"answer"\s*:\s*"[^"]*"[^{}]*\}', stdout, re.DOTALL)
+    if match:
+        try:
+            data = json.loads(match.group())
+            return BackendResult(
+                thinking=data.get("thinking", ""),
+                answer=data["answer"],
+                usage=dict(_SUBSCRIPTION_USAGE),
+            )
+        except json.JSONDecodeError:
+            pass
+
+    # Try more aggressive JSON extraction with multiline
+    match = re.search(r'\{[\s\S]*?"thinking"[\s\S]*?"answer"[\s\S]*?\}', stdout)
+    if match:
+        try:
+            data = json.loads(match.group())
+            return BackendResult(
+                thinking=data.get("thinking", ""),
+                answer=data["answer"],
+                usage=dict(_SUBSCRIPTION_USAGE),
+            )
+        except json.JSONDecodeError:
+            pass
+
+    # Fallback: treat entire output as answer
+    return BackendResult(
+        thinking="",
+        answer=stdout,
+        usage=dict(_SUBSCRIPTION_USAGE),
+    )