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

openhands/sdk/event/__init__.py

@@ -1,27 +0,0 @@
-from openhands.sdk.event.base import Event, EventBase, LLMConvertibleEvent
-from openhands.sdk.event.condenser import Condensation, CondensationRequest
-from openhands.sdk.event.llm_convertible import (
-    ActionEvent,
-    AgentErrorEvent,
-    MessageEvent,
-    ObservationEvent,
-    SystemPromptEvent,
-    UserRejectObservation,
-)
-from openhands.sdk.event.user_action import PauseEvent
-
-
-__all__ = [
-    "EventBase",
-    "LLMConvertibleEvent",
-    "SystemPromptEvent",
-    "ActionEvent",
-    "ObservationEvent",
-    "MessageEvent",
-    "AgentErrorEvent",
-    "UserRejectObservation",
-    "PauseEvent",
-    "Event",
-    "Condensation",
-    "CondensationRequest",
-]

openhands/sdk/event/base.py

@@ -1,148 +0,0 @@
-import uuid
-from abc import ABC, abstractmethod
-from datetime import datetime
-from typing import TYPE_CHECKING, Annotated, cast
-
-from pydantic import BaseModel, ConfigDict, Field
-
-from openhands.sdk.event.types import SourceType
-from openhands.sdk.llm import ImageContent, Message, TextContent
-from openhands.sdk.utils.discriminated_union import (
-    DiscriminatedUnionMixin,
-    DiscriminatedUnionType,
-)
-
-
-if TYPE_CHECKING:
-    from openhands.sdk.event.llm_convertible import ActionEvent
-
-N_CHAR_PREVIEW = 500
-
-
-class EventBase(DiscriminatedUnionMixin, BaseModel, ABC):
-    """Base class for all events."""
-
-    model_config = ConfigDict(extra="forbid")
-    id: str = Field(
-        default_factory=lambda: str(uuid.uuid4()),
-        description="Unique event id (ULID/UUID)",
-    )
-    timestamp: str = Field(
-        default_factory=lambda: datetime.now().isoformat(),
-        description="Event timestamp",
-    )  # consistent with V1
-    source: SourceType = Field(..., description="The source of this event")
-
-    def __str__(self) -> str:
-        """Plain text string representation for display."""
-        return f"{self.__class__.__name__} ({self.source})"
-
-    def __repr__(self) -> str:
-        """Developer-friendly representation."""
-        return (
-            f"{self.__class__.__name__}(id='{self.id[:8]}...', "
-            f"source='{self.source}', timestamp='{self.timestamp}')"
-        )
-
-
-Event = Annotated[EventBase, DiscriminatedUnionType[EventBase]]
-"""Type annotation for values that can be any implementation of EventBase.
-
-In most situations, this is equivalent to EventBase. However, when used in Pydantic
-BaseModels as a field annotation, it enables polymorphic deserialization by delaying the
-discriminator resolution until runtime.
-"""
-
-
-class LLMConvertibleEvent(EventBase, ABC):
-    """Base class for events that can be converted to LLM messages."""
-
-    @abstractmethod
-    def to_llm_message(self) -> Message:
-        raise NotImplementedError()
-
-    def __str__(self) -> str:
-        """Plain text string representation showing LLM message content."""
-        base_str = super().__str__()
-        try:
-            llm_message = self.to_llm_message()
-            # Extract text content from the message
-            text_parts = []
-            for content in llm_message.content:
-                if isinstance(content, TextContent):
-                    text_parts.append(content.text)
-                elif isinstance(content, ImageContent):
-                    text_parts.append(f"[Image: {len(content.image_urls)} URLs]")
-
-            if text_parts:
-                content_preview = " ".join(text_parts)
-                # Truncate long content for display
-                if len(content_preview) > N_CHAR_PREVIEW:
-                    content_preview = content_preview[: N_CHAR_PREVIEW - 3] + "..."
-                return f"{base_str}\n  {llm_message.role}: {content_preview}"
-            else:
-                return f"{base_str}\n  {llm_message.role}: [no text content]"
-        except Exception:
-            # Fallback to base representation if LLM message conversion fails
-            return base_str
-
-    @staticmethod
-    def events_to_messages(events: list["LLMConvertibleEvent"]) -> list[Message]:
-        """Convert event stream to LLM message stream, handling multi-action batches"""
-        # TODO: We should add extensive tests for this
-        from openhands.sdk.event.llm_convertible import ActionEvent
-
-        messages = []
-        i = 0
-
-        while i < len(events):
-            event = events[i]
-
-            if isinstance(event, ActionEvent):
-                # Collect all ActionEvents from same LLM respone
-                # This happens when function calling happens
-                batch_events: list[ActionEvent] = [event]
-                response_id = event.llm_response_id
-
-                # Look ahead for related events
-                j = i + 1
-                while (
-                    j < len(events)
-                    and isinstance(events[j], ActionEvent)
-                    and cast(ActionEvent, events[j]).llm_response_id == response_id
-                ):
-                    batch_events.append(cast(ActionEvent, events[j]))
-                    j += 1
-
-                # Create combined message for the response
-                messages.append(_combine_action_events(batch_events))
-                i = j
-            else:
-                # Regular event - direct conversion
-                messages.append(event.to_llm_message())
-                i += 1
-
-        return messages
-
-
-def _combine_action_events(events: list["ActionEvent"]) -> Message:
-    """Combine multiple ActionEvents into single LLM message.
-
-    We receive multiple ActionEvents per LLM message WHEN LLM returns
-    multiple tool calls with parallel function calling.
-    """
-    if len(events) == 1:
-        return events[0].to_llm_message()
-    # Multi-action case - reconstruct original LLM response
-    for e in events[1:]:
-        assert len(e.thought) == 0, (
-            "Expected empty thought for multi-action events after the first one"
-        )
-
-    return Message(
-        role="assistant",
-        content=cast(
-            list[TextContent | ImageContent], events[0].thought
-        ),  # Shared thought content only in the first event
-        tool_calls=[event.tool_call for event in events],
-    )

