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

openhands/sdk/llm/llm_registry.py

@@ -1,116 +0,0 @@
-from typing import Callable
-from uuid import uuid4
-
-from pydantic import BaseModel, ConfigDict
-
-from openhands.sdk.llm.llm import LLM
-from openhands.sdk.logger import get_logger
-
-
-logger = get_logger(__name__)
-
-
-class RegistryEvent(BaseModel):
-    llm: LLM
-    service_id: str
-
-    model_config = ConfigDict(
-        arbitrary_types_allowed=True,
-    )
-
-
-class LLMRegistry:
-    """A minimal LLM registry for managing LLM instances by service ID.
-
-    This registry provides a simple way to manage multiple LLM instances,
-    avoiding the need to recreate LLMs with the same configuration.
-    """
-
-    def __init__(
-        self,
-        retry_listener: Callable[[int, int], None] | None = None,
-    ):
-        """Initialize the LLM registry.
-
-        Args:
-            retry_listener: Optional callback for retry events.
-        """
-        self.registry_id = str(uuid4())
-        self.retry_listener = retry_listener
-        self.service_to_llm: dict[str, LLM] = {}
-        self.subscriber: Callable[[RegistryEvent], None] | None = None
-
-    def subscribe(self, callback: Callable[[RegistryEvent], None]) -> None:
-        """Subscribe to registry events.
-
-        Args:
-            callback: Function to call when LLMs are created or updated.
-        """
-        self.subscriber = callback
-
-    def notify(self, event: RegistryEvent) -> None:
-        """Notify subscribers of registry events.
-
-        Args:
-            event: The registry event to notify about.
-        """
-        if self.subscriber:
-            try:
-                self.subscriber(event)
-            except Exception as e:
-                logger.warning(f"Failed to emit event: {e}")
-
-    def add(self, service_id: str, llm: LLM) -> None:
-        """Add an LLM instance to the registry.
-
-        Args:
-            service_id: Unique identifier for the LLM service.
-            llm: The LLM instance to register.
-
-        Raises:
-            ValueError: If service_id already exists in the registry.
-        """
-        if service_id in self.service_to_llm:
-            raise ValueError(
-                f"Service ID '{service_id}' already exists in registry. "
-                "Use a different service_id or call get() to retrieve the existing LLM."
-            )
-
-        # Set the service_id on the LLM instance
-        llm.service_id = service_id
-        self.service_to_llm[service_id] = llm
-        self.notify(RegistryEvent(llm=llm, service_id=service_id))
-        logger.info(
-            f"[LLM registry {self.registry_id}]: Added LLM for service {service_id}"
-        )
-
-    def get(self, service_id: str) -> LLM:
-        """Get an LLM instance from the registry.
-
-        Args:
-            service_id: Unique identifier for the LLM service.
-
-        Returns:
-            The LLM instance.
-
-        Raises:
-            KeyError: If service_id is not found in the registry.
-        """
-        if service_id not in self.service_to_llm:
-            raise KeyError(
-                f"Service ID '{service_id}' not found in registry. "
-                "Use add() to register an LLM first."
-            )
-
-        logger.info(
-            f"[LLM registry {self.registry_id}]: Retrieved LLM for service {service_id}"
-        )
-        return self.service_to_llm[service_id]
-
-    def list_services(self) -> list[str]:
-        """List all registered service IDs.
-
-        Returns:
-            List of service IDs currently in the registry.
-        """
-        return list(self.service_to_llm.keys())

openhands/sdk/llm/message.py

