openhands 0.0.0__py3-none-any.whl → 1.0.1__py3-none-any.whl

openhands_cli/tui/tui.py

@@ -0,0 +1,100 @@
+from collections.abc import Generator
+from uuid import UUID
+
+from prompt_toolkit import print_formatted_text
+from prompt_toolkit.completion import CompleteEvent, Completer, Completion
+from prompt_toolkit.document import Document
+from prompt_toolkit.formatted_text import HTML
+from prompt_toolkit.shortcuts import clear
+
+from openhands_cli import __version__
+from openhands_cli.pt_style import get_cli_style
+
+DEFAULT_STYLE = get_cli_style()
+
+# Available commands with descriptions
+COMMANDS = {
+    '/exit': 'Exit the application',
+    '/help': 'Display available commands',
+    '/clear': 'Clear the screen',
+    '/new': 'Start a fresh conversation',
+    '/status': 'Display conversation details',
+    '/confirm': 'Toggle confirmation mode on/off',
+    '/resume': 'Resume a paused conversation',
+    '/settings': 'Display and modify current settings',
+    '/mcp': 'View MCP (Model Context Protocol) server configuration',
+}
+
+
+class CommandCompleter(Completer):
+    """Custom completer for commands with interactive dropdown."""
+
+    def get_completions(
+        self, document: Document, complete_event: CompleteEvent
+    ) -> Generator[Completion, None, None]:
+        text = document.text_before_cursor.lstrip()
+        if text.startswith('/'):
+            for command, description in COMMANDS.items():
+                if command.startswith(text):
+                    yield Completion(
+                        command,
+                        start_position=-len(text),
+                        display_meta=description,
+                        style='bg:ansidarkgray fg:gold',
+                    )
+
+
+def display_banner(conversation_id: str, resume: bool = False) -> None:
+    print_formatted_text(
+        HTML(r"""<gold>
+     ___                    _   _                 _
+    /  _ \ _ __   ___ _ __ | | | | __ _ _ __   __| |___
+    | | | | '_ \ / _ \ '_ \| |_| |/ _` | '_ \ / _` / __|
+    | |_| | |_) |  __/ | | |  _  | (_| | | | | (_| \__ \
+    \___ /| .__/ \___|_| |_|_| |_|\__,_|_| |_|\__,_|___/
+          |_|
+    </gold>"""),
+        style=DEFAULT_STYLE,
+    )
+
+    print_formatted_text('')
+    if not resume:
+        print_formatted_text(
+            HTML(f'<grey>Initialized conversation {conversation_id}</grey>')
+        )
+    else:
+        print_formatted_text(
+            HTML(f'<grey>Resumed conversation {conversation_id}</grey>')
+        )
+    print_formatted_text('')
+
+
+def display_help() -> None:
+    """Display help information about available commands."""
+    print_formatted_text('')
+    print_formatted_text(HTML('<gold>🤖 OpenHands CLI Help</gold>'))
+    print_formatted_text(HTML('<grey>Available commands:</grey>'))
+    print_formatted_text('')
+
+    for command, description in COMMANDS.items():
+        print_formatted_text(HTML(f'  <white>{command}</white> - {description}'))
+
+    print_formatted_text('')
+    print_formatted_text(HTML('<grey>Tips:</grey>'))
+    print_formatted_text('  • Type / and press Tab to see command suggestions')
+    print_formatted_text('  • Use arrow keys to navigate through suggestions')
+    print_formatted_text('  • Press Enter to select a command')
+    print_formatted_text('')
+
+
+def display_welcome(conversation_id: UUID, resume: bool = False) -> None:
+    """Display welcome message."""
+    clear()
+    display_banner(str(conversation_id), resume)
+    print_formatted_text(HTML("<gold>Let's start building!</gold>"))
+    print_formatted_text(
+        HTML(
+            '<green>What do you want to build? <grey>Type /help for help</grey></green>'
+        )
+    )
+    print()

openhands_cli/tui/utils.py

