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

openhands/sdk/context/view.py

@@ -1,116 +0,0 @@
-from logging import getLogger
-from typing import overload
-
-from pydantic import BaseModel
-
-from openhands.sdk.event import (
-    Condensation,
-    CondensationRequest,
-    Event,
-    LLMConvertibleEvent,
-    MessageEvent,
-)
-from openhands.sdk.llm import Message, TextContent
-
-
-logger = getLogger(__name__)
-
-
-class View(BaseModel):
-    """Linearly ordered view of events.
-
-    Produced by a condenser to indicate the included events are ready to process as LLM
-    input.
-    """
-
-    events: list[LLMConvertibleEvent]
-    unhandled_condensation_request: bool = False
-
-    def __len__(self) -> int:
-        return len(self.events)
-
-    # To preserve list-like indexing, we ideally support slicing and position-based
-    # indexing. The only challenge with that is switching the return type based on the
-    # input type -- we can mark the different signatures for MyPy with `@overload`
-    # decorators.
-
-    @overload
-    def __getitem__(self, key: slice) -> list[LLMConvertibleEvent]: ...
-
-    @overload
-    def __getitem__(self, key: int) -> LLMConvertibleEvent: ...
-
-    def __getitem__(
-        self, key: int | slice
-    ) -> LLMConvertibleEvent | list[LLMConvertibleEvent]:
-        if isinstance(key, slice):
-            start, stop, step = key.indices(len(self))
-            return [self[i] for i in range(start, stop, step)]
-        elif isinstance(key, int):
-            return self.events[key]
-        else:
-            raise ValueError(f"Invalid key type: {type(key)}")
-
-    @staticmethod
-    def from_events(events: list[Event]) -> "View":
-        """Create a view from a list of events, respecting the semantics of any
-        condensation events.
-        """
-        forgotten_event_ids: set[str] = set()
-        for event in events:
-            if isinstance(event, Condensation):
-                forgotten_event_ids.update(event.forgotten)
-                # Make sure we also forget the condensation action itself
-                forgotten_event_ids.add(event.id)
-            if isinstance(event, CondensationRequest):
-                forgotten_event_ids.add(event.id)
-
-        kept_events = [
-            event
-            for event in events
-            if event.id not in forgotten_event_ids
-            and isinstance(event, LLMConvertibleEvent)
-        ]
-
-        # If we have a summary, insert it at the specified offset.
-        summary: str | None = None
-        summary_offset: int | None = None
-
-        # The relevant summary is always in the last condensation event (i.e., the most
-        # recent one).
-        for event in reversed(events):
-            if isinstance(event, Condensation):
-                if event.summary is not None and event.summary_offset is not None:
-                    summary = event.summary
-                    summary_offset = event.summary_offset
-                    break
-
-        if summary is not None and summary_offset is not None:
-            logger.info(f"Inserting summary at offset {summary_offset}")
-
-            kept_events.insert(
-                summary_offset,
-                MessageEvent(
-                    llm_message=Message(
-                        role="system",
-                        content=[TextContent(text=summary)],
-                        name="system",
-                    ),
-                    source="environment",
-                ),
-            )
-
-        # Check for an unhandled condensation request -- these are events closer to the
-        # end of the list than any condensation action.
-        unhandled_condensation_request = False
-        for event in reversed(events):
-            if isinstance(event, Condensation):
-                break
-            if isinstance(event, CondensationRequest):
-                unhandled_condensation_request = True
-                break
-
-        return View(
-            events=kept_events,
-            unhandled_condensation_request=unhandled_condensation_request,
-        )

openhands/sdk/conversation/__init__.py

@@ -1,12 +0,0 @@
-from openhands.sdk.conversation.conversation import Conversation
-from openhands.sdk.conversation.state import ConversationState
-from openhands.sdk.conversation.types import ConversationCallbackType
-from openhands.sdk.conversation.visualizer import ConversationVisualizer
-
-
-__all__ = [
-    "Conversation",
-    "ConversationState",
-    "ConversationCallbackType",
-    "ConversationVisualizer",
-]