@@ -1,216 +0,0 @@
-from typing import Any, Literal, cast
-
-import mcp.types
-from litellm import ChatCompletionMessageToolCall
-from litellm.types.utils import Message as LiteLLMMessage
-from pydantic import BaseModel, ConfigDict, Field
-
-from openhands.sdk.logger import get_logger
-from openhands.sdk.utils import DEFAULT_TEXT_CONTENT_LIMIT, maybe_truncate
-
-
-logger = get_logger(__name__)
-
-
-class BaseContent(BaseModel):
-    cache_prompt: bool = False
-
-    def to_llm_dict(
-        self,
-    ) -> dict[str, str | dict[str, str]] | list[dict[str, str | dict[str, str]]]:
-        """Convert to LLM API format. Subclasses should implement this method."""
-        raise NotImplementedError("Subclasses should implement this method.")
-
-
-class TextContent(mcp.types.TextContent, BaseContent):
-    type: Literal["text"] = "text"
-    text: str
-    # We use populate_by_name since mcp.types.TextContent
-    # alias meta -> _meta, but .model_dumps() will output "meta"
-    model_config = ConfigDict(extra="forbid", populate_by_name=True)
-
-    def to_llm_dict(self) -> dict[str, str | dict[str, str]]:
-        """Convert to LLM API format."""
-        text = self.text
-        if len(text) > DEFAULT_TEXT_CONTENT_LIMIT:
-            logger.warning(
-                f"TextContent text length ({len(text)}) exceeds limit "
-                f"({DEFAULT_TEXT_CONTENT_LIMIT}), truncating"
-            )
-            text = maybe_truncate(text, DEFAULT_TEXT_CONTENT_LIMIT)
-
-        data: dict[str, str | dict[str, str]] = {
-            "type": self.type,
-            "text": text,
-        }
-        if self.cache_prompt:
-            data["cache_control"] = {"type": "ephemeral"}
-        return data
-
-
-class ImageContent(mcp.types.ImageContent, BaseContent):
-    type: Literal["image"] = "image"
-    image_urls: list[str]
-    # We use populate_by_name since mcp.types.ImageContent
-    # alias meta -> _meta, but .model_dumps() will output "meta"
-    model_config = ConfigDict(extra="forbid", populate_by_name=True)
-
-    def to_llm_dict(self) -> list[dict[str, str | dict[str, str]]]:
-        """Convert to LLM API format."""
-        images: list[dict[str, str | dict[str, str]]] = []
-        for url in self.image_urls:
-            images.append({"type": "image_url", "image_url": {"url": url}})
-        if self.cache_prompt and images:
-            images[-1]["cache_control"] = {"type": "ephemeral"}
-        return images
-
-
-class Message(BaseModel):
-    # NOTE: this is not the same as EventSource
-    # These are the roles in the LLM's APIs
-    role: Literal["user", "system", "assistant", "tool"]
-    content: list[TextContent | ImageContent] = Field(default_factory=list)
-    cache_enabled: bool = False
-    vision_enabled: bool = False
-    # function calling
-    function_calling_enabled: bool = False
-    # - tool calls (from LLM)
-    tool_calls: list[ChatCompletionMessageToolCall] | None = None
-    # - tool execution result (to LLM)
-    tool_call_id: str | None = None
-    name: str | None = None  # name of the tool
-    # force string serializer
-    force_string_serializer: bool = False
-    # reasoning content (from reasoning models like o1, Claude thinking, DeepSeek R1)
-    reasoning_content: str | None = Field(
-        default=None,
-        description="Intermediate reasoning/thinking content from reasoning models",
-    )
-
-    @property
-    def contains_image(self) -> bool:
-        return any(isinstance(content, ImageContent) for content in self.content)
-
-    def to_llm_dict(self) -> dict[str, Any]:
-        """Serialize message for LLM API consumption.
-
-        This method chooses the appropriate serialization format based on the message
-        configuration and provider capabilities:
-        - String format: for providers that don't support list of content items
-        - List format: for providers with vision/prompt caching/tool calls support
-        """
-        if not self.force_string_serializer and (
-            self.cache_enabled or self.vision_enabled or self.function_calling_enabled
-        ):
-            message_dict = self._list_serializer()
-        else:
-            # some providers, like HF and Groq/llama, don't support a list here, but a
-            # single string
-            message_dict = self._string_serializer()
-
-        return message_dict
-
-    def _string_serializer(self) -> dict[str, Any]:
-        # convert content to a single string
-        content = "\n".join(
-            item.text for item in self.content if isinstance(item, TextContent)
-        )
-        message_dict: dict[str, Any] = {"content": content, "role": self.role}
-
-        # add tool call keys if we have a tool call or response
-        return self._add_tool_call_keys(message_dict)
-
-    def _list_serializer(self) -> dict[str, Any]:
-        content: list[dict[str, Any]] = []
-        role_tool_with_prompt_caching = False
-
-        for item in self.content:
-            # Serialize with the subclass-specific return type
-            raw = item.to_llm_dict()
-            # We have to remove cache_prompt for tool content and move it up to the
-            # message level
-            # See discussion here for details: https://github.com/BerriAI/litellm/issues/6422#issuecomment-2438765472
-            if isinstance(item, TextContent):
-                d = cast(dict[str, Any], raw)
-                if self.role == "tool" and item.cache_prompt:
-                    role_tool_with_prompt_caching = True
-                    d.pop("cache_control", None)
-                content.append(d)
-
-            elif isinstance(item, ImageContent) and self.vision_enabled:
-                # ImageContent.model_dump() always returns a list of dicts
-                d_list = cast(list[dict[str, Any]], raw)
-                if self.role == "tool" and item.cache_prompt:
-                    role_tool_with_prompt_caching = True
-                    for elem in d_list:
-                        elem.pop("cache_control", None)
-                content.extend(d_list)
-
-        message_dict: dict[str, Any] = {"content": content, "role": self.role}
-        if role_tool_with_prompt_caching:
-            message_dict["cache_control"] = {"type": "ephemeral"}
-
-        return self._add_tool_call_keys(message_dict)
-
-    def _add_tool_call_keys(self, message_dict: dict[str, Any]) -> dict[str, Any]:
-        """Add tool call keys if we have a tool call or response.
-
-        NOTE: this is necessary for both native and non-native tool calling
-        """
-        # an assistant message calling a tool
-        if self.tool_calls is not None:
-            message_dict["tool_calls"] = [
-                {
-                    "id": tool_call.id,
-                    "type": "function",
-                    "function": {
-                        "name": tool_call.function.name,
-                        "arguments": tool_call.function.arguments,
-                    },
-                }
-                for tool_call in self.tool_calls
-            ]
-
-        # an observation message with tool response
-        if self.tool_call_id is not None:
-            assert self.name is not None, (
-                "name is required when tool_call_id is not None"
-            )
-            message_dict["tool_call_id"] = self.tool_call_id
-            message_dict["name"] = self.name
-
-        return message_dict
-
-    @classmethod
-    def from_litellm_message(cls, message: LiteLLMMessage) -> "Message":
-        """Convert a LiteLLMMessage to our Message class.
-
-        Provider-agnostic mapping for reasoning:
-        - Prefer `message.reasoning_content` if present (LiteLLM normalized field)
-        """
-        assert message.role != "function", "Function role is not supported"
-
-        rc = getattr(message, "reasoning_content", None)
-
-        return Message(
-            role=message.role,
-            content=[TextContent(text=message.content)]
-            if isinstance(message.content, str)
-            else [],
-            tool_calls=message.tool_calls,
-            reasoning_content=rc,
-        )
-
-
-def content_to_str(contents: list[TextContent | ImageContent]) -> list[str]:
-    """Convert a list of TextContent and ImageContent to a list of strings.
-
-    This is primarily used for display purposes.
-    """
-    text_parts = []
-    for content_item in contents:
-        if isinstance(content_item, TextContent):
-            text_parts.append(content_item.text)
-        elif isinstance(content_item, ImageContent):
-            text_parts.append(f"[Image: {len(content_item.image_urls)} URLs]")
-    return text_parts

openhands/sdk/llm/metadata.py

@@ -1,34 +0,0 @@
-import os
-
-
-def get_llm_metadata(
-    model_name: str,
-    agent_name: str,
-    session_id: str | None = None,
-    user_id: str | None = None,
-) -> dict:
-    import openhands.sdk
-
-    openhands_tools_version: str = "n/a"
-    try:
-        import openhands.tools
-
-        openhands_tools_version = openhands.tools.__version__
-    except ModuleNotFoundError:
-        pass
-
-    metadata = {
-        "trace_version": openhands.sdk.__version__,
-        "tags": [
-            f"model:{model_name}",
-            f"agent:{agent_name}",
-            f"web_host:{os.environ.get('WEB_HOST', 'unspecified')}",
-            f"openhands_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