openreward 0.1.96.dev0__tar.gz → 0.1.96.dev2__tar.gz

{openreward-0.1.96.dev0 → openreward-0.1.96.dev2}/PKG-INFO

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

{openreward-0.1.96.dev0 → openreward-0.1.96.dev2}/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"]
+_VALID_BUILTIN_TOOLSETS = {"claude-code", "codex"}
 from .types import (
     ImageBlock,
     JSONObject,

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

@@ -1,11 +1,9 @@
 """Hermes Agent 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.
-
-Tool names, parameter schemas, and descriptions match Hermes Agent's upstream
-registry definitions (``nousresearch/hermes-agent``).
+Provides the five built-in coding tools Hermes Agent exposes
+(``terminal``, ``read_file``, ``write_file``, ``search_files``, ``patch``).
+Tool names, parameter schemas, and descriptions match Hermes Agent's
+upstream registry definitions (``nousresearch/hermes-agent``).
 """
 from __future__ import annotations
 
@@ -20,8 +18,6 @@ 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")
@@ -57,6 +53,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 +73,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 +97,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.
 
@@ -102,10 +121,12 @@ Include enough surrounding context to ensure uniqueness."""
 # ── Toolset ──
 
 class HermesToolset(Toolset):
-    """Session toolset exposing the Hermes Agent four-tool coding surface.
+    """Session toolset exposing the Hermes Agent five-tool coding surface.
 
     The toolset is bound to a session by passing it to ``env.session(...)``::
 
+        from openreward.toolsets import HermesToolset
+
         with env.session(task=task, toolset="hermes") as session:
             session.call_tool("terminal", {"command": "ls"})
 
@@ -139,15 +160,11 @@ class HermesToolset(Toolset):
             content = await _download_text(self.sandbox, params.path)
             lines = content.splitlines()
 
-            # Apply offset (1-indexed) and limit
             start = max(0, params.offset - 1)
             end = start + params.limit
             selected_lines = lines[start:end]
 
-            # Format as LINE_NUM|CONTENT (Hermes native format)
-            output_lines = []
-            for i, line in enumerate(selected_lines, start=start + 1):
-                output_lines.append(f"{i}|{line}")
+            output_lines = [f"{i}|{line}" for i, line in enumerate(selected_lines, start=start + 1)]
             output = "\n".join(output_lines)
 
             return ToolOutput(
@@ -188,6 +205,66 @@ class HermesToolset(Toolset):
                 finished=False,
             )
 
+    @tool
+    async def search_files(self, params: SearchFilesParams) -> ToolOutput:
+        try:
+            if params.target == "files":
+                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,
+                    )
+                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:
+                glob_flag = f" --include='{params.file_glob}'" if params.file_glob else ""
+                context_flag = f" -C {params.context}" if params.context > 0 else ""
+
+                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,
+                    )
+
+                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":
@@ -202,7 +279,6 @@ class HermesToolset(Toolset):
             )
 
     async def _patch_replace(self, params: PatchParams) -> ToolOutput:
-        """Replace mode: find a unique string and replace it."""
         try:
             if not params.path or params.old_string is None or params.new_string is None:
                 return ToolOutput(
@@ -248,7 +324,6 @@ class HermesToolset(Toolset):
             )
 
     async def _patch_v4a(self, params: PatchParams) -> ToolOutput:
-        """Patch mode: apply V4A multi-file patch content."""
         try:
             if not params.patch:
                 return ToolOutput(
@@ -257,14 +332,11 @@ class HermesToolset(Toolset):
                     finished=False,
                 )
 
-            # Upload patch content to a temp file and apply via patch command
             patch_tmp = "/tmp/_hermes_patch.diff"
             await _upload_text(self.sandbox, patch_tmp, params.patch, ensure_trailing_newline=True)
 
-            # Try applying as a unified diff first
             output, code = await self.sandbox.run(f"patch -p1 < {patch_tmp}")
             if code != 0:
-                # Clean up and report
                 await self.sandbox.run(f"rm -f {patch_tmp}")
                 return ToolOutput(
                     metadata={"error": output, "exit_code": code},
@@ -287,9 +359,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.search_files.__doc__ = SEARCH_FILES_DESCRIPTION
 HermesToolset.patch.__doc__ = PATCH_DESCRIPTION

{openreward-0.1.96.dev0 → openreward-0.1.96.dev2}/openreward/toolsets/openclaw.py

@@ -1,11 +1,9 @@
 """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``).