@@ -0,0 +1,14 @@
+class StepCounter:
+    """Automatically manages step numbering for settings flows."""
+
+    def __init__(self, total_steps: int):
+        self.current_step = 0
+        self.total_steps = total_steps
+
+    def next_step(self, prompt: str) -> str:
+        """Get the next step prompt with automatic numbering."""
+        self.current_step += 1
+        return f'(Step {self.current_step}/{self.total_steps}) {prompt}'
+
+    def existing_step(self, prompt: str) -> str:
+        return f'(Step {self.current_step}/{self.total_steps}) {prompt}'

openhands_cli/user_actions/__init__.py

@@ -0,0 +1,17 @@
+from openhands_cli.user_actions.agent_action import ask_user_confirmation
+from openhands_cli.user_actions.exit_session import (
+    exit_session_confirmation,
+)
+from openhands_cli.user_actions.settings_action import (
+    choose_llm_provider,
+    settings_type_confirmation,
+)
+from openhands_cli.user_actions.types import UserConfirmation
+
+__all__ = [
+    'ask_user_confirmation',
+    'exit_session_confirmation',
+    'UserConfirmation',
+    'settings_type_confirmation',
+    'choose_llm_provider',
+]

openhands_cli/user_actions/agent_action.py

@@ -0,0 +1,95 @@
+import html
+from prompt_toolkit import HTML, print_formatted_text
+
+from openhands.sdk.security.confirmation_policy import (
+    ConfirmRisky,
+    NeverConfirm,
+    SecurityRisk,
+)
+from openhands_cli.user_actions.types import ConfirmationResult, UserConfirmation
+from openhands_cli.user_actions.utils import cli_confirm, cli_text_input
+
+
+def ask_user_confirmation(
+    pending_actions: list, using_risk_based_policy: bool = False
+) -> ConfirmationResult:
+    """Ask user to confirm pending actions.
+
+    Args:
+        pending_actions: List of pending actions from the agent
+
+    Returns:
+        ConfirmationResult with decision, optional policy_change, and reason
+    """
+
+    if not pending_actions:
+        return ConfirmationResult(decision=UserConfirmation.ACCEPT)
+
+    print_formatted_text(
+        HTML(
+            f'<yellow>🔍 Agent created {len(pending_actions)} action(s) and is waiting for confirmation:</yellow>'
+        )
+    )
+
+    for i, action in enumerate(pending_actions, 1):
+        tool_name = getattr(action, 'tool_name', '[unknown tool]')
+        action_content = (
+            str(getattr(action, 'action', ''))[:100].replace('\n', ' ')
+            or '[unknown action]'
+        )
+        print_formatted_text(
+            HTML(f'<grey>  {i}. {tool_name}: {html.escape(action_content)}...</grey>')
+        )
+
+    question = 'Choose an option:'
+    options = [
+        'Yes, proceed',
+        'No, reject (w/o reason)',
+        'No, reject with reason',
+        "Always proceed (don't ask again)",
+    ]
+
+    if not using_risk_based_policy:
+        options.append('Auto-confirm LOW/MEDIUM risk, ask for HIGH risk')
+
+    try:
+        index = cli_confirm(question, options, escapable=True)
+    except (EOFError, KeyboardInterrupt):
+        print_formatted_text(HTML('\n<red>No input received; pausing agent.</red>'))
+        return ConfirmationResult(decision=UserConfirmation.DEFER)
+
+    if index == 0:
+        return ConfirmationResult(decision=UserConfirmation.ACCEPT)
+    elif index == 1:
+        return ConfirmationResult(decision=UserConfirmation.REJECT)
+    elif index == 2:
+        try:
+            reason_result = cli_text_input(
+                'Please enter your reason for rejecting these actions: '
+            )
+        except Exception:
+            return ConfirmationResult(decision=UserConfirmation.DEFER)
+
+        # Support both string return and (reason, cancelled) tuple for tests
+        cancelled = False
+        if isinstance(reason_result, tuple) and len(reason_result) >= 1:
+            reason = reason_result[0] or ''
+            cancelled = bool(reason_result[1]) if len(reason_result) > 1 else False
+        else:
+            reason = str(reason_result or '').strip()
+
+        if cancelled:
+            return ConfirmationResult(decision=UserConfirmation.DEFER)
+
+        return ConfirmationResult(decision=UserConfirmation.REJECT, reason=reason)
+    elif index == 3:
+        return ConfirmationResult(
+            decision=UserConfirmation.ACCEPT, policy_change=NeverConfirm()
+        )
+    elif index == 4:
+        return ConfirmationResult(
+            decision=UserConfirmation.ACCEPT,
+            policy_change=ConfirmRisky(threshold=SecurityRisk.HIGH),
+        )
+
+    return ConfirmationResult(decision=UserConfirmation.REJECT)

