test(cli): Update tests for markdown rendering and agent message display

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

openhands/agenthub/codeact_agent/codeact_agent.py

@@ -106,10 +106,15 @@ class CodeActAgent(Agent):
     def _get_tools(self) -> list['ChatCompletionToolParam']:
         # For these models, we use short tool descriptions ( < 1024 tokens)
         # to avoid hitting the OpenAI token limit for tool descriptions.
-        SHORT_TOOL_DESCRIPTION_LLM_SUBSTRS = ['gpt-', 'o3', 'o1', 'o4']
+        SHORT_TOOL_DESCRIPTION_LLM_SUBSTRS = ['gpt-4', 'o3', 'o1', 'o4']
 
         use_short_tool_desc = False
         if self.llm is not None:
+            # For historical reasons, previously OpenAI enforces max function description length of 1k characters
+            # https://community.openai.com/t/function-call-description-max-length/529902
+            # But it no longer seems to be an issue recently
+            # https://community.openai.com/t/was-the-character-limit-for-schema-descriptions-upgraded/1225975
+            # Tested on GPT-5 and longer description still works. But we still keep the logic to be safe for older models.
             use_short_tool_desc = any(
                 model_substr in self.llm.config.model
                 for model_substr in SHORT_TOOL_DESCRIPTION_LLM_SUBSTRS

openhands/agenthub/codeact_agent/tools/bash.py

@@ -1,3 +1,4 @@
+import re
 import sys
 
 from litellm import ChatCompletionToolParam, ChatCompletionToolParamFunctionChunk
@@ -37,7 +38,16 @@ _SHORT_BASH_DESCRIPTION = """Execute a bash command in the terminal.
 
 def refine_prompt(prompt: str):
     if sys.platform == 'win32':
-        return prompt.replace('bash', 'powershell')
+        # Replace 'bash' with 'powershell' including tool names like 'execute_bash'
+        # First replace 'execute_bash' with 'execute_powershell' to handle tool names
+        result = re.sub(
+            r'\bexecute_bash\b', 'execute_powershell', prompt, flags=re.IGNORECASE
+        )
+        # Then replace standalone 'bash' with 'powershell'
+        result = re.sub(
+            r'(?<!execute_)(?<!_)\bbash\b', 'powershell', result, flags=re.IGNORECASE
+        )
+        return result
     return prompt
 
 

openhands/cli/main.py

@@ -739,19 +739,3 @@ def run_cli_command(args):
         except Exception as e:
             print_formatted_text(f'Error during cleanup: {e}')
             sys.exit(1)
-
-
-def main():
-    """Main entry point for OpenHands CLI."""
-    from openhands.core.config import get_cli_parser
-
-    parser = get_cli_parser()
-    args = parser.parse_args()
-
-    if hasattr(args, 'version') and args.version:
-        import openhands
-
-        print(f'OpenHands CLI version: {openhands.get_version()}')
-        sys.exit(0)
-
-    run_cli_command(args)

openhands/cli/tui.py

@@ -5,7 +5,9 @@
 import asyncio
 import contextlib
 import datetime
+import io
 import json
+import shutil
 import sys
 import threading
 import time
@@ -28,6 +30,8 @@ from prompt_toolkit.patch_stdout import patch_stdout
 from prompt_toolkit.shortcuts import print_container
 from prompt_toolkit.styles import Style
 from prompt_toolkit.widgets import Frame, TextArea
+from rich.console import Console
+from rich.markdown import Markdown
 
 from openhands import __version__
 from openhands.core.config import OpenHandsConfig
@@ -36,6 +40,7 @@ from openhands.events import EventSource, EventStream
 from openhands.events.action import (
     Action,
     ActionConfirmationStatus,
+    AgentFinishAction,
     ChangeAgentStateAction,
     CmdRunAction,
     MCPAction,
@@ -65,10 +70,12 @@ MAX_RECENT_THOUGHTS = 5
 # Color and styling constants
 COLOR_GOLD = '#FFD700'
 COLOR_GREY = '#808080'
+COLOR_AGENT_BLUE = '#5FAFFF'  # Soft blue for all agent outputs
 DEFAULT_STYLE = Style.from_dict(
     {
         'gold': COLOR_GOLD,
         'grey': COLOR_GREY,
+        'agent-blue': COLOR_AGENT_BLUE,
         'prompt': f'{COLOR_GOLD} bold',
     }
 )
@@ -252,7 +259,19 @@ def display_thought_if_new(thought: str) -> None:
 def display_event(event: Event, config: OpenHandsConfig) -> None:
     global streaming_output_text_area
     with print_lock:
-        if isinstance(event, CmdRunAction):
+        if isinstance(event, AgentFinishAction):
+            # Handle agent finish actions with special styling
+            # Determine the message to display
+            if event.final_thought:
+                message = event.final_thought
+            elif event.thought:
+                message = event.thought
+            else:
+                message = "All done! What's next on the agenda?"
+            
+            # Display with finish styling
+            display_agent_message(message, is_finish=True)
+        elif isinstance(event, CmdRunAction):
             # For CmdRunAction, display thought first, then command
             if hasattr(event, 'thought') and event.thought:
                 display_message(event.thought)
@@ -275,8 +294,8 @@ def display_event(event: Event, config: OpenHandsConfig) -> None:
 
         if isinstance(event, MessageAction):
             if event.source == EventSource.AGENT:
-                # Check if this message content is a duplicate thought
-                display_thought_if_new(event.content)
+                # Display agent messages with distinctive styling
+                display_agent_message(event.content)
         elif isinstance(event, CmdOutputObservation):
             display_command_output(event.content)
         elif isinstance(event, FileEditObservation):
@@ -291,6 +310,24 @@ def display_event(event: Event, config: OpenHandsConfig) -> None:
             display_error(event.content)
 
 
+def process_markdown_for_terminal(text: str) -> str:
+    """
+    Process markdown syntax for terminal display using Rich.
+    This function renders markdown as formatted text for the terminal.
+    """
+    if not text:
+        return text
+    
+    # Use Rich to render the markdown without width constraints
+    console = Console(file=io.StringIO(), highlight=False, width=None)
+    console.print(Markdown(text))
+    
+    # Get the rendered output
+    rendered_text = console.file.getvalue()  # type: ignore
+    
+    return rendered_text.strip()
+
+
 def display_message(message: str) -> None:
     message = message.strip()
 
@@ -298,6 +335,38 @@ def display_message(message: str) -> None:
         print_formatted_text(f'\n{message}')
 
 
+def display_agent_message(message: str, is_finish: bool = False) -> None:
+    """
+    Display a message from the agent with distinctive styling and markdown rendering.
+    
+    Args:
+        message: The message content to display
+        is_finish: Whether this is a finish message (changes the icon)
+    """
+    message = message.strip()
+
+    if message:
+        # Process markdown in the message
+        try:
+            # Process markdown for terminal display
+            processed_message = process_markdown_for_terminal(message)
+        except Exception:
+            # If markdown processing fails, use the original message
+            processed_message = message
+
+        # Choose the appropriate icon based on message type
+        icon = '🎯' if is_finish else '🔹'
+        header_text = 'Agent Finished' if is_finish else 'Agent Message'
+        
+        # Print a simple header
+        print_formatted_text(FormattedText([('fg:' + COLOR_AGENT_BLUE, f'\n{icon} {header_text}')]))
+        print_formatted_text('')
+        
+        # Print the message content directly without any wrapping constraints
+        print_formatted_text(FormattedText([('fg:' + COLOR_AGENT_BLUE, processed_message)]))
+        print_formatted_text('')
+
+
 def display_error(error: str) -> None:
     error = error.strip()
 

openhands/llm/fn_call_converter.py

@@ -383,7 +383,7 @@ Do NOT assume the environment is the same as in the example above.
 """
     example = example.lstrip()
 
-    return example
+    return refine_prompt(example)
 
 
 IN_CONTEXT_LEARNING_EXAMPLE_PREFIX = get_example_for_tools

openhands/utils/prompt.py

@@ -4,6 +4,7 @@ from itertools import islice
 
 from jinja2 import Template
 
+from openhands.agenthub.codeact_agent.tools.bash import refine_prompt
 from openhands.controller.state.state import State
 from openhands.core.message import Message, TextContent
 from openhands.events.observation.agent import MicroagentKnowledge
@@ -91,7 +92,8 @@ class PromptManager:
             return Template(file.read())
 
     def get_system_message(self) -> str:
-        return self.system_template.render().strip()
+        system_message = self.system_template.render().strip()
+        return refine_prompt(system_message)
 
     def get_example_user_message(self) -> str:
         """This is an initial user message that can be provided to the agent

poetry.lock

@@ -3770,6 +3770,22 @@ http2 = ["h2 (>=3,<5)"]
 socks = ["socksio (==1.*)"]
 zstd = ["zstandard (>=0.18.0)"]
 
+[[package]]
+name = "httpx-aiohttp"
+version = "0.1.8"
+description = "Aiohttp transport for HTTPX"
+optional = false
+python-versions = ">=3.8"
+groups = ["main"]
+files = [
+    {file = "httpx_aiohttp-0.1.8-py3-none-any.whl", hash = "sha256:b7bd958d1331f3759a38a0ba22ad29832cb63ca69498c17735228055bf78fa7e"},
+    {file = "httpx_aiohttp-0.1.8.tar.gz", hash = "sha256:756c5e74cdb568c3248ba63fe82bfe8bbe64b928728720f7eaac64b3cf46f308"},
+]
+
+[package.dependencies]
+aiohttp = ">=3.10.0,<4"
+httpx = ">=0.27.0"
+
 [[package]]
 name = "httpx-sse"
 version = "0.4.0"
@@ -5136,11 +5152,8 @@ files = [
     {file = "lxml-5.4.0-cp36-cp36m-win_amd64.whl", hash = "sha256:7ce1a171ec325192c6a636b64c94418e71a1964f56d002cc28122fceff0b6121"},
     {file = "lxml-5.4.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:795f61bcaf8770e1b37eec24edf9771b307df3af74d1d6f27d812e15a9ff3872"},
     {file = "lxml-5.4.0-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:29f451a4b614a7b5b6c2e043d7b64a15bd8304d7e767055e8ab68387a8cacf4e"},
-    {file = "lxml-5.4.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:891f7f991a68d20c75cb13c5c9142b2a3f9eb161f1f12a9489c82172d1f133c0"},
     {file = "lxml-5.4.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4aa412a82e460571fad592d0f93ce9935a20090029ba08eca05c614f99b0cc92"},
-    {file = "lxml-5.4.0-cp37-cp37m-manylinux_2_28_aarch64.whl", hash = "sha256:ac7ba71f9561cd7d7b55e1ea5511543c0282e2b6450f122672a2694621d63b7e"},
     {file = "lxml-5.4.0-cp37-cp37m-manylinux_2_28_x86_64.whl", hash = "sha256:c5d32f5284012deaccd37da1e2cd42f081feaa76981f0eaa474351b68df813c5"},
-    {file = "lxml-5.4.0-cp37-cp37m-musllinux_1_2_aarch64.whl", hash = "sha256:ce31158630a6ac85bddd6b830cffd46085ff90498b397bd0a259f59d27a12188"},
     {file = "lxml-5.4.0-cp37-cp37m-musllinux_1_2_x86_64.whl", hash = "sha256:31e63621e073e04697c1b2d23fcb89991790eef370ec37ce4d5d469f40924ed6"},
     {file = "lxml-5.4.0-cp37-cp37m-win32.whl", hash = "sha256:be2ba4c3c5b7900246a8f866580700ef0d538f2ca32535e991027bdaba944063"},
     {file = "lxml-5.4.0-cp37-cp37m-win_amd64.whl", hash = "sha256:09846782b1ef650b321484ad429217f5154da4d6e786636c38e434fa32e94e49"},
@@ -11753,4 +11766,4 @@ third-party-runtimes = ["daytona", "e2b", "modal", "runloop-api-client"]
 [metadata]
 lock-version = "2.1"
 python-versions = "^3.12,<3.14"
-content-hash = "4640c66849d6436eed73826154e2d8cf88b456a4d1b71efb9438531245845826"
+content-hash = "8568c6ec2e11d4fcb23e206a24896b4d2d50e694c04011b668148f484e95b406"

pyproject.toml

@@ -20,6 +20,7 @@ packages = [
 ]
 include = [
   "openhands/integrations/vscode/openhands-vscode-0.0.1.vsix",
+  "microagents/**/*",
 ]
 build = "build_vscode.py" # Build VSCode extension during Poetry build
 
@@ -41,6 +42,8 @@ numpy = "*"
 json-repair = "*"
 browsergym-core = "0.13.3"                         # integrate browsergym-core as the browsing interface
 html2text = "*"
+rich = "*"                                         # For terminal formatting and markdown rendering
+deprecated = "*"
 pexpect = "*"
 jinja2 = "^3.1.3"
 python-multipart = "*"
@@ -97,6 +100,7 @@ e2b = { version = ">=1.0.5,<1.8.0", optional = true }
 modal = { version = ">=0.66.26,<1.2.0", optional = true }
 runloop-api-client = { version = "0.50.0", optional = true }
 daytona = { version = "0.24.2", optional = true }
+httpx-aiohttp = "^0.1.8"
 
 [tool.poetry.extras]
 third_party_runtimes = [ "e2b", "modal", "runloop-api-client", "daytona" ]
@@ -163,7 +167,7 @@ joblib = "*"
 swebench = { git = "https://github.com/ryanhoangt/SWE-bench.git", rev = "fix-modal-patch-eval" }
 
 [tool.poetry.scripts]
-openhands = "openhands.cli.main:main"
+openhands = "openhands.cli.entry:main"
 
 [tool.poetry.group.testgeneval.dependencies]
 fuzzywuzzy = "^0.18.0"

tests/unit/test_cli_thought_order.py

@@ -145,8 +145,8 @@ class TestThoughtDisplayOrder:
         # Verify that final thought is displayed
         mock_display_message.assert_called_once_with('This is a final thought.')
 
-    @patch('openhands.cli.tui.display_message')
-    def test_message_action_from_agent(self, mock_display_message):
+    @patch('openhands.cli.tui.display_agent_message')
+    def test_message_action_from_agent(self, mock_display_agent_message):
         """Test that MessageAction from agent is displayed."""
         config = MagicMock(spec=OpenHandsConfig)
 
@@ -156,8 +156,8 @@ class TestThoughtDisplayOrder:
 
         display_event(message_action, config)
 
-        # Verify that message is displayed
-        mock_display_message.assert_called_once_with('Hello from agent')
+        # Verify that agent message is displayed
+        mock_display_agent_message.assert_called_once_with('Hello from agent')
 
     @patch('openhands.cli.tui.display_message')
     def test_message_action_from_user_not_displayed(self, mock_display_message):

tests/unit/test_cli_tui.py

@@ -6,6 +6,7 @@ from openhands.cli.tui import (
     CustomDiffLexer,
     UsageMetrics,
     UserCancelledError,
+    display_agent_message,
     display_banner,
     display_command,
     display_event,
@@ -26,6 +27,7 @@ from openhands.events import EventSource
 from openhands.events.action import (
     Action,
     ActionConfirmationStatus,
+    AgentFinishAction,
     CmdRunAction,
     MCPAction,
     MessageAction,
@@ -107,15 +109,15 @@ class TestDisplayFunctions:
         assert 'What do you want to build?' in message_text
         assert 'Type /help for help' in message_text
 
-    @patch('openhands.cli.tui.display_message')
-    def test_display_event_message_action(self, mock_display_message):
+    @patch('openhands.cli.tui.display_agent_message')
+    def test_display_event_message_action(self, mock_display_agent_message):
         config = MagicMock(spec=OpenHandsConfig)
         message = MessageAction(content='Test message')
         message._source = EventSource.AGENT
 
         display_event(message, config)
 
-        mock_display_message.assert_called_once_with('Test message')
+        mock_display_agent_message.assert_called_once_with('Test message')
 
     @patch('openhands.cli.tui.display_command')
     def test_display_event_cmd_action(self, mock_display_command):
@@ -181,6 +183,15 @@ class TestDisplayFunctions:
         display_event(action, config)
 
         mock_display_message.assert_called_once_with('Thinking about this...')
+        
+    @patch('openhands.cli.tui.display_agent_message')
+    def test_display_event_agent_finish(self, mock_display_agent_message):
+        config = MagicMock(spec=OpenHandsConfig)
+        finish_action = AgentFinishAction(final_thought='Task completed')
+
+        display_event(finish_action, config)
+
+        mock_display_agent_message.assert_called_once_with('Task completed', is_finish=True)
 
     @patch('openhands.cli.tui.display_mcp_action')
     def test_display_event_mcp_action(self, mock_display_mcp_action):
@@ -255,6 +266,37 @@ class TestDisplayFunctions:
         mock_print.assert_called_once()
         args, kwargs = mock_print.call_args
         assert message in str(args[0])
+        
+    @patch('openhands.cli.tui.shutil.get_terminal_size')
+    @patch('openhands.cli.tui.print_formatted_text')
+    def test_display_agent_message(self, mock_print_formatted, mock_terminal_size):
+        from collections import namedtuple
+        
+        # Mock terminal size
+        Size = namedtuple('Size', ['columns', 'lines'])
+        mock_terminal_size.return_value = Size(columns=80, lines=24)
+        
+        message = 'Agent message'
+        display_agent_message(message)
+        
+        # Should be called multiple times now (header, separator, content)
+        assert mock_print_formatted.call_count >= 3
+        
+    @patch('openhands.cli.tui.shutil.get_terminal_size')
+    @patch('openhands.cli.tui.print_formatted_text')
+    def test_display_agent_message_with_markdown(self, mock_print_formatted, mock_terminal_size):
+        from collections import namedtuple
+        
+        # Mock terminal size
+        Size = namedtuple('Size', ['columns', 'lines'])
+        mock_terminal_size.return_value = Size(columns=80, lines=24)
+        
+        # Test with markdown content
+        message = '# Heading\n\nThis is **bold** text.'
+        display_agent_message(message)
+        
+        # Should be called multiple times now (header, separator, content)
+        assert mock_print_formatted.call_count >= 3
 
     @patch('openhands.cli.tui.print_container')
     def test_display_command_awaiting_confirmation(self, mock_print_container):

tests/unit/test_windows_prompt_refinement.py

@@ -0,0 +1,179 @@
+import sys
+from unittest.mock import patch
+
+import pytest
+
+from openhands.agenthub.codeact_agent.codeact_agent import CodeActAgent
+from openhands.core.config import AgentConfig
+from openhands.llm.llm import LLM
+
+# Skip all tests in this module if not running on Windows
+pytestmark = pytest.mark.skipif(
+    sys.platform != 'win32', reason='Windows prompt refinement tests require Windows'
+)
+
+
+@pytest.fixture
+def mock_llm():
+    """Create a mock LLM for testing."""
+    llm = LLM(config={'model': 'gpt-4', 'api_key': 'test'})
+    return llm
+
+
+@pytest.fixture
+def agent_config():
+    """Create a basic agent config for testing."""
+    return AgentConfig()
+
+
+def test_codeact_agent_system_prompt_no_bash_on_windows(mock_llm, agent_config):
+    """Test that CodeActAgent's system prompt doesn't contain 'bash' on Windows."""
+    # Create a CodeActAgent instance
+    agent = CodeActAgent(llm=mock_llm, config=agent_config)
+
+    # Get the system prompt
+    system_prompt = agent.prompt_manager.get_system_message()
+
+    # Assert that 'bash' doesn't exist in the system prompt (case-insensitive)
+    assert 'bash' not in system_prompt.lower(), (
+        f"System prompt contains 'bash' on Windows platform. "
+        f"It should be replaced with 'powershell'. "
+        f'System prompt: {system_prompt}'
+    )
+
+    # Verify that 'powershell' exists instead (case-insensitive)
+    assert 'powershell' in system_prompt.lower(), (
+        f"System prompt should contain 'powershell' on Windows platform. "
+        f'System prompt: {system_prompt}'
+    )
+
+
+def test_codeact_agent_tool_descriptions_no_bash_on_windows(mock_llm, agent_config):
+    """Test that CodeActAgent's tool descriptions don't contain 'bash' on Windows."""
+    # Create a CodeActAgent instance
+    agent = CodeActAgent(llm=mock_llm, config=agent_config)
+
+    # Get the tools
+    tools = agent.tools
+
+    # Check each tool's description and parameters
+    for tool in tools:
+        if tool['type'] == 'function':
+            function_info = tool['function']
+
+            # Check function description
+            description = function_info.get('description', '')
+            assert 'bash' not in description.lower(), (
+                f"Tool '{function_info['name']}' description contains 'bash' on Windows. "
+                f'Description: {description}'
+            )
+
+            # Check parameter descriptions
+            parameters = function_info.get('parameters', {})
+            properties = parameters.get('properties', {})
+
+            for param_name, param_info in properties.items():
+                param_description = param_info.get('description', '')
+                assert 'bash' not in param_description.lower(), (
+                    f"Tool '{function_info['name']}' parameter '{param_name}' "
+                    f"description contains 'bash' on Windows. "
+                    f'Parameter description: {param_description}'
+                )
+
+
+def test_in_context_learning_example_no_bash_on_windows():
+    """Test that in-context learning examples don't contain 'bash' on Windows."""
+    from openhands.agenthub.codeact_agent.tools.bash import create_cmd_run_tool
+    from openhands.agenthub.codeact_agent.tools.finish import FinishTool
+    from openhands.agenthub.codeact_agent.tools.str_replace_editor import (
+        create_str_replace_editor_tool,
+    )
+    from openhands.llm.fn_call_converter import get_example_for_tools
+
+    # Create a sample set of tools
+    tools = [
+        create_cmd_run_tool(),
+        create_str_replace_editor_tool(),
+        FinishTool,
+    ]
+
+    # Get the in-context learning example
+    example = get_example_for_tools(tools)
+
+    # Assert that 'bash' doesn't exist in the example (case-insensitive)
+    assert 'bash' not in example.lower(), (
+        f"In-context learning example contains 'bash' on Windows platform. "
+        f"It should be replaced with 'powershell'. "
+        f'Example: {example}'
+    )
+
+    # Verify that 'powershell' exists instead (case-insensitive)
+    if example:  # Only check if example is not empty
+        assert 'powershell' in example.lower(), (
+            f"In-context learning example should contain 'powershell' on Windows platform. "
+            f'Example: {example}'
+        )
+
+
+def test_refine_prompt_function_works():
+    """Test that the refine_prompt function correctly replaces 'bash' with 'powershell'."""
+    from openhands.agenthub.codeact_agent.tools.bash import refine_prompt
+
+    # Test basic replacement
+    test_prompt = 'Execute a bash command to list files'
+    refined_prompt = refine_prompt(test_prompt)
+
+    assert 'bash' not in refined_prompt.lower()
+    assert 'powershell' in refined_prompt.lower()
+    assert refined_prompt == 'Execute a powershell command to list files'
+
+    # Test multiple occurrences
+    test_prompt = 'Use bash to run bash commands in the bash shell'
+    refined_prompt = refine_prompt(test_prompt)
+
+    assert 'bash' not in refined_prompt.lower()
+    assert (
+        refined_prompt
+        == 'Use powershell to run powershell commands in the powershell shell'
+    )
+
+    # Test case sensitivity
+    test_prompt = 'BASH and Bash and bash should all be replaced'
+    refined_prompt = refine_prompt(test_prompt)
+
+    assert 'bash' not in refined_prompt.lower()
+    assert (
+        refined_prompt
+        == 'powershell and powershell and powershell should all be replaced'
+    )
+
+    # Test execute_bash tool name replacement
+    test_prompt = 'Use the execute_bash tool to run commands'
+    refined_prompt = refine_prompt(test_prompt)
+
+    assert 'execute_bash' not in refined_prompt.lower()
+    assert 'execute_powershell' in refined_prompt.lower()
+    assert refined_prompt == 'Use the execute_powershell tool to run commands'
+
+    # Test that words containing 'bash' but not equal to 'bash' are preserved
+    test_prompt = 'The bashful person likes bash-like syntax'
+    refined_prompt = refine_prompt(test_prompt)
+
+    # 'bashful' should be preserved, 'bash-like' should become 'powershell-like'
+    assert 'bashful' in refined_prompt
+    assert 'powershell-like' in refined_prompt
+    assert refined_prompt == 'The bashful person likes powershell-like syntax'
+
+
+def test_refine_prompt_function_on_non_windows():
+    """Test that the refine_prompt function doesn't change anything on non-Windows platforms."""
+    from openhands.agenthub.codeact_agent.tools.bash import refine_prompt
+
+    # Mock sys.platform to simulate non-Windows
+    with patch('openhands.agenthub.codeact_agent.tools.bash.sys.platform', 'linux'):
+        test_prompt = 'Execute a bash command to list files'
+        refined_prompt = refine_prompt(test_prompt)
+
+        # On non-Windows, the prompt should remain unchanged
+        assert refined_prompt == test_prompt
+        assert 'bash' in refined_prompt.lower()