openhands/sdk/conversation/conversation.py

@@ -1,207 +0,0 @@
-from typing import TYPE_CHECKING, Iterable
-
-
-if TYPE_CHECKING:
-    from openhands.sdk.agent import AgentBase
-
-from openhands.sdk.conversation.state import ConversationState
-from openhands.sdk.conversation.types import ConversationCallbackType
-from openhands.sdk.conversation.visualizer import ConversationVisualizer
-from openhands.sdk.event import (
-    MessageEvent,
-    PauseEvent,
-    UserRejectObservation,
-)
-from openhands.sdk.event.utils import get_unmatched_actions
-from openhands.sdk.llm import Message, TextContent
-from openhands.sdk.logger import get_logger
-
-
-logger = get_logger(__name__)
-
-
-def compose_callbacks(
-    callbacks: Iterable[ConversationCallbackType],
-) -> ConversationCallbackType:
-    def composed(event) -> None:
-        for cb in callbacks:
-            if cb:
-                cb(event)
-
-    return composed
-
-
-class Conversation:
-    def __init__(
-        self,
-        agent: "AgentBase",
-        callbacks: list[ConversationCallbackType] | None = None,
-        max_iteration_per_run: int = 500,
-    ):
-        """Initialize the conversation."""
-        self._visualizer = ConversationVisualizer()
-        self.agent = agent
-        self.state = ConversationState()
-
-        # Default callback: persist every event to state
-        def _append_event(e):
-            self.state.events.append(e)
-
-        # Compose callbacks; default appender runs last to keep agent-emitted event order (on_event then persist)  # noqa: E501
-        composed_list = (
-            [self._visualizer.on_event]
-            + (callbacks if callbacks else [])
-            + [_append_event]
-        )
-        self._on_event = compose_callbacks(composed_list)
-
-        self.max_iteration_per_run = max_iteration_per_run
-
-        with self.state:
-            self.agent.init_state(self.state, on_event=self._on_event)
-
-    @property
-    def id(self) -> str:
-        """Get the unique ID of the conversation."""
-        return self.state.id
-
-    def send_message(self, message: Message) -> None:
-        """Sending messages to the agent."""
-        assert message.role == "user", (
-            "Only user messages are allowed to be sent to the agent."
-        )
-        with self.state:
-            if self.state.agent_finished:
-                self.state.agent_finished = False  # now we have a new message
-
-            # TODO: We should add test cases for all these scenarios
-            activated_microagent_names: list[str] = []
-            extended_content: list[TextContent] = []
-
-            # Handle per-turn user message (i.e., knowledge agent trigger)
-            if self.agent.agent_context:
-                ctx = self.agent.agent_context.get_user_message_suffix(
-                    user_message=message,
-                    # We skip microagents that were already activated
-                    skip_microagent_names=self.state.activated_knowledge_microagents,
-                )
-                # TODO(calvin): we need to update
-                # self.state.activated_knowledge_microagents
-                # so condenser can work
-                if ctx:
-                    content, activated_microagent_names = ctx
-                    logger.debug(
-                        f"Got augmented user message content: {content}, "
-                        f"activated microagents: {activated_microagent_names}"
-                    )
-                    extended_content.append(content)
-                    self.state.activated_knowledge_microagents.extend(
-                        activated_microagent_names
-                    )
-
-            user_msg_event = MessageEvent(
-                source="user",
-                llm_message=message,
-                activated_microagents=activated_microagent_names,
-                extended_content=extended_content,
-            )
-            self._on_event(user_msg_event)
-
-    def run(self) -> None:
-        """Runs the conversation until the agent finishes.
-
-        In confirmation mode:
-        - First call: creates actions but doesn't execute them, stops and waits
-        - Second call: executes pending actions (implicit confirmation)
-
-        In normal mode:
-        - Creates and executes actions immediately
-
-        Can be paused between steps
-        """
-
-        with self.state:
-            self.state.agent_paused = False
-
-        iteration = 0
-        while True:
-            logger.debug(f"Conversation run iteration {iteration}")
-            # TODO(openhands): we should add a testcase that test IF:
-            # 1. a loop is running
-            # 2. in a separate thread .send_message is called
-            # and check will we be able to execute .send_message
-            # BEFORE the .run loop finishes?
-            with self.state:
-                # Pause attempts to acquire the state lock
-                # Before value can be modified step can be taken
-                # Ensure step conditions are checked when lock is already acquired
-                if self.state.agent_finished or self.state.agent_paused:
-                    break
-
-                # clear the flag before calling agent.step() (user approved)
-                if self.state.agent_waiting_for_confirmation:
-                    self.state.agent_waiting_for_confirmation = False
-
-                # step must mutate the SAME state object
-                self.agent.step(self.state, on_event=self._on_event)
-
-            # In confirmation mode, stop after one iteration if waiting for confirmation
-            if self.state.agent_waiting_for_confirmation:
-                break
-
-            iteration += 1
-            if iteration >= self.max_iteration_per_run:
-                break
-
-    def set_confirmation_mode(self, enabled: bool) -> None:
-        """Enable or disable confirmation mode and store it in conversation state."""
-        with self.state:
-            self.state.confirmation_mode = enabled
-        logger.info(f"Confirmation mode {'enabled' if enabled else 'disabled'}")
-
-    def reject_pending_actions(self, reason: str = "User rejected the action") -> None:
-        """Reject all pending actions from the agent.
-
-        This is a non-invasive method to reject actions between run() calls.
-        Also clears the agent_waiting_for_confirmation flag.
-        """
-        pending_actions = get_unmatched_actions(self.state.events)
-
-        with self.state:
-            # Always clear the agent_waiting_for_confirmation flag
-            self.state.agent_waiting_for_confirmation = False
-
-            if not pending_actions:
-                logger.warning("No pending actions to reject")
-                return
-
-            for action_event in pending_actions:
-                # Create rejection observation
-                rejection_event = UserRejectObservation(
-                    action_id=action_event.id,
-                    tool_name=action_event.tool_name,
-                    tool_call_id=action_event.tool_call_id,
-                    rejection_reason=reason,
-                )
-                self._on_event(rejection_event)
-                logger.info(f"Rejected pending action: {action_event} - {reason}")
-
-    def pause(self) -> None:
-        """Pause agent execution.
-
-        This method can be called from any thread to request that the agent
-        pause execution. The pause will take effect at the next iteration
-        of the run loop (between agent steps).
-
-        Note: If called during an LLM completion, the pause will not take
-        effect until the current LLM call completes.
-        """
-
-        if self.state.agent_paused:
-            return
-
-        with self.state:
-            self.state.agent_paused = True
-            pause_event = PauseEvent()
-            self._on_event(pause_event)
-        logger.info("Agent execution pause requested")

