aicortexpy 0.1.0__py3-none-any.whl

aicortexpy/models.py

@@ -0,0 +1,385 @@
+"""Model list discovery for heartbeat pending_model_list."""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import re
+import subprocess
+import tempfile
+import threading
+import time
+from typing import Any, Callable
+
+log = logging.getLogger("aicortexpy.models")
+
+_CACHE_TTL = 60.0
+_cache_mu = threading.Lock()
+_cache: dict[str, tuple[float, list[dict[str, Any]]]] = {}
+
+_STATIC: dict[str, list[dict[str, Any]]] = {
+    "claude": [
+        {"id": "sonnet", "label": "Claude Sonnet", "provider": "claude", "default": True},
+        {"id": "opus", "label": "Claude Opus", "provider": "claude"},
+        {"id": "haiku", "label": "Claude Haiku", "provider": "claude"},
+    ],
+    "codex": [
+        {"id": "o4-mini", "label": "o4-mini", "provider": "codex", "default": True},
+        {"id": "gpt-5", "label": "GPT-5", "provider": "codex"},
+    ],
+    "cursor": [
+        {"id": "auto", "label": "Auto", "provider": "cursor", "default": True},
+    ],
+    "gemini": [
+        {"id": "gemini-2.5-pro", "label": "Gemini 2.5 Pro", "provider": "gemini", "default": True},
+    ],
+    "copilot": [
+        {"id": "gpt-4.1", "label": "GPT-4.1", "provider": "copilot", "default": True},
+        {"id": "claude-sonnet-4", "label": "Claude Sonnet 4", "provider": "copilot"},
+    ],
+}
+
+_ACP_PROVIDERS = frozenset({"hermes", "kimi", "kiro", "dsh", "copilot"})
+
+
+def list_models(provider: str, executable: str) -> list[dict[str, Any]]:
+    key = f"{provider}:{executable}"
+    now = time.time()
+    with _cache_mu:
+        hit = _cache.get(key)
+        if hit and now - hit[0] < _CACHE_TTL:
+            return list(hit[1])
+
+    models = _discover(provider, executable)
+    if not models:
+        models = list(_STATIC.get(provider, []))
+    with _cache_mu:
+        _cache[key] = (now, list(models))
+    return models
+
+
+def model_selection_supported(provider: str) -> bool:
+    return provider in _STATIC or provider in {
+        "claude",
+        "codex",
+        "cursor",
+        "gemini",
+        "copilot",
+        "opencode",
+        "pi",
+        "hermes",
+        "kimi",
+        "kiro",
+        "dsh",
+        "openclaw",
+    }
+
+
+def _discover(provider: str, executable: str) -> list[dict[str, Any]]:
+    if provider in ("claude", "codex", "gemini"):
+        return list(_STATIC.get(provider, []))
+    if provider == "opencode":
+        return _probe_args(executable, ["models"], provider) or _probe_cli(provider, executable)
+    if provider == "pi":
+        return _probe_args(executable, ["--list-models"], provider) or _probe_cli(
+            provider, executable
+        )
+    if provider == "cursor":
+        return _probe_args(executable, ["--list-models"], provider) or _probe_cli(
+            provider, executable
+        )
+    if provider == "openclaw":
+        return _discover_openclaw_agents(executable)
+    if provider in _ACP_PROVIDERS:
+        acp_args = _acp_args_for(provider)
+        extra_env = {"HERMES_YOLO_MODE": "1"} if provider == "hermes" else None
+        parse = _parse_dsh_session_models if provider == "dsh" else _parse_acp_session_models
+        models = discover_acp_models(executable, acp_args, extra_env=extra_env, parse_fn=parse)
+        if models:
+            return models
+        if provider == "copilot":
+            return list(_STATIC["copilot"])
+        return []
+    return _probe_cli(provider, executable)
+
+
+def _acp_args_for(provider: str) -> list[str]:
+    if provider == "copilot":
+        return ["--acp"]
+    if provider == "dsh":
+        return ["--profile", "acp"]
+    if provider == "kiro":
+        return ["acp"]
+    return ["acp"]
+
+
+def discover_acp_models(
+    executable: str,
+    acp_args: list[str],
+    *,
+    extra_env: dict[str, str] | None = None,
+    parse_fn: Callable[[dict[str, Any], str], list[dict[str, Any]]] | None = None,
+    provider: str = "",
+) -> list[dict[str, Any]]:
+    """Spawn ACP, initialize + session/new, parse availableModels (Go discoverACPModels)."""
+    parse_fn = parse_fn or _parse_acp_session_models
+    env = os.environ.copy()
+    if extra_env:
+        env.update(extra_env)
+    try:
+        proc = subprocess.Popen(
+            [executable, *acp_args],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.DEVNULL,
+            text=True,
+            env=env,
+            bufsize=1,
+        )
+    except OSError as e:
+        log.debug("acp model discovery spawn failed: %s", e)
+        return []
+
+    cwd = tempfile.gettempdir()
+    reqs = [
+        {
+            "jsonrpc": "2.0",
+            "id": 1,
+            "method": "initialize",
+            "params": {
+                "protocolVersion": 1,
+                "clientInfo": {"name": "aicortex-model-discovery", "version": "0.1.0"},
+                "clientCapabilities": {},
+            },
+        },
+        {
+            "jsonrpc": "2.0",
+            "id": 2,
+            "method": "session/new",
+            "params": {"cwd": cwd, "mcpServers": []},
+        },
+    ]
+    try:
+        assert proc.stdin is not None
+        for req in reqs:
+            proc.stdin.write(json.dumps(req) + "\n")
+            proc.stdin.flush()
+    except OSError:
+        _kill(proc)
+        return []
+
+    deadline = time.time() + 12.0
+    result_obj: dict[str, Any] | None = None
+    try:
+        assert proc.stdout is not None
+        while time.time() < deadline:
+            line = proc.stdout.readline()
+            if not line:
+                if proc.poll() is not None:
+                    break
+                time.sleep(0.05)
+                continue
+            try:
+                msg = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+            if not isinstance(msg, dict):
+                continue
+            if msg.get("id") == 2 and "result" in msg:
+                result_obj = msg.get("result") if isinstance(msg.get("result"), dict) else {}
+                break
+    finally:
+        _kill(proc)
+
+    if not isinstance(result_obj, dict):
+        return []
+    return parse_fn(result_obj, provider or "acp")
+
+
+def _kill(proc: subprocess.Popen) -> None:
+    try:
+        if proc.stdin:
+            proc.stdin.close()
+    except OSError:
+        pass
+    try:
+        proc.kill()
+    except OSError:
+        pass
+    try:
+        proc.wait(timeout=2)
+    except Exception:
+        pass
+
+
+def _parse_acp_session_models(result: dict[str, Any], provider: str) -> list[dict[str, Any]]:
+    models_obj = result.get("models")
+    available: list[Any] = []
+    current = ""
+    if isinstance(models_obj, dict):
+        available = models_obj.get("availableModels") or []
+        current = str(models_obj.get("currentModelId") or "")
+    elif isinstance(result.get("availableModels"), list):
+        available = result["availableModels"]
+        current = str(result.get("currentModelId") or "")
+    out: list[dict[str, Any]] = []
+    for i, m in enumerate(available):
+        if not isinstance(m, dict):
+            continue
+        mid = str(m.get("modelId") or m.get("id") or "").strip()
+        if not mid:
+            continue
+        label = str(m.get("name") or m.get("label") or mid)
+        out.append(
+            {
+                "id": mid,
+                "label": label,
+                "provider": provider or "acp",
+                "default": (current and mid == current) or (not current and i == 0),
+            }
+        )
+    return out
+
+
+def _parse_dsh_session_models(result: dict[str, Any], provider: str) -> list[dict[str, Any]]:
+    opts = result.get("configOptions")
+    if not isinstance(opts, list):
+        return _parse_acp_session_models(result, provider)
+    for opt in opts:
+        if not isinstance(opt, dict):
+            continue
+        if str(opt.get("id") or "") != "model":
+            continue
+        choices = opt.get("options") or opt.get("values") or []
+        out: list[dict[str, Any]] = []
+        current = str(opt.get("value") or "")
+        if isinstance(choices, list):
+            for i, c in enumerate(choices):
+                if isinstance(c, dict):
+                    mid = str(c.get("value") or c.get("id") or "").strip()
+                    label = str(c.get("label") or c.get("name") or mid)
+                else:
+                    mid = str(c).strip()
+                    label = mid
+                if not mid:
+                    continue
+                out.append(
+                    {
+                        "id": mid,
+                        "label": label,
+                        "provider": provider or "dsh",
+                        "default": (current and mid == current) or (not current and i == 0),
+                    }
+                )
+        return out
+    return _parse_acp_session_models(result, provider)
+
+
+def _discover_openclaw_agents(executable: str) -> list[dict[str, Any]]:
+    for args in (["agents", "list", "--json"], ["agents", "list"]):
+        try:
+            proc = subprocess.run(
+                [executable, *args],
+                capture_output=True,
+                text=True,
+                timeout=20,
+                check=False,
+            )
+        except Exception:
+            continue
+        out = (proc.stdout or "").strip()
+        if proc.returncode != 0 or not out:
+            continue
+        try:
+            data = json.loads(out)
+        except json.JSONDecodeError:
+            continue
+        entries = data if isinstance(data, list) else (data.get("agents") if isinstance(data, dict) else None)
+        if not isinstance(entries, list):
+            continue
+        models: list[dict[str, Any]] = []
+        for i, e in enumerate(entries):
+            if isinstance(e, dict):
+                mid = str(e.get("id") or e.get("name") or "").strip()
+                label = str(e.get("name") or e.get("id") or mid)
+            else:
+                mid = str(e).strip()
+                label = mid
+            if not mid:
+                continue
+            models.append(
+                {"id": mid, "label": label, "provider": "openclaw", "default": i == 0}
+            )
+        if models:
+            return models
+    return []
+
+
+def _probe_args(executable: str, args: list[str], provider: str) -> list[dict[str, Any]]:
+    try:
+        proc = subprocess.run(
+            [executable, *args],
+            capture_output=True,
+            text=True,
+            timeout=20,
+            check=False,
+        )
+    except Exception:
+        return []
+    out = (proc.stdout or "") + "\n" + (proc.stderr or "")
+    if proc.returncode != 0 or not out.strip():
+        return []
+    return _parse_model_lines(out, provider)
+
+
+def _probe_cli(provider: str, executable: str) -> list[dict[str, Any]]:
+    for args in (
+        [executable, "models"],
+        [executable, "--list-models"],
+        [executable, "model", "list"],
+    ):
+        try:
+            proc = subprocess.run(
+                args,
+                capture_output=True,
+                text=True,
+                timeout=20,
+                check=False,
+            )
+        except Exception:
+            continue
+        out = (proc.stdout or "") + "\n" + (proc.stderr or "")
+        if proc.returncode != 0 or not out.strip():
+            continue
+        models = _parse_model_lines(out, provider)
+        if models:
+            return models
+    return []
+
+
+def _parse_model_lines(text: str, provider: str) -> list[dict[str, Any]]:
+    models: list[dict[str, Any]] = []
+    seen: set[str] = set()
+    for line in text.splitlines():
+        line = line.strip().strip("-*• ")
+        if not line or line.lower().startswith("model"):
+            continue
+        m = re.match(r"([A-Za-z0-9._:/-]+)", line)
+        if not m:
+            continue
+        mid = m.group(1)
+        if mid.lower() in {"id", "name", "models"} or mid in seen:
+            continue
+        seen.add(mid)
+        models.append(
+            {
+                "id": mid,
+                "label": line if len(line) < 80 else mid,
+                "provider": provider,
+                "default": len(models) == 0,
+            }
+        )
+        if len(models) >= 40:
+            break
+    return models

