rlmness-cli 0.2.0__py3-none-any.whl

rlmagent/model/correlation.py

@@ -0,0 +1,21 @@
+"""Wire-safe tool-call identifiers."""
+
+from __future__ import annotations
+
+import re
+from hashlib import sha256
+
+# The narrowest alphabet any supported vendor accepts. Ids already inside it
+# pass through untouched so same-vendor replay stays byte-identical.
+_SAFE_ID = re.compile(r"[A-Za-z0-9_-]{1,64}")
+_DIGEST_CHARS = 40
+
+
+def wire_call_id(raw: str) -> str:
+    """Map ``raw`` to a deterministic id every provider accepts."""
+    if _SAFE_ID.fullmatch(raw):
+        return raw
+    return "tc_" + sha256(raw.encode("utf-8")).hexdigest()[:_DIGEST_CHARS]
+
+
+__all__ = ["wire_call_id"]

rlmagent/model/deadline.py

@@ -0,0 +1,19 @@
+"""A wall-clock deadline around one complete provider stream."""
+import asyncio
+
+from rlmagent.harness.contracts.transcript import ModelEntry
+from rlmagent.harness.provider.wire import StreamFaultEvent
+
+
+async def bounded_stream(stream, model, seconds=300.0):
+    try:
+        async with asyncio.timeout(seconds):
+            async for event in stream:
+                yield event
+    except TimeoutError:
+        yield StreamFaultEvent(reason="error", error=ModelEntry(model=model,
+            stop_reason="error", error_message=f"Model request exceeded its {seconds:g}s deadline"))
+    finally:
+        close = getattr(stream, "aclose", None)
+        if close is not None:
+            await close()

rlmagent/model/discovery.py

