rlmness-cli 0.2.0__py3-none-any.whl

rlmagent/subscriptions.py

@@ -0,0 +1,219 @@
+"""Saved subscriptions for workspace changes and session jobs."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from dataclasses import dataclass
+from functools import wraps
+from math import isfinite
+from pathlib import Path
+from time import time
+from uuid import uuid4
+
+MAX_WATCHES = 32
+MAX_EVENTS = 200
+POLL_SECONDS = 1.0
+
+
+@dataclass
+class ActivityRequest:
+    watch_id: str | None
+    previous: set[str]
+    timeout: float
+    owner: str | None
+    deadline: float | None = None
+
+
+class Subscriptions:
+    def __init__(self, storage: Path, snapshot):
+        self.storage = storage
+        self.snapshot = snapshot
+        self.task = None
+        try:
+            self.watches = json.loads(storage.read_text(encoding="utf-8"))
+        except FileNotFoundError:
+            self.watches = {}
+
+    def _save(self, watches):
+        self.storage.parent.mkdir(parents=True, exist_ok=True)
+        staged = self.storage.with_suffix(f".{uuid4().hex}.tmp")
+        try:
+            staged.write_text(json.dumps(watches, ensure_ascii=False), encoding="utf-8")
+            staged.replace(self.storage)
+        finally:
+            staged.unlink(missing_ok=True)
+        self.watches = watches
+
+    def _put(self, watch):
+        self._save({**self.watches, watch["id"]: watch})
+
+    def _visible(self, owner):
+        return {key: watch for key, watch in self.watches.items()
+                if watch.get("owner") in (None, owner)}
+
+    def _get(self, identity, owner=None):
+        if not isinstance(identity, str) or identity not in (visible := self._visible(owner)):
+            raise ValueError("unknown watch ID")
+        return visible[identity]
+
+    @staticmethod
+    def _summary(watch):
+        return {key: watch[key] for key in ("id", "kind", "target", "active", "dropped")} | {
+            "unread": sum(event["status"] == "unread" for event in watch["events"]),
+        }
+
+    async def watch_start(self, job=None, path=None):
+        """Subscribe to one job or workspace path. Returns a persistent watch ID."""
+        if (job is None) == (path is None):
+            raise ValueError("give exactly one of job or path")
+        kind, target = ("job", job) if job is not None else ("path", path)
+        return self._subscribe(kind, target)
+
+    def watch_child(self, child_id, owner):
+        return self._subscribe("child", child_id, owner)
+
+    def _subscribe(self, kind, target, owner=None):
+        if not isinstance(target, str) or not target:
+            raise ValueError("watch target must be a nonempty string")
+        if len(self.watches) >= MAX_WATCHES:
+            raise ValueError("watch limit reached; remove an old watch with watch_cancel")
+        target, state = self.snapshot(kind, target)
+        watch = {"id": uuid4().hex, "kind": kind, "target": target, "state": state, "owner": owner,
+                 "events": [], "active": kind != "job" or not state["done"], "dropped": 0}
+        self._put(watch)
+        self.start()
+        return self._summary(watch)
+
+    async def watch_list(self, *, owner=None):
+        """List subscriptions and their unread counts."""
+        self.poll()
+        return [self._summary(watch) for watch in self._visible(owner).values()]
+
+    async def watch_events(self, watch_id, new_only=True, *, owner=None):
+        """List event metadata without changing read state."""
+        self.poll()
+        return [{k: v for k, v in event.items() if k != "change"}
+                for event in self._get(watch_id, owner)["events"]
+                if not new_only or event["status"] == "unread"]
+
+    async def watch_read(self, watch_id, event_id, *, owner=None):
+        """Read one event by ID. Repeated reads return the same event."""
+        watch = self._get(watch_id, owner)
+        for event in watch["events"]:
+            if event["id"] != event_id:
+                continue
+            if event["status"] == "read":
+                return dict(event)
+            read = {**event, "status": "read"}
+            self._put({**watch, "events": [read if row is event else row for row in watch["events"]]})
+            return read
+        raise ValueError("unknown watch event ID")
+
+    async def watch_cancel(self, watch_id, *, owner=None):
+        """Remove a subscription and its retained events."""
+        self._get(watch_id, owner)
+        self._save({key: value for key, value in self.watches.items() if key != watch_id})
+        return {"id": watch_id, "active": False}
+
+    def poll(self):
+        changed = {}
+        for key, watch in self.watches.items():
+            if not watch["active"]:
+                continue
+            try:
+                _, state = self.snapshot(watch["kind"], watch["target"])
+            except (OSError, ValueError):
+                # A target may be briefly unavailable during a job update or file swap.
+                continue
+            prior = watch["state"]
+            if prior == state:
+                continue
+            if watch["kind"] == "path":
+                paths = sorted(name for name in prior.keys() | state.keys()
+                               if prior.get(name) != state.get(name))
+                change = {"paths": paths[:200], "truncated": len(paths) > 200}
+            elif watch["kind"] == "job":
+                change = {"start": prior["bytes"], "end": state["bytes"],
+                          "done": state["done"], "exit": state["exit"]}
+            else:
+                change = dict(state)
+            events = [*watch["events"], {"id": uuid4().hex, "status": "unread",
+                                        "time": time(), "change": change}]
+            dropped = watch["dropped"] + sum(event["status"] == "unread" for event in events[:-MAX_EVENTS])
+            ended = (watch["kind"] == "job" and state["done"] or
+                     watch["kind"] == "child" and state["status"] in ("cancelled", "missing"))
+            changed[key] = {**watch, "state": state, "events": events[-MAX_EVENTS:], "dropped": dropped,
+                            "active": not ended}
+        if changed:
+            self._save({**self.watches, **changed})
+
+    def prepare_wait(self, watch_id, timeout, *, owner=None):
+        timeout = float(timeout)
+        if not isfinite(timeout) or not 0 < timeout <= 300:
+            raise ValueError("wait timeout must be between 0 and 300 seconds")
+        if watch_id is not None:
+            self._get(watch_id, owner)
+        self.poll()
+        return ActivityRequest(watch_id, self._event_ids(watch_id, owner), timeout, owner)
+
+    def _event_ids(self, watch_id, owner):
+        return {event["id"] for key, watch in self._visible(owner).items()
+                if watch_id is None or key == watch_id for event in watch["events"]}
+
+    def wait_status(self, request, steering_pending):
+        loop = asyncio.get_running_loop()
+        if request.deadline is None:
+            request.deadline = loop.time() + request.timeout
+        watch_id = request.watch_id
+        if steering_pending():
+            return {"event": "steering"}
+        if watch_id is not None and watch_id not in self.watches:
+            return {"event": "cancelled", "watch_id": watch_id}
+        self.poll()
+        if self._event_ids(watch_id, request.owner) - request.previous:
+            return {"event": "watch", "watch_id": watch_id}
+        remaining = request.deadline - loop.time()
+        if remaining <= 0:
+            return {"event": "timeout"}
+        return {"retry_after": min(POLL_SECONDS, remaining)}
+
+    async def wait_for_change(self, request, steering_pending):
+        while True:
+            status = self.wait_status(request, steering_pending)
+            if "event" in status:
+                return status
+            await asyncio.sleep(status["retry_after"])
+
+    def start(self):
+        if self.task is None and any(watch["active"] for watch in self.watches.values()):
+            self.task = asyncio.create_task(self._monitor())
+
+    async def _monitor(self):
+        try:
+            while any(watch["active"] for watch in self.watches.values()):
+                try:
+                    self.poll()
+                except OSError:
+                    # Keep the prior cursor and retry persistence on the next sample.
+                    pass
+                await asyncio.sleep(POLL_SECONDS)
+        finally:
+            self.task = None
+
+    async def close(self):
+        if self.task is not None:
+            task = self.task
+            task.cancel()
+            await asyncio.gather(task, return_exceptions=True)
+            self.task = None
+
+    def functions(self, *, owner=None):
+        def scoped(method):
+            @wraps(method)
+            async def call(*args, **kwargs):
+                return await method(*args, **kwargs, owner=owner)
+            return call
+
+        return {"watch_start": self.watch_start, **{method.__name__: scoped(method) for method in (
+            self.watch_list, self.watch_events, self.watch_read, self.watch_cancel)}}

rlmagent/tasks.py

@@ -0,0 +1,98 @@
+"""The task list an agent keeps for itself while it works, saved with the session."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+MAX_TASKS = 100
+MAX_TEXT = 300
+
+
+class TaskList:
+    def __init__(self, path: Path | None = None) -> None:
+        self.path = path
+        self.items: list[dict] = []
+        self.on_change = None  # called after every change, e.g. to redraw a panel
+        self.load()
+
+    def attach(self, path: Path | None) -> None:
+        """Keep the list in `path` from now on, reading what is already there."""
+        self.path = path
+        self.load()
+
+    def load(self) -> None:
+        if self.path is None or not self.path.exists():
+            return
+        try:
+            data = json.loads(self.path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError):
+            return
+        if isinstance(data, list):
+            self.items = [
+                {"text": str(item.get("text", ""))[:MAX_TEXT], "done": bool(item.get("done"))}
+                for item in data if isinstance(item, dict)
+            ][:MAX_TASKS]
+
+    def _save(self) -> None:
+        if self.path is not None:
+            self.path.parent.mkdir(parents=True, exist_ok=True)
+            self.path.write_text(json.dumps(self.items, indent=1), encoding="utf-8")
+        if self.on_change is not None:
+            self.on_change(self)
+
+    def _index(self, number) -> int:
+        index = int(number) - 1
+        if not 0 <= index < len(self.items):
+            raise ValueError(f"there is no task {number}; tasks are numbered 1 to {len(self.items)}")
+        return index
+
+    def add(self, text: str) -> int:
+        text = " ".join(str(text).split())[:MAX_TEXT]
+        if not text:
+            raise ValueError("a task needs some text")
+        if len(self.items) >= MAX_TASKS:
+            raise ValueError(f"the list already has {MAX_TASKS} tasks; clear finished ones")
+        self.items.append({"text": text, "done": False})
+        self._save()
+        return len(self.items)
+
+    def done(self, number) -> None:
+        self.items[self._index(number)]["done"] = True
+        self._save()
+
+    def undo(self, number) -> None:
+        self.items[self._index(number)]["done"] = False
+        self._save()
+
+    def remove(self, number) -> None:
+        del self.items[self._index(number)]
+        self._save()
+
+    def clear(self, finished_only: bool = True) -> None:
+        self.items = [item for item in self.items if finished_only and not item["done"]]
+        self._save()
+
+    def render(self) -> str:
+        if not self.items:
+            return "No tasks."
+        return "\n".join(f"{n}. [{'x' if item['done'] else ' '}] {item['text']}"
+                         for n, item in enumerate(self.items, 1))
+
+    async def todo(self, action: str = "list", value=None):
+        """Keep your own task list: todo() lists it; todo("add", text);
+        todo("done", n); todo("undo", n); todo("remove", n); todo("clear") drops finished ones."""
+        if action == "list":
+            pass
+        elif action == "add":
+            self.add(value)
+        elif action in ("done", "undo", "remove"):
+            getattr(self, action)(value)
+        elif action == "clear":
+            self.clear()
+        else:
+            raise ValueError("action is one of list, add, done, undo, remove, clear")
+        return self.render()
+
+
+__all__ = ["TaskList"]