openhands/sdk/conversation/state.py

@@ -1,50 +0,0 @@
-import uuid
-from threading import RLock, get_ident
-from typing import Optional
-
-from pydantic import BaseModel, ConfigDict, Field, PrivateAttr
-
-from openhands.sdk.event import Event
-
-
-class ConversationState(BaseModel):
-    model_config = ConfigDict(
-        arbitrary_types_allowed=True,  # allow RLock in PrivateAttr
-        validate_assignment=True,  # validate on attribute set
-        frozen=False,
-    )
-
-    # Public, validated fields
-    id: str = Field(default_factory=lambda: str(uuid.uuid4()))
-    events: list[Event] = Field(default_factory=list)
-    agent_finished: bool = False
-    confirmation_mode: bool = False
-    agent_waiting_for_confirmation: bool = False
-    agent_paused: bool = False
-    activated_knowledge_microagents: list[str] = Field(
-        default_factory=list, description="List of activated knowledge microagents name"
-    )
-
-    # Private attrs (NOT Fields) — allowed to start with underscore
-    _lock: RLock = PrivateAttr(default_factory=RLock)
-    _owner_tid: Optional[int] = PrivateAttr(default=None)
-
-    # Lock/guard API
-    def acquire(self) -> None:
-        self._lock.acquire()
-        self._owner_tid = get_ident()
-
-    def release(self) -> None:
-        self._owner_tid = None
-        self._lock.release()
-
-    def __enter__(self) -> "ConversationState":
-        self.acquire()
-        return self
-
-    def __exit__(self, exc_type, exc, tb) -> None:
-        self.release()
-
-    def assert_locked(self) -> None:
-        if self._owner_tid != get_ident():
-            raise RuntimeError("State not held by current thread")