@@ -0,0 +1,181 @@
+"""Remote model discovery and credential checks without generating a completion."""
+
+from __future__ import annotations
+
+import os
+
+from rlmagent.config.loader import load_api_key
+from rlmagent.config.store import load_config, provider_info
+from rlmagent.model.transport.client import build_async_client
+
+
+#: Prices a provider's own model listing reported, per provider and model:
+#: (input, output) in dollars per million tokens. Only listings that carry
+#: prices fill it; nothing here is guessed.
+PRICES: dict[str, dict[str, tuple[float, float]]] = {}
+
+
+def _per_million(value) -> float | None:
+    try:
+        number = float(value)
+    except (TypeError, ValueError):
+        return None
+    return number * 1_000_000 if number >= 0 else None
+
+
+def remember_prices(provider: str, rows) -> None:
+    """Keep prices from rows shaped ``{"id", "pricing": {"prompt", "completion"}}``."""
+    table = PRICES.setdefault(provider, {})
+    for row in rows or []:
+        pricing = row.get("pricing") if isinstance(row, dict) else None
+        if not isinstance(pricing, dict) or not row.get("id"):
+            continue
+        given, taken = _per_million(pricing.get("prompt")), _per_million(pricing.get("completion"))
+        if given is not None and taken is not None:
+            table[str(row["id"])] = (given, taken)
+
+
+def price_label(provider: str, model: str) -> str:
+    """``$3.00/$15.00 per M`` when the listing said, else empty."""
+    price = PRICES.get(provider, {}).get(model)
+    if price is None:
+        return ""
+    given, taken = price
+    if given == taken == 0:
+        return "free"
+    return f"${given:,.2f}/${taken:,.2f} per M"
+
+
+async def discover_models(provider: str, *, api_key=None, base_url=None, client=None) -> list[str]:
+    if os.environ.get("RLM_AGENT_OFFLINE") == "1":
+        raise ValueError("Model discovery is disabled in offline startup mode")
+    info = provider_info(provider)
+    headers = {}
+    if provider == "copilot":
+        from copilot import CopilotClient
+
+        sdk = CopilotClient()
+        try:
+            await sdk.start()
+            return [model.id for model in await sdk.list_models()]
+        finally:
+            await sdk.stop()
+    if provider == "claude-subscription":
+        import shutil
+        if shutil.which("claude") is None:
+            raise ValueError("Install and sign in to the official Claude Code CLI")
+        return list(info.models)
+    if provider in ("codex", "xai-subscription"):
+        if provider == "codex":
+            from rlmagent.model.subscription import resolve
+        else:
+            from rlmagent.model.registered_oauth import resolve
+
+        if api_key is not None or base_url is not None:
+            raise ValueError("Subscription discovery uses the signed-in account and fixed endpoint")
+        credential = await resolve()
+        url, key = credential.base_url, credential.api_key
+    elif provider == "vertex":
+        raise ValueError(
+            "Remote model listing is unavailable for this cloud endpoint; "
+            "enter a compatible model identifier"
+        )
+    else:
+        config = load_config()
+        url_var = {"anthropic": "ANTHROPIC_BASE_URL", "openai": "OPENAI_BASE_URL"}.get(
+            provider, provider.upper() + "_BASE_URL"
+        )
+        if provider == "azure":
+            url_var = "AZURE_OPENAI_BASE_URL"
+        elif provider == "google":
+            url_var = "GOOGLE_API_BASE"
+        url = base_url or config.base_urls.get(provider) or os.environ.get(url_var) or info.base_url
+        key = api_key or load_api_key(provider)
+    if provider == "anthropic":
+        if key:
+            headers["x-api-key"] = key
+        headers["anthropic-version"] = "2023-06-01"
+        endpoint = url.rstrip("/") + (
+            "/models" if url.rstrip("/").endswith("/v1") else "/v1/models"
+        )
+    elif provider in ("google", "azure"):
+        if key:
+            headers["x-goog-api-key" if provider == "google" else "api-key"] = key
+        endpoint = url.rstrip("/") + "/models"
+    else:
+        if key:
+            headers["Authorization"] = f"Bearer {key}"
+        endpoint = url.rstrip("/") + "/models"
+    owned = client is None
+    client = client or build_async_client(timeout=20)
+    try:
+        response = await client.get(endpoint, headers=headers)
+        response.raise_for_status()
+        data = response.json()
+        if provider == "codex":
+            return [row["slug"] for row in data.get("models", [])
+                    if isinstance(row, dict) and row.get("visibility") == "list"
+                    and isinstance(row.get("slug"), str)]
+        if provider == "google":
+            models = list(data.get("models", []))
+            seen = set()
+            while token := data.get("nextPageToken"):
+                if token in seen or len(seen) >= 1000:
+                    raise ValueError("Invalid model-catalog pagination")
+                seen.add(token)
+                page = await client.get(endpoint, headers=headers, params={"pageToken": token})
+                page.raise_for_status()
+                data = page.json()
+                models.extend(data.get("models", []))
+            return sorted({row["name"].removeprefix("models/") for row in models
+                           if isinstance(row, dict) and isinstance(row.get("name"), str)})
+        remember_prices(provider, data.get("data", []))
+        return sorted(
+            {
+                str(row["id"])
+                for row in data.get("data", [])
+                if isinstance(row, dict) and row.get("id")
+            }
+        )
+    finally:
+        if owned:
+            await client.aclose()
+
+
+async def check_provider(provider: str, *, base_url=None, client=None) -> str:
+    if provider == "claude-subscription":
+        await discover_models(provider)
+        return "Official CLI found; account and inference access have not been tested."
+    if provider == "vertex":
+        from rlmagent.model.vertex import ApplicationCredentials
+
+        await ApplicationCredentials()()
+        return "Application credentials refreshed; inference access has not been tested."
+    if provider in ("openrouter", "huggingface"):
+        key = load_api_key(provider)
+        if not key:
+            raise ValueError("No provider credential configured")
+        config = load_config()
+        if provider == "openrouter":
+            url = base_url or config.base_urls.get(provider) or provider_info(provider).base_url
+            endpoint = url.rstrip("/") + "/key"
+        else:
+            if base_url:
+                raise ValueError(
+                    "Credential testing is unavailable for a custom endpoint on this provider"
+                )
+            endpoint = "https://huggingface.co/api/whoami-v2"
+        owned = client is None
+        client = client or build_async_client(timeout=20)
+        try:
+            response = await client.get(endpoint, headers={"Authorization": f"Bearer {key}"})
+            response.raise_for_status()
+        finally:
+            if owned:
+                await client.aclose()
+        return "Credential endpoint accepted authentication; inference access has not been tested."
+    models = await discover_models(provider, base_url=base_url, client=client)
+    return (
+        f"Model endpoint reachable; {len(models)} models returned. "
+        "Inference access has not been tested."
+    )

rlmagent/model/external/__init__.py

