feat: add nemotron tool preset (bash + str_replace aliases for Anthropic schema compatibility)

Add a new 'nemotron' tool preset for Nemotron-3 Super (nvidia/nemotron-3-super-120b-a12b)
which was fine-tuned on trajectories using Anthropic's tool schema. The preset exposes:

- BashTool: A tool named 'bash' (instead of 'terminal') that wraps TerminalExecutor
- StrReplaceTool: A tool named 'str_replace' (instead of 'file_editor') that wraps
  FileEditorExecutor

This fixes the 63-67% conversation error rate observed in Nemotron evaluations,
caused entirely by tool name mismatches where the model called tools like 'bash',
'str_replace', 'command', 'execute' that don't exist in the default OpenHands schema.

New files:
- openhands-tools/openhands/tools/nemotron/bash/ - BashTool implementation
- openhands-tools/openhands/tools/nemotron/str_replace/ - StrReplaceTool implementation
- openhands-tools/openhands/tools/preset/nemotron.py - Preset configuration
- tests/tools/nemotron/ - Test coverage for new tools and preset

Exports added:
- get_nemotron_agent, get_nemotron_tools from openhands.tools.preset

Fixes #2553

Co-authored-by: openhands <openhands@all-hands.dev>

Author: openhands-agent

openhands-tools/openhands/tools/nemotron/__init__.py

@@ -0,0 +1,73 @@
+"""Nemotron-compatible tools (Anthropic bash/str_replace schema).
+
+Nemotron-3 Super (nvidia/nemotron-3-super-120b-a12b) was fine-tuned on
+trajectories that use the Anthropic str_replace_based_edit_tool / bash
+tool schema. This module exposes those exact tool names so the model's
+calls succeed without any prompt engineering or model-side changes.
+
+  bash        → BashExecutor        (model calls "bash", not "terminal")
+  str_replace → StrReplaceExecutor  (model calls "str_replace", not "file_editor")
+
+Tools:
+    - bash: Run shell commands (Anthropic-compatible)
+    - str_replace: File viewing and editing operations (Anthropic-compatible)
+
+Usage:
+    To use Nemotron-compatible tools instead of the standard terminal/file_editor:
+
+    ```python
+    from openhands.tools.nemotron import NEMOTRON_TOOLS
+
+    agent = Agent(
+        llm=llm,
+        tools=[
+            *NEMOTRON_TOOLS,
+            Tool(name=TaskTrackerTool.name),
+        ],
+    )
+    ```
+
+    Or use the preset:
+
+    ```python
+    from openhands.tools.preset.nemotron import get_nemotron_agent
+
+    agent = get_nemotron_agent(llm=llm)
+    ```
+"""
+
+from openhands.sdk import Tool
+from openhands.tools.nemotron.bash import (
+    BashAction,
+    BashExecutor,
+    BashObservation,
+    BashTool,
+)
+from openhands.tools.nemotron.str_replace import (
+    StrReplaceAction,
+    StrReplaceExecutor,
+    StrReplaceObservation,
+    StrReplaceTool,
+)
+
+
+# Convenience list for easy replacement of terminal/file_editor tools
+NEMOTRON_TOOLS: list[Tool] = [
+    Tool(name=BashTool.name),
+    Tool(name=StrReplaceTool.name),
+]
+
+__all__ = [
+    # Convenience list
+    "NEMOTRON_TOOLS",
+    # Bash tool
+    "BashTool",
+    "BashAction",
+    "BashObservation",
+    "BashExecutor",
+    # StrReplace tool
+    "StrReplaceTool",
+    "StrReplaceAction",
+    "StrReplaceObservation",
+    "StrReplaceExecutor",
+]

openhands-tools/openhands/tools/nemotron/bash/__init__.py

@@ -0,0 +1,15 @@
+# Core tool interface
+from openhands.tools.nemotron.bash.definition import (
+    BashAction,
+    BashObservation,
+    BashTool,
+)
+from openhands.tools.nemotron.bash.impl import BashExecutor
+
+
+__all__ = [
+    "BashTool",
+    "BashAction",
+    "BashObservation",
+    "BashExecutor",
+]

openhands-tools/openhands/tools/nemotron/bash/definition.py

