rlmness-cli 0.2.0__py3-none-any.whl

rlmagent/acp/updates.py

@@ -0,0 +1,128 @@
+"""Our events turned into ACP session/update payloads."""
+
+from __future__ import annotations
+
+from rlmagent.harness.contracts.stream import (
+    MessageEndEvent,
+    MessageUpdateEvent,
+    RetryEvent,
+    ToolRunEndEvent,
+    ToolRunStartEvent,
+    ToolRunUpdateEvent,
+)
+from rlmagent.harness.contracts.transcript.entries import ModelEntry
+from rlmagent.harness.contracts.transcript.segments import TextSegment, ThoughtSegment
+
+KINDS = {"python": "execute", "Read": "read", "Write": "edit", "Edit": "edit"}
+PLAN_STATUS = {"starting": "pending", "running": "in_progress", "idle": "in_progress"}
+
+
+def chunk(kind: str, text: str) -> dict:
+    return {"sessionUpdate": kind, "content": {"type": "text", "text": text}}
+
+
+def _title(name: str, args: dict) -> str:
+    if name == "python":
+        first = str(args.get("code", "")).strip().splitlines()
+        return first[0][:80] if first else "python"
+    path = args.get("path") or args.get("file_path")
+    return f"{name} {path}" if path else name
+
+
+def _text_content(text: str) -> list[dict]:
+    return [{"type": "content", "content": {"type": "text", "text": text}}] if text else []
+
+
+class Translator:
+    """Keeps how much of the current reply was already sent, so updates carry only deltas."""
+
+    def __init__(self) -> None:
+        self.sent_text = 0
+        self.sent_thought = 0
+
+    def _deltas(self, msg: ModelEntry) -> list[dict]:
+        text = "".join(b.text for b in msg.content if isinstance(b, TextSegment))
+        thought = "".join(b.thinking for b in msg.content if isinstance(b, ThoughtSegment))
+        out = []
+        if len(thought) > self.sent_thought:
+            out.append(chunk("agent_thought_chunk", thought[self.sent_thought:]))
+            self.sent_thought = len(thought)
+        if len(text) > self.sent_text:
+            out.append(chunk("agent_message_chunk", text[self.sent_text:]))
+            self.sent_text = len(text)
+        return out
+
+    def updates(self, event) -> list[dict]:
+        if isinstance(event, MessageUpdateEvent) and isinstance(event.message, ModelEntry):
+            return self._deltas(event.message)
+        if isinstance(event, MessageEndEvent) and isinstance(event.message, ModelEntry):
+            out = self._deltas(event.message)
+            if event.message.stop_reason == "error" and event.message.error_message:
+                out.append(chunk("agent_message_chunk", f"\n\nError: {event.message.error_message}"))
+            self.sent_text = self.sent_thought = 0
+            return out
+        if isinstance(event, ToolRunStartEvent):
+            update = {"sessionUpdate": "tool_call", "toolCallId": event.tool_call_id,
+                      "title": _title(event.tool_name, event.args),
+                      "kind": KINDS.get(event.tool_name, "other"), "status": "in_progress",
+                      "rawInput": event.args}
+            path = event.args.get("path") or event.args.get("file_path")
+            if path:
+                update["locations"] = [{"path": str(path)}]
+            return [update]
+        if isinstance(event, ToolRunUpdateEvent):
+            return [{"sessionUpdate": "tool_call_update", "toolCallId": event.tool_call_id,
+                     "content": _text_content(event.partial_result.text)}]
+        if isinstance(event, ToolRunEndEvent):
+            return [{"sessionUpdate": "tool_call_update", "toolCallId": event.tool_call_id,
+                     "status": "failed" if event.is_error else "completed",
+                     "content": _text_content(event.result.text)}]
+        if isinstance(event, RetryEvent):
+            return [chunk("agent_thought_chunk", f"[retry] {event.message}\n")]
+        return []
+
+
+def stop_reason(messages: list) -> str:
+    last = next((m for m in reversed(messages) if isinstance(m, ModelEntry)), None)
+    if last is None:
+        return "end_turn"
+    if last.stop_reason == "aborted":
+        return "cancelled"
+    if last.stop_reason == "length":
+        return "max_tokens"
+    if last.stop_reason == "error" and any(
+            w in (last.error_message or "").lower() for w in ("budget", "limit", "allowance")):
+        return "max_turn_requests"
+    return "end_turn"
+
+
+def plan(tree) -> list[dict]:
+    """Every sub-agent as one plan entry, nested ones indented by depth."""
+    entries = []
+    for agent in list(getattr(tree, "backend_agents", {}).values()):
+        if agent.get("depth", 0) == 0:
+            continue
+        entries.append({"content": "  " * max(agent.get("depth", 1) - 1, 0)
+                        + str(agent.get("instruction") or agent["run_id"])[:120],
+                        "priority": "medium", "status": "in_progress"
+                        if agent["status"] == "running" else "completed"})
+    for rec in tree.records.values():
+        node = rec.node
+        status = PLAN_STATUS.get(rec.status, "completed")
+        suffix = f" ({rec.status})" if rec.status in ("failed", "cancelled") else ""
+        task = (node.task.strip().splitlines() or [node.id])[0][:120]
+        entries.append({"content": "  " * max(node.depth - 1, 0) + task + suffix,
+                        "priority": "medium", "status": status})
+    return entries
+
+
+def replay(transcript) -> list[dict]:
+    """A loaded session's history as message updates."""
+    out = []
+    for msg in transcript:
+        role = getattr(msg, "role", "")
+        if role == "user":
+            out.append(chunk("user_message_chunk", msg.text))
+        elif role == "assistant" and msg.text:
+            out.append(chunk("agent_message_chunk", msg.text))
+    return out

