openhands 1.3.0__py3-none-any.whl

openhands_cli/user_actions/settings_action.py

@@ -0,0 +1,176 @@
+from enum import Enum
+
+from prompt_toolkit.completion import FuzzyWordCompleter
+from pydantic import SecretStr
+
+from openhands.sdk.llm import UNVERIFIED_MODELS_EXCLUDING_BEDROCK, VERIFIED_MODELS
+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, SettingsType.BASIC)
+
+
+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[:10] + [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: str | SecretStr | None = None,
+    escapable=True,
+) -> str:
+    api_key: str | None = (
+        existing_api_key.get_secret_value()
+        if isinstance(existing_api_key, SecretStr)
+        else existing_api_key
+    )
+    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 api_key:
+        masked_key = api_key[:3] + "***"
+        question = (
+            f"Enter API Key [{masked_key}] (CTRL-c to cancel, ENTER to keep "
+            f"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 api_key and not user_input.strip():
+        return api_key
+
+    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 True

openhands_cli/user_actions/types.py

@@ -0,0 +1,17 @@
+from enum import Enum
+
+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: ConfirmationPolicyBase | None = 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:  # noqa: ARG001
+        selected[0] = (selected[0] - 1) % len(choices)
+
+    @kb.add("down")
+    def _handle_down(event: KeyPressEvent) -> None:  # noqa: ARG001
+        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=16),
+    )
+    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 = 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,
+        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_cli/utils.py

@@ -0,0 +1,122 @@
+"""Utility functions for LLM configuration in OpenHands CLI."""
+
+import os
+from argparse import Namespace
+from pathlib import Path
+from typing import Any
+
+from prompt_toolkit import print_formatted_text
+from prompt_toolkit.formatted_text import HTML
+
+from openhands.sdk import LLM
+from openhands.tools.preset import get_default_agent
+
+
+def should_set_litellm_extra_body(model_name: str) -> bool:
+    """
+    Determine if litellm_extra_body should be set based on the model name.
+
+    Only set litellm_extra_body for openhands models to avoid issues
+    with providers that don't support extra_body parameters.
+
+    The SDK internally translates "openhands/" prefix to "litellm_proxy/"
+    when making API calls.
+
+    Args:
+        model_name: Name of the LLM model
+
+    Returns:
+        True if litellm_extra_body should be set, False otherwise
+    """
+    return "openhands/" in model_name
+
+
+def get_llm_metadata(
+    model_name: str,
+    llm_type: str,
+    session_id: str | None = None,
+    user_id: str | None = None,
+) -> dict[str, Any]:
+    """
+    Generate LLM metadata for OpenHands CLI.
+
+    Args:
+        model_name: Name of the LLM model
+        agent_name: Name of the agent (defaults to "openhands")
+        session_id: Optional session identifier
+        user_id: Optional user identifier
+
+    Returns:
+        Dictionary containing metadata for LLM initialization
+    """
+    # Import here to avoid circular imports
+    openhands_sdk_version: str = "n/a"
+    try:
+        import openhands.sdk
+
+        openhands_sdk_version = openhands.sdk.__version__
+    except (ModuleNotFoundError, AttributeError):
+        pass
+
+    openhands_tools_version: str = "n/a"
+    try:
+        import openhands.tools
+
+        openhands_tools_version = openhands.tools.__version__
+    except (ModuleNotFoundError, AttributeError):
+        pass
+
+    metadata = {
+        "trace_version": openhands_sdk_version,
+        "tags": [
+            "app:openhands",
+            f"model:{model_name}",
+            f"type:{llm_type}",
+            f"web_host:{os.environ.get('WEB_HOST', 'unspecified')}",
+            f"openhands_sdk_version:{openhands_sdk_version}",
+            f"openhands_tools_version:{openhands_tools_version}",
+        ],
+    }
+    if session_id is not None:
+        metadata["session_id"] = session_id
+    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)
+
+    return agent
+
+
+def create_seeded_instructions_from_args(args: Namespace) -> list[str] | None:
+    """
+    Build initial CLI input(s) from parsed arguments.
+    """
+    if getattr(args, "command", None) == "serve":
+        return None
+
+    # --file takes precedence over --task
+    if getattr(args, "file", None):
+        path = Path(args.file).expanduser()
+        try:
+            content = path.read_text(encoding="utf-8")
+        except OSError as exc:
+            print_formatted_text(HTML(f"<red>Failed to read file {path}: {exc}</red>"))
+            raise SystemExit(1)
+
+        initial_message = (
+            "Starting this session with file context.\n\n"
+            f"File path: {path}\n\n"
+            "File contents:\n"
+            "--------------------\n"
+            f"{content}\n"
+            "--------------------\n"
+        )
+        return [initial_message]
+
+    if getattr(args, "task", None):
+        return [args.task]
+
+    return None

openhands_cli/version_check.py

@@ -0,0 +1,83 @@
+"""Version checking utilities for OpenHands CLI."""
+
+import json
+import urllib.request
+from typing import NamedTuple
+
+from openhands_cli import __version__
+
+
+class VersionInfo(NamedTuple):
+    """Version information for display."""
+
+    current_version: str
+    latest_version: str | None
+    needs_update: bool
+    error: str | None
+
+
+def parse_version(version_str: str) -> tuple[int, ...]:
+    """Parse a version string into a tuple of integers for comparison.
+
+    Args:
+        version_str: Version string like "1.2.1"
+
+    Returns:
+        Tuple of integers like (1, 2, 1)
+    """
+    return tuple(int(x) for x in version_str.split("."))
+
+
+def check_for_updates(timeout: float = 2.0) -> VersionInfo:
+    """Check if a newer version is available on PyPI.
+
+    Args:
+        timeout: Timeout for PyPI request in seconds
+
+    Returns:
+        VersionInfo with update information
+    """
+    current = __version__
+
+    # Handle dev versions or special cases
+    if current == "0.0.0" or "dev" in current:
+        return VersionInfo(
+            current_version=current,
+            latest_version=None,
+            needs_update=False,
+            error=None,
+        )
+
+    try:
+        # Fetch latest version from PyPI
+        url = "https://pypi.org/pypi/openhands/json"
+        req = urllib.request.Request(url)
+        req.add_header("User-Agent", f"openhands-cli/{current}")
+
+        with urllib.request.urlopen(req, timeout=timeout) as response:
+            data = json.loads(response.read().decode("utf-8"))
+            latest = data["info"]["version"]
+
+        # Compare versions
+        try:
+            current_tuple = parse_version(current)
+            latest_tuple = parse_version(latest)
+            needs_update = latest_tuple > current_tuple
+        except (ValueError, AttributeError):
+            # If we can't parse versions, assume no update needed
+            needs_update = False
+
+        return VersionInfo(
+            current_version=current,
+            latest_version=latest,
+            needs_update=needs_update,
+            error=None,
+        )
+    except Exception as e:
+        # Don't block on network errors - just return current version
+        return VersionInfo(
+            current_version=current,
+            latest_version=None,
+            needs_update=False,
+            error=str(e),
+        )