openhands_cli/user_actions/exit_session.py

@@ -0,0 +1,18 @@
+from openhands_cli.user_actions.types import UserConfirmation
+from openhands_cli.user_actions.utils import cli_confirm
+
+
+def exit_session_confirmation() -> UserConfirmation:
+    """
+    Ask user to confirm exiting session.
+    """
+
+    question = 'Terminate session?'
+    options = ['Yes, proceed', 'No, dismiss']
+    index = cli_confirm(question, options)  # Blocking UI, not escapable
+
+    options_mapping = {
+        0: UserConfirmation.ACCEPT,  # User accepts termination session
+        1: UserConfirmation.REJECT,  # User does not terminate session
+    }
+    return options_mapping.get(index, UserConfirmation.REJECT)

openhands_cli/user_actions/settings_action.py

@@ -0,0 +1,171 @@
+from enum import Enum
+
+from openhands.sdk.llm import UNVERIFIED_MODELS_EXCLUDING_BEDROCK, VERIFIED_MODELS
+from prompt_toolkit.completion import FuzzyWordCompleter
+from pydantic import SecretStr
+
+from openhands_cli.tui.utils import StepCounter
+from openhands_cli.user_actions.utils import (
+    NonEmptyValueValidator,
+    cli_confirm,
+    cli_text_input,
+)
+
+
+class SettingsType(Enum):
+    BASIC = 'basic'
+    ADVANCED = 'advanced'
+
+
+def settings_type_confirmation(first_time: bool = False) -> SettingsType:
+    question = (
+            '\nWelcome to OpenHands! Let\'s configure your LLM settings.\n'
+            'Choose your preferred setup method:'
+        )
+    choices = [
+        'LLM (Basic)',
+        'LLM (Advanced)'
+    ]
+    if not first_time:
+        question = 'Which settings would you like to modify?'
+        choices.append('Go back')
+
+
+    index = cli_confirm(question, choices, escapable=True)
+
+    if choices[index] == 'Go back':
+        raise KeyboardInterrupt
+
+    options_map = {0: SettingsType.BASIC, 1: SettingsType.ADVANCED}
+
+    return options_map.get(index)
+
+
+def choose_llm_provider(step_counter: StepCounter, escapable=True) -> str:
+    question = step_counter.next_step(
+        'Select LLM Provider (TAB for options, CTRL-c to cancel): '
+    )
+    options = (
+        list(VERIFIED_MODELS.keys()).copy()
+        + list(UNVERIFIED_MODELS_EXCLUDING_BEDROCK.keys()).copy()
+    )
+    alternate_option = 'Select another provider'
+
+    display_options = options[:4] + [alternate_option]
+
+    index = cli_confirm(question, display_options, escapable=escapable)
+    chosen_option = display_options[index]
+    if display_options[index] != alternate_option:
+        return chosen_option
+
+    question = step_counter.existing_step(
+        'Type LLM Provider (TAB to complete, CTRL-c to cancel): '
+    )
+    return cli_text_input(
+        question, escapable=True, completer=FuzzyWordCompleter(options, WORD=True)
+    )
+
+
+def choose_llm_model(step_counter: StepCounter, provider: str, escapable=True) -> str:
+    """Choose LLM model using spec-driven approach. Return (model, deferred)."""
+
+    models = VERIFIED_MODELS.get(
+        provider, []
+    ) + UNVERIFIED_MODELS_EXCLUDING_BEDROCK.get(provider, [])
+
+    if provider == 'openhands':
+        question = (
+            step_counter.next_step('Select Available OpenHands Model:\n')
+            + 'LLM usage is billed at the providers’ rates with no markup. Details: https://docs.all-hands.dev/usage/llms/openhands-llms'
+        )
+    else:
+        question = step_counter.next_step(
+            'Select LLM Model (TAB for options, CTRL-c to cancel): '
+        )
+    alternate_option = 'Select another model'
+    display_options = models[:4] + [alternate_option]
+    index = cli_confirm(question, display_options, escapable=escapable)
+    chosen_option = display_options[index]
+
+    if chosen_option != alternate_option:
+        return chosen_option
+
+    question = step_counter.existing_step(
+        'Type model id (TAB to complete, CTRL-c to cancel): '
+    )
+
+    return cli_text_input(
+        question, escapable=True, completer=FuzzyWordCompleter(models, WORD=True)
+    )
+
+
+def prompt_api_key(
+    step_counter: StepCounter,
+    provider: str,
+    existing_api_key: SecretStr | None = None,
+    escapable=True,
+) -> str:
+    helper_text = (
+        '\nYou can find your OpenHands LLM API Key in the API Keys tab of OpenHands Cloud: '
+        'https://app.all-hands.dev/settings/api-keys\n'
+        if provider == 'openhands'
+        else ''
+    )
+
+    if existing_api_key:
+        masked_key = existing_api_key.get_secret_value()[:3] + '***'
+        question = f'Enter API Key [{masked_key}] (CTRL-c to cancel, ENTER to keep current, type new to change): '
+        # For existing keys, allow empty input to keep current key
+        validator = None
+    else:
+        question = 'Enter API Key (CTRL-c to cancel): '
+        # For new keys, require non-empty input
+        validator = NonEmptyValueValidator()
+
+    question = helper_text + step_counter.next_step(question)
+    user_input = cli_text_input(
+        question, escapable=escapable, validator=validator, is_password=True
+    )
+    
+    # If user pressed ENTER with existing key (empty input), return the existing key
+    if existing_api_key and not user_input.strip():
+        return existing_api_key.get_secret_value()
+    
+    return user_input
+
+
+# Advanced settings functions
+def prompt_custom_model(step_counter: StepCounter, escapable=True) -> str:
+    """Prompt for custom model name."""
+    question = step_counter.next_step('Custom Model (CTRL-c to cancel): ')
+    return cli_text_input(question, escapable=escapable)
+
+
+def prompt_base_url(step_counter: StepCounter, escapable=True) -> str:
+    """Prompt for base URL."""
+    question = step_counter.next_step('Base URL (CTRL-c to cancel): ')
+    return cli_text_input(
+        question, escapable=escapable, validator=NonEmptyValueValidator()
+    )
+
+
+def choose_memory_condensation(step_counter: StepCounter, escapable=True) -> bool:
+    """Choose memory condensation setting."""
+    question = step_counter.next_step('Memory Condensation (CTRL-c to cancel): ')
+    choices = ['Enable', 'Disable']
+
+    index = cli_confirm(question, choices, escapable=escapable)
+    return index == 0  # True for Enable, False for Disable
+
+
+def save_settings_confirmation() -> bool:
+    """Prompt user to confirm saving settings."""
+    question = 'Save new settings? (They will take effect after restart)'
+    discard = 'No, discard'
+    options = ['Yes, save', discard]
+
+    index = cli_confirm(question, options, escapable=True)
+    if options[index] == discard:
+        raise KeyboardInterrupt
+
+    return options[index]