openhands/sdk/event/condenser.py

@@ -1,49 +0,0 @@
-from openhands.sdk.event.base import EventBase
-from openhands.sdk.event.types import SourceType
-
-
-class Condensation(EventBase):
-    """This action indicates a condensation of the conversation history is happening."""
-
-    forgotten_event_ids: list[str] | None = None
-    """The IDs of the events that are being forgotten (removed from the `View` given to
-    the LLM).
-    """
-
-    summary: str | None = None
-    """An optional summary of the events being forgotten."""
-
-    summary_offset: int | None = None
-    """An optional offset to the start of the resulting view indicating where the
-    summary should be inserted.
-    """
-
-    source: SourceType = "environment"
-
-    @property
-    def forgotten(self) -> list[str]:
-        """The list of event IDs that should be forgotten."""
-        if self.forgotten_event_ids is not None:
-            return self.forgotten_event_ids
-        else:
-            return []
-
-    @property
-    def message(self) -> str:
-        if self.summary:
-            return f"Summary: {self.summary}"
-        return f"Condenser is dropping the events: {self.forgotten}."
-
-
-class CondensationRequest(EventBase):
-    """This action is used to request a condensation of the conversation history.
-
-    Attributes:
-        action (str): The action type, namely ActionType.CONDENSATION_REQUEST.
-    """
-
-    source: SourceType = "environment"
-
-    @property
-    def message(self) -> str:
-        return "Requesting a condensation of the conversation history."

openhands/sdk/event/llm_convertible.py