rlmagent/agentnet.py

@@ -0,0 +1,237 @@
+"""Agents on this machine finding and messaging each other, scheduling work, reporting progress.
+
+Every interactive session registers itself under <home>/agents/<id>/ while it runs; workers
+are already listed under <home>/workers/. A message to a worker becomes its next task; a
+message to a session waits in its inbox and is shown to it before its next turn.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import time
+import uuid
+from pathlib import Path
+
+MAX_MESSAGE = 8_000
+MAX_MESSAGES = 50
+
+
+def _home() -> Path:
+    from rlmagent.plugins import rlm_agent_home
+
+    return rlm_agent_home() / "agents"
+
+
+def _write(path: Path, value: dict) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    staged = path.with_name(f".{path.name}.{uuid.uuid4().hex[:8]}")
+    staged.write_text(json.dumps(value, ensure_ascii=False), encoding="utf-8")
+    os.replace(staged, path)
+
+
+def _read(path: Path) -> dict | None:
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return None
+    return value if isinstance(value, dict) else None
+
+
+class AgentNet:
+    """This agent's place among the others: its name, inbox, and what it can reach."""
+
+    def __init__(self, me: str, cwd: str, worker: str | None = None) -> None:
+        self.me = me
+        self.cwd = cwd
+        self.worker = worker  # set when this session is a background worker
+        self.on_progress = None  # called with progress text, to show it to the user
+
+    # -- registration ------------------------------------------------------
+
+    def _folder(self, name: str) -> Path:
+        return _home() / name
+
+    def register(self) -> None:
+        if self.worker is None:
+            _write(self._folder(self.me) / "meta.json", {
+                "pid": os.getpid(), "cwd": self.cwd, "started": time.time(),
+                "beat": time.time()})
+
+    def beat(self) -> None:
+        meta = _read(self._folder(self.me) / "meta.json")
+        if meta is not None:
+            meta["beat"] = time.time()
+            _write(self._folder(self.me) / "meta.json", meta)
+
+    def leave(self) -> None:
+        (self._folder(self.me) / "meta.json").unlink(missing_ok=True)
+
+    # -- functions agents call ---------------------------------------------
+
+    async def list_agents(self) -> list[dict]:
+        """Other agents on this machine you can message: background workers and open sessions."""
+        from rlmagent import worker
+        from rlmagent.worker import _pid_alive
+
+        found = []
+        base = worker.root()
+        for path in sorted(base.iterdir()) if base.is_dir() else []:
+            if path.is_dir():
+                meta = worker.state_of(path.name)
+                found.append({"name": path.name, "kind": "worker",
+                              "state": meta.get("state", "?") if meta["alive"] else "not running",
+                              "cwd": meta.get("cwd"), "me": path.name == self.worker})
+        sessions = _home()
+        for path in sorted(sessions.iterdir()) if sessions.is_dir() else []:
+            meta = _read(path / "meta.json")
+            if meta is None:
+                continue
+            alive = bool(meta.get("pid")) and _pid_alive(int(meta["pid"]))
+            if alive or path.name == self.me:
+                found.append({"name": path.name, "kind": "session", "state": "open",
+                              "cwd": meta.get("cwd"), "me": path.name == self.me})
+        return found
+
+    async def send_message(self, to: str, text: str, *, receipt: bool = False) -> str | dict:
+        """Send text to an agent. Set receipt=True to get an ID for message_receipt()."""
+        from rlmagent import worker
+
+        text = str(text)[:MAX_MESSAGE]
+        sender = self.worker or self.me
+        if to in (self.me, self.worker):
+            raise ValueError("that is you; pick another agent from list_agents()")
+        base = self._recipient(to)
+        try:
+            is_worker = worker.folder(to).is_dir()
+        except ValueError:
+            is_worker = False
+        if is_worker:
+            kind = "worker"
+            identity = worker.send(to, f"[message from {sender}] {text}", source=sender,
+                                   receipt_owner=self._receipt_owner())
+        elif (base / "meta.json").is_file():
+            kind = "session"
+            identity = f"{time.time_ns()}-{uuid.uuid4().hex}"
+            _write(base / "inbox" / f"{identity}.json",
+                   {"from": sender, "text": text, "time": time.time(),
+                    "receipt_owner": self._receipt_owner()})
+        else:
+            raise ValueError(f"no agent named {to!r}; list_agents() shows who is there")
+        if receipt:
+            return {"id": identity, "to": to, "kind": kind, "status": "queued"}
+        return f"sent to {kind} {to}"
+
+    def _receipt_owner(self) -> str:
+        return f"worker:{self.worker}" if self.worker is not None else f"session:{self.me}"
+
+    def _recipient(self, name: str) -> Path:
+        if not isinstance(name, str) or re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9_.-]{0,127}", name) is None:
+            raise ValueError("invalid agent name")
+        return self._folder(name)
+
+    async def message_receipt(self, to: str, message_id: str, kind: str) -> dict:
+        """Look up a sent message with the ID and kind returned by send_message()."""
+        from rlmagent import worker
+
+        base = self._recipient(to)
+        if not isinstance(message_id, str) or re.fullmatch(r"[0-9]+-[0-9a-f]{6,32}", message_id) is None:
+            raise ValueError("invalid message ID")
+        owner = self._receipt_owner()
+        status = "unknown"
+        if kind == "worker":
+            status = worker.receipt_of(to, message_id, owner=owner)["status"]
+        elif kind == "session":
+            filename = f"{message_id}.json"
+            for directory, state in (("inbox", "queued"), ("read", "read")):
+                if (_read(base / directory / filename) or {}).get("receipt_owner") == owner:
+                    status = state
+                    break
+        else:
+            raise ValueError("invalid recipient kind")
+        return {"id": message_id, "to": to, "kind": kind, "status": status}
+
+    async def read_messages(self) -> list[dict]:
+        """Messages other agents sent you since your last read, with their IDs."""
+        return self.take()
+
+    def take(self) -> list[dict]:
+        from rlmagent.harness.session.lease import SessionBusy, acquire
+
+        base = self._folder(self.me)
+        inbox = base / "inbox"
+        if not inbox.is_dir():
+            return []
+        try:
+            lease = acquire(base, "inbox")
+        except SessionBusy:
+            return []
+        taken = []
+        with lease:
+            for path in sorted(inbox.glob("*.json"))[:MAX_MESSAGES]:
+                read = base / "read" / path.name
+                read.parent.mkdir(parents=True, exist_ok=True)
+                try:
+                    path.replace(read)
+                except FileNotFoundError:
+                    continue
+                except PermissionError as error:
+                    if getattr(error, "winerror", None) not in (32, 33):
+                        raise
+                    continue  # A receipt lookup has the file open on Windows.
+                if message := _read(read):
+                    message.pop("receipt_owner", None)
+                    taken.append({**message, "id": path.stem})
+        return taken
+
+    async def schedule(self, task: str, at: float | None = None, in_seconds: float | None = None,
+                       every: float | None = None, worker: str | None = None, *,
+                       cron: str | None = None, timezone: str | None = None) -> str:
+        """Run task later on a background worker: at a unix time, or in_seconds from now,
+        optionally every N seconds. Alternatively use a five-field cron expression and
+        an IANA timezone (defaults to UTC). Defaults to this worker when you are one."""
+        from rlmagent import worker as workers
+
+        target = worker or self.worker
+        if target is None:
+            raise ValueError("this session is not a worker; pass worker=NAME (see list_agents())")
+        if sum(value is not None for value in (at, in_seconds, cron)) != 1:
+            raise ValueError("give exactly one of at, in_seconds, or cron")
+        due = None
+        if at is not None:
+            due = float(at)
+        elif in_seconds is not None:
+            due = time.time() + float(in_seconds)
+        if every is not None and float(every) < 60:
+            raise ValueError("every must be at least 60 seconds")
+        job = workers.schedule(target, str(task), due, float(every) if every else None,
+                               cron=cron, timezone=timezone)
+        when = workers.job_time(job)
+        return f"job {job['id']} on {target} at {when}" + (f", every {every}s" if every else "")
+
+    async def heartbeat(self, text: str) -> str:
+        """Report progress on long work; the user sees it while you keep going."""
+        from rlmagent import worker
+
+        text = str(text)[:500]
+        if self.worker is not None:
+            worker.log_line(self.worker, "progress", text)
+        if self.on_progress is not None:
+            self.on_progress(text)
+        return "noted"
+
+    def functions(self) -> dict:
+        return {"list_agents": self.list_agents, "send_message": self.send_message,
+                "read_messages": self.read_messages, "message_receipt": self.message_receipt,
+                "schedule": self.schedule,
+                "heartbeat": self.heartbeat}
+
+
+def inbox_note(messages: list[dict]) -> str:
+    """Messages put in front of the model before its next turn."""
+    lines = [f"[message from {m.get('from', '?')}] {m.get('text', '')}" for m in messages]
+    return "Messages from other agents arrived:\n" + "\n".join(lines)
+
+
+__all__ = ["AgentNet", "inbox_note"]