@@ -0,0 +1,253 @@
+"""Bash tool definition (Nemotron/Anthropic-compatible).
+
+This is a thin wrapper around TerminalExecutor that exposes the tool as "bash"
+instead of "terminal", matching Anthropic's bash tool schema exactly.
+"""
+
+import os
+from collections.abc import Sequence
+from typing import TYPE_CHECKING
+
+from pydantic import Field
+from rich.text import Text
+
+from openhands.sdk.tool import (
+    Action,
+    Observation,
+    ToolAnnotations,
+    ToolDefinition,
+    register_tool,
+)
+from openhands.tools.terminal.constants import (
+    MAX_CMD_OUTPUT_SIZE,
+    NO_CHANGE_TIMEOUT_SECONDS,
+)
+from openhands.tools.terminal.metadata import CmdOutputMetadata
+
+
+if TYPE_CHECKING:
+    from openhands.sdk.conversation.state import ConversationState
+
+from openhands.sdk.llm import ImageContent, TextContent
+from openhands.sdk.utils import maybe_truncate
+
+
+class BashAction(Action):
+    """Schema for bash command execution (Anthropic-compatible).
+
+    This matches the Anthropic bash tool schema exactly:
+    - command: str (required)
+    """
+
+    command: str = Field(
+        description=(
+            "The bash command to execute. Can be empty string to view additional "
+            "logs when previous exit code is `-1`. Can be `C-c` (Ctrl+C) to "
+            "interrupt the currently running process. Note: You can only execute "
+            "one bash command at a time. If you need to run multiple commands "
+            "sequentially, you can use `&&` or `;` to chain them together."
+        )
+    )
+
+    @property
+    def visualize(self) -> Text:
+        """Return Rich Text representation with PS1-style bash prompt."""
+        content = Text()
+        content.append("$ ", style="bold green")
+        if self.command:
+            content.append(self.command, style="white")
+        else:
+            content.append("[empty command]", style="italic")
+        return content
+
+
+class BashObservation(Observation):
+    """A ToolResult that can be rendered as a CLI output."""
+
+    command: str | None = Field(
+        description=(
+            "The bash command that was executed. Can be empty string if the "
+            "observation is from a previous command that hit soft timeout and "
+            "is not yet finished."
+        ),
+    )
+    exit_code: int | None = Field(
+        default=None,
+        description=(
+            "The exit code of the command. -1 indicates the process hit the "
+            "soft timeout and is not yet finished."
+        ),
+    )
+    timeout: bool = Field(
+        default=False, description="Whether the command execution timed out."
+    )
+    metadata: CmdOutputMetadata = Field(
+        default_factory=CmdOutputMetadata,
+        description="Additional metadata captured from PS1 after command execution.",
+    )
+    full_output_save_dir: str | None = Field(
+        default=None,
+        description="Directory where full output files are saved",
+    )
+
+    @property
+    def command_id(self) -> int | None:
+        """Get the command ID from metadata."""
+        return self.metadata.pid
+
+    @property
+    def to_llm_content(self) -> Sequence[TextContent | ImageContent]:
+        llm_content: list[TextContent | ImageContent] = []
+
+        if self.is_error:
+            llm_content.append(TextContent(text=self.ERROR_MESSAGE_HEADER))
+
+        content_text = self.text
+
+        ret = f"{self.metadata.prefix}{content_text}{self.metadata.suffix}"
+        if self.metadata.working_dir:
+            ret += f"\n[Current working directory: {self.metadata.working_dir}]"
+        if self.metadata.py_interpreter_path:
+            ret += f"\n[Python interpreter: {self.metadata.py_interpreter_path}]"
+        if self.metadata.exit_code != -1:
+            ret += f"\n[Command finished with exit code {self.metadata.exit_code}]"
+
+        truncated_text = maybe_truncate(
+            content=ret,
+            truncate_after=MAX_CMD_OUTPUT_SIZE,
+            save_dir=self.full_output_save_dir,
+            tool_prefix="bash",
+        )
+        llm_content.append(TextContent(text=truncated_text))
+
+        return llm_content
+
+    @property
+    def visualize(self) -> Text:
+        """Return Rich Text representation with terminal-style output formatting."""
+        text = Text()
+
+        if self.is_error:
+            text.append("❌ ", style="red bold")
+            text.append(self.ERROR_MESSAGE_HEADER, style="bold red")
+
+        content_text = self.text
+
+        if content_text:
+            output_lines = content_text.split("\n")
+            for line in output_lines:
+                if line.strip():
+                    if any(
+                        keyword in line.lower()
+                        for keyword in ["error", "failed", "exception", "traceback"]
+                    ):
+                        text.append(line, style="red")
+                    elif any(
+                        keyword in line.lower() for keyword in ["warning", "warn"]
+                    ):
+                        text.append(line, style="yellow")
+                    elif line.startswith("+ "):
+                        text.append(line, style="cyan")
+                    else:
+                        text.append(line, style="white")
+                text.append("\n")
+
+        if hasattr(self, "metadata") and self.metadata:
+            if self.metadata.working_dir:
+                text.append("\n📁 ", style="blue")
+                text.append(
+                    f"Working directory: {self.metadata.working_dir}", style="blue"
+                )
+
+            if self.metadata.py_interpreter_path:
+                text.append("\n🐍 ", style="green")
+                text.append(
+                    f"Python interpreter: {self.metadata.py_interpreter_path}",
+                    style="green",
+                )
+
+            if (
+                hasattr(self.metadata, "exit_code")
+                and self.metadata.exit_code is not None
+            ):
+                if self.metadata.exit_code == 0:
+                    text.append("\n✅ ", style="green")
+                    text.append(f"Exit code: {self.metadata.exit_code}", style="green")
+                elif self.metadata.exit_code == -1:
+                    text.append("\n⏳ ", style="yellow")
+                    text.append("Process still running (soft timeout)", style="yellow")
+                else:
+                    text.append("\n❌ ", style="red")
+                    text.append(f"Exit code: {self.metadata.exit_code}", style="red")
+
+        return text
+
+
+TOOL_DESCRIPTION = f"""Run a shell command and return stdout/stderr.
+
+### Command Execution
+* One command at a time: You can only execute one bash command at a time. \
+If you need to run multiple commands sequentially, use `&&` or `;` to chain \
+them together.
+* Persistent session: Commands execute in a persistent shell session where \
+environment variables, virtual environments, and working directory persist \
+between commands.
+* Soft timeout: Commands have a soft timeout of {NO_CHANGE_TIMEOUT_SECONDS} \
+seconds, once that's reached, you have the option to continue or interrupt the \
+command.
+
+### Long-running Commands
+* For commands that may run indefinitely, run them in the background and \
+redirect output to a file, e.g. `python3 app.py > server.log 2>&1 &`.
+* If a bash command returns exit code `-1`, this means the process hit the \
+soft timeout and is not yet finished. Send empty `command` to retrieve \
+additional logs or send `C-c` to interrupt.
+
+### Output Handling
+* Output truncation: If the output exceeds a maximum length, it will be \
+truncated before being returned.
+"""
+
+
+class BashTool(ToolDefinition[BashAction, BashObservation]):
+    """Bash tool (Anthropic-compatible) that wraps TerminalExecutor."""
+
+    @classmethod
+    def create(
+        cls,
+        conv_state: "ConversationState",
+    ) -> Sequence["BashTool"]:
+        """Initialize BashTool with executor parameters.
+
+        Args:
+            conv_state: Conversation state to get working directory from.
+        """
+        from openhands.tools.nemotron.bash.impl import BashExecutor
+
+        working_dir = conv_state.workspace.working_dir
+        if not os.path.isdir(working_dir):
+            raise ValueError(f"working_dir '{working_dir}' is not a valid directory")
+
+        executor = BashExecutor(
+            working_dir=working_dir,
+            full_output_save_dir=conv_state.env_observation_persistence_dir,
+        )
+
+        return [
+            cls(
+                action_type=BashAction,
+                observation_type=BashObservation,
+                description=TOOL_DESCRIPTION,
+                annotations=ToolAnnotations(
+                    title="bash",
+                    readOnlyHint=False,
+                    destructiveHint=True,
+                    idempotentHint=False,
+                    openWorldHint=True,
+                ),
+                executor=executor,
+            )
+        ]
+
+
+register_tool(BashTool.name, BashTool)