@@ -1,265 +0,0 @@
-import copy
-from typing import cast
-
-from litellm import ChatCompletionMessageToolCall, ChatCompletionToolParam
-from pydantic import ConfigDict, Field, computed_field
-
-from openhands.sdk.event.base import N_CHAR_PREVIEW, LLMConvertibleEvent
-from openhands.sdk.event.types import SourceType
-from openhands.sdk.llm import ImageContent, Message, TextContent, content_to_str
-from openhands.sdk.llm.utils.metrics import MetricsSnapshot
-from openhands.sdk.tool import Action, Observation
-
-
-class SystemPromptEvent(LLMConvertibleEvent):
-    """System prompt added by the agent."""
-
-    source: SourceType = "agent"
-    system_prompt: TextContent = Field(..., description="The system prompt text")
-    tools: list[ChatCompletionToolParam] = Field(
-        ..., description="List of tools in OpenAI tool format"
-    )
-
-    def to_llm_message(self) -> Message:
-        return Message(role="system", content=[self.system_prompt])
-
-    def __str__(self) -> str:
-        """Plain text string representation for SystemPromptEvent."""
-        base_str = f"{self.__class__.__name__} ({self.source})"
-        prompt_preview = (
-            self.system_prompt.text[:N_CHAR_PREVIEW] + "..."
-            if len(self.system_prompt.text) > N_CHAR_PREVIEW
-            else self.system_prompt.text
-        )
-        tool_count = len(self.tools)
-        return (
-            f"{base_str}\n  System: {prompt_preview}\n  Tools: {tool_count} available"
-        )
-
-
-class ActionEvent(LLMConvertibleEvent):
-    source: SourceType = "agent"
-    thought: list[TextContent] = Field(
-        ..., description="The thought process of the agent before taking this action"
-    )
-    reasoning_content: str | None = Field(
-        default=None,
-        description="Intermediate reasoning/thinking content from reasoning models",
-    )
-    action: Action = Field(..., description="Single action (tool call) returned by LLM")
-    tool_name: str = Field(..., description="The name of the tool being called")
-    tool_call_id: str = Field(
-        ..., description="The unique id returned by LLM API for this tool call"
-    )
-    tool_call: ChatCompletionMessageToolCall = Field(
-        ...,
-        description=(
-            "The tool call received from the LLM response. We keep a copy of it "
-            "so it is easier to construct it into LLM message"
-        ),
-    )
-    llm_response_id: str = Field(
-        ...,
-        description=(
-            "Groups related actions from same LLM response. This helps in tracking "
-            "and managing results of parallel function calling from the same LLM "
-            "response."
-        ),
-    )
-    metrics: MetricsSnapshot | None = Field(
-        default=None,
-        description=(
-            "Snapshot of LLM metrics (token counts and costs). Only attached "
-            "to the last action when multiple actions share the same LLM response."
-        ),
-    )
-
-    def to_llm_message(self) -> Message:
-        """Individual message - may be incomplete for multi-action batches"""
-        content: list[TextContent | ImageContent] = cast(
-            list[TextContent | ImageContent], self.thought
-        )
-        return Message(
-            role="assistant",
-            content=content,
-            tool_calls=[self.tool_call],
-            reasoning_content=self.reasoning_content,
-        )
-
-    def __str__(self) -> str:
-        """Plain text string representation for ActionEvent."""
-        base_str = f"{self.__class__.__name__} ({self.source})"
-        thought_text = " ".join([t.text for t in self.thought])
-        thought_preview = (
-            thought_text[:N_CHAR_PREVIEW] + "..."
-            if len(thought_text) > N_CHAR_PREVIEW
-            else thought_text
-        )
-        action_name = self.action.__class__.__name__
-        return f"{base_str}\n  Thought: {thought_preview}\n  Action: {action_name}"
-
-
-class ObservationEvent(LLMConvertibleEvent):
-    source: SourceType = "environment"
-    observation: Observation = Field(
-        ..., description="The observation (tool call) sent to LLM"
-    )
-
-    action_id: str = Field(
-        ..., description="The action id that this observation is responding to"
-    )
-    tool_name: str = Field(
-        ..., description="The tool name that this observation is responding to"
-    )
-    tool_call_id: str = Field(
-        ..., description="The tool call id that this observation is responding to"
-    )
-
-    def to_llm_message(self) -> Message:
-        return Message(
-            role="tool",
-            content=self.observation.agent_observation,
-            name=self.tool_name,
-            tool_call_id=self.tool_call_id,
-        )
-
-    def __str__(self) -> str:
-        """Plain text string representation for ObservationEvent."""
-        base_str = f"{self.__class__.__name__} ({self.source})"
-        content_str = "".join(content_to_str(self.observation.agent_observation))
-        obs_preview = (
-            content_str[:N_CHAR_PREVIEW] + "..."
-            if len(content_str) > N_CHAR_PREVIEW
-            else content_str
-        )
-        return f"{base_str}\n  Tool: {self.tool_name}\n  Result: {obs_preview}"
-
-
-class MessageEvent(LLMConvertibleEvent):
-    """Message from either agent or user.
-
-    This is originally the "MessageAction", but it suppose not to be tool call."""
-
-    model_config = ConfigDict(extra="ignore")
-
-    source: SourceType
-    llm_message: Message = Field(
-        ..., description="The exact LLM message for this message event"
-    )
-    metrics: MetricsSnapshot | None = Field(
-        default=None,
-        description=(
-            "Snapshot of LLM metrics (token counts and costs) for this message. "
-            "Only attached to messages from agent."
-        ),
-    )
-
-    # context extensions stuff / microagent can go here
-    activated_microagents: list[str] = Field(
-        default_factory=list, description="List of activated microagent name"
-    )
-    extended_content: list[TextContent] = Field(
-        default_factory=list, description="List of content added by agent context"
-    )
-
-    @computed_field
-    def reasoning_content(self) -> str:
-        return self.llm_message.reasoning_content or ""
-
-    def to_llm_message(self) -> Message:
-        msg = copy.deepcopy(self.llm_message)
-        msg.content.extend(self.extended_content)
-        return msg
-
-    def __str__(self) -> str:
-        """Plain text string representation for MessageEvent."""
-        base_str = f"{self.__class__.__name__} ({self.source})"
-        # Extract text content from the message
-        text_parts = []
-        message = self.to_llm_message()
-        for content in message.content:
-            if isinstance(content, TextContent):
-                text_parts.append(content.text)
-            elif isinstance(content, ImageContent):
-                text_parts.append(f"[Image: {len(content.image_urls)} URLs]")
-
-        if text_parts:
-            content_preview = " ".join(text_parts)
-            if len(content_preview) > N_CHAR_PREVIEW:
-                content_preview = content_preview[: N_CHAR_PREVIEW - 3] + "..."
-            microagent_info = (
-                f" [Microagents: {', '.join(self.activated_microagents)}]"
-                if self.activated_microagents
-                else ""
-            )
-            return f"{base_str}\n  {message.role}: {content_preview}{microagent_info}"
-        else:
-            return f"{base_str}\n  {message.role}: [no text content]"
-
-
-class UserRejectObservation(LLMConvertibleEvent):
-    """Observation when user rejects an action in confirmation mode."""
-
-    source: SourceType = "user"
-    action_id: str = Field(
-        ..., description="The action id that this rejection is responding to"
-    )
-    tool_name: str = Field(
-        ..., description="The tool name that this rejection is responding to"
-    )
-    tool_call_id: str = Field(
-        ..., description="The tool call id that this rejection is responding to"
-    )
-    rejection_reason: str = Field(
-        default="User rejected the action",
-        description="Reason for rejecting the action",
-    )
-
-    def to_llm_message(self) -> Message:
-        return Message(
-            role="tool",
-            content=[TextContent(text=f"Action rejected: {self.rejection_reason}")],
-            name=self.tool_name,
-            tool_call_id=self.tool_call_id,
-        )
-
-    def __str__(self) -> str:
-        """Plain text string representation for UserRejectObservation."""
-        base_str = f"{self.__class__.__name__} ({self.source})"
-        reason_preview = (
-            self.rejection_reason[:N_CHAR_PREVIEW] + "..."
-            if len(self.rejection_reason) > N_CHAR_PREVIEW
-            else self.rejection_reason
-        )
-        return f"{base_str}\n  Tool: {self.tool_name}\n  Reason: {reason_preview}"
-
-
-class AgentErrorEvent(LLMConvertibleEvent):
-    """Error triggered by the agent.
-
-    Note: This event should not contain model "thought" or "reasoning_content". It
-    represents an error produced by the agent/scaffold, not model output.
-    """
-
-    source: SourceType = "agent"
-    error: str = Field(..., description="The error message from the scaffold")
-    metrics: MetricsSnapshot | None = Field(
-        default=None,
-        description=(
-            "Snapshot of LLM metrics (token counts and costs). Only attached "
-            "to the last action when multiple actions share the same LLM response."
-        ),
-    )
-
-    def to_llm_message(self) -> Message:
-        return Message(role="user", content=[TextContent(text=self.error)])
-
-    def __str__(self) -> str:
-        """Plain text string representation for AgentErrorEvent."""
-        base_str = f"{self.__class__.__name__} ({self.source})"
-        error_preview = (
-            self.error[:N_CHAR_PREVIEW] + "..."
-            if len(self.error) > N_CHAR_PREVIEW
-            else self.error
-        )
-        return f"{base_str}\n  Error: {error_preview}"