rlmagent/agents/__init__.py

@@ -0,0 +1 @@
+"""Sub-agents: the channel from a kernel to its host, and the tree of agents."""

rlmagent/agents/approval.py

@@ -0,0 +1,90 @@
+"""Approval for what the sandbox asks the host to change, bound to exactly what runs."""
+
+from __future__ import annotations
+
+import asyncio
+import hashlib
+import json
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass
+
+from rlmagent.safety import is_dangerous_command, is_safe_command
+
+ONCE, ALWAYS, DENY = "once", "always", "deny"
+AUTO = "auto"  # allow this one and stop asking for the rest of the session
+
+
+@dataclass(frozen=True)
+class Request:
+    kind: str  # "write", "edit" or "run"
+    target: str  # the path, or the command for "run"
+    payload: tuple = ()  # what will be written: content, or (old, new)
+
+    preview: str | None = None
+
+    @property
+    def digest(self) -> str:
+        blob = json.dumps([self.kind, self.target, list(self.payload)], ensure_ascii=False)
+        return hashlib.sha256(blob.encode("utf-8")).hexdigest()
+
+    def describe(self, limit: int = 2000) -> str:
+        if self.kind == "run":
+            return f"Run: {self.target}"
+        body = self.preview if self.preview is not None else "\n".join(str(p) for p in self.payload)
+        if len(body) > limit:
+            body = body[:limit] + f"\n... ({len(body) - limit} more characters)"
+        return f"{self.kind.capitalize()} {self.target}\n{body}"
+
+
+class Refused(Exception):
+    pass
+
+
+Ask = Callable[[Request], Awaitable[str]]
+
+
+class Approver:
+    """`ask`, `auto` or `deny`; `ask` needs a function that shows the request to the user."""
+
+    def __init__(self, policy: str = "deny", ask: Ask | None = None) -> None:
+        self.policy = policy
+        self.ask = ask
+        self.question = None  # async (question, choices) -> answer; None: nobody to ask
+        self.one_question = asyncio.Lock()
+        self._always: set[tuple[str, str]] = set()
+
+    async def approve(self, request: Request) -> str:
+        """The digest that may run, or Refused."""
+        if request.kind == "run" and is_dangerous_command(request.target):
+            raise Refused(f"refused: {request.target!r} is a destructive command")
+        if request.kind == "run" and is_safe_command(request.target):
+            return request.digest
+        if self.policy == "auto" or (request.kind, request.target) in self._always:
+            return request.digest
+        if self.policy != "ask" or self.ask is None:
+            raise Refused(
+                f"refused: {request.kind} {request.target} needs approval "
+                "(run with --auto-approve, or interactively)"
+            )
+        answer = await self.ask(request)
+        if answer == DENY:
+            raise Refused(f"the user refused: {request.kind} {request.target}")
+        if answer == ALWAYS:
+            self._always.add((request.kind, request.target))
+        if answer == AUTO:
+            self.policy = "auto"
+        return request.digest
+
+    def toggle_auto(self) -> bool:
+        """Switch between asking and auto-accepting; True when auto-accept is now on."""
+        if self.policy == "ask":
+            self.policy = "auto"
+        elif self.policy == "auto" and self.ask is not None:
+            self.policy = "ask"
+        return self.policy == "auto"
+
+
+def check(approved: str, request: Request) -> None:
+    """Refuse when what is about to run is not what was approved."""
+    if approved != request.digest:
+        raise Refused(f"refused: {request.kind} {request.target} changed after approval")