openhands/sdk/conversation/types.py

@@ -1,6 +0,0 @@
-from typing import Callable
-
-from openhands.sdk.event import Event
-
-
-ConversationCallbackType = Callable[[Event], None]

openhands/sdk/conversation/visualizer.py

@@ -1,300 +0,0 @@
-import json
-from typing import cast
-
-from rich.console import Console
-from rich.panel import Panel
-from rich.text import Text
-
-from openhands.sdk.event import (
-    ActionEvent,
-    AgentErrorEvent,
-    Event,
-    MessageEvent,
-    ObservationEvent,
-    PauseEvent,
-    SystemPromptEvent,
-)
-from openhands.sdk.llm import ImageContent, TextContent, content_to_str
-
-
-class ConversationVisualizer:
-    """Handles visualization of conversation events with Rich formatting.
-
-    Provides Rich-formatted output with panels and complete content display.
-    """
-
-    def __init__(self):
-        self._console = Console()
-
-    def on_event(self, event: Event) -> None:
-        """Main event handler that displays events with Rich formatting."""
-        panel = self._create_event_panel(event)
-        self._console.print(panel)
-        self._console.print()  # Add spacing between events
-
-    def _create_event_panel(self, event: Event) -> Panel:
-        """Create a Rich Panel for the event with appropriate styling."""
-        if isinstance(event, SystemPromptEvent):
-            return self._create_system_prompt_panel(event)
-        elif isinstance(event, ActionEvent):
-            return self._create_action_panel(event)
-        elif isinstance(event, ObservationEvent):
-            return self._create_observation_panel(event)
-        elif isinstance(event, MessageEvent):
-            return self._create_message_panel(event)
-        elif isinstance(event, AgentErrorEvent):
-            return self._create_error_panel(event)
-        elif isinstance(event, PauseEvent):
-            return self._create_pause_panel(event)
-        else:
-            # Fallback panel for unknown event types
-            content = Text(f"Unknown event type: {event.__class__.__name__}")
-            return Panel(
-                content,
-                title=f"[bold blue]{event.__class__.__name__}[/bold blue]",
-                subtitle=f"[dim]({event.source})[/dim]",
-                border_style="blue",
-                expand=True,
-            )
-
-    def _create_system_prompt_panel(self, event: SystemPromptEvent) -> Panel:
-        """Create a Rich Panel for SystemPromptEvent with complete content."""
-        content = Text()
-        content.append("System Prompt:\n", style="bold cyan")
-        content.append(event.system_prompt.text, style="white")
-        content.append(f"\n\nTools Available: {len(event.tools)}", style="cyan")
-        for tool in event.tools:
-            tool_fn = tool.get("function", None)
-            # make each field short
-            for k, v in tool.items():
-                if isinstance(v, str) and len(v) > 30:
-                    tool[k] = v[:27] + "..."
-            if tool_fn:
-                assert "name" in tool_fn
-                assert "description" in tool_fn
-                assert "parameters" in tool_fn
-                params_str = json.dumps(tool_fn["parameters"])
-                content.append(
-                    f"\n  - {tool_fn['name']}: "
-                    f"{tool_fn['description'].split('\n')[0][:100]}...\n",
-                    style="dim cyan",
-                )
-                content.append(f"  Parameters: {params_str}", style="dim white")
-            else:
-                content.append(
-                    f"\n  - Cannot access .function for {tool}", style="dim cyan"
-                )
-
-        return Panel(
-            content,
-            title="[bold magenta]System Prompt[/bold magenta]",
-            border_style="magenta",
-            expand=True,
-        )
-
-    def _format_metrics_subtitle(
-        self, event: ActionEvent | MessageEvent | AgentErrorEvent
-    ) -> str | None:
-        """Format LLM metrics as a visually appealing subtitle string with icons,
-        colors, and k/m abbreviations (cache hit rate only)."""
-        if not event.metrics or not event.metrics.accumulated_token_usage:
-            return None
-
-        usage = event.metrics.accumulated_token_usage
-        cost = event.metrics.accumulated_cost or 0.0
-
-        # helper: 1234 -> "1.2K", 1200000 -> "1.2M"
-        def abbr(n: int | float) -> str:
-            n = int(n or 0)
-            if n >= 1_000_000_000:
-                s = f"{n / 1_000_000_000:.2f}B"
-            elif n >= 1_000_000:
-                s = f"{n / 1_000_000:.2f}M"
-            elif n >= 1_000:
-                s = f"{n / 1_000:.2f}K"
-            else:
-                return str(n)
-            return s.replace(".0", "")
-
-        input_tokens = abbr(usage.prompt_tokens or 0)
-        output_tokens = abbr(usage.completion_tokens or 0)
-
-        # Cache hit rate (prompt + cache)
-        prompt = usage.prompt_tokens or 0
-        cache_read = usage.cache_read_tokens or 0
-        cache_rate = f"{(cache_read / prompt * 100):.2f}%" if prompt > 0 else "N/A"
-        reasoning_tokens = usage.reasoning_tokens or 0
-
-        # Cost
-        cost_str = f"{cost:.4f}" if cost > 0 else "$0.00"
-
-        # Build with fixed color scheme
-        parts: list[str] = []
-        parts.append(f"[cyan]↑ input {input_tokens}[/cyan]")
-        parts.append(f"[magenta]cache hit {cache_rate}[/magenta]")
-        if reasoning_tokens > 0:
-            parts.append(f"[yellow] reasoning {abbr(reasoning_tokens)}[/yellow]")
-        parts.append(f"[blue]↓ output {output_tokens}[/blue]")
-        parts.append(f"[green]$ {cost_str}[/green]")
-
-        return "Tokens: " + " [dim]•[/dim] ".join(parts)
-
-    def _create_action_panel(self, event: ActionEvent) -> Panel:
-        """Create a Rich Panel for ActionEvent with complete content."""
-        content = Text()
-
-        # Display reasoning content first if available (common to all three types)
-        if event.reasoning_content:
-            content.append("Reasoning:\n", style="bold magenta")
-            content.append(event.reasoning_content, style="white")
-            content.append("\n\n")
-
-        # Display complete thought content
-        thought_text = " ".join([t.text for t in event.thought])
-        if thought_text:
-            content.append("Thought:\n", style="bold green")
-            content.append(thought_text, style="white")
-            content.append("\n\n")
-
-        # Display action information
-        action_name = event.action.__class__.__name__
-        content.append("Action: ", style="bold green")
-        content.append(action_name, style="yellow")
-        content.append("\n\n")
-
-        # Display all action fields systematically
-        content.append("Action Fields:\n", style="bold green")
-        action_fields = event.action.model_dump()
-        for field_name, field_value in action_fields.items():
-            content.append(f"  {field_name}: ", style="cyan")
-            if field_value is None:
-                content.append("None", style="dim white")
-            elif isinstance(field_value, str):
-                # Handle multiline strings with proper indentation
-                if "\n" in field_value:
-                    content.append("\n", style="white")
-                    for line in field_value.split("\n"):
-                        content.append(f"    {line}\n", style="white")
-                else:
-                    content.append(f'"{field_value}"', style="white")
-            elif isinstance(field_value, (list, dict)):
-                content.append(str(field_value), style="white")
-            else:
-                content.append(str(field_value), style="white")
-            content.append("\n")
-
-        return Panel(
-            content,
-            title="[bold green]Agent Action[/bold green]",
-            subtitle=self._format_metrics_subtitle(event),
-            border_style="green",
-            expand=True,
-        )
-
-    def _create_observation_panel(self, event: ObservationEvent) -> Panel:
-        """Create a Rich Panel for ObservationEvent with complete content."""
-        content = Text()
-        content.append("Tool: ", style="bold blue")
-        content.append(event.tool_name, style="cyan")
-        content.append("\n\nResult:\n", style="bold blue")
-
-        text_parts = content_to_str(event.observation.agent_observation)
-        if text_parts:
-            full_content = " ".join(text_parts)
-            content.append(full_content, style="white")
-        else:
-            content.append("[no text content]", style="dim white")
-
-        return Panel(
-            content,
-            title="[bold blue]Tool Observation[/bold blue]",
-            border_style="blue",
-            expand=True,
-        )
-
-    def _create_message_panel(self, event: MessageEvent) -> Panel:
-        """Create a Rich Panel for MessageEvent with complete content."""
-        content = Text()
-
-        # Role-based styling
-        role_colors = {
-            "user": "bright_cyan",
-            "assistant": "bright_green",
-            "system": "bright_magenta",
-        }
-        role_color = role_colors.get(event.llm_message.role, "white")
-
-        content.append(
-            f"{event.llm_message.role.title()}:\n", style=f"bold {role_color}"
-        )
-
-        text_parts = content_to_str(event.llm_message.content)
-        if text_parts:
-            full_content = " ".join(text_parts)
-            content.append(full_content, style="white")
-        else:
-            content.append("[no text content]", style="dim white")
-
-        # Add microagent information if present
-        if event.activated_microagents:
-            content.append(
-                f"\n\nActivated Microagents: {', '.join(event.activated_microagents)}",
-                style="dim yellow",
-            )
-
-        # Add extended content if available
-        if event.extended_content:
-            assert not any(
-                isinstance(c, ImageContent) for c in event.extended_content
-            ), "Extended content should not contain images"
-            text_parts = content_to_str(
-                cast(list[TextContent | ImageContent], event.extended_content)
-            )
-            content.append("\n\nExtended Content:\n", style="dim yellow")
-            content.append(" ".join(text_parts), style="white")
-
-        # Panel styling based on role
-        panel_colors = {
-            "user": "cyan",
-            "assistant": "green",
-            "system": "magenta",
-        }
-        border_color = panel_colors.get(event.llm_message.role, "white")
-
-        title_text = (
-            f"[bold {role_color}]Message (source={event.source})[/bold {role_color}]"
-        )
-        return Panel(
-            content,
-            title=title_text,
-            subtitle=self._format_metrics_subtitle(event),
-            border_style=border_color,
-            expand=True,
-        )
-
-    def _create_error_panel(self, event: AgentErrorEvent) -> Panel:
-        """Create a Rich Panel for AgentErrorEvent with complete content."""
-        content = Text()
-
-        content.append("Error Details:\n", style="bold red")
-        content.append(event.error, style="bright_red")
-
-        return Panel(
-            content,
-            title="[bold red]Agent Error[/bold red]",
-            subtitle=self._format_metrics_subtitle(event),
-            border_style="red",
-            expand=True,
-        )
-
-    def _create_pause_panel(self, event: PauseEvent) -> Panel:
-        """Create a Rich Panel for PauseEvent with complete content."""
-        content = Text()
-        content.append("Conversation Paused", style="bold yellow")
-
-        return Panel(
-            content,
-            title="[bold yellow]User Paused[/bold yellow]",
-            border_style="yellow",
-            expand=True,
-        )