openhands/sdk/event/types.py

@@ -1,5 +0,0 @@
-from typing import Literal
-
-
-EventType = Literal["action", "observation", "message", "system_prompt", "agent_error"]
-SourceType = Literal["agent", "user", "environment"]

openhands/sdk/event/user_action.py

@@ -1,12 +0,0 @@
-from openhands.sdk.event.base import EventBase
-from openhands.sdk.event.types import SourceType
-
-
-class PauseEvent(EventBase):
-    """Event indicating that the agent execution was paused by user request."""
-
-    source: SourceType = "user"
-
-    def __str__(self) -> str:
-        """Plain text string representation for PauseEvent."""
-        return f"{self.__class__.__name__} ({self.source}): Agent execution paused"

openhands/sdk/event/utils.py

@@ -1,30 +0,0 @@
-"""Utility functions for event processing."""
-
-from openhands.sdk.event import ActionEvent, ObservationEvent, UserRejectObservation
-
-
-def get_unmatched_actions(events: list) -> list[ActionEvent]:
-    """Find actions in the event history that don't have matching observations.
-
-    Optimized to search in reverse chronological order since recent actions
-    are more likely to be unmatched (pending confirmation).
-
-    Args:
-        events: List of events to search through
-
-    Returns:
-        List of ActionEvent objects that don't have corresponding observations
-    """
-    observed_action_ids = set()
-    unmatched_actions = []
-
-    # Search in reverse - recent events are more likely to be unmatched
-    for event in reversed(events):
-        if isinstance(event, (ObservationEvent, UserRejectObservation)):
-            observed_action_ids.add(event.action_id)
-        elif isinstance(event, ActionEvent):
-            if event.id not in observed_action_ids:
-                # Insert at beginning to maintain chronological order in result
-                unmatched_actions.insert(0, event)
-
-    return unmatched_actions