aicortexpy/openclaw_config.py

@@ -0,0 +1,153 @@
+"""Per-task OpenClaw config wrapper (OPENCLAW_CONFIG_PATH + workspace pin)."""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import shutil
+import subprocess
+from copy import deepcopy
+from dataclasses import dataclass
+from pathlib import Path
+
+log = logging.getLogger("aicortexpy.openclaw_config")
+
+OPENCLAW_CONFIG_FILE = "openclaw-config.json"
+CLI_TIMEOUT = 5.0
+
+
+class OpenclawConfigError(RuntimeError):
+    """Fail-closed prepare error (matches Go execenv prepareOpenclawConfig)."""
+
+
+@dataclass
+class OpenclawConfigResult:
+    config_path: str = ""
+    include_root: str = ""
+    env_updates: dict[str, str] | None = None
+
+
+def prepare_openclaw_config(
+    env_root: Path,
+    work_dir: Path,
+    *,
+    openclaw_bin: str = "",
+) -> OpenclawConfigResult:
+    """Write env_root/openclaw-config.json pinning agents.*.workspace to work_dir."""
+    bin_name = openclaw_bin or shutil.which("openclaw") or "openclaw"
+    active_path, exists = _active_config_path(bin_name)
+
+    work = str(work_dir.resolve())
+    agents_list = _resolved_agents_list(bin_name) if exists else []
+    rewritten = _rewrite_agents_list_workspaces(agents_list, work)
+
+    wrapper: dict = {
+        "agents": {
+            "defaults": {"workspace": work},
+            "list": rewritten,
+        }
+    }
+    include_root = ""
+    if exists and active_path:
+        wrapper["$include"] = [active_path]
+        include_root = str(Path(active_path).resolve().parent)
+
+    env_root.mkdir(parents=True, exist_ok=True)
+    out_path = env_root / OPENCLAW_CONFIG_FILE
+    out_path.write_text(json.dumps(wrapper, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+
+    env_updates = {"OPENCLAW_CONFIG_PATH": str(out_path.resolve())}
+    if include_root:
+        prev = os.environ.get("OPENCLAW_INCLUDE_ROOTS", "")
+        roots = [include_root] + ([p for p in prev.split(os.pathsep) if p] if prev else [])
+        seen: set[str] = set()
+        ordered: list[str] = []
+        for r in roots:
+            if r not in seen:
+                seen.add(r)
+                ordered.append(r)
+        env_updates["OPENCLAW_INCLUDE_ROOTS"] = os.pathsep.join(ordered)
+
+    log.info("openclaw config written path=%s include_root=%s", out_path, include_root or "-")
+    return OpenclawConfigResult(
+        config_path=str(out_path),
+        include_root=include_root,
+        env_updates=env_updates,
+    )
+
+
+def _run(bin_name: str, args: list[str]) -> str:
+    try:
+        proc = subprocess.run(
+            [bin_name, *args],
+            capture_output=True,
+            text=True,
+            timeout=CLI_TIMEOUT,
+            check=False,
+        )
+    except FileNotFoundError as e:
+        raise OpenclawConfigError(f"openclaw executable not found: {bin_name}") from e
+    except subprocess.TimeoutExpired as e:
+        raise OpenclawConfigError(f"openclaw {' '.join(args)} timed out") from e
+    except OSError as e:
+        raise OpenclawConfigError(f"openclaw cli failed: {e}") from e
+    if proc.returncode != 0:
+        err = (proc.stderr or proc.stdout or "").strip()[:500]
+        raise OpenclawConfigError(
+            f"openclaw {' '.join(args)} exited {proc.returncode}: {err or 'no output'}"
+        )
+    return (proc.stdout or "").strip()
+
+
+def _active_config_path(bin_name: str) -> tuple[str, bool]:
+    try:
+        out = _run(bin_name, ["config", "file"])
+    except OpenclawConfigError:
+        default = Path.home() / ".openclaw" / "openclaw.json"
+        if default.is_file():
+            return str(default), True
+        # Fresh install: allow minimal wrapper with no $include.
+        return str(default), False
+    path = out.splitlines()[0].strip()
+    if not path:
+        default = Path.home() / ".openclaw" / "openclaw.json"
+        return str(default), default.is_file()
+    p = Path(path)
+    if not p.is_file():
+        # Path reported but missing → fresh install; fail-open to minimal wrapper.
+        return path, False
+    return path, True
+
+
+def _resolved_agents_list(bin_name: str) -> list[dict]:
+    out = _run(bin_name, ["config", "get", "agents.list", "--json"])
+    if not out:
+        return []
+    try:
+        data = json.loads(out)
+    except json.JSONDecodeError as e:
+        raise OpenclawConfigError(f"openclaw agents.list JSON invalid: {e}") from e
+    if data is None:
+        return []
+    if not isinstance(data, list):
+        raise OpenclawConfigError("openclaw agents.list is not a JSON array")
+    entries: list[dict] = []
+    for item in data:
+        if isinstance(item, dict):
+            entries.append(item)
+        elif isinstance(item, str) and item.strip():
+            entries.append({"id": item.strip()})
+    return entries
+
+
+def _rewrite_agents_list_workspaces(entries: list[dict], work: str) -> list[dict]:
+    """Deep-copy agent entries and pin workspace (Go rewriteAgentsListWorkspaces)."""
+    out: list[dict] = []
+    for entry in entries:
+        copied = deepcopy(entry)
+        if not isinstance(copied, dict):
+            continue
+        copied["workspace"] = work
+        out.append(copied)
+    return out

aicortexpy/pinned_workdir.py

@@ -0,0 +1,60 @@
+"""Shared project workdir layout."""
+
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+from typing import Any
+
+from .client import Task
+
+log = logging.getLogger("aicortexpy.pinned")
+
+STAGE_DIRS = ("docs", "design", "app", "test", "release")
+
+
+def project_uses_pinned_workdir(task: Task) -> bool:
+    return bool(task.project_id.strip())
+
+
+def extract_local_path(resources: list[dict[str, Any]]) -> str:
+    for r in resources:
+        if r.get("resource_type") != "local_path":
+            continue
+        ref = r.get("resource_ref")
+        if isinstance(ref, str):
+            try:
+                ref = json.loads(ref)
+            except json.JSONDecodeError:
+                continue
+        if isinstance(ref, dict) and ref.get("path"):
+            return str(ref["path"])
+    return ""
+
+
+def pinned_workdir_path(workspaces_root: Path, workspace_id: str, project_id: str) -> Path:
+    return workspaces_root / workspace_id / "projects" / project_id
+
+
+def ensure_project_layout(root: Path) -> None:
+    root.mkdir(parents=True, exist_ok=True)
+    for name in STAGE_DIRS:
+        (root / name).mkdir(parents=True, exist_ok=True)
+
+
+def prepare_pinned_workdir(
+    workspaces_root: Path,
+    task: Task,
+) -> Path:
+    local = extract_local_path(task.project_resources)
+    if local:
+        root = Path(local)
+        ensure_project_layout(root)
+        log.info("using local_path project workdir %s", root)
+        return root
+    root = pinned_workdir_path(
+        workspaces_root, task.workspace_id or "default", task.project_id
+    )
+    ensure_project_layout(root)
+    return root

aicortexpy/platform_info.py

@@ -0,0 +1,61 @@
+"""Cross-platform helpers shared by daemon / sandbox / process."""
+
+from __future__ import annotations
+
+import os
+import platform
+import shutil
+import sys
+from typing import Literal
+
+HostOS = Literal["windows", "macos", "linux", "unknown"]
+
+
+def host_os() -> HostOS:
+    if sys.platform == "win32":
+        return "windows"
+    if sys.platform == "darwin":
+        return "macos"
+    if sys.platform.startswith("linux"):
+        return "linux"
+    return "unknown"
+
+
+def is_wsl() -> bool:
+    if host_os() != "linux":
+        return False
+    try:
+        data = open("/proc/version", encoding="utf-8").read().lower()
+        return "microsoft" in data or "wsl" in data
+    except OSError:
+        return False
+
+
+def which(cmd: str) -> str | None:
+    return shutil.which(cmd)
+
+
+def has_bubblewrap() -> bool:
+    return which("bwrap") is not None
+
+
+def has_sandbox_exec() -> bool:
+    return host_os() == "macos" and which("sandbox-exec") is not None
+
+
+def platform_label() -> str:
+    bits = [
+        host_os(),
+        platform.machine(),
+        f"py{sys.version_info.major}.{sys.version_info.minor}",
+    ]
+    if is_wsl():
+        bits.insert(1, "wsl")
+    return "/".join(bits)
+
+
+def env_truthy(name: str, default: bool = False) -> bool:
+    raw = os.environ.get(name)
+    if raw is None:
+        return default
+    return raw.strip().lower() in {"1", "true", "yes", "on"}

aicortexpy/poisoned.py

@@ -0,0 +1,44 @@
+"""Classify poisoned agent outputs/errors (aligned with Go poisoned.go)."""
+
+from __future__ import annotations
+
+POISONED_OUTPUT_MAX_LEN = 320
+
+FAILURE_ITERATION_LIMIT = "iteration_limit"
+FAILURE_AGENT_FALLBACK = "agent_fallback_message"
+FAILURE_API_INVALID = "api_invalid_request"
+
+_MARKERS = (
+    ("i reached the iteration limit", FAILURE_ITERATION_LIMIT),
+    ("put your final update inside the content string", FAILURE_AGENT_FALLBACK),
+)
+
+
+def classify_poisoned_output(output: str) -> tuple[str, bool]:
+    trimmed = (output or "").strip()
+    if not trimmed or len(trimmed) > POISONED_OUTPUT_MAX_LEN:
+        return "", False
+    lowered = trimmed.lower()
+    for substr, reason in _MARKERS:
+        if substr in lowered:
+            return reason, True
+    return "", False
+
+
+def classify_poisoned_error(err: str) -> tuple[str, bool]:
+    lowered = (err or "").lower()
+    needles = (
+        "invalid_request_error",
+        "invalid request",
+        "prompt is too long",
+        "context_length_exceeded",
+        "image exceeds",
+        "could not process image",
+    )
+    if any(n in lowered for n in needles) and (
+        "400" in lowered or "invalid" in lowered or "exceed" in lowered
+    ):
+        return FAILURE_API_INVALID, True
+    if "invalid_request_error" in lowered:
+        return FAILURE_API_INVALID, True
+    return "", False