rlmagent/agents/bridge.py

@@ -0,0 +1,109 @@
+"""A localhost channel that only this run's kernels can use."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import secrets
+from collections.abc import Awaitable, Callable
+
+Handler = Callable[[str, str, dict], Awaitable[object]]
+LINE_LIMIT = 2**26  # 64 MB: a sub-agent may hand back a large value
+
+
+def kernel_env(port: int, token: str, agent_id: str, *, can_delegate: bool, is_child: bool) -> dict[str, str]:
+    return {
+        "RLM_AGENT_BRIDGE_PORT": str(port),
+        "RLM_AGENT_BRIDGE_TOKEN": token,
+        "RLM_AGENT_ID": agent_id,
+        "RLM_AGENT_CAN_DELEGATE": "1" if can_delegate else "0",
+        "RLM_AGENT_IS_CHILD": "1" if is_child else "0",
+    }
+
+
+class BridgeServer:
+    """Serves kernel requests; the per-agent token alone identifies the caller."""
+
+    def __init__(self, handler: Handler) -> None:
+        self._handler = handler
+        self._agents: dict[str, str] = {}
+        self._running: set[asyncio.Task] = set()
+        self.port = 0
+        self._server: asyncio.base_events.Server | None = None
+
+    async def start(self) -> None:
+        self._server = await asyncio.start_server(
+            self._serve, "127.0.0.1", 0, limit=LINE_LIMIT
+        )
+        self.port = self._server.sockets[0].getsockname()[1]
+
+    def issue(self, agent_id: str) -> str:
+        token = secrets.token_hex(16)
+        self._agents[token] = agent_id
+        return token
+
+    def revoke(self, token: str) -> None:
+        self._agents.pop(token, None)
+
+    def _caller(self, token: object) -> str | None:
+        for known, agent_id in self._agents.items():
+            if secrets.compare_digest(str(token), known):
+                return agent_id
+        return None
+
+    async def _serve(self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter) -> None:
+        try:
+            reply = await self._reply(reader)
+            if reply is None:
+                return  # the caller hung up; nobody is left to answer
+            writer.write((json.dumps(reply, default=repr) + "\n").encode())
+            await writer.drain()
+        except ConnectionError:
+            pass
+        finally:
+            writer.close()
+
+    async def _reply(self, reader: asyncio.StreamReader) -> dict | None:
+        try:
+            line = await reader.readline()
+        except (ValueError, asyncio.LimitOverrunError):
+            return {"error": "refused: request too large"}
+        try:
+            request = json.loads(line)
+        except json.JSONDecodeError:
+            return {"error": "refused: not a JSON request"}
+        if not isinstance(request, dict) or "op" not in request:
+            return {"error": "refused: malformed request"}
+        caller = self._caller(request.get("token", ""))
+        if caller is None:
+            return {"error": "refused: bad token"}
+        return await self._answer(caller, request, reader)
+
+    async def _answer(self, caller: str, request: dict, reader: asyncio.StreamReader) -> dict | None:
+        """Run the request; cancel it if the kernel hangs up first."""
+        work = asyncio.create_task(
+            self._handler(caller, str(request["op"]), dict(request.get("args") or {}))
+        )
+        self._running.add(work)
+        hangup = asyncio.create_task(reader.read(1))
+        try:
+            await asyncio.wait({work, hangup}, return_when=asyncio.FIRST_COMPLETED)
+            if not work.done():
+                work.cancel()
+                await asyncio.gather(work, return_exceptions=True)
+                return None
+            try:
+                return {"ok": work.result()}
+            except Exception as exc:  # the kernel sees it as an exception in its cell
+                return {"error": str(exc) or type(exc).__name__, "type": type(exc).__name__}
+        finally:
+            hangup.cancel()
+            self._running.discard(work)
+
+    async def close(self) -> None:
+        for work in list(self._running):
+            work.cancel()
+        if self._server is not None:
+            self._server.close()
+            await self._server.wait_closed()
+            self._server = None