openhands_cli/user_actions/types.py

@@ -0,0 +1,18 @@
+from enum import Enum
+from typing import Optional
+
+from pydantic import BaseModel
+
+from openhands.sdk.security.confirmation_policy import ConfirmationPolicyBase
+
+
+class UserConfirmation(Enum):
+    ACCEPT = 'accept'
+    REJECT = 'reject'
+    DEFER = 'defer'
+
+
+class ConfirmationResult(BaseModel):
+    decision: UserConfirmation
+    policy_change: Optional[ConfirmationPolicyBase] = None
+    reason: str = ''

openhands_cli/user_actions/utils.py

@@ -0,0 +1,199 @@
+from prompt_toolkit import HTML, PromptSession
+from prompt_toolkit.application import Application
+from prompt_toolkit.completion import Completer
+from prompt_toolkit.input.base import Input
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.key_binding.key_processor import KeyPressEvent
+from prompt_toolkit.layout.containers import HSplit, Window
+from prompt_toolkit.layout.controls import FormattedTextControl
+from prompt_toolkit.layout.dimension import Dimension
+from prompt_toolkit.layout.layout import Layout
+from prompt_toolkit.output.base import Output
+from prompt_toolkit.shortcuts import prompt
+from prompt_toolkit.validation import ValidationError, Validator
+
+from openhands_cli.tui import DEFAULT_STYLE
+from openhands_cli.tui.tui import CommandCompleter
+
+
+def build_keybindings(
+    choices: list[str], selected: list[int], escapable: bool
+) -> KeyBindings:
+    """Create keybindings for the confirm UI. Split for testability."""
+    kb = KeyBindings()
+
+    @kb.add('up')
+    def _handle_up(event: KeyPressEvent) -> None:
+        selected[0] = (selected[0] - 1) % len(choices)
+
+    @kb.add('down')
+    def _handle_down(event: KeyPressEvent) -> None:
+        selected[0] = (selected[0] + 1) % len(choices)
+
+    @kb.add('enter')
+    def _handle_enter(event: KeyPressEvent) -> None:
+        event.app.exit(result=selected[0])
+
+    if escapable:
+
+        @kb.add('c-c')  # Ctrl+C
+        def _handle_hard_interrupt(event: KeyPressEvent) -> None:
+            event.app.exit(exception=KeyboardInterrupt())
+
+        @kb.add('c-p')  # Ctrl+P
+        def _handle_pause_interrupt(event: KeyPressEvent) -> None:
+            event.app.exit(exception=KeyboardInterrupt())
+
+        @kb.add('escape')  # Escape key
+        def _handle_escape(event: KeyPressEvent) -> None:
+            event.app.exit(exception=KeyboardInterrupt())
+
+    return kb
+
+
+def build_layout(question: str, choices: list[str], selected_ref: list[int]) -> Layout:
+    """Create the layout for the confirm UI. Split for testability."""
+
+    def get_choice_text() -> list[tuple[str, str]]:
+        lines: list[tuple[str, str]] = []
+        lines.append(('class:question', f'{question}\n\n'))
+        for i, choice in enumerate(choices):
+            is_selected = i == selected_ref[0]
+            prefix = '> ' if is_selected else '  '
+            style = 'class:selected' if is_selected else 'class:unselected'
+            lines.append((style, f'{prefix}{choice}\n'))
+        return lines
+
+    content_window = Window(
+        FormattedTextControl(get_choice_text),
+        always_hide_cursor=True,
+        height=Dimension(max=8),
+    )
+    return Layout(HSplit([content_window]))
+
+
+def cli_confirm(
+    question: str = 'Are you sure?',
+    choices: list[str] | None = None,
+    initial_selection: int = 0,
+    escapable: bool = False,
+    input: Input | None = None,  # strictly for unit testing
+    output: Output | None = None,  # strictly for unit testing
+) -> int:
+    """Display a confirmation prompt with the given question and choices.
+
+    Returns the index of the selected choice.
+    """
+    if choices is None:
+        choices = ['Yes', 'No']
+    selected = [initial_selection]  # Using list to allow modification in closure
+
+    kb = build_keybindings(choices, selected, escapable)
+    layout = build_layout(question, choices, selected)
+
+    app = Application(
+        layout=layout,
+        key_bindings=kb,
+        style=DEFAULT_STYLE,
+        full_screen=False,
+        input=input,
+        output=output,
+    )
+
+    return int(app.run(in_thread=True))
+
+
+def cli_text_input(
+    question: str,
+    escapable: bool = True,
+    completer: Completer | None = None,
+    validator: Validator = None,
+    is_password: bool = False,
+) -> str:
+    """Prompt user to enter text input with optional validation.
+
+    Args:
+        question: The prompt question to display
+        escapable: Whether the user can escape with Ctrl+C or Ctrl+P
+        completer: Optional completer for tab completion
+        validator: Optional callable that takes a string and returns True if valid.
+                  If validation fails, the callable should display error messages
+                  and the user will be reprompted.
+
+    Returns:
+        The validated user input string (stripped of whitespace)
+    """
+
+    kb = KeyBindings()
+
+    if escapable:
+
+        @kb.add('c-c')
+        def _(event: KeyPressEvent) -> None:
+            event.app.exit(exception=KeyboardInterrupt())
+
+        @kb.add('c-p')
+        def _(event: KeyPressEvent) -> None:
+            event.app.exit(exception=KeyboardInterrupt())
+
+    @kb.add('enter')
+    def _handle_enter(event: KeyPressEvent):
+        event.app.exit(result=event.current_buffer.text)
+
+    reason = str(
+        prompt(
+            question,
+            style=DEFAULT_STYLE,
+            key_bindings=kb,
+            completer=completer,
+            is_password=is_password,
+            validator=validator,
+        )
+    )
+    return reason.strip()
+
+
+def get_session_prompter(
+    input: Input | None = None,  # strictly for unit testing
+    output: Output | None = None,  # strictly for unit testing
+) -> PromptSession:
+    bindings = KeyBindings()
+
+    @bindings.add('\\', 'enter')
+    def _(event: KeyPressEvent) -> None:
+        # Typing '\' + Enter forces a newline regardless
+        event.current_buffer.insert_text('\n')
+
+    @bindings.add('enter')
+    def _handle_enter(event: KeyPressEvent):
+        event.app.exit(result=event.current_buffer.text)
+
+    @bindings.add('c-c')
+    def _keyboard_interrupt(event: KeyPressEvent):
+        event.app.exit(exception=KeyboardInterrupt())
+
+    session = PromptSession(
+        completer=CommandCompleter(),
+        key_bindings=bindings,
+        prompt_continuation=lambda width, line_number, is_soft_wrap: '...',
+        multiline=True,
+        input=input,
+        output=output,
+        style=DEFAULT_STYLE,
+        placeholder=HTML(
+            '<placeholder>'
+            'Type your message… (tip: press <b>\\</b> + <b>Enter</b> to insert a newline)'
+            '</placeholder>'
+        ),
+    )
+
+    return session
+
+
+class NonEmptyValueValidator(Validator):
+    def validate(self, document):
+        text = document.text
+        if not text:
+            raise ValidationError(
+                message='API key cannot be empty. Please enter a valid API key.'
+            )

