openhands 1.0.2__tar.gz → 1.0.4__tar.gz

{openhands-1.0.2 → openhands-1.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openhands
-Version: 1.0.2
+Version: 1.0.4
 Summary: OpenHands CLI - Terminal User Interface for OpenHands AI Agent
 Author-email: OpenHands Team <contact@all-hands.dev>
 License: MIT
@@ -8,17 +8,17 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.12
-Requires-Dist: openhands-sdk==1.0.0a3
-Requires-Dist: openhands-tools==1.0.0a3
+Requires-Dist: openhands-sdk==1.0.0a5
+Requires-Dist: openhands-tools==1.0.0a5
 Requires-Dist: prompt-toolkit>=3
 Requires-Dist: typer>=0.17.4
 Description-Content-Type: text/markdown
 
 # OpenHands V1 CLI
 
-A **lightweight, modern CLI** to interact with the OpenHands agent (powered by [agent-sdk](https://github.com/All-Hands-AI/agent-sdk)). 
+A **lightweight, modern CLI** to interact with the OpenHands agent (powered by [agent-sdk](https://github.com/OpenHands/agent-sdk)). 
 
-The [OpenHands V0 CLI (legacy)](https://github.com/All-Hands-AI/OpenHands/tree/main/openhands/cli) is being deprecated.
+The [OpenHands V0 CLI (legacy)](https://github.com/OpenHands/OpenHands/tree/main/openhands/cli) is being deprecated.
 
 ---
 

{openhands-1.0.2 → openhands-1.0.4}/README.md

@@ -1,8 +1,8 @@
 # OpenHands V1 CLI
 
-A **lightweight, modern CLI** to interact with the OpenHands agent (powered by [agent-sdk](https://github.com/All-Hands-AI/agent-sdk)). 
+A **lightweight, modern CLI** to interact with the OpenHands agent (powered by [agent-sdk](https://github.com/OpenHands/agent-sdk)). 
 
-The [OpenHands V0 CLI (legacy)](https://github.com/All-Hands-AI/OpenHands/tree/main/openhands/cli) is being deprecated.
+The [OpenHands V0 CLI (legacy)](https://github.com/OpenHands/OpenHands/tree/main/openhands/cli) is being deprecated.
 
 ---
 

{openhands-1.0.2 → openhands-1.0.4}/build.py

@@ -15,13 +15,12 @@ import sys
 import time
 from pathlib import Path
 
-from openhands_cli.llm_utils import get_llm_metadata
-from openhands_cli.locations import AGENT_SETTINGS_PATH, PERSISTENCE_DIR, WORK_DIR
+from openhands_cli.utils import get_llm_metadata, get_default_cli_agent
+from openhands_cli.locations import AGENT_SETTINGS_PATH, PERSISTENCE_DIR
 
 from openhands.sdk import LLM
-from openhands.tools.preset.default import get_default_agent
 
-dummy_agent = get_default_agent(
+dummy_agent = get_default_cli_agent(
     llm=LLM(
         model='dummy-model',
         api_key='dummy-key',

{openhands-1.0.2 → openhands-1.0.4}/openhands_cli/agent_chat.py

@@ -6,6 +6,7 @@ Provides a conversation interface with an AI agent using OpenHands patterns.
 
 import sys
 from datetime import datetime
+import uuid
 
 from openhands.sdk import (
     Message,
@@ -16,7 +17,11 @@ from prompt_toolkit import print_formatted_text
 from prompt_toolkit.formatted_text import HTML
 
 from openhands_cli.runner import ConversationRunner
-from openhands_cli.setup import MissingAgentSpec, setup_conversation, start_fresh_conversation
+from openhands_cli.setup import (
+    MissingAgentSpec,
+    setup_conversation,
+    verify_agent_exists_or_setup_agent
+)
 from openhands_cli.tui.settings.mcp_screen import MCPScreen
 from openhands_cli.tui.settings.settings_screen import SettingsScreen
 from openhands_cli.tui.status import display_status
@@ -65,21 +70,33 @@ def run_cli_entry(resume_conversation_id: str | None = None) -> None:
         EOFError: If EOF is encountered
     """
 
+    conversation_id = uuid.uuid4()
+    if resume_conversation_id:
+        try:
+            conversation_id = uuid.UUID(resume_conversation_id)
+        except ValueError as e:
+            print_formatted_text(
+                HTML(
+                    f"<yellow>Warning: '{resume_conversation_id}' is not a valid UUID.</yellow>"
+                )
+            )
+            return
+
     try:
-        conversation = start_fresh_conversation(resume_conversation_id)
+        initialized_agent = verify_agent_exists_or_setup_agent()
     except MissingAgentSpec:
         print_formatted_text(HTML('\n<yellow>Setup is required to use OpenHands CLI.</yellow>'))
         print_formatted_text(HTML('\n<yellow>Goodbye! 👋</yellow>'))
         return
 
 
-    display_welcome(conversation.id, bool(resume_conversation_id))
+    display_welcome(conversation_id, bool(resume_conversation_id))
 
     # Track session start time for uptime calculation
     session_start_time = datetime.now()
 
     # Create conversation runner to handle state machine logic
-    runner = ConversationRunner(conversation)
+    runner = None
     session = get_session_prompter()
 
     # Main chat loop
@@ -106,7 +123,7 @@ def run_cli_entry(resume_conversation_id: str | None = None) -> None:
                 exit_confirmation = exit_session_confirmation()
                 if exit_confirmation == UserConfirmation.ACCEPT:
                     print_formatted_text(HTML('\n<yellow>Goodbye! 👋</yellow>'))
-                    _print_exit_hint(conversation.id)
+                    _print_exit_hint(conversation_id)
                     break
 
             elif command == '/settings':
@@ -116,19 +133,19 @@ def run_cli_entry(resume_conversation_id: str | None = None) -> None:
 
             elif command == '/mcp':
                 mcp_screen = MCPScreen()
-                mcp_screen.display_mcp_info(conversation.agent)
+                mcp_screen.display_mcp_info(initialized_agent)
                 continue
 
             elif command == '/clear':
-                display_welcome(conversation.id)
+                display_welcome(conversation_id)
                 continue
 
             elif command == '/new':
                 try:
                     # Start a fresh conversation (no resume ID = new conversation)
-                    conversation = setup_conversation()
+                    conversation = setup_conversation(conversation_id)
                     runner = ConversationRunner(conversation)
-                    display_welcome(conversation.id, resume=False)
+                    display_welcome(conversation_id, resume=False)
                     print_formatted_text(
                         HTML('<green>✓ Started fresh conversation</green>')
                     )
@@ -158,6 +175,13 @@ def run_cli_entry(resume_conversation_id: str | None = None) -> None:
                 continue
 
             elif command == '/resume':
+                if not runner:
+                    print_formatted_text(
+                        HTML('<yellow>No active conversation running...</yellow>')
+                    )
+                    continue
+
+                conversation = runner.conversation
                 if not (
                     conversation.state.agent_status == AgentExecutionStatus.PAUSED
                     or conversation.state.agent_status
@@ -171,6 +195,9 @@ def run_cli_entry(resume_conversation_id: str | None = None) -> None:
                 # Resume without new message
                 message = None
 
+            if not runner:
+                conversation = setup_conversation(conversation_id)
+                runner = ConversationRunner(conversation)
             runner.process_message(message)
 
             print()  # Add spacing
@@ -179,7 +206,7 @@ def run_cli_entry(resume_conversation_id: str | None = None) -> None:
             exit_confirmation = exit_session_confirmation()
             if exit_confirmation == UserConfirmation.ACCEPT:
                 print_formatted_text(HTML('\n<yellow>Goodbye! 👋</yellow>'))
-                _print_exit_hint(conversation.id)
+                _print_exit_hint(conversation_id)
                 break
 
     # Clean up terminal state

{openhands-1.0.2 → openhands-1.0.4}/openhands_cli/gui_launcher.py

@@ -104,8 +104,8 @@ def launch_gui_server(mount_cwd: bool = False, gpu: bool = False) -> None:
 
     # Get the current version for the Docker image
     version = get_openhands_version()
-    runtime_image = f'docker.all-hands.dev/all-hands-ai/runtime:{version}-nikolaik'
-    app_image = f'docker.all-hands.dev/all-hands-ai/openhands:{version}'
+    runtime_image = f'docker.openhands.dev/openhands/runtime:{version}-nikolaik'
+    app_image = f'docker.openhands.dev/openhands/openhands:{version}'
 
     print_formatted_text(HTML('<grey>Pulling required Docker images...</grey>'))
 

{openhands-1.0.2 → openhands-1.0.4}/openhands_cli/pt_style.py

@@ -20,7 +20,7 @@ def get_cli_style() -> BaseStyle:
             'prompt': f'{COLOR_GOLD} bold',
             # Ensure good contrast for fuzzy matches on the selected completion row
             # across terminals/themes (e.g., Ubuntu GNOME, Alacritty, Kitty).
-            # See https://github.com/All-Hands-AI/OpenHands/issues/10330
+            # See https://github.com/OpenHands/OpenHands/issues/10330
             'completion-menu.completion.current fuzzymatch.outside': 'fg:#ffffff bg:#888888',
             'selected': COLOR_GOLD,
             'risk-high': '#FF0000 bold',  # Red bold for HIGH risk

{openhands-1.0.2 → openhands-1.0.4}/openhands_cli/runner.py

@@ -120,6 +120,7 @@ class ConversationRunner:
             else:
                 raise Exception('Infinite loop')
 
+
     def _handle_confirmation_request(self) -> UserConfirmation:
         """Handle confirmation request from user.
 

{openhands-1.0.2 → openhands-1.0.4}/openhands_cli/setup.py

@@ -2,7 +2,7 @@ import uuid
 
 from prompt_toolkit import HTML, print_formatted_text
 
-from openhands.sdk import BaseConversation, Conversation, Workspace, register_tool
+from openhands.sdk import Agent, BaseConversation, Conversation, Workspace, register_tool
 from openhands.tools.execute_bash import BashTool
 from openhands.tools.file_editor import FileEditorTool
 from openhands.tools.task_tracker import TaskTrackerTool
@@ -26,8 +26,38 @@ class MissingAgentSpec(Exception):
     pass
 
 
-def setup_conversation(
+
+def load_agent_specs(
     conversation_id: str | None = None,
+) -> Agent:
+    agent_store = AgentStore()
+    agent = agent_store.load(session_id=conversation_id)
+    if not agent:
+        raise MissingAgentSpec(
+            'Agent specification not found. Please configure your agent settings.'
+        )
+    return agent
+
+
+def verify_agent_exists_or_setup_agent() -> Agent:
+    """Verify agent specs exists by attempting to load it.
+
+    """
+    settings_screen = SettingsScreen()
+    try:
+        agent = load_agent_specs()
+        return agent
+    except MissingAgentSpec:
+        # For first-time users, show the full settings flow with choice between basic/advanced
+        settings_screen.configure_settings(first_time=True)
+
+
+    # Try once again after settings setup attempt
+    return load_agent_specs()
+
+
+def setup_conversation(
+    conversation_id: uuid,
     include_security_analyzer: bool = True
 ) -> BaseConversation:
     """
@@ -40,28 +70,8 @@ def setup_conversation(
         MissingAgentSpec: If agent specification is not found or invalid.
     """
 
-    # Use provided conversation_id or generate a random one
-    if conversation_id is None:
-        conversation_id = uuid.uuid4()
-    elif isinstance(conversation_id, str):
-        try:
-            conversation_id = uuid.UUID(conversation_id)
-        except ValueError as e:
-            print_formatted_text(
-                HTML(
-                    f"<yellow>Warning: '{conversation_id}' is not a valid UUID.</yellow>"
-                )
-            )
-            raise e
-
     with LoadingContext('Initializing OpenHands agent...'):
-        agent_store = AgentStore()
-        agent = agent_store.load(session_id=str(conversation_id))
-        if not agent:
-            raise MissingAgentSpec(
-                'Agent specification not found. Please configure your agent settings.'
-            )
-
+        agent = load_agent_specs(str(conversation_id))
 
         if not include_security_analyzer:
             # Remove security analyzer from agent spec
@@ -86,31 +96,3 @@ def setup_conversation(
     )
     return conversation
 
-
-
-def start_fresh_conversation(
-    resume_conversation_id: str | None = None
-) -> BaseConversation:
-    """Start a fresh conversation by creating a new conversation instance.
-
-    Handles the complete conversation setup process including settings screen
-    if agent configuration is missing.
-
-    Args:
-        resume_conversation_id: Optional conversation ID to resume
-
-    Returns:
-        BaseConversation: A new conversation instance
-    """
-    conversation = None
-    settings_screen = SettingsScreen()
-    try:
-        conversation = setup_conversation(resume_conversation_id)
-        return conversation
-    except MissingAgentSpec:
-        # For first-time users, show the full settings flow with choice between basic/advanced
-        settings_screen.configure_settings(first_time=True)
-
-
-    # Try once again after settings setup attempt
-    return setup_conversation(resume_conversation_id)

{openhands-1.0.2 → openhands-1.0.4}/openhands_cli/tui/settings/settings_screen.py

@@ -1,13 +1,11 @@
 import os
 
 from openhands.sdk import LLM, BaseConversation, LocalFileStore
-from openhands.sdk.security.confirmation_policy import NeverConfirm
-from openhands.tools.preset.default import get_default_agent
 from prompt_toolkit import HTML, print_formatted_text
 from prompt_toolkit.shortcuts import print_container
 from prompt_toolkit.widgets import Frame, TextArea
 
-from openhands_cli.llm_utils import get_llm_metadata
+from openhands_cli.utils import get_llm_metadata, get_default_cli_agent
 from openhands_cli.locations import AGENT_SETTINGS_PATH, PERSISTENCE_DIR
 from openhands_cli.pt_style import COLOR_GREY
 from openhands_cli.tui.settings.store import AgentStore
@@ -176,13 +174,13 @@ class SettingsScreen:
             model=model,
             api_key=api_key,
             base_url=base_url,
-            service_id='agent',
+            usage_id='agent',
             metadata=get_llm_metadata(model_name=model, llm_type='agent'),
         )
 
         agent = self.agent_store.load()
         if not agent:
-            agent = get_default_agent(llm=llm, cli_mode=True)
+            agent = get_default_cli_agent(llm=llm)
 
         agent = agent.model_copy(update={'llm': llm})
         self.agent_store.save(agent)

{openhands-1.0.2 → openhands-1.0.4}/openhands_cli/tui/settings/store.py

@@ -5,7 +5,7 @@ from pathlib import Path
 from typing import Any
 
 from fastmcp.mcp_config import MCPConfig
-from openhands_cli.llm_utils import get_llm_metadata
+from openhands_cli.utils import get_llm_metadata
 from openhands_cli.locations import (
     AGENT_SETTINGS_PATH,
     MCP_CONFIG_FILE,

openhands-1.0.2/openhands_cli/llm_utils.py → openhands-1.0.4/openhands_cli/utils.py

@@ -2,7 +2,9 @@
 
 import os
 from typing import Any
-
+from openhands.sdk.security.llm_analyzer import LLMSecurityAnalyzer
+from openhands.tools.preset import get_default_agent
+from openhands.sdk import LLM
 
 def get_llm_metadata(
     model_name: str,
@@ -55,3 +57,20 @@ def get_llm_metadata(
     if user_id is not None:
         metadata['trace_user_id'] = user_id
     return metadata
+
+
+def get_default_cli_agent(
+    llm: LLM
+):
+    agent = get_default_agent(
+        llm=llm,
+        cli_mode=True
+    )
+
+    agent = agent.model_copy(
+        update={
+            'security_analyzer': LLMSecurityAnalyzer()
+        }
+    )
+    
+    return agent

{openhands-1.0.2 → openhands-1.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ requires = [ "hatchling>=1.25" ]
 
 [project]
 name = "openhands"
-version = "1.0.2"
+version = "1.0.4"
 description = "OpenHands CLI - Terminal User Interface for OpenHands AI Agent"
 readme = "README.md"
 license = { text = "MIT" }
@@ -18,8 +18,8 @@ classifiers = [
 # Using Git URLs for dependencies so installs from PyPI pull from GitHub
 # TODO: pin package versions once agent-sdk has published PyPI packages
 dependencies = [
-  "openhands-sdk==1.0.0a3",
-  "openhands-tools==1.0.0a3",
+  "openhands-sdk==1.0.0a5",
+  "openhands-tools==1.0.0a5",
   "prompt-toolkit>=3",
   "typer>=0.17.4",
 ]

{openhands-1.0.2 → openhands-1.0.4}/tests/commands/test_new_command.py

@@ -4,51 +4,49 @@ from unittest.mock import MagicMock, patch
 from uuid import UUID
 from prompt_toolkit.input.defaults import create_pipe_input
 from prompt_toolkit.output.defaults import DummyOutput
-from openhands_cli.setup import MissingAgentSpec, start_fresh_conversation
+from openhands_cli.setup import MissingAgentSpec, verify_agent_exists_or_setup_agent, setup_conversation
 from openhands_cli.user_actions import UserConfirmation
 
-@patch('openhands_cli.setup.setup_conversation')
-def test_start_fresh_conversation_success(mock_setup_conversation):
-    """Test that start_fresh_conversation creates a new conversation successfully."""
-    # Mock the conversation object
-    mock_conversation = MagicMock()
-    mock_conversation.id = UUID('12345678-1234-5678-9abc-123456789abc')
-    mock_setup_conversation.return_value = mock_conversation
+@patch('openhands_cli.setup.load_agent_specs')
+def test_verify_agent_exists_or_setup_agent_success(mock_load_agent_specs):
+    """Test that verify_agent_exists_or_setup_agent returns agent successfully."""
+    # Mock the agent object
+    mock_agent = MagicMock()
+    mock_load_agent_specs.return_value = mock_agent
 
     # Call the function
-    result = start_fresh_conversation()
+    result = verify_agent_exists_or_setup_agent()
 
     # Verify the result
-    assert result == mock_conversation
-    mock_setup_conversation.assert_called_once_with(None)
+    assert result == mock_agent
+    mock_load_agent_specs.assert_called_once_with()
 
 
 @patch('openhands_cli.setup.SettingsScreen')
-@patch('openhands_cli.setup.setup_conversation')
-def test_start_fresh_conversation_missing_agent_spec(
-    mock_setup_conversation,
+@patch('openhands_cli.setup.load_agent_specs')
+def test_verify_agent_exists_or_setup_agent_missing_agent_spec(
+    mock_load_agent_specs,
     mock_settings_screen_class
 ):
-    """Test that start_fresh_conversation handles MissingAgentSpec exception."""
+    """Test that verify_agent_exists_or_setup_agent handles MissingAgentSpec exception."""
     # Mock the SettingsScreen instance
     mock_settings_screen = MagicMock()
     mock_settings_screen_class.return_value = mock_settings_screen
 
-    # Mock setup_conversation to raise MissingAgentSpec on first call, then succeed
-    mock_conversation = MagicMock()
-    mock_conversation.id = UUID('12345678-1234-5678-9abc-123456789abc')
-    mock_setup_conversation.side_effect = [
+    # Mock load_agent_specs to raise MissingAgentSpec on first call, then succeed
+    mock_agent = MagicMock()
+    mock_load_agent_specs.side_effect = [
         MissingAgentSpec("Agent spec missing"),
-        mock_conversation
+        mock_agent
     ]
 
     # Call the function
-    result = start_fresh_conversation()
+    result = verify_agent_exists_or_setup_agent()
 
     # Verify the result
-    assert result == mock_conversation
+    assert result == mock_agent
     # Should be called twice: first fails, second succeeds
-    assert mock_setup_conversation.call_count == 2
+    assert mock_load_agent_specs.call_count == 2
     # Settings screen should be called once with first_time=True (new behavior)
     mock_settings_screen.configure_settings.assert_called_once_with(first_time=True)
 
@@ -59,11 +57,11 @@ def test_start_fresh_conversation_missing_agent_spec(
 @patch('openhands_cli.agent_chat.exit_session_confirmation')
 @patch('openhands_cli.agent_chat.get_session_prompter')
 @patch('openhands_cli.agent_chat.setup_conversation')
-@patch('openhands_cli.agent_chat.start_fresh_conversation')
+@patch('openhands_cli.agent_chat.verify_agent_exists_or_setup_agent')
 @patch('openhands_cli.agent_chat.ConversationRunner')
 def test_new_command_resets_confirmation_mode(
     mock_runner_cls,
-    mock_start_fresh_conversation,
+    mock_verify_agent,
     mock_setup_conversation,
     mock_get_session_prompter,
     mock_exit_confirm,
@@ -71,15 +69,17 @@ def test_new_command_resets_confirmation_mode(
     # Auto-accept the exit prompt to avoid interactive UI and EOFError
     mock_exit_confirm.return_value = UserConfirmation.ACCEPT
 
+    # Mock agent verification to succeed
+    mock_agent = MagicMock()
+    mock_verify_agent.return_value = mock_agent
+
+    # Mock conversation - only one is created when /new is called
     conv1 = MagicMock(); conv1.id = UUID('aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa')
-    conv2 = MagicMock(); conv2.id = UUID('bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb')
-    mock_start_fresh_conversation.return_value = conv1
-    mock_setup_conversation.side_effect = [conv2]
+    mock_setup_conversation.return_value = conv1
 
-    # Distinct runner instances for each conversation
+    # One runner instance for the conversation
     runner1 = MagicMock(); runner1.is_confirmation_mode_active = True
-    runner2 = MagicMock(); runner2.is_confirmation_mode_active = False
-    mock_runner_cls.side_effect = [runner1, runner2]
+    mock_runner_cls.return_value = runner1
 
     # Real session fed by a pipe (no interactive confirmation now)
     from openhands_cli.user_actions.utils import get_session_prompter as real_get_session_prompter
@@ -89,13 +89,12 @@ def test_new_command_resets_confirmation_mode(
         mock_get_session_prompter.return_value = session
 
         from openhands_cli.agent_chat import run_cli_entry
-        # Trigger /new, then /status, then /exit (exit will be auto-accepted)
+        # Trigger /new, then /exit (exit will be auto-accepted)
         for ch in "/new\r/exit\r":
             pipe.send_text(ch)
 
         run_cli_entry(None)
 
-    # Assert we switched to a new runner for conv2
-    assert mock_runner_cls.call_count == 2
+    # Assert we created one runner for the conversation when /new was called
+    assert mock_runner_cls.call_count == 1
     assert mock_runner_cls.call_args_list[0].args[0] is conv1
-    assert mock_runner_cls.call_args_list[1].args[0] is conv2

openhands-1.0.4/tests/commands/test_resume_command.py

@@ -0,0 +1,147 @@
+"""Tests for the /resume command functionality."""
+
+from unittest.mock import MagicMock, patch
+from uuid import UUID
+import pytest
+from prompt_toolkit.input.defaults import create_pipe_input
+from prompt_toolkit.output.defaults import DummyOutput
+
+from openhands.sdk.conversation.state import AgentExecutionStatus
+from openhands_cli.user_actions import UserConfirmation
+
+
+# ---------- Fixtures & helpers ----------
+
+@pytest.fixture
+def mock_agent():
+    """Mock agent for verification."""
+    return MagicMock()
+
+
+@pytest.fixture
+def mock_conversation():
+    """Mock conversation with default settings."""
+    conv = MagicMock()
+    conv.id = UUID('aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa')
+    return conv
+
+
+@pytest.fixture
+def mock_runner():
+    """Mock conversation runner."""
+    return MagicMock()
+
+
+def run_resume_command_test(commands, agent_status=None, expect_runner_created=True):
+    """Helper function to run resume command tests with common setup."""
+    with patch('openhands_cli.agent_chat.exit_session_confirmation') as mock_exit_confirm, \
+         patch('openhands_cli.agent_chat.get_session_prompter') as mock_get_session_prompter, \
+         patch('openhands_cli.agent_chat.setup_conversation') as mock_setup_conversation, \
+         patch('openhands_cli.agent_chat.verify_agent_exists_or_setup_agent') as mock_verify_agent, \
+         patch('openhands_cli.agent_chat.ConversationRunner') as mock_runner_cls:
+        
+        # Auto-accept the exit prompt to avoid interactive UI
+        mock_exit_confirm.return_value = UserConfirmation.ACCEPT
+        
+        # Mock agent verification to succeed
+        mock_agent = MagicMock()
+        mock_verify_agent.return_value = mock_agent
+        
+        # Mock conversation setup
+        conv = MagicMock()
+        conv.id = UUID('aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa')
+        if agent_status:
+            conv.state.agent_status = agent_status
+        mock_setup_conversation.return_value = conv
+        
+        # Mock runner
+        runner = MagicMock()
+        runner.conversation = conv
+        mock_runner_cls.return_value = runner
+        
+        # Real session fed by a pipe
+        from openhands_cli.user_actions.utils import get_session_prompter as real_get_session_prompter
+        with create_pipe_input() as pipe:
+            output = DummyOutput()
+            session = real_get_session_prompter(input=pipe, output=output)
+            mock_get_session_prompter.return_value = session
+            
+            from openhands_cli.agent_chat import run_cli_entry
+            
+            # Send commands
+            for ch in commands:
+                pipe.send_text(ch)
+            
+            # Capture printed output
+            with patch('openhands_cli.agent_chat.print_formatted_text') as mock_print:
+                run_cli_entry(None)
+            
+            return mock_runner_cls, runner, mock_print
+
+
+# ---------- Warning tests (parametrized) ----------
+
+@pytest.mark.parametrize(
+    "commands,expected_warning,expect_runner_created",
+    [
+        # No active conversation - /resume immediately
+        ("/resume\r/exit\r", "No active conversation running", False),
+        # Conversation exists but not in paused state - send message first, then /resume
+        ("hello\r/resume\r/exit\r", "No paused conversation to resume", True),
+    ],
+)
+def test_resume_command_warnings(commands, expected_warning, expect_runner_created):
+    """Test /resume command shows appropriate warnings."""
+    # Set agent status to FINISHED for the "conversation exists but not paused" test
+    agent_status = AgentExecutionStatus.FINISHED if expect_runner_created else None
+    
+    mock_runner_cls, runner, mock_print = run_resume_command_test(
+        commands, agent_status=agent_status, expect_runner_created=expect_runner_created
+    )
+    
+    # Verify warning message was printed
+    warning_calls = [call for call in mock_print.call_args_list 
+                    if expected_warning in str(call)]
+    assert len(warning_calls) > 0, f"Expected warning about {expected_warning}"
+    
+    # Verify runner creation expectation
+    if expect_runner_created:
+        assert mock_runner_cls.call_count == 1
+        runner.process_message.assert_called()
+    else:
+        assert mock_runner_cls.call_count == 0
+
+
+# ---------- Successful resume tests (parametrized) ----------
+
+@pytest.mark.parametrize(
+    "agent_status",
+    [
+        AgentExecutionStatus.PAUSED,
+        AgentExecutionStatus.WAITING_FOR_CONFIRMATION,
+    ],
+)
+def test_resume_command_successful_resume(agent_status):
+    """Test /resume command successfully resumes paused/waiting conversations."""
+    commands = "hello\r/resume\r/exit\r"
+    
+    mock_runner_cls, runner, mock_print = run_resume_command_test(
+        commands, agent_status=agent_status, expect_runner_created=True
+    )
+    
+    # Verify runner was created and process_message was called
+    assert mock_runner_cls.call_count == 1
+    
+    # Verify process_message was called twice: once with the initial message, once with None for resume
+    assert runner.process_message.call_count == 2
+    
+    # Check the calls to process_message
+    calls = runner.process_message.call_args_list
+    
+    # First call should have a message (the "hello" message)
+    first_call_args = calls[0][0]
+    assert first_call_args[0] is not None, "First call should have a message"
+    
+    # Second call should have None (the /resume command)
+    second_call_args = calls[1][0]
+    assert second_call_args[0] is None, "Second call should have None message for resume"

openhands-1.0.4/tests/settings/test_default_agent_security_analyzer.py

@@ -0,0 +1,104 @@
+"""Test that first-time settings screen usage creates a default agent with security analyzer."""
+
+from unittest.mock import patch
+import pytest
+from openhands_cli.tui.settings.settings_screen import SettingsScreen
+from openhands_cli.user_actions.settings_action import SettingsType
+from openhands.sdk import LLM
+from pydantic import SecretStr
+
+
+def test_first_time_settings_creates_default_agent_with_security_analyzer():
+    """Test that using the settings screen for the first time creates a default agent with a non-None security analyzer."""
+    
+    # Create a settings screen instance (no conversation initially)
+    screen = SettingsScreen(conversation=None)
+    
+    # Mock all the user interaction steps to simulate first-time setup
+    with (
+        patch(
+            'openhands_cli.tui.settings.settings_screen.settings_type_confirmation',
+            return_value=SettingsType.BASIC,
+        ),
+        patch(
+            'openhands_cli.tui.settings.settings_screen.choose_llm_provider',
+            return_value='openai',
+        ),
+        patch(
+            'openhands_cli.tui.settings.settings_screen.choose_llm_model',
+            return_value='gpt-4o-mini',
+        ),
+        patch(
+            'openhands_cli.tui.settings.settings_screen.prompt_api_key',
+            return_value='sk-test-key-123',
+        ),
+        patch(
+            'openhands_cli.tui.settings.settings_screen.save_settings_confirmation',
+            return_value=True,
+        ),
+    ):
+        # Run the settings configuration workflow
+        screen.configure_settings(first_time=True)
+    
+    # Load the saved agent from the store
+    saved_agent = screen.agent_store.load()
+    
+    # Verify that an agent was created and saved
+    assert saved_agent is not None, "Agent should be created and saved after first-time settings configuration"
+    
+    # Verify that the agent has the expected LLM configuration
+    assert saved_agent.llm.model == 'openai/gpt-4o-mini', f"Expected model 'openai/gpt-4o-mini', got '{saved_agent.llm.model}'"
+    assert saved_agent.llm.api_key.get_secret_value() == 'sk-test-key-123', "API key should match the provided value"
+    
+    # Verify that the agent has a security analyzer and it's not None
+    assert hasattr(saved_agent, 'security_analyzer'), "Agent should have a security_analyzer attribute"
+    assert saved_agent.security_analyzer is not None, "Security analyzer should not be None"
+    
+    # Verify the security analyzer has the expected type/kind
+    assert hasattr(saved_agent.security_analyzer, 'kind'), "Security analyzer should have a 'kind' attribute"
+    assert saved_agent.security_analyzer.kind == 'LLMSecurityAnalyzer', f"Expected security analyzer kind 'LLMSecurityAnalyzer', got '{saved_agent.security_analyzer.kind}'"
+
+
+def test_first_time_settings_with_advanced_configuration():
+    """Test that advanced settings also create a default agent with security analyzer."""
+    
+    screen = SettingsScreen(conversation=None)
+    
+    with (
+        patch(
+            'openhands_cli.tui.settings.settings_screen.settings_type_confirmation',
+            return_value=SettingsType.ADVANCED,
+        ),
+        patch(
+            'openhands_cli.tui.settings.settings_screen.prompt_custom_model',
+            return_value='anthropic/claude-3-5-sonnet',
+        ),
+        patch(
+            'openhands_cli.tui.settings.settings_screen.prompt_base_url',
+            return_value='https://api.anthropic.com',
+        ),
+        patch(
+            'openhands_cli.tui.settings.settings_screen.prompt_api_key',
+            return_value='sk-ant-test-key',
+        ),
+        patch(
+            'openhands_cli.tui.settings.settings_screen.choose_memory_condensation',
+            return_value=True,
+        ),
+        patch(
+            'openhands_cli.tui.settings.settings_screen.save_settings_confirmation',
+            return_value=True,
+        ),
+    ):
+        screen.configure_settings(first_time=True)
+    
+    saved_agent = screen.agent_store.load()
+    
+    # Verify agent creation and security analyzer
+    assert saved_agent is not None, "Agent should be created with advanced settings"
+    assert saved_agent.security_analyzer is not None, "Security analyzer should not be None in advanced settings"
+    assert saved_agent.security_analyzer.kind == 'LLMSecurityAnalyzer', "Security analyzer should be LLMSecurityAnalyzer"
+    
+    # Verify advanced settings were applied
+    assert saved_agent.llm.model == 'anthropic/claude-3-5-sonnet', "Custom model should be set"
+    assert saved_agent.llm.base_url == 'https://api.anthropic.com', "Base URL should be set"

{openhands-1.0.2 → openhands-1.0.4}/tests/settings/test_settings_workflow.py

@@ -6,10 +6,10 @@ import pytest
 from openhands_cli.tui.settings.settings_screen import SettingsScreen
 from openhands_cli.tui.settings.store import AgentStore
 from openhands_cli.user_actions.settings_action import SettingsType
+from openhands_cli.utils import get_default_cli_agent
 from pydantic import SecretStr
 
 from openhands.sdk import LLM, Conversation, LocalFileStore
-from openhands.tools.preset.default import get_default_agent
 
 
 def read_json(path: Path) -> dict:
@@ -18,7 +18,7 @@ def read_json(path: Path) -> dict:
 
 
 def make_screen_with_conversation(model='openai/gpt-4o-mini', api_key='sk-xyz'):
-    llm = LLM(model=model, api_key=SecretStr(api_key), service_id='test-service')
+    llm = LLM(model=model, api_key=SecretStr(api_key), usage_id='test-service')
     # Conversation(agent) signature may vary across versions; adapt if needed:
     from openhands.sdk.agent import Agent
 
@@ -30,8 +30,8 @@ def make_screen_with_conversation(model='openai/gpt-4o-mini', api_key='sk-xyz'):
 def seed_file(path: Path, model: str = 'openai/gpt-4o-mini', api_key: str = 'sk-old'):
     store = AgentStore()
     store.file_store = LocalFileStore(root=str(path))
-    agent = get_default_agent(
-        llm=LLM(model=model, api_key=SecretStr(api_key), service_id='test-service')
+    agent = get_default_cli_agent(
+        llm=LLM(model=model, api_key=SecretStr(api_key), usage_id='test-service')
     )
     store.save(agent)
 

{openhands-1.0.2 → openhands-1.0.4}/tests/test_confirmation_mode.py

@@ -4,6 +4,7 @@ Tests for confirmation mode functionality in OpenHands CLI.
 """
 
 import os
+import uuid
 from concurrent.futures import ThreadPoolExecutor
 from typing import Any
 from unittest.mock import ANY, MagicMock, patch
@@ -60,7 +61,7 @@ class TestConfirmationMode:
                 mock_conversation_instance = MagicMock()
                 mock_conversation_class.return_value = mock_conversation_instance
 
-                result = setup_conversation()
+                result = setup_conversation(mock_conversation_id)
 
                 # Verify conversation was created and returned
                 assert result == mock_conversation_instance
@@ -87,7 +88,7 @@ class TestConfirmationMode:
 
             # Should raise MissingAgentSpec
             with pytest.raises(MissingAgentSpec) as exc_info:
-                setup_conversation()
+                setup_conversation(uuid.uuid4())
 
             assert 'Agent specification not found' in str(exc_info.value)
             mock_agent_store_class.assert_called_once()

{openhands-1.0.2 → openhands-1.0.4}/tests/test_conversation_runner.py

@@ -6,13 +6,13 @@ from openhands_cli.runner import ConversationRunner
 from openhands_cli.user_actions.types import UserConfirmation
 from pydantic import ConfigDict, SecretStr, model_validator
 
-from openhands.sdk import Conversation, ConversationCallbackType
+from openhands.sdk import Conversation, ConversationCallbackType, LocalConversation
 from openhands.sdk.agent.base import AgentBase
 from openhands.sdk.conversation import ConversationState
 from openhands.sdk.conversation.state import AgentExecutionStatus
 from openhands.sdk.llm import LLM
 from openhands.sdk.security.confirmation_policy import AlwaysConfirm, NeverConfirm
-
+from unittest.mock import MagicMock
 
 class FakeLLM(LLM):
     @model_validator(mode='after')
@@ -41,16 +41,16 @@ class FakeAgent(AgentBase):
         pass
 
     def step(
-        self, state: ConversationState, on_event: ConversationCallbackType
+        self, conversation: LocalConversation, on_event: ConversationCallbackType
     ) -> None:
         self.step_count += 1
         if self.step_count == self.finish_on_step:
-            state.agent_status = AgentExecutionStatus.FINISHED
+            conversation.state.agent_status = AgentExecutionStatus.FINISHED
 
 
 @pytest.fixture()
 def agent() -> FakeAgent:
-    llm = LLM(**default_config(), service_id='test-service')
+    llm = LLM(**default_config(), usage_id='test-service')
     return FakeAgent(llm=llm, tools=[])
 
 
@@ -102,15 +102,15 @@ class TestConversationRunner:
         """
         if final_status == AgentExecutionStatus.FINISHED:
             agent.finish_on_step = 1
-        
+
         # Add a mock security analyzer to enable confirmation mode
-        from unittest.mock import MagicMock
         agent.security_analyzer = MagicMock()
-        
+
         convo = Conversation(agent)
         convo.state.agent_status = AgentExecutionStatus.WAITING_FOR_CONFIRMATION
         cr = ConversationRunner(convo)
         cr.set_confirmation_policy(AlwaysConfirm())
+
         with patch.object(
             cr, '_handle_confirmation_request', return_value=confirmation
         ) as mock_confirmation_request:

{openhands-1.0.2 → openhands-1.0.4}/tests/test_directory_separation.py

@@ -37,7 +37,7 @@ class TestToolFix:
         """Test that entire tools list is replaced with default tools when loading agent."""
         # Create a mock agent with different tools and working directories
         mock_agent = Agent(
-            llm=LLM(model='test/model', api_key='test-key', service_id='test-service'),
+            llm=LLM(model='test/model', api_key='test-key', usage_id='test-service'),
             tools=[
                 Tool(name='BashTool'),
                 Tool(name='FileEditorTool'),

{openhands-1.0.2 → openhands-1.0.4}/tests/test_gui_launcher.py

@@ -182,7 +182,7 @@ class TestLaunchGuiServer:
             # Check pull command
             pull_call = mock_run.call_args_list[0]
             pull_cmd = pull_call[0][0]
-            assert pull_cmd[0:3] == ['docker', 'pull', 'docker.all-hands.dev/all-hands-ai/runtime:latest-nikolaik']
+            assert pull_cmd[0:3] == ['docker', 'pull', 'docker.openhands.dev/openhands/runtime:latest-nikolaik']
 
             # Check run command
             run_call = mock_run.call_args_list[1]

{openhands-1.0.2 → openhands-1.0.4}/tests/test_mcp_config_validation.py

@@ -26,7 +26,7 @@ def _create_agent(mcp_config=None) -> Agent:
     if mcp_config is None:
         mcp_config = {}
     return Agent(
-        llm=LLM(model='test-model', api_key='test-key', service_id='test-service'),
+        llm=LLM(model='test-model', api_key='test-key', usage_id='test-service'),
         tools=[],
         mcp_config=mcp_config,
     )

{openhands-1.0.2 → openhands-1.0.4}/uv.lock

@@ -1828,7 +1828,7 @@ wheels = [
 
 [[package]]
 name = "openhands"
-version = "1.0.1"
+version = "1.0.3"
 source = { editable = "." }
 dependencies = [
     { name = "openhands-sdk" },
@@ -1855,8 +1855,8 @@ dev = [
 
 [package.metadata]
 requires-dist = [
-    { name = "openhands-sdk", specifier = "==1.0.0a3" },
-    { name = "openhands-tools", specifier = "==1.0.0a3" },
+    { name = "openhands-sdk", specifier = "==1.0.0a5" },
+    { name = "openhands-tools", specifier = "==1.0.0a5" },
     { name = "prompt-toolkit", specifier = ">=3" },
     { name = "typer", specifier = ">=0.17.4" },
 ]
@@ -1879,7 +1879,7 @@ dev = [
 
 [[package]]
 name = "openhands-sdk"
-version = "1.0.0a3"
+version = "1.0.0a5"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "fastmcp" },
@@ -1891,14 +1891,14 @@ dependencies = [
     { name = "tenacity" },
     { name = "websockets" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/7e/82/33b3e3560e259803b773eee9cb377fce63b56c4252f3036126e225171926/openhands_sdk-1.0.0a3.tar.gz", hash = "sha256:c2cf6ab2ac105d257a31fde0e502a81faa969c7e64e0b2364d0634d2ce8e93b4", size = 144940, upload-time = "2025-10-20T15:38:39.647Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1a/90/d40f6716641a95a61d2042f00855e0eadc0b2558167078324576cc5a3c22/openhands_sdk-1.0.0a5.tar.gz", hash = "sha256:8888d6892d58cf9b11a71fa80086156c0b6c9a0b50df6839c0a9cafffba2338c", size = 152810, upload-time = "2025-10-29T16:19:52.086Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/de/ab/4464d2470ef1e02334f9ade094dfefa2cfc5bb761b201663a3e4121e1892/openhands_sdk-1.0.0a3-py3-none-any.whl", hash = "sha256:c8ab45160b67e7de391211ae5607ccfdf44e39781f74d115a2a22df35a2f4311", size = 191937, upload-time = "2025-10-20T15:38:38.668Z" },
+    { url = "https://files.pythonhosted.org/packages/00/6b/d3aa28019163f22f4b589ad818b83e3bea23d0a50b0c51ecc070ffdec139/openhands_sdk-1.0.0a5-py3-none-any.whl", hash = "sha256:db20272b04cf03627f9f7d1e87992078ac4ce15d188955a2962aa9e754d0af03", size = 204063, upload-time = "2025-10-29T16:19:50.684Z" },
 ]
 
 [[package]]
 name = "openhands-tools"
-version = "1.0.0a3"
+version = "1.0.0a5"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "bashlex" },
@@ -1910,9 +1910,9 @@ dependencies = [
     { name = "openhands-sdk" },
     { name = "pydantic" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/d6/93/53cf1a5ae97e0c23d7e024db5bbb1ba1da9855c6352cc91d6b65fc6f5e13/openhands_tools-1.0.0a3.tar.gz", hash = "sha256:2a15fff3749ee5856906ffce999fec49c8305e7f9911f05e01dbcf4ea772e385", size = 59103, upload-time = "2025-10-20T15:38:43.705Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/0c/8d/d62bc5e6c986676363692743688f10b6a922fd24dd525e5c6e87bd6fc08e/openhands_tools-1.0.0a5.tar.gz", hash = "sha256:6c67454e612596e95c5151267659ddd3b633a5d4a1b70b348f7f913c62146562", size = 63012, upload-time = "2025-10-29T16:19:53.783Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f8/aa/251ce4ecd560cad295e1c81def9efadfd1009cec3b7e79bd41357c6a0670/openhands_tools-1.0.0a3-py3-none-any.whl", hash = "sha256:f4c81df682c2a1a1c0bfa450bfe25ba9de5a6a3b56d6bab90f7541bf149bb3ed", size = 78814, upload-time = "2025-10-20T15:38:42.795Z" },
+    { url = "https://files.pythonhosted.org/packages/07/9d/4da48258f0af73d017b61ed3f12786fae4caccc7e7cd97d77ef2bb25f00c/openhands_tools-1.0.0a5-py3-none-any.whl", hash = "sha256:74c27e23e6adc9a0bad00e32448bd4872019ce0786474e8de2fbf2d7c0887e8e", size = 84724, upload-time = "2025-10-29T16:19:52.84Z" },
 ]
 
 [[package]]