@@ -0,0 +1,11 @@
+from rlmagent.model.external.cli import ExternalAgentProvider, is_external, parse_model
+
+
+def with_external(provider):
+    """`provider`, plus `cli:` and `acp:` models for any agent that asks for one."""
+    if isinstance(provider, ExternalAgentProvider):
+        return provider
+    return ExternalAgentProvider(fallback=provider)
+
+
+__all__ = ["ExternalAgentProvider", "is_external", "parse_model", "with_external"]

rlmagent/model/external/acp.py

@@ -0,0 +1,202 @@
+"""An agent reached over the Agent Client Protocol, used as the model."""
+
+from __future__ import annotations
+
+import asyncio
+import itertools
+import json
+import os
+import shutil
+from pathlib import Path
+
+from rlmagent.harness.contracts.tooling import CancelToken
+from rlmagent.harness.contracts.transcript import UsageStats
+
+_DENY_CLAUDE = ["Bash(*)", "Read(*)", "Write(*)", "Edit(*)", "Glob(*)", "Grep(*)",
+                "WebFetch(*)", "WebSearch(*)", "Task(*)", "NotebookEdit(*)"]
+
+PRESETS: dict[str, dict] = {
+    "claude-code": {
+        "command": "npx", "bridge": "claude-code",
+        "files": {".claude/settings.json": {"permissions": {"deny": _DENY_CLAUDE}}},
+    },
+    "codex": {
+        "command": "npx", "bridge": "codex",
+        "readonly_mode": "read-only",
+        "approve": True,
+    },
+    "opencode": {
+        "command": "opencode", "args": ["acp"], "readonly_mode": "plan",
+        "files": {"opencode.json": {"permission": {k: "deny" for k in (
+            "bash", "edit", "read", "glob", "grep", "list", "webfetch", "task")}}},
+    },
+}
+
+START_TIMEOUT = 180.0
+TURN_TIMEOUT = 180.0
+
+
+def agents() -> dict[str, dict]:
+    """The presets, plus any agents registered in ~/.rlm-agent/acp_agents.json."""
+    from rlmagent.plugins import rlm_agent_home
+
+    found = dict(PRESETS)
+    path = rlm_agent_home() / "acp_agents.json"
+    try:
+        found.update(json.loads(path.read_text(encoding="utf-8")))
+    except (OSError, json.JSONDecodeError):
+        pass
+    return found
+
+
+class Cancelled(Exception):
+    pass
+
+
+class _Connection:
+    """JSON-RPC 2.0, one message per line, over the agent's stdin and stdout."""
+
+    def __init__(self, proc, approve: bool = False) -> None:
+        self.proc = proc
+        self.approve = approve
+        self.ids = itertools.count(1)
+        self.waiting: dict[int, asyncio.Future] = {}
+        self.text: list[str] = []
+        self.closed = asyncio.get_running_loop().create_future()
+
+    async def _send(self, message: dict) -> None:
+        self.proc.stdin.write((json.dumps({"jsonrpc": "2.0", **message}) + "\n").encode("utf-8"))
+        await self.proc.stdin.drain()
+
+    async def request(self, method: str, params: dict) -> dict:
+        rid = next(self.ids)
+        future = asyncio.get_running_loop().create_future()
+        self.waiting[rid] = future
+        await self._send({"id": rid, "method": method, "params": params})
+        done, _ = await asyncio.wait({future, self.closed}, return_when=asyncio.FIRST_COMPLETED)
+        if future not in done:
+            raise ValueError(f"the agent exited during {method}")
+        return future.result()
+
+    async def notify(self, method: str, params: dict) -> None:
+        await self._send({"method": method, "params": params})
+
+    async def pump(self) -> None:
+        try:
+            while line := await self.proc.stdout.readline():
+                try:
+                    message = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+                if trace := os.environ.get("RLM_AGENT_ACP_TRACE"):
+                    with open(trace, "a", encoding="utf-8") as f:
+                        f.write(line.decode("utf-8", errors="replace"))
+                await self._dispatch(message)
+        finally:
+            if not self.closed.done():
+                self.closed.set_result(None)
+
+    async def _dispatch(self, message: dict) -> None:
+        method = message.get("method")
+        if method is None:
+            future = self.waiting.pop(message.get("id"), None)
+            if future is not None and not future.done():
+                if "error" in message:
+                    error = message["error"]
+                    detail = (error.get("data") or {}).get("message") if isinstance(error.get("data"), dict) else None
+                    text = error.get("message", "agent error") + (f": {detail}" if detail else "")
+                    future.set_exception(ValueError(text[:500]))
+                else:
+                    future.set_result(message.get("result") or {})
+            return
+        params = message.get("params") or {}
+        if method == "session/update":
+            update = params.get("update") or {}
+            content = update.get("content") or {}
+            if update.get("sessionUpdate") == "agent_message_chunk" and content.get("type") == "text":
+                self.text.append(content.get("text", ""))
+            return
+        if "id" not in message:
+            return
+        if method == "session/request_permission":
+            wanted = "allow_once" if self.approve else "reject"
+            picks = [o for o in params.get("options", []) if o.get("kind", "").startswith(wanted)]
+            outcome = ({"outcome": "selected", "optionId": picks[0]["optionId"]} if picks
+                       else {"outcome": "cancelled"})
+            await self._send({"id": message["id"], "result": {"outcome": outcome}})
+        else:
+            await self._send({"id": message["id"],
+                              "error": {"code": -32601, "message": f"{method} is not offered"}})
+
+
+async def answer(name: str, sub: str | None, prompt: str, cwd: Path,
+                 signal: CancelToken | None) -> tuple[str, UsageStats]:
+    spec = agents()[name]
+    for rel, content in (spec.get("files") or {}).items():
+        target = cwd / rel
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_text(json.dumps(content), encoding="utf-8")
+    args = list(spec.get("args", []))
+    if spec.get("bridge"):
+        from rlmagent.model.external.acp_install import bridge_spec
+
+        args = ["-y", bridge_spec(spec["bridge"]), *args]
+    from rlmagent.model.external.cli import own_group
+
+    exe = shutil.which(spec["command"])
+    if exe is None:
+        raise ValueError(f"{spec['command']} not found on PATH")
+    with open(cwd / "agent-stderr.log", "wb") as errors:
+        proc = await asyncio.create_subprocess_exec(
+            exe, *args, cwd=str(cwd), limit=2**24,
+            stdin=asyncio.subprocess.PIPE, stdout=asyncio.subprocess.PIPE, stderr=errors,
+            env={**os.environ, **(spec.get("env") or {})}, **own_group(),
+        )
+    conn = _Connection(proc, approve=bool(spec.get("approve")))
+    pump = asyncio.create_task(conn.pump())
+    turn = None
+    try:
+        try:
+            async with asyncio.timeout(START_TIMEOUT):
+                await conn.request("initialize", {
+                    "protocolVersion": 1,
+                    "clientCapabilities": {"fs": {"readTextFile": False, "writeTextFile": False},
+                                           "terminal": False},
+                    "clientInfo": {"name": "rlm-agent", "version": "0"},
+                })
+                session = await conn.request("session/new", {"cwd": str(cwd), "mcpServers": []})
+                sid = session["sessionId"]
+                modes = {m.get("id") for m in (session.get("modes") or {}).get("availableModes", [])}
+                if spec.get("readonly_mode") in modes:
+                    await conn.request("session/set_mode", {
+                        "sessionId": sid, "modeId": spec["readonly_mode"],
+                    })
+                model = sub or spec.get("model")
+                if model and session.get("models"):
+                    await conn.request("session/set_model", {"sessionId": sid, "modelId": model})
+        except TimeoutError:
+            raise ValueError(f"{name} did not initialize within {START_TIMEOUT:g}s") from None
+        try:
+            async with asyncio.timeout(TURN_TIMEOUT):
+                turn = asyncio.create_task(conn.request("session/prompt", {
+                    "sessionId": sid, "prompt": [{"type": "text", "text": prompt}]}))
+                while not turn.done():
+                    if signal is not None and signal.is_cancelled():
+                        await conn.notify("session/cancel", {"sessionId": sid})
+                        raise Cancelled
+                    await asyncio.wait({turn}, timeout=0.2)
+                result = turn.result()
+        except TimeoutError:
+            raise ValueError(f"{name} did not finish its ACP turn within {TURN_TIMEOUT:g}s") from None
+    finally:
+        from rlmagent.model.external.cli import kill_tree
+
+        if turn is not None and not turn.done():
+            turn.cancel()
+        kill_tree(proc)
+        await proc.wait()
+        pump.cancel()
+    if result.get("stopReason") == "refusal":
+        raise ValueError(f"{name} refused")
+    # ACP replies carry no token counts, so cost stays 0; --max-calls is what limits a run.
+    return "".join(conn.text), UsageStats()