openhands/__init__.py

@@ -1 +0,0 @@
-__path__ = __import__("pkgutil").extend_path(__path__, __name__)

openhands/sdk/__init__.py

@@ -1,45 +0,0 @@
-from importlib.metadata import PackageNotFoundError, version
-
-from openhands.sdk.agent import Agent, AgentBase
-from openhands.sdk.context import AgentContext
-from openhands.sdk.conversation import Conversation, ConversationCallbackType
-from openhands.sdk.event import Event, EventBase, LLMConvertibleEvent
-from openhands.sdk.llm import (
-    LLM,
-    ImageContent,
-    LLMRegistry,
-    Message,
-    RegistryEvent,
-    TextContent,
-)
-from openhands.sdk.logger import get_logger
-from openhands.sdk.mcp import MCPClient, MCPTool, create_mcp_tools
-from openhands.sdk.tool import ActionBase, ObservationBase, Tool
-
-
-__version__ = "1.0.0a0"
-
-__all__ = [
-    "LLM",
-    "LLMRegistry",
-    "RegistryEvent",
-    "Message",
-    "TextContent",
-    "ImageContent",
-    "Tool",
-    "AgentBase",
-    "Agent",
-    "ActionBase",
-    "ObservationBase",
-    "MCPClient",
-    "MCPTool",
-    "create_mcp_tools",
-    "get_logger",
-    "Conversation",
-    "ConversationCallbackType",
-    "Event",
-    "EventBase",
-    "LLMConvertibleEvent",
-    "AgentContext",
-    "__version__",
-]

openhands/sdk/agent/__init__.py

@@ -1,8 +0,0 @@
-from openhands.sdk.agent.agent import Agent
-from openhands.sdk.agent.base import AgentBase
-
-
-__all__ = [
-    "Agent",
-    "AgentBase",
-]