rlmagent/toolhost.py

@@ -0,0 +1,310 @@
+"""Split execution: the agent loop and its keys stay here, the tools run in another workspace.
+
+The tool host is a small process next to the files it works on:
+
+    python -m rlmagent.toolhost --root /work            # over stdin/stdout
+    python -m rlmagent.toolhost --root /work --tcp 0.0.0.0:7700   # over TCP
+
+Over TCP the first line a client sends must carry the token from RLM_AGENT_TOOLS_TOKEN.
+The host only runs what it is asked; approvals, the git guard and every decision about
+whether something may run are made by the harness before a call is sent.
+
+Each request is one JSON line: {"id": 1, "fn": "read_file", "args": [...], "kwargs": {...}}.
+Each reply is one JSON line: {"id": 1, "ok": true, "value": ...} or {"id": 1, "ok": false,
+"error": "..."}.
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import hmac
+import json
+import os
+import sys
+from pathlib import Path
+
+TOKEN_ENV = "RLM_AGENT_TOOLS_TOKEN"
+MAX_LINE = 64 * 1024 * 1024
+
+# What a tool host serves. Changes and commands are approved by the harness first.
+SERVED = ("read_file", "list_files", "search_files", "write_file", "edit_file", "apply_patch",
+          "run", "instruction_docs", "job_start", "job_read", "job_wait", "job_stop", "jobs",
+          "service_start", "watch")
+CHANGES = {"write_file", "edit_file", "apply_patch", "run", "job_start", "service_start"}
+# Positional parameter names of the calls the harness checks before sending.
+_POSITIONAL = {"run": ("cmd",), "write_file": ("path", "content"),
+               "edit_file": ("path", "old", "new"), "apply_patch": ("diff",),
+               "job_start": ("command",), "service_start": ("name", "command")}
+
+
+class ToolHost:
+    def __init__(self, root: str, *, shell_access="host", shell_network=False) -> None:
+        from rlmagent.agents.approval import Approver
+        from rlmagent.agents.workspace import Workspace
+        from rlmagent.jobs import Jobs
+
+        self.root = str(Path(root).resolve())
+        workspace = Workspace(self.root, Approver("auto"))
+        from rlmagent.policy import Policy
+        workspace.policy = Policy(shell_access=shell_access, shell_network=shell_network)
+        self.jobs = Jobs(self.root, Path(self.root) / ".rlm-agent" / "jobs",
+                         shell_access=shell_access, shell_network=shell_network)
+        self.functions = {**workspace.functions(), **self.jobs.functions()}
+
+    async def answer(self, request: dict) -> dict:
+        number = request.get("id")
+        name = request.get("fn")
+        if name not in SERVED or name not in self.functions:
+            return {"id": number, "ok": False, "error": f"the tool host does not serve {name!r}"}
+        try:
+            value = await self.functions[name](*request.get("args", []), **request.get("kwargs", {}))
+        except Exception as exc:  # noqa: BLE001 - every failure goes back to the caller
+            return {"id": number, "ok": False, "error": f"{type(exc).__name__}: {exc}"}
+        return {"id": number, "ok": True, "value": value}
+
+    async def serve(self, reader, writer, token: str | None = None) -> None:
+        if token is not None:
+            first = await reader.readline()
+            try:
+                given = str(json.loads(first).get("token", ""))
+            except (json.JSONDecodeError, AttributeError):
+                given = ""
+            if not hmac.compare_digest(given, token):
+                writer.write(b'{"ok": false, "error": "bad token"}\n')
+                await writer.drain()
+                writer.close()
+                return
+            writer.write(b'{"ok": true}\n')
+            await writer.drain()
+        pending = set()
+        lock = asyncio.Lock()
+
+        async def handle(line: bytes) -> None:
+            try:
+                request = json.loads(line)
+            except json.JSONDecodeError:
+                return
+            reply = await self.answer(request)
+            data = (json.dumps(reply, default=str) + "\n").encode()
+            async with lock:
+                writer.write(data)
+                await writer.drain()
+
+        while line := await reader.readline():
+            task = asyncio.create_task(handle(line))
+            pending.add(task)
+            task.add_done_callback(pending.discard)
+        await asyncio.gather(*pending, return_exceptions=True)
+
+    async def close(self) -> None:
+        await self.jobs.close()
+
+
+class RemoteTools:
+    """The harness's side: calls tools in a tool host over a stream."""
+
+    def __init__(self, reader, writer, process=None) -> None:
+        self.reader, self.writer, self.process = reader, writer, process
+        self._next = 0
+        self._waiting: dict[int, asyncio.Future] = {}
+        self._reading = asyncio.create_task(self._read())
+
+    @classmethod
+    async def over_stdio(cls, command: list[str]) -> RemoteTools:
+        process = await asyncio.create_subprocess_exec(
+            *command, stdin=asyncio.subprocess.PIPE, stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.DEVNULL, limit=MAX_LINE)
+        return cls(process.stdout, process.stdin, process)
+
+    @classmethod
+    async def over_tcp(cls, host: str, port: int, token: str) -> RemoteTools:
+        reader, writer = await asyncio.open_connection(host, port, limit=MAX_LINE)
+        writer.write((json.dumps({"token": token}) + "\n").encode())
+        await writer.drain()
+        hello = json.loads(await reader.readline() or b"{}")
+        if not hello.get("ok"):
+            writer.close()
+            raise ConnectionError(f"the tool host refused the connection: {hello.get('error')}")
+        return cls(reader, writer)
+
+    async def _read(self) -> None:
+        try:
+            while line := await self.reader.readline():
+                reply = json.loads(line)
+                waiter = self._waiting.pop(reply.get("id"), None)
+                if waiter is not None and not waiter.done():
+                    waiter.set_result(reply)
+        finally:
+            for waiter in self._waiting.values():
+                if not waiter.done():
+                    waiter.set_exception(ConnectionError("the tool host went away"))
+
+    async def call(self, name: str, *args, **kwargs):
+        self._next += 1
+        number = self._next
+        waiter = asyncio.get_running_loop().create_future()
+        self._waiting[number] = waiter
+        line = json.dumps({"id": number, "fn": name, "args": list(args), "kwargs": kwargs})
+        self.writer.write((line + "\n").encode())
+        await self.writer.drain()
+        reply = await waiter
+        if not reply.get("ok"):
+            raise ValueError(reply.get("error", "the tool host failed"))
+        return reply.get("value")
+
+    def functions(self, approver, policy=None) -> dict:
+        """The served tools as cell functions, approved here before they are sent."""
+        import difflib
+
+        from rlmagent.agents.approval import Request, check
+        from rlmagent.policy import git_refusal
+
+        async def approve(request: Request) -> None:
+            check(await approver.approve(request), Request(request.kind, request.target,
+                                                           request.payload))
+
+        def make(name):
+            async def call(*args, **kwargs):
+                given = {**dict(zip(_POSITIONAL.get(name, ()), args)), **kwargs}
+                if name in ("run", "job_start", "service_start"):
+                    command = str(given.get("cmd", given.get("command", "")))
+                    argv = given.get("argv") if name == "job_start" else None
+                    if argv is not None:
+                        import shlex
+                        if not isinstance(argv, list) or not argv or not all(
+                            isinstance(item, str) for item in argv
+                        ):
+                            raise ValueError("argv must be a nonempty list of strings")
+                        command = shlex.join(argv)
+                    if policy is not None and (reason := git_refusal(command, policy)):
+                        raise ValueError(reason)
+                    payload = ("argv", tuple(argv)) if argv is not None else ()
+                    await approve(Request("run", command, payload))
+                elif name == "write_file":
+                    path, content = str(given.get("path")), str(given.get("content", ""))
+                    try:
+                        before = await self.call("read_file", path)
+                    except ValueError:
+                        before = ""
+                    preview = "\n".join(difflib.unified_diff(
+                        before.splitlines(), content.splitlines(), f"a/{path}", f"b/{path}",
+                        lineterm=""))
+                    await approve(Request("write", path, (content,), preview=preview))
+                elif name == "edit_file":
+                    await approve(Request("edit", str(given.get("path")),
+                                          (given.get("old"), given.get("new"))))
+                elif name == "apply_patch":
+                    diff = str(given.get("diff", ""))
+                    await approve(Request("patch", "remote workspace", (diff,), preview=diff))
+                return await self.call(name, *args, **kwargs)
+
+            call.__name__ = name
+            return call
+
+        return {name: make(name) for name in SERVED}
+
+    async def close(self) -> None:
+        self.writer.close()
+        self._reading.cancel()
+        if self.process is not None and self.process.returncode is None:
+            self.process.kill()
+            await self.process.wait()
+
+
+async def connect(spec: str) -> RemoteTools:
+    """`tcp://host:port` (token from RLM_AGENT_TOOLS_TOKEN), or a command run over stdio."""
+    import shlex
+
+    if spec.startswith("tcp://"):
+        host, _, port = spec[len("tcp://"):].rpartition(":")
+        token = os.environ.get(TOKEN_ENV)
+        if not token:
+            raise ValueError(f"set {TOKEN_ENV} to the tool host's token")
+        return await RemoteTools.over_tcp(host or "127.0.0.1", int(port), token)
+    words = shlex.split(spec, posix=os.name != "nt")
+    if os.name == "nt":
+        # Windows splitting keeps the quotes that protect paths with spaces.
+        words = [w[1:-1] if len(w) > 1 and w[0] == w[-1] and w[0] in "\"'" else w for w in words]
+    return await RemoteTools.over_stdio(words)
+
+
+async def _stdio(host: ToolHost) -> None:
+    loop = asyncio.get_running_loop()
+    reader = asyncio.StreamReader(limit=MAX_LINE)
+    await loop.connect_read_pipe(lambda: asyncio.StreamReaderProtocol(reader), sys.stdin)
+    transport, protocol = await loop.connect_write_pipe(
+        asyncio.streams.FlowControlMixin, sys.stdout)
+    writer = asyncio.StreamWriter(transport, protocol, reader, loop)
+    await host.serve(reader, writer)
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="python -m rlmagent.toolhost",
+                                     description="Serve workspace tools to an rlm-agent harness.")
+    parser.add_argument("--root", default=".", help="The workspace the tools work in.")
+    parser.add_argument("--tcp", default=None, metavar="HOST:PORT",
+                        help=f"Listen on TCP; clients must send the token in {TOKEN_ENV}.")
+    parser.add_argument("--shell-access", choices=("workspace", "host"), default="workspace")
+    parser.add_argument("--shell-network", action="store_true")
+    ns = parser.parse_args(argv)
+    host = ToolHost(ns.root, shell_access=ns.shell_access, shell_network=ns.shell_network)
+
+    async def run() -> None:
+        try:
+            if ns.tcp is None:
+                if os.name == "nt":
+                    # Pipes on Windows do not work with the selector loop's pipe readers.
+                    await _stdio_threads(host)
+                else:
+                    await _stdio(host)
+                return
+            token = os.environ.get(TOKEN_ENV)
+            if not token:
+                raise SystemExit(f"set {TOKEN_ENV} before listening on TCP")
+            address, _, port = ns.tcp.rpartition(":")
+            server = await asyncio.start_server(
+                lambda r, w: host.serve(r, w, token), address or "127.0.0.1", int(port),
+                limit=MAX_LINE)
+            print(f"tool host listening on {ns.tcp} for {host.root}", file=sys.stderr, flush=True)
+            async with server:
+                await server.serve_forever()
+        finally:
+            await host.close()
+
+    asyncio.run(run())
+    return 0
+
+
+async def _stdio_threads(host: ToolHost) -> None:
+    """stdin/stdout through threads, for platforms whose event loop cannot watch pipes."""
+    loop = asyncio.get_running_loop()
+    reader = asyncio.StreamReader(limit=MAX_LINE)
+
+    def pump():
+        stream = sys.stdin.buffer
+        while line := stream.readline():
+            loop.call_soon_threadsafe(reader.feed_data, line)
+        loop.call_soon_threadsafe(reader.feed_eof)
+
+    loop.run_in_executor(None, pump)
+
+    class Writer:
+        def write(self, data: bytes) -> None:
+            sys.stdout.buffer.write(data)
+            sys.stdout.buffer.flush()
+
+        async def drain(self) -> None:
+            return None
+
+        def close(self) -> None:
+            return None
+
+    await host.serve(reader, Writer())
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
+
+
+__all__ = ["CHANGES", "SERVED", "TOKEN_ENV", "RemoteTools", "ToolHost", "connect", "main"]