openhands/sdk/llm/__init__.py

@@ -1,19 +0,0 @@
-from openhands.sdk.llm.llm import LLM
-from openhands.sdk.llm.llm_registry import LLMRegistry, RegistryEvent
-from openhands.sdk.llm.message import ImageContent, Message, TextContent, content_to_str
-from openhands.sdk.llm.metadata import get_llm_metadata
-from openhands.sdk.llm.utils.metrics import Metrics, MetricsSnapshot
-
-
-__all__ = [
-    "LLM",
-    "LLMRegistry",
-    "RegistryEvent",
-    "Message",
-    "TextContent",
-    "ImageContent",
-    "content_to_str",
-    "get_llm_metadata",
-    "Metrics",
-    "MetricsSnapshot",
-]

openhands/sdk/llm/exceptions.py

@@ -1,108 +0,0 @@
-class LLMError(Exception):
-    """Base class for all LLM-related exceptions."""
-
-    def __init__(self, message: str) -> None:
-        super().__init__(message)
-        self.message = message
-
-    def __str__(self) -> str:
-        return self.message
-
-
-class LLMMalformedActionError(LLMError):
-    """Exception raised when the LLM response is malformed or does not conform to the expected format."""  # noqa: E501
-
-    def __init__(self, message: str = "Malformed response") -> None:
-        super().__init__(message)
-
-
-class LLMNoActionError(LLMError):
-    """Exception raised when the LLM response does not include an action."""
-
-    def __init__(self, message: str = "Agent must return an action") -> None:
-        super().__init__(message)
-
-
-class LLMResponseError(LLMError):
-    """Exception raised when the LLM response does not include an action or the action is not of the expected type."""  # noqa: E501
-
-    def __init__(
-        self, message: str = "Failed to retrieve action from LLM response"
-    ) -> None:
-        super().__init__(message)
-
-
-class LLMNoResponseError(LLMError):
-    """Exception raised when the LLM does not return a response, typically seen in
-    Gemini models.
-
-    This exception should be retried
-    Typically, after retry with a non-zero temperature, the LLM will return a response
-    """
-
-    def __init__(
-        self,
-        message: str = "LLM did not return a response. This is only seen in Gemini models so far.",  # noqa: E501
-    ) -> None:
-        super().__init__(message)
-
-
-class LLMContextWindowExceedError(LLMError):
-    def __init__(
-        self,
-        message: str = "Conversation history longer than LLM context window limit. Consider turning on enable_history_truncation config to avoid this error",  # noqa: E501
-    ) -> None:
-        super().__init__(message)
-
-
-# ============================================
-# LLM function calling Exceptions
-# ============================================
-
-
-class FunctionCallConversionError(LLMError):
-    """Exception raised when FunctionCallingConverter failed to convert a non-function
-    call message to a function call message.
-
-    This typically happens when there's a malformed message (e.g., missing
-    <function=...> tags). But not due to LLM output.
-    """
-
-    def __init__(self, message: str) -> None:
-        super().__init__(message)
-
-
-class FunctionCallValidationError(LLMError):
-    """Exception raised when FunctionCallingConverter failed to validate a function
-    call message.
-
-    This typically happens when the LLM outputs unrecognized function call /
-    parameter names / values.
-    """
-
-    def __init__(self, message: str) -> None:
-        super().__init__(message)
-
-
-class FunctionCallNotExistsError(LLMError):
-    """Exception raised when an LLM call a tool that is not registered."""
-
-    def __init__(self, message: str) -> None:
-        super().__init__(message)
-
-
-# ============================================
-# Other Exceptions
-# ============================================
-
-
-class UserCancelledError(Exception):
-    def __init__(self, message: str = "User cancelled the request") -> None:
-        super().__init__(message)
-
-
-class OperationCancelled(Exception):
-    """Exception raised when an operation is cancelled (e.g. by a keyboard interrupt)."""  # noqa: E501
-
-    def __init__(self, message: str = "Operation was cancelled") -> None:
-        super().__init__(message)