openreward 0.1.95.dev0__tar.gz → 0.1.96.dev1__tar.gz

{openreward-0.1.95.dev0 → openreward-0.1.96.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openreward
-Version: 0.1.95.dev0
+Version: 0.1.96.dev1
 Summary: Python SDK for the OpenReward platform.
 Author-email: GR Inc <hello@gr.inc>
 Requires-Python: >=3.11

{openreward-0.1.95.dev0 → openreward-0.1.96.dev1}/openreward/api/environments/client.py

@@ -12,8 +12,8 @@ from openreward.api._session.http import (
 )
 from openreward.api._session.session import BaseAsyncSession, SessionTerminatedError
 
-BuiltinToolset = Literal["claude-code", "codex", "openclaw", "hermes"]
-_VALID_BUILTIN_TOOLSETS = {"claude-code", "codex", "openclaw", "hermes"}
+BuiltinToolset = Literal["claude-code", "codex", "openclaw-sandboxed", "hermes-sandboxed"]
+_VALID_BUILTIN_TOOLSETS = {"claude-code", "codex", "openclaw-sandboxed", "hermes-sandboxed"}
 from .types import (
     ImageBlock,
     JSONObject,

{openreward-0.1.95.dev0 → openreward-0.1.96.dev1}/openreward/toolsets/__init__.py

@@ -5,8 +5,8 @@ from openreward.environments.toolset import Toolset
 from .claude_code import ClaudeCodeToolset
 from .codex import CodexToolset
 from .excel import ExcelToolset
-from .hermes import HermesToolset
-from .openclaw import OpenClawToolset
+from .hermes import HermesSandboxedToolset
+from .openclaw import OpenClawSandboxedToolset
 from .pdf import PDFToolset
 from .powerpoint import PowerPointToolset
 from .word import WordToolset
@@ -18,8 +18,8 @@ from .word import WordToolset
 BUILTIN_TOOLSETS: dict[str, type[Toolset]] = {
     ClaudeCodeToolset.name(): ClaudeCodeToolset,
     CodexToolset.name(): CodexToolset,
-    OpenClawToolset.name(): OpenClawToolset,
-    HermesToolset.name(): HermesToolset,
+    OpenClawSandboxedToolset.name(): OpenClawSandboxedToolset,
+    HermesSandboxedToolset.name(): HermesSandboxedToolset,
 }
 
 __all__ = [
@@ -27,8 +27,8 @@ __all__ = [
     "ClaudeCodeToolset",
     "CodexToolset",
     "ExcelToolset",
-    "HermesToolset",
-    "OpenClawToolset",
+    "HermesSandboxedToolset",
+    "OpenClawSandboxedToolset",
     "PowerPointToolset",
     "WordToolset",
     "PDFToolset",

{openreward-0.1.95.dev0 → openreward-0.1.96.dev1}/openreward/toolsets/hermes.py

@@ -1,8 +1,14 @@
-"""Hermes Agent session toolset.
+"""Hermes Agent sandboxed session toolset.
 
-Provides the four built-in tools that Hermes Agent exposes for coding tasks
-(``terminal``, ``read_file``, ``write_file``, ``patch``), each backed by
-``self.sandbox`` from the bound environment.
+Provides the five built-in tools that Hermes Agent exposes for coding tasks
+(``terminal``, ``read_file``, ``write_file``, ``search_files``, ``patch``),
+each backed by ``self.sandbox`` from the bound environment.  All file and
+shell operations are routed through the sandbox so the agent runs in an
+isolated environment.
+
+For the non-sandboxed variant (``hermes``), Hermes uses its own native tools
+and only environment-specific tools (e.g. ``submit_answer``) are exposed via
+MCP — no SDK toolset is needed.
 
 Tool names, parameter schemas, and descriptions match Hermes Agent's upstream
 registry definitions (``nousresearch/hermes-agent``).
@@ -11,7 +17,7 @@ from __future__ import annotations
 
 import base64
 import os
-from typing import Any, Optional
+from typing import Any, List, Optional
 
 from pydantic import BaseModel
 
@@ -57,6 +63,17 @@ class WriteFileParams(BaseModel, extra="forbid"):
     content: str
 
 
+class SearchFilesParams(BaseModel, extra="forbid"):
+    pattern: str
+    target: str = "content"
+    path: str = "."
+    file_glob: Optional[str] = None
+    limit: int = 50
+    offset: int = 0
+    output_mode: str = "content"
+    context: int = 0
+
+
 class PatchParams(BaseModel, extra="forbid"):
     mode: str = "replace"
     path: Optional[str] = None
@@ -66,13 +83,14 @@ class PatchParams(BaseModel, extra="forbid"):
     patch: Optional[str] = None
 
 
-# ── Tool descriptions (matching Hermes registry style) ──
+# ── Tool descriptions (matching Hermes upstream registry) ──
 
 TERMINAL_DESCRIPTION = """\
 Execute shell commands on a Linux environment. Filesystem usually persists between calls.
 
 Do NOT use cat/head/tail to read files — use read_file instead.
 Do NOT use grep/rg/find to search — use search_files instead.
+Do NOT use ls to list directories — use search_files(target='files') instead.
 Do NOT use sed/awk to edit files — use patch instead.
 Do NOT use echo/cat heredoc to create files — use write_file instead.
 Reserve terminal for: builds, installs, git, processes, scripts, network, package managers, and anything that needs a shell.
@@ -89,6 +107,17 @@ Write content to a file, completely replacing existing content. Use this instead
 in terminal. Creates parent directories automatically. OVERWRITES the entire file — use 'patch' for \
 targeted edits."""
 
+SEARCH_FILES_DESCRIPTION = """\
+Search file contents or find files by name using regex/glob patterns. Use this instead of \
+grep/rg/find/ls in terminal.
+
+target='content' (default): search inside file contents with regex. Returns matching lines with \
+line numbers and optional context.
+target='files': search for files by name/glob pattern. Returns matching file paths.
+
+Use file_glob to filter which files to search (e.g., '*.py'). Use output_mode to control \
+output format: 'content' (matching lines), 'files_only' (file paths), 'count' (match counts)."""
+
 PATCH_DESCRIPTION = """\
 Targeted find-and-replace edits in files. Use this instead of sed/awk in terminal.
 
@@ -101,12 +130,12 @@ Include enough surrounding context to ensure uniqueness."""
 
 # ── Toolset ──
 
-class HermesToolset(Toolset):
-    """Session toolset exposing the Hermes Agent four-tool coding surface.
+class HermesSandboxedToolset(Toolset):
+    """Sandboxed session toolset exposing the Hermes Agent five-tool coding surface.
 
     The toolset is bound to a session by passing it to ``env.session(...)``::
 
-        with env.session(task=task, toolset="hermes") as session:
+        with env.session(task=task, toolset="hermes-sandboxed") as session:
             session.call_tool("terminal", {"command": "ls"})
 
     Requires the bound environment to define ``self.sandbox``.
@@ -114,7 +143,7 @@ class HermesToolset(Toolset):
 
     @classmethod
     def name(cls) -> str:
-        return "hermes"
+        return "hermes-sandboxed"
 
     @tool
     async def terminal(self, params: TerminalParams) -> ToolOutput:
@@ -188,6 +217,75 @@ class HermesToolset(Toolset):
                 finished=False,
             )
 
+    @tool
+    async def search_files(self, params: SearchFilesParams) -> ToolOutput:
+        try:
+            if params.target == "files":
+                # File name search using find
+                cmd = f"find {params.path} -type f -name '{params.pattern}'"
+                output, code = await self.sandbox.run(cmd)
+                if code != 0:
+                    return ToolOutput(
+                        metadata={"error": output, "exit_code": code},
+                        blocks=[TextBlock(text=f"search_files failed (exit {code}):\n{output}")],
+                        finished=False,
+                    )
+                # Apply offset/limit to results
+                lines = [l for l in output.splitlines() if l.strip()]
+                lines = lines[params.offset:params.offset + params.limit]
+                result = "\n".join(lines)
+                return ToolOutput(
+                    metadata={"output": result, "exit_code": 0},
+                    blocks=[TextBlock(text=result if result else "No files found.")],
+                    reward=0.0,
+                    finished=False,
+                )
+            else:
+                # Content search using grep
+                glob_flag = ""
+                if params.file_glob:
+                    glob_flag = f" --include='{params.file_glob}'"
+
+                context_flag = ""
+                if params.context > 0:
+                    context_flag = f" -C {params.context}"
+
+                if params.output_mode == "files_only":
+                    mode_flag = " -l"
+                elif params.output_mode == "count":
+                    mode_flag = " -c"
+                else:
+                    mode_flag = " -n"
+
+                cmd = f"grep -r{mode_flag}{context_flag}{glob_flag} '{params.pattern}' {params.path}"
+                output, code = await self.sandbox.run(cmd)
+
+                # grep returns 1 for no matches — not an error
+                if code > 1:
+                    return ToolOutput(
+                        metadata={"error": output, "exit_code": code},
+                        blocks=[TextBlock(text=f"search_files failed (exit {code}):\n{output}")],
+                        finished=False,
+                    )
+
+                # Apply offset/limit to results
+                lines = output.splitlines()
+                lines = lines[params.offset:params.offset + params.limit]
+                result = "\n".join(lines)
+
+                return ToolOutput(
+                    metadata={"output": result, "exit_code": 0},
+                    blocks=[TextBlock(text=result if result else "No matches found.")],
+                    reward=0.0,
+                    finished=False,
+                )
+        except Exception as e:
+            return ToolOutput(
+                metadata={"error": str(e)},
+                blocks=[TextBlock(text=f"Error searching files: {str(e)}")],
+                finished=False,
+            )
+
     @tool
     async def patch(self, params: PatchParams) -> ToolOutput:
         if params.mode == "replace":
@@ -289,7 +387,8 @@ class HermesToolset(Toolset):
 
 # Assign descriptions onto each tool method's __doc__ so the framework's
 # introspection picks them up.
-HermesToolset.terminal.__doc__ = TERMINAL_DESCRIPTION
-HermesToolset.read_file.__doc__ = READ_FILE_DESCRIPTION
-HermesToolset.write_file.__doc__ = WRITE_FILE_DESCRIPTION
-HermesToolset.patch.__doc__ = PATCH_DESCRIPTION
+HermesSandboxedToolset.terminal.__doc__ = TERMINAL_DESCRIPTION
+HermesSandboxedToolset.read_file.__doc__ = READ_FILE_DESCRIPTION
+HermesSandboxedToolset.write_file.__doc__ = WRITE_FILE_DESCRIPTION
+HermesSandboxedToolset.search_files.__doc__ = SEARCH_FILES_DESCRIPTION
+HermesSandboxedToolset.patch.__doc__ = PATCH_DESCRIPTION

openreward-0.1.96.dev1/openreward/toolsets/openclaw.py

@@ -0,0 +1,369 @@
+"""OpenClaw sandboxed session toolset.
+
+Provides the built-in tools that OpenClaw exposes for coding tasks
+(``exec``, ``process``, ``read``, ``write``, ``edit``, ``apply_patch``),
+each backed by
+``self.sandbox`` from the bound environment.  All file and shell operations
+are routed through the sandbox so the agent runs in an isolated environment.
+
+For the non-sandboxed variant (``openclaw``), OpenClaw uses its own native
+tools and only environment-specific tools (e.g. ``submit_answer``) are
+exposed via MCP — no SDK toolset is needed.
+
+Tool names, parameter schemas, and descriptions match OpenClaw's upstream
+definitions.
+"""
+from __future__ import annotations
+
+import base64
+import os
+from typing import Any, List, Optional
+
+from pydantic import BaseModel, Field
+
+from openreward.environments.environment import tool
+from openreward.environments.toolset import Toolset
+from openreward.environments.types import TextBlock, ToolOutput
+
+
+# ── Sandbox text helpers (inlined; same as claude_code.py) ──
+
+async def _download_text(sandbox: Any, path: str) -> str:
+    data = await sandbox.download(path)
+    return data.decode("utf-8")
+
+
+async def _upload_text(
+    sandbox: Any,
+    path: str,
+    content: str,
+    ensure_trailing_newline: bool = True,
+) -> None:
+    if ensure_trailing_newline and not content.endswith("\n"):
+        content = content + "\n"
+    encoded = base64.b64encode(content.encode("utf-8")).decode("ascii")
+    await sandbox.check_run(f"echo '{encoded}' | base64 -d > {path}")
+
+
+# ── Pydantic parameter models ──
+
+class ExecParams(BaseModel, extra="forbid"):
+    command: str
+    timeout: Optional[float] = 1800.0
+
+
+class ReadParams(BaseModel, extra="forbid"):
+    path: str
+    offset: Optional[int] = None
+    limit: Optional[int] = None
+
+
+class WriteParams(BaseModel, extra="forbid"):
+    path: str
+    content: str
+
+
+class EditItem(BaseModel, extra="forbid"):
+    oldText: str
+    newText: str
+
+
+class EditParams(BaseModel, extra="forbid"):
+    path: str
+    edits: List[EditItem]
+
+
+class ApplyPatchParams(BaseModel, extra="forbid"):
+    input: str
+
+
+class ProcessParams(BaseModel, extra="forbid"):
+    action: str
+    sessionId: Optional[str] = None
+    data: Optional[str] = None
+    eof: Optional[bool] = None
+    offset: Optional[int] = None
+    limit: Optional[int] = None
+
+
+# ── Tool descriptions (matching OpenClaw upstream) ──
+
+EXEC_DESCRIPTION = """\
+Execute a shell command and return its output and exit code. \
+Set timeout in seconds (default 1800). \
+Use for builds, installs, git, processes, scripts, network, package managers, \
+and anything that needs a shell."""
+
+READ_DESCRIPTION = """\
+Read the contents of a file at the given path. \
+Supports optional offset (1-indexed line number to start from) and limit \
+(maximum number of lines to read) for pagination of large files."""
+
+WRITE_DESCRIPTION = """\
+Write content to a file, creating it if it doesn't exist or overwriting if it does. \
+Creates parent directories automatically. \
+Use the edit tool for targeted modifications to existing files."""
+
+EDIT_DESCRIPTION = """\
+Apply one or more targeted text replacements to a file. \
+Each edit specifies an oldText to find and a newText to replace it with. \
+oldText must be unique in the file for each edit."""
+
+PROCESS_DESCRIPTION = """\
+Manage background processes. Use exec with background=true to start a process, \
+then use this tool to interact with it.
+
+Actions:
+- list: show running and finished background sessions
+- poll: check for new output from a session (requires sessionId)
+- log: read session output with optional offset/limit pagination (requires sessionId)
+- write: send data to a session's stdin (requires sessionId and data)
+- kill: terminate a background session (requires sessionId)
+- remove: kill if running, clear if finished (requires sessionId)"""
+
+APPLY_PATCH_DESCRIPTION = """\
+Apply file modifications using a structured patch format, designed for multiple file \
+or multi-hunk edits where individual edit calls would be fragile.
+
+The input must include '*** Begin Patch' and '*** End Patch' markers. Supported \
+operations: '*** Add File:', '*** Update File:' (with optional '*** Move to:'), \
+'*** Delete File:', and '*** End of File' for EOF-only insertions."""
+
+
+# ── Toolset ──
+
+class OpenClawSandboxedToolset(Toolset):
+    """Sandboxed session toolset exposing the OpenClaw six-tool coding surface.
+
+    The toolset is bound to a session by passing it to ``env.session(...)``::
+
+        with env.session(task=task, toolset="openclaw-sandboxed") as session:
+            session.call_tool("exec", {"command": "ls"})
+
+    Requires the bound environment to define ``self.sandbox``.
+    """
+
+    @classmethod
+    def name(cls) -> str:
+        return "openclaw-sandboxed"
+
+    @tool
+    async def exec(self, params: ExecParams) -> ToolOutput:
+        try:
+            output, code = await self.sandbox.run(params.command.strip())
+            return ToolOutput(
+                blocks=[TextBlock(text=f"{output}\n\n(exit {code})")],
+                metadata={"output": output, "exit_code": code},
+                reward=0.0,
+                finished=False,
+            )
+        except Exception as e:
+            return ToolOutput(
+                metadata={"error": str(e)},
+                blocks=[TextBlock(text=f"Error executing command: {str(e)}")],
+                finished=False,
+            )
+
+    @tool
+    async def process(self, params: ProcessParams) -> ToolOutput:
+        try:
+            action = params.action
+            sid = params.sessionId or ""
+
+            if action == "list":
+                output, code = await self.sandbox.run("ps aux --no-headers 2>/dev/null || ps aux")
+                return ToolOutput(
+                    blocks=[TextBlock(text=output if output.strip() else "No background processes.")],
+                    metadata={"output": output, "exit_code": code},
+                    reward=0.0,
+                    finished=False,
+                )
+
+            if not sid:
+                return ToolOutput(
+                    metadata={"error": "sessionId is required for this action"},
+                    blocks=[TextBlock(text=f"Error: sessionId is required for action '{action}'.")],
+                    finished=False,
+                )
+
+            if action in ("poll", "log"):
+                # Read output from a background process log file
+                tail_n = params.limit or 200
+                cmd = f"cat /tmp/_oc_proc_{sid}.log 2>/dev/null || echo 'No output available for session {sid}'"
+                if params.offset is not None:
+                    cmd = f"tail -n +{params.offset} /tmp/_oc_proc_{sid}.log 2>/dev/null | head -n {tail_n}"
+                elif params.limit:
+                    cmd = f"tail -n {tail_n} /tmp/_oc_proc_{sid}.log 2>/dev/null"
+                output, code = await self.sandbox.run(cmd)
+                return ToolOutput(
+                    blocks=[TextBlock(text=output)],
+                    metadata={"output": output, "exit_code": code},
+                    reward=0.0,
+                    finished=False,
+                )
+
+            if action == "write":
+                data = params.data or ""
+                # Write data to the process's stdin via a named pipe or file
+                output, code = await self.sandbox.run(
+                    f"echo '{data}' >> /tmp/_oc_proc_{sid}.stdin 2>/dev/null"
+                )
+                return ToolOutput(
+                    blocks=[TextBlock(text=f"Sent data to session {sid}")],
+                    metadata={"output": output, "exit_code": code},
+                    reward=0.0,
+                    finished=False,
+                )
+
+            if action in ("kill", "remove"):
+                output, code = await self.sandbox.run(
+                    f"kill $(cat /tmp/_oc_proc_{sid}.pid 2>/dev/null) 2>/dev/null; "
+                    f"rm -f /tmp/_oc_proc_{sid}.pid /tmp/_oc_proc_{sid}.log /tmp/_oc_proc_{sid}.stdin"
+                )
+                return ToolOutput(
+                    blocks=[TextBlock(text=f"Session {sid} terminated and cleaned up.")],
+                    metadata={"output": output, "exit_code": code},
+                    reward=0.0,
+                    finished=False,
+                )
+
+            return ToolOutput(
+                metadata={"error": f"Unknown action: {action}"},
+                blocks=[TextBlock(text=f"Error: unknown process action '{action}'. "
+                        "Use list, poll, log, write, kill, or remove.")],
+                finished=False,
+            )
+        except Exception as e:
+            return ToolOutput(
+                metadata={"error": str(e)},
+                blocks=[TextBlock(text=f"Error managing process: {str(e)}")],
+                finished=False,
+            )
+
+    @tool
+    async def read(self, params: ReadParams) -> ToolOutput:
+        try:
+            content = await _download_text(self.sandbox, params.path)
+            lines = content.splitlines()
+
+            if params.offset is not None or params.limit is not None:
+                start = (params.offset or 1) - 1  # Convert 1-indexed to 0-indexed
+                if params.limit is not None:
+                    lines = lines[start:start + params.limit]
+                else:
+                    lines = lines[start:]
+
+            output = "\n".join(lines)
+            return ToolOutput(
+                metadata={"output": output, "exit_code": 0},
+                blocks=[TextBlock(text=output)],
+                reward=0.0,
+                finished=False,
+            )
+        except Exception as e:
+            return ToolOutput(
+                metadata={"error": str(e)},
+                blocks=[TextBlock(text=f"Error reading file: {str(e)}")],
+                finished=False,
+            )
+
+    @tool
+    async def write(self, params: WriteParams) -> ToolOutput:
+        try:
+            dir_name = os.path.dirname(params.path)
+            if dir_name:
+                await self.sandbox.run(f"mkdir -p {dir_name}")
+            await _upload_text(
+                self.sandbox,
+                params.path,
+                params.content,
+                ensure_trailing_newline=True,
+            )
+            return ToolOutput(
+                metadata={"output": "", "exit_code": 0},
+                blocks=[TextBlock(text=f"Successfully wrote to {params.path}")],
+                reward=0.0,
+                finished=False,
+            )
+        except Exception as e:
+            return ToolOutput(
+                metadata={"error": str(e)},
+                blocks=[TextBlock(text=f"Error writing file: {str(e)}")],
+                finished=False,
+            )
+
+    @tool
+    async def edit(self, params: EditParams) -> ToolOutput:
+        try:
+            content = await _download_text(self.sandbox, params.path)
+
+            for item in params.edits:
+                count = content.count(item.oldText)
+                if count == 0:
+                    return ToolOutput(
+                        metadata={"error": f"oldText not found in {params.path}"},
+                        blocks=[TextBlock(text=f"Error: oldText not found in {params.path}: {item.oldText[:100]}")],
+                        finished=False,
+                    )
+                if count > 1:
+                    return ToolOutput(
+                        metadata={"error": f"oldText appears {count} times; must be unique"},
+                        blocks=[TextBlock(text=f"Error: oldText appears {count} times in {params.path}. Must be unique.")],
+                        finished=False,
+                    )
+                content = content.replace(item.oldText, item.newText, 1)
+
+            await _upload_text(self.sandbox, params.path, content, ensure_trailing_newline=True)
+
+            return ToolOutput(
+                metadata={"output": "", "exit_code": 0},
+                blocks=[TextBlock(text=f"Successfully edited {params.path}")],
+                reward=0.0,
+                finished=False,
+            )
+        except Exception as e:
+            return ToolOutput(
+                metadata={"error": str(e)},
+                blocks=[TextBlock(text=f"Error editing file: {str(e)}")],
+                finished=False,
+            )
+
+    @tool
+    async def apply_patch(self, params: ApplyPatchParams) -> ToolOutput:
+        try:
+            # Upload patch content to a temp file and apply via patch command
+            patch_tmp = "/tmp/_openclaw_patch.diff"
+            await _upload_text(self.sandbox, patch_tmp, params.input, ensure_trailing_newline=True)
+
+            output, code = await self.sandbox.run(f"patch -p1 < {patch_tmp}")
+            if code != 0:
+                await self.sandbox.run(f"rm -f {patch_tmp}")
+                return ToolOutput(
+                    metadata={"error": output, "exit_code": code},
+                    blocks=[TextBlock(text=f"apply_patch failed (exit {code}):\n{output}")],
+                    finished=False,
+                )
+
+            await self.sandbox.run(f"rm -f {patch_tmp}")
+            return ToolOutput(
+                metadata={"output": output, "exit_code": 0},
+                blocks=[TextBlock(text=f"Successfully applied patch:\n{output}")],
+                reward=0.0,
+                finished=False,
+            )
+        except Exception as e:
+            return ToolOutput(
+                metadata={"error": str(e)},
+                blocks=[TextBlock(text=f"Error applying patch: {str(e)}")],
+                finished=False,
+            )
+
+
+# Assign descriptions onto each tool method's __doc__ so the framework's
+# introspection picks them up.
+OpenClawSandboxedToolset.exec.__doc__ = EXEC_DESCRIPTION
+OpenClawSandboxedToolset.process.__doc__ = PROCESS_DESCRIPTION
+OpenClawSandboxedToolset.read.__doc__ = READ_DESCRIPTION
+OpenClawSandboxedToolset.write.__doc__ = WRITE_DESCRIPTION
+OpenClawSandboxedToolset.edit.__doc__ = EDIT_DESCRIPTION
+OpenClawSandboxedToolset.apply_patch.__doc__ = APPLY_PATCH_DESCRIPTION

{openreward-0.1.95.dev0 → openreward-0.1.96.dev1}/openreward.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openreward
-Version: 0.1.95.dev0
+Version: 0.1.96.dev1
 Summary: Python SDK for the OpenReward platform.
 Author-email: GR Inc <hello@gr.inc>
 Requires-Python: >=3.11

{openreward-0.1.95.dev0 → openreward-0.1.96.dev1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "openreward"
-version = "0.1.95.dev0"
+version = "0.1.96.dev1"
 description = "Python SDK for the OpenReward platform."
 readme = "README.md"
 authors = [

{openreward-0.1.95.dev0 → openreward-0.1.96.dev1}/tests/test_session_toolset.py

@@ -287,14 +287,14 @@ async def test_session_toolset_warns_on_shadow(monkeypatch):
 
 # ── OpenClaw toolset ──
 
-OPENCLAW_TOOLS = {"exec", "read", "write", "edit"}
+OPENCLAW_TOOLS = {"exec", "process", "read", "write", "edit", "apply_patch"}
 
 
 @pytest.mark.asyncio
 async def test_openclaw_toolset_tools(client: AsyncOpenReward, server: str):
     env = client.environments.get("envwithsandbox", variant="envwithsandbox", base_url=server)
     tasks = await env.list_tasks(split="train")
-    async with env.session(tasks[0], toolset="openclaw") as session:
+    async with env.session(tasks[0], toolset="openclaw-sandboxed") as session:
         tools = await session.list_tools()
         toolset_names = {t.name for t in tools}
         for name in OPENCLAW_TOOLS:
@@ -310,7 +310,7 @@ async def test_openclaw_toolset_tools(client: AsyncOpenReward, server: str):
 async def test_openclaw_exec_routes_to_sandbox(client: AsyncOpenReward, server: str):
     env = client.environments.get("envwithsandbox", variant="envwithsandbox", base_url=server)
     tasks = await env.list_tasks(split="train")
-    async with env.session(tasks[0], toolset="openclaw") as session:
+    async with env.session(tasks[0], toolset="openclaw-sandboxed") as session:
         result = await session.call_tool("exec", {"command": "echo hi"})
         assert "ran: echo hi" in result.blocks[0].text
 
@@ -319,7 +319,7 @@ async def test_openclaw_exec_routes_to_sandbox(client: AsyncOpenReward, server:
 async def test_openclaw_write_then_read_roundtrip(client: AsyncOpenReward, server: str):
     env = client.environments.get("envwithsandbox", variant="envwithsandbox", base_url=server)
     tasks = await env.list_tasks(split="train")
-    async with env.session(tasks[0], toolset="openclaw") as session:
+    async with env.session(tasks[0], toolset="openclaw-sandboxed") as session:
         await session.call_tool("write", {"path": "/tmp/oc.txt", "content": "hello openclaw"})
         result = await session.call_tool("read", {"path": "/tmp/oc.txt"})
         assert "hello openclaw" in result.blocks[0].text
@@ -329,7 +329,7 @@ async def test_openclaw_write_then_read_roundtrip(client: AsyncOpenReward, serve
 async def test_openclaw_edit_with_edits_array(client: AsyncOpenReward, server: str):
     env = client.environments.get("envwithsandbox", variant="envwithsandbox", base_url=server)
     tasks = await env.list_tasks(split="train")
-    async with env.session(tasks[0], toolset="openclaw") as session:
+    async with env.session(tasks[0], toolset="openclaw-sandboxed") as session:
         await session.call_tool("write", {"path": "/tmp/oc_edit.txt", "content": "foo bar baz"})
         result = await session.call_tool("edit", {
             "path": "/tmp/oc_edit.txt",
@@ -341,16 +341,28 @@ async def test_openclaw_edit_with_edits_array(client: AsyncOpenReward, server: s
         assert "bar" not in read_result.blocks[0].text
 
 
+@pytest.mark.asyncio
+async def test_openclaw_apply_patch(client: AsyncOpenReward, server: str):
+    env = client.environments.get("envwithsandbox", variant="envwithsandbox", base_url=server)
+    tasks = await env.list_tasks(split="train")
+    async with env.session(tasks[0], toolset="openclaw-sandboxed") as session:
+        result = await session.call_tool("apply_patch", {
+            "input": "*** Begin Patch\n*** Update File: /tmp/test.txt\n--- old\n+++ new\n*** End Patch",
+        })
+        # apply_patch runs patch under the hood; mock sandbox returns "ran: ..."
+        assert result.blocks[0].text is not None
+
+
 # ── Hermes toolset ──
 
-HERMES_TOOLS = {"terminal", "read_file", "write_file", "patch"}
+HERMES_TOOLS = {"terminal", "read_file", "write_file", "search_files", "patch"}
 
 
 @pytest.mark.asyncio
 async def test_hermes_toolset_tools(client: AsyncOpenReward, server: str):
     env = client.environments.get("envwithsandbox", variant="envwithsandbox", base_url=server)
     tasks = await env.list_tasks(split="train")
-    async with env.session(tasks[0], toolset="hermes") as session:
+    async with env.session(tasks[0], toolset="hermes-sandboxed") as session:
         tools = await session.list_tools()
         toolset_names = {t.name for t in tools}
         for name in HERMES_TOOLS:
@@ -364,7 +376,7 @@ async def test_hermes_toolset_tools(client: AsyncOpenReward, server: str):
 async def test_hermes_terminal_routes_to_sandbox(client: AsyncOpenReward, server: str):
     env = client.environments.get("envwithsandbox", variant="envwithsandbox", base_url=server)
     tasks = await env.list_tasks(split="train")
-    async with env.session(tasks[0], toolset="hermes") as session:
+    async with env.session(tasks[0], toolset="hermes-sandboxed") as session:
         result = await session.call_tool("terminal", {"command": "echo hi"})
         assert "ran: echo hi" in result.blocks[0].text
 
@@ -373,7 +385,7 @@ async def test_hermes_terminal_routes_to_sandbox(client: AsyncOpenReward, server
 async def test_hermes_write_then_read_roundtrip(client: AsyncOpenReward, server: str):
     env = client.environments.get("envwithsandbox", variant="envwithsandbox", base_url=server)
     tasks = await env.list_tasks(split="train")
-    async with env.session(tasks[0], toolset="hermes") as session:
+    async with env.session(tasks[0], toolset="hermes-sandboxed") as session:
         await session.call_tool("write_file", {"path": "/tmp/hm.txt", "content": "hello hermes"})
         result = await session.call_tool("read_file", {"path": "/tmp/hm.txt"})
         # Hermes read_file uses LINE_NUM|CONTENT format
@@ -381,11 +393,21 @@ async def test_hermes_write_then_read_roundtrip(client: AsyncOpenReward, server:
         assert "1|" in result.blocks[0].text
 
 
+@pytest.mark.asyncio
+async def test_hermes_search_files_content(client: AsyncOpenReward, server: str):
+    env = client.environments.get("envwithsandbox", variant="envwithsandbox", base_url=server)
+    tasks = await env.list_tasks(split="train")
+    async with env.session(tasks[0], toolset="hermes-sandboxed") as session:
+        result = await session.call_tool("search_files", {"pattern": "hello", "path": "/tmp"})
+        # search_files runs grep under the hood; mock sandbox returns "ran: ..."
+        assert result.blocks[0].text is not None
+
+
 @pytest.mark.asyncio
 async def test_hermes_patch_replace_mode(client: AsyncOpenReward, server: str):
     env = client.environments.get("envwithsandbox", variant="envwithsandbox", base_url=server)
     tasks = await env.list_tasks(split="train")
-    async with env.session(tasks[0], toolset="hermes") as session:
+    async with env.session(tasks[0], toolset="hermes-sandboxed") as session:
         await session.call_tool("write_file", {"path": "/tmp/hm_patch.txt", "content": "foo bar baz"})
         result = await session.call_tool("patch", {
             "mode": "replace",

openreward-0.1.95.dev0/openreward/toolsets/openclaw.py

@@ -1,222 +0,0 @@
-"""OpenClaw session toolset.
-
-Provides the four built-in tools that OpenClaw exposes for coding tasks
-(``exec``, ``read``, ``write``, ``edit``), each backed by ``self.sandbox``
-from the bound environment.
-
-Tool names, parameter schemas, and descriptions match OpenClaw's upstream
-TypeBox definitions (``@mariozechner/pi-coding-agent``).
-"""
-from __future__ import annotations
-
-import base64
-import os
-from typing import Any, List, Optional
-
-from pydantic import BaseModel, Field
-
-from openreward.environments.environment import tool
-from openreward.environments.toolset import Toolset
-from openreward.environments.types import TextBlock, ToolOutput
-
-
-# ── Sandbox text helpers (inlined; same as claude_code.py) ──
-
-async def _download_text(sandbox: Any, path: str) -> str:
-    data = await sandbox.download(path)
-    return data.decode("utf-8")
-
-
-async def _upload_text(
-    sandbox: Any,
-    path: str,
-    content: str,
-    ensure_trailing_newline: bool = True,
-) -> None:
-    if ensure_trailing_newline and not content.endswith("\n"):
-        content = content + "\n"
-    encoded = base64.b64encode(content.encode("utf-8")).decode("ascii")
-    await sandbox.check_run(f"echo '{encoded}' | base64 -d > {path}")
-
-
-# ── Pydantic parameter models ──
-
-class ExecParams(BaseModel, extra="forbid"):
-    command: str
-    timeout: Optional[float] = 1800.0
-
-
-class ReadParams(BaseModel, extra="forbid"):
-    path: str
-    offset: Optional[int] = None
-    limit: Optional[int] = None
-
-
-class WriteParams(BaseModel, extra="forbid"):
-    path: str
-    content: str
-
-
-class EditItem(BaseModel, extra="forbid"):
-    oldText: str
-    newText: str
-
-
-class EditParams(BaseModel, extra="forbid"):
-    path: str
-    edits: List[EditItem]
-
-
-# ── Tool descriptions (matching OpenClaw TypeBox style) ──
-
-EXEC_DESCRIPTION = """\
-Execute a shell command and return its output and exit code. \
-Set timeout in seconds (default 1800). \
-Use for builds, installs, git, processes, scripts, network, package managers, \
-and anything that needs a shell."""
-
-READ_DESCRIPTION = """\
-Read the contents of a file at the given path. \
-Supports optional offset (1-indexed line number to start from) and limit \
-(maximum number of lines to read) for pagination of large files."""
-
-WRITE_DESCRIPTION = """\
-Write content to a file, creating it if it doesn't exist or overwriting if it does. \
-Creates parent directories automatically. \
-Use the edit tool for targeted modifications to existing files."""
-
-EDIT_DESCRIPTION = """\
-Apply one or more targeted text replacements to a file. \
-Each edit specifies an oldText to find and a newText to replace it with. \
-oldText must be unique in the file for each edit."""
-
-
-# ── Toolset ──
-
-class OpenClawToolset(Toolset):
-    """Session toolset exposing the OpenClaw four-tool coding surface.
-
-    The toolset is bound to a session by passing it to ``env.session(...)``::
-
-        with env.session(task=task, toolset="openclaw") as session:
-            session.call_tool("exec", {"command": "ls"})
-
-    Requires the bound environment to define ``self.sandbox``.
-    """
-
-    @classmethod
-    def name(cls) -> str:
-        return "openclaw"
-
-    @tool
-    async def exec(self, params: ExecParams) -> ToolOutput:
-        try:
-            output, code = await self.sandbox.run(params.command.strip())
-            return ToolOutput(
-                blocks=[TextBlock(text=f"{output}\n\n(exit {code})")],
-                metadata={"output": output, "exit_code": code},
-                reward=0.0,
-                finished=False,
-            )
-        except Exception as e:
-            return ToolOutput(
-                metadata={"error": str(e)},
-                blocks=[TextBlock(text=f"Error executing command: {str(e)}")],
-                finished=False,
-            )
-
-    @tool
-    async def read(self, params: ReadParams) -> ToolOutput:
-        try:
-            content = await _download_text(self.sandbox, params.path)
-            lines = content.splitlines()
-
-            if params.offset is not None or params.limit is not None:
-                start = (params.offset or 1) - 1  # Convert 1-indexed to 0-indexed
-                if params.limit is not None:
-                    lines = lines[start:start + params.limit]
-                else:
-                    lines = lines[start:]
-
-            output = "\n".join(lines)
-            return ToolOutput(
-                metadata={"output": output, "exit_code": 0},
-                blocks=[TextBlock(text=output)],
-                reward=0.0,
-                finished=False,
-            )
-        except Exception as e:
-            return ToolOutput(
-                metadata={"error": str(e)},
-                blocks=[TextBlock(text=f"Error reading file: {str(e)}")],
-                finished=False,
-            )
-
-    @tool
-    async def write(self, params: WriteParams) -> ToolOutput:
-        try:
-            dir_name = os.path.dirname(params.path)
-            if dir_name:
-                await self.sandbox.run(f"mkdir -p {dir_name}")
-            await _upload_text(
-                self.sandbox,
-                params.path,
-                params.content,
-                ensure_trailing_newline=True,
-            )
-            return ToolOutput(
-                metadata={"output": "", "exit_code": 0},
-                blocks=[TextBlock(text=f"Successfully wrote to {params.path}")],
-                reward=0.0,
-                finished=False,
-            )
-        except Exception as e:
-            return ToolOutput(
-                metadata={"error": str(e)},
-                blocks=[TextBlock(text=f"Error writing file: {str(e)}")],
-                finished=False,
-            )
-
-    @tool
-    async def edit(self, params: EditParams) -> ToolOutput:
-        try:
-            content = await _download_text(self.sandbox, params.path)
-
-            for item in params.edits:
-                count = content.count(item.oldText)
-                if count == 0:
-                    return ToolOutput(
-                        metadata={"error": f"oldText not found in {params.path}"},
-                        blocks=[TextBlock(text=f"Error: oldText not found in {params.path}: {item.oldText[:100]}")],
-                        finished=False,
-                    )
-                if count > 1:
-                    return ToolOutput(
-                        metadata={"error": f"oldText appears {count} times; must be unique"},
-                        blocks=[TextBlock(text=f"Error: oldText appears {count} times in {params.path}. Must be unique.")],
-                        finished=False,
-                    )
-                content = content.replace(item.oldText, item.newText, 1)
-
-            await _upload_text(self.sandbox, params.path, content, ensure_trailing_newline=True)
-
-            return ToolOutput(
-                metadata={"output": "", "exit_code": 0},
-                blocks=[TextBlock(text=f"Successfully edited {params.path}")],
-                reward=0.0,
-                finished=False,
-            )
-        except Exception as e:
-            return ToolOutput(
-                metadata={"error": str(e)},
-                blocks=[TextBlock(text=f"Error editing file: {str(e)}")],
-                finished=False,
-            )
-
-
-# Assign descriptions onto each tool method's __doc__ so the framework's
-# introspection picks them up.
-OpenClawToolset.exec.__doc__ = EXEC_DESCRIPTION
-OpenClawToolset.read.__doc__ = READ_DESCRIPTION
-OpenClawToolset.write.__doc__ = WRITE_DESCRIPTION
-OpenClawToolset.edit.__doc__ = EDIT_DESCRIPTION