openreward 0.1.96.dev1__tar.gz → 0.1.96.dev2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openreward
-Version: 0.1.96.dev1
+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.dev1 → 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-sandboxed", "hermes-sandboxed"]
-_VALID_BUILTIN_TOOLSETS = {"claude-code", "codex", "openclaw-sandboxed", "hermes-sandboxed"}
+BuiltinToolset = Literal["claude-code", "codex"]
+_VALID_BUILTIN_TOOLSETS = {"claude-code", "codex"}
 from .types import (
     ImageBlock,
     JSONObject,

{openreward-0.1.96.dev1 → openreward-0.1.96.dev2}/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 HermesSandboxedToolset
-from .openclaw import OpenClawSandboxedToolset
+from .hermes import HermesToolset
+from .openclaw import OpenClawToolset
 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,
-    OpenClawSandboxedToolset.name(): OpenClawSandboxedToolset,
-    HermesSandboxedToolset.name(): HermesSandboxedToolset,
+    HermesToolset.name(): HermesToolset,
+    OpenClawToolset.name(): OpenClawToolset,
 }
 
 __all__ = [
@@ -27,8 +27,8 @@ __all__ = [
     "ClaudeCodeToolset",
     "CodexToolset",
     "ExcelToolset",
-    "HermesSandboxedToolset",
-    "OpenClawSandboxedToolset",
+    "HermesToolset",
+    "OpenClawToolset",
     "PowerPointToolset",
     "WordToolset",
     "PDFToolset",

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

@@ -1,23 +1,15 @@
-"""Hermes Agent sandboxed session toolset.
+"""Hermes Agent session toolset.
 
-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``).
+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
 
 import base64
 import os
-from typing import Any, List, Optional
+from typing import Any, Optional
 
 from pydantic import BaseModel
 
@@ -26,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")
@@ -130,12 +120,14 @@ Include enough surrounding context to ensure uniqueness."""
 
 # ── Toolset ──
 
-class HermesSandboxedToolset(Toolset):
-    """Sandboxed session toolset exposing the Hermes Agent five-tool coding surface.
+class HermesToolset(Toolset):
+    """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-sandboxed") as session:
+        from openreward.toolsets import HermesToolset
+
+        with env.session(task=task, toolset="hermes") as session:
             session.call_tool("terminal", {"command": "ls"})
 
     Requires the bound environment to define ``self.sandbox``.
@@ -143,7 +135,7 @@ class HermesSandboxedToolset(Toolset):
 
     @classmethod
     def name(cls) -> str:
-        return "hermes-sandboxed"
+        return "hermes"
 
     @tool
     async def terminal(self, params: TerminalParams) -> ToolOutput:
@@ -168,15 +160,11 @@ class HermesSandboxedToolset(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(
@@ -221,7 +209,6 @@ class HermesSandboxedToolset(Toolset):
     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:
@@ -230,7 +217,6 @@ class HermesSandboxedToolset(Toolset):
                         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)
@@ -241,14 +227,8 @@ class HermesSandboxedToolset(Toolset):
                     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}"
+                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"
@@ -268,7 +248,6 @@ class HermesSandboxedToolset(Toolset):
                         finished=False,
                     )
 
-                # Apply offset/limit to results
                 lines = output.splitlines()
                 lines = lines[params.offset:params.offset + params.limit]
                 result = "\n".join(lines)
@@ -300,7 +279,6 @@ class HermesSandboxedToolset(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(
@@ -346,7 +324,6 @@ class HermesSandboxedToolset(Toolset):
             )
 
     async def _patch_v4a(self, params: PatchParams) -> ToolOutput:
-        """Patch mode: apply V4A multi-file patch content."""
         try:
             if not params.patch:
                 return ToolOutput(
@@ -355,14 +332,11 @@ class HermesSandboxedToolset(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},
@@ -385,10 +359,8 @@ class HermesSandboxedToolset(Toolset):
             )
 
 
-# Assign descriptions onto each tool method's __doc__ so the framework's
-# introspection picks them up.
-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
+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.dev1 → openreward-0.1.96.dev2}/openreward/toolsets/openclaw.py

@@ -1,17 +1,9 @@
-"""OpenClaw sandboxed session toolset.
+"""OpenClaw 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.
+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
 
@@ -19,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")
@@ -132,12 +122,14 @@ operations: '*** Add File:', '*** Update File:' (with optional '*** Move to:'),
 
 # ── Toolset ──
 
-class OpenClawSandboxedToolset(Toolset):
-    """Sandboxed session toolset exposing the OpenClaw six-tool coding surface.
+class OpenClawToolset(Toolset):
+    """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:
+        from openreward.toolsets import OpenClawToolset
+
+        with env.session(task=task, toolset="openclaw") as session:
             session.call_tool("exec", {"command": "ls"})
 
     Requires the bound environment to define ``self.sandbox``.
@@ -145,7 +137,7 @@ class OpenClawSandboxedToolset(Toolset):
 
     @classmethod
     def name(cls) -> str:
-        return "openclaw-sandboxed"
+        return "openclaw"
 
     @tool
     async def exec(self, params: ExecParams) -> ToolOutput:
@@ -187,7 +179,6 @@ class OpenClawSandboxedToolset(Toolset):
                 )
 
             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:
@@ -204,7 +195,6 @@ class OpenClawSandboxedToolset(Toolset):
 
             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"
                 )
@@ -247,7 +237,7 @@ class OpenClawSandboxedToolset(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:
@@ -331,7 +321,6 @@ class OpenClawSandboxedToolset(Toolset):
     @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)
 
@@ -359,11 +348,9 @@ class OpenClawSandboxedToolset(Toolset):
             )
 
 
-# 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
+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.dev1 → openreward-0.1.96.dev2}/openreward.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openreward
-Version: 0.1.96.dev1
+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.dev1 → openreward-0.1.96.dev2}/pyproject.toml

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

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

@@ -283,139 +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", "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-sandboxed") 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-sandboxed") 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-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
-
-
-@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-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",
-            "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
-
-
-@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", "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-sandboxed") 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-sandboxed") 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-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
-        assert "hello hermes" in result.blocks[0].text
-        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-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",
-            "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