+Provides the six built-in coding tools OpenClaw exposes
+(``exec``, ``process``, ``read``, ``write``, ``edit``, ``apply_patch``).
+Tool names, parameter schemas, and descriptions match OpenClaw's
+upstream definitions.
 """
 from __future__ import annotations
 
@@ -13,15 +11,13 @@ import base64
 import os
 from typing import Any, List, Optional
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel
 
 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")
@@ -67,7 +63,20 @@ class EditParams(BaseModel, extra="forbid"):
     edits: List[EditItem]
 
 
-# ── Tool descriptions (matching OpenClaw TypeBox style) ──
+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. \
@@ -90,14 +99,36 @@ 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 OpenClawToolset(Toolset):
-    """Session toolset exposing the OpenClaw four-tool coding surface.
+    """Session toolset exposing the OpenClaw six-tool coding surface.
 
     The toolset is bound to a session by passing it to ``env.session(...)``::
 
+        from openreward.toolsets import OpenClawToolset
+
         with env.session(task=task, toolset="openclaw") as session:
             session.call_tool("exec", {"command": "ls"})
 
@@ -125,6 +156,80 @@ class OpenClawToolset(Toolset):
                 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"):
+                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 ""
+                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:
@@ -132,7 +237,7 @@ class OpenClawToolset(Toolset):
             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
+                start = (params.offset or 1) - 1
                 if params.limit is not None:
                     lines = lines[start:start + params.limit]
                 else:
@@ -213,10 +318,39 @@ class OpenClawToolset(Toolset):
                 finished=False,
             )
 
+    @tool
+    async def apply_patch(self, params: ApplyPatchParams) -> ToolOutput:
+        try:
+            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.
 OpenClawToolset.exec.__doc__ = EXEC_DESCRIPTION
+OpenClawToolset.process.__doc__ = PROCESS_DESCRIPTION
 OpenClawToolset.read.__doc__ = READ_DESCRIPTION
 OpenClawToolset.write.__doc__ = WRITE_DESCRIPTION
 OpenClawToolset.edit.__doc__ = EDIT_DESCRIPTION
+OpenClawToolset.apply_patch.__doc__ = APPLY_PATCH_DESCRIPTION

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

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

{openreward-0.1.96.dev0 → openreward-0.1.96.dev2}/pyproject.toml

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

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

@@ -283,117 +283,3 @@ async def test_session_toolset_warns_on_shadow(monkeypatch):
     call_warnings = [e for e in captured if e[0] == "session_toolset_shadows_env_tool"]
     assert len(call_warnings) == 1
     assert call_warnings[0][1]["tool"] == "bash"
-
-
-# ── OpenClaw toolset ──
-
-OPENCLAW_TOOLS = {"exec", "read", "write", "edit"}
-
-
-@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:
-        tools = await session.list_tools()
-        toolset_names = {t.name for t in tools}
-        for name in OPENCLAW_TOOLS:
-            assert name in toolset_names, f"missing tool {name}"
-        # Env's submit tool is preserved.
-        assert "submit" in toolset_names
-        # exec description matches OpenClaw style.
-        exec_spec = next(t for t in tools if t.name == "exec")
-        assert exec_spec.description.startswith("Execute a shell command")
-
-
-@pytest.mark.asyncio
-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:
-        result = await session.call_tool("exec", {"command": "echo hi"})
-        assert "ran: echo hi" in result.blocks[0].text
-
-
-@pytest.mark.asyncio
-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:
-        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
-
-
-@pytest.mark.asyncio
-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:
-        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",
-            "edits": [{"oldText": "bar", "newText": "qux"}],
-        })
-        assert "Successfully edited" in result.blocks[0].text
-        read_result = await session.call_tool("read", {"path": "/tmp/oc_edit.txt"})
-        assert "qux" in read_result.blocks[0].text
-        assert "bar" not in read_result.blocks[0].text
-
-
-# ── Hermes toolset ──
-
-HERMES_TOOLS = {"terminal", "read_file", "write_file", "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:
-        tools = await session.list_tools()
-        toolset_names = {t.name for t in tools}
-        for name in HERMES_TOOLS:
-            assert name in toolset_names, f"missing tool {name}"
-        assert "submit" in toolset_names
-        terminal_spec = next(t for t in tools if t.name == "terminal")
-        assert terminal_spec.description.startswith("Execute shell commands")
-
-
-@pytest.mark.asyncio
-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:
-        result = await session.call_tool("terminal", {"command": "echo hi"})
-        assert "ran: echo hi" in result.blocks[0].text
-
-
-@pytest.mark.asyncio
-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:
-        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
-        assert "hello hermes" in result.blocks[0].text
-        assert "1|" in result.blocks[0].text
-
-
-@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:
-        await session.call_tool("write_file", {"path": "/tmp/hm_patch.txt", "content": "foo bar baz"})
-        result = await session.call_tool("patch", {
-            "mode": "replace",
-            "path": "/tmp/hm_patch.txt",
-            "old_string": "bar",
-            "new_string": "qux",
-        })
-        assert "Successfully patched" in result.blocks[0].text
-        read_result = await session.call_tool("read_file", {"path": "/tmp/hm_patch.txt"})
-        assert "qux" in read_result.blocks[0].text
-        assert "bar" not in read_result.blocks[0].text

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

@@ -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,
+    OpenClawToolset.name(): OpenClawToolset,
 }
 
 __all__ = [