rlmagent/tools/__init__.py

@@ -0,0 +1,56 @@
+"""Coding tools (files, the python kernel) + tool registry/assembly."""
+
+from __future__ import annotations
+
+from rlmagent.tools._shared import (
+    CallBlock,
+    CancelToken,
+    InputShaper,
+    InvocationPrinter,
+    JValue,
+    OutcomePresenter,
+    Parallelism,
+    ProgressNotifier,
+    RunHandler,
+    ToolOutcome,
+    ToolSpec,
+)
+from rlmagent.tools.files import file_tools
+from rlmagent.tools.kernel import make_python_tool
+from rlmagent.tools.patch_tool import make_patch_tool
+from rlmagent.tools.search import search_tools
+
+
+def build_tool_registry(kernel=None) -> list[ToolSpec]:
+    """File tools, plus the python tool when the agent has a kernel."""
+    from rlmagent.kernel.wasm import WasmKernel
+
+    tools: list[ToolSpec] = []
+    # A sandboxed agent changes files only through its approved workspace functions.
+    sandboxed = isinstance(kernel, WasmKernel) or getattr(kernel, "kernel_kind", None) == "wasm"
+    tools.extend(t for t in file_tools() if not sandboxed or t.name == "Read")
+    if not sandboxed:
+        tools.append(make_patch_tool())
+    tools.extend(search_tools())
+    if kernel is not None:
+        tools.append(make_python_tool(kernel))
+    return tools
+
+
+__all__ = [
+    "CallBlock",
+    "CancelToken",
+    "InputShaper",
+    "InvocationPrinter",
+    "JValue",
+    "OutcomePresenter",
+    "Parallelism",
+    "ProgressNotifier",
+    "RunHandler",
+    "ToolOutcome",
+    "ToolSpec",
+    "build_tool_registry",
+    "file_tools",
+    "make_python_tool",
+    "search_tools",
+]