rlmagent/model/external/acp_install.py

@@ -0,0 +1,109 @@
+"""`rlm-agent acp install` / `acp status`: choose the bridge versions acp: runs use.
+
+Choices are saved in ~/.rlm-agent/bridges.json as {"format": 1, "pins": {agent:
+{"package", "version"}}}. A run launches exactly the saved version; `install -u`
+moves to the newest one. To follow a bridge that changed its npm name, edit that
+agent's "package" in the file.
+"""
+
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+from pathlib import Path
+
+FORMAT = 1
+DEFAULT_PACKAGES = {
+    "claude-code": "@agentclientprotocol/claude-agent-acp",
+    "codex": "@agentclientprotocol/codex-acp",
+}
+MISSING = ("acp:{agent} needs its bridge, which has not been set up. "
+           "Run `rlm-agent acp install` (Node and npm must be on PATH).")
+
+
+def pin_file() -> Path:
+    from rlmagent.plugins import rlm_agent_home
+
+    return rlm_agent_home() / "bridges.json"
+
+
+def read_pins() -> dict[str, dict] | None:
+    """Saved pins per agent, or None when install has not run (or the file is unreadable)."""
+    try:
+        saved = json.loads(pin_file().read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return None
+    if not isinstance(saved, dict) or saved.get("format") != FORMAT:
+        return None
+    pins = saved.get("pins")
+    return pins if isinstance(pins, dict) else None
+
+
+def bridge_spec(agent: str) -> str:
+    """What npx should launch for `agent`: package@version, or the bare package if unpinned."""
+    pins = read_pins()
+    if pins is None:
+        raise ValueError(MISSING.format(agent=agent))
+    pin = pins.get(agent) or {}
+    package = pin.get("package") or DEFAULT_PACKAGES[agent]
+    return f"{package}@{pin['version']}" if pin.get("version") else package
+
+
+def _npm(*args: str) -> str | None:
+    """stdout of a successful npm command; None when npm is missing or fails."""
+    npm = shutil.which("npm")
+    if npm is None:
+        return None
+    try:
+        done = subprocess.run([npm, *args], capture_output=True, text=True, encoding="utf-8", errors="replace", timeout=120)
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    return done.stdout.strip() if done.returncode == 0 else None
+
+
+def install(update: bool = False) -> dict[str, dict]:
+    """Pin every bridge (keeping saved versions unless `update`) and pre-fetch it."""
+    saved = read_pins() or {}
+    pins: dict[str, dict] = {}
+    for agent, default in DEFAULT_PACKAGES.items():
+        before = saved.get(agent) or {}
+        package = before.get("package") or default
+        kept = None if update else before.get("version")
+        version = kept or _npm("view", package, "version") or before.get("version")
+        pins[agent] = {"package": package, "version": version}
+        if version is None:
+            print(f"acp:{agent}: npm did not answer; {package} stays unpinned (newest at each launch)")
+            continue
+        fetched = _npm("cache", "add", f"{package}@{version}") is not None
+        print(f"acp:{agent}: {package}@{version}" + ("" if fetched else " (not pre-fetched)"))
+    pin_file().parent.mkdir(parents=True, exist_ok=True)
+    pin_file().write_text(json.dumps({"format": FORMAT, "pins": pins}, indent=2), encoding="utf-8")
+    print(f"Saved to {pin_file()}")
+    if shutil.which("npx") is None:
+        print("Warning: npx was not found; acp: runs start their bridge with it.")
+    return pins
+
+
+def status() -> int:
+    pins = read_pins()
+    if pins is None:
+        print(f"No bridges set up ({pin_file()} missing). Run: rlm-agent acp install")
+        return 1
+    for agent, pin in pins.items():
+        version = pin.get("version") or "unpinned"
+        newest = _npm("view", pin.get("package", ""), "version")
+        hint = f", newer {newest} (rlm-agent acp install -u)" if newest and newest != version else ""
+        print(f"acp:{agent}: {pin.get('package')}@{version}{hint}")
+    return 0
+
+
+def main(argv: list[str]) -> int:
+    command = argv[0] if argv else ""
+    if command == "install":
+        install(update=bool({"-u", "--update"} & set(argv)))
+        return 0
+    if command == "status":
+        return status()
+    print("usage: rlm-agent acp install [-u] | rlm-agent acp status")
+    return 2