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

openhands/sdk/tests/llm/test_model_features.py

@@ -1,221 +0,0 @@
-import pytest
-
-from openhands.sdk.llm.utils.model_features import (
-    get_features,
-    model_matches,
-    normalize_model_name,
-)
-
-
-@pytest.mark.parametrize(
-    "raw,expected",
-    [
-        ("  OPENAI/gpt-4o  ", "gpt-4o"),
-        ("anthropic/claude-3-7-sonnet", "claude-3-7-sonnet"),
-        ("litellm_proxy/gemini-2.5-pro", "gemini-2.5-pro"),
-        ("qwen3-coder-480b-a35b-instruct", "qwen3-coder-480b-a35b-instruct"),
-        ("gpt-5", "gpt-5"),
-        ("openai/GLM-4.5-GGUF", "glm-4.5"),
-        ("openrouter/gpt-4o-mini", "gpt-4o-mini"),
-        (
-            "bedrock/anthropic.claude-3-5-sonnet-20241022-v2:0",
-            "anthropic.claude-3-5-sonnet-20241022-v2",
-        ),
-        ("", ""),
-        (None, ""),  # type: ignore[arg-type]
-    ],
-)
-def test_normalize_model_name(raw, expected):
-    assert normalize_model_name(raw) == expected
-
-
-@pytest.mark.parametrize(
-    "name,pattern,expected",
-    [
-        ("gpt-4o", "gpt-4o*", True),
-        ("openai/gpt-4o", "gpt-4o*", True),
-        ("litellm_proxy/gpt-4o-mini", "gpt-4o*", True),
-        ("claude-3-7-sonnet-20250219", "claude-3-7-sonnet*", True),
-        ("o1-2024-12-17", "o1*", True),
-        ("grok-4-0709", "grok-4-0709", True),
-        ("grok-4-0801", "grok-4-0709", False),
-    ],
-)
-def test_model_matches(name, pattern, expected):
-    assert model_matches(name, [pattern]) is expected
-
-
-@pytest.mark.parametrize(
-    "model,expected_function_calling",
-    [
-        ("gpt-4o", True),
-        ("gpt-4o-mini", True),
-        ("claude-3-5-sonnet", True),
-        ("claude-3-7-sonnet", True),
-        ("gemini-2.5-pro", True),
-        (
-            "llama-3.1-70b",
-            False,
-        ),  # Most open source models don't support native function calling
-        ("unknown-model", False),  # Default to False for unknown models
-    ],
-)
-def test_function_calling_support(model, expected_function_calling):
-    features = get_features(model)
-    assert features.supports_function_calling == expected_function_calling
-
-
-@pytest.mark.parametrize(
-    "model,expected_reasoning",
-    [
-        ("o1-2024-12-17", True),
-        ("o1", True),
-        ("o3-mini", True),
-        ("o3", True),
-        ("gpt-4o", False),
-        ("claude-3-5-sonnet", False),
-        ("gemini-1.5-pro", False),
-        ("unknown-model", False),
-    ],
-)
-def test_reasoning_effort_support(model, expected_reasoning):
-    features = get_features(model)
-    assert features.supports_reasoning_effort == expected_reasoning
-
-
-@pytest.mark.parametrize(
-    "model,expected_cache",
-    [
-        ("claude-3-5-sonnet", True),
-        ("claude-3-7-sonnet", True),
-        ("claude-3-haiku-20240307", True),
-        ("claude-3-opus-20240229", True),
-        ("gpt-4o", False),  # OpenAI doesn't support explicit prompt caching
-        ("gemini-1.5-pro", False),
-        ("unknown-model", False),
-    ],
-)
-def test_prompt_cache_support(model, expected_cache):
-    features = get_features(model)
-    assert features.supports_prompt_cache == expected_cache
-
-
-@pytest.mark.parametrize(
-    "model,expected_stop_words",
-    [
-        ("gpt-4o", True),
-        ("gpt-4o-mini", True),
-        ("claude-3-5-sonnet", True),
-        ("gemini-1.5-pro", True),
-        ("llama-3.1-70b", True),
-        ("unknown-model", True),  # Most models support stop words
-    ],
-)
-def test_stop_words_support(model, expected_stop_words):
-    features = get_features(model)
-    assert features.supports_stop_words == expected_stop_words
-
-
-def test_get_features_with_provider_prefix():
-    """Test that get_features works with provider prefixes."""
-    # Test with various provider prefixes
-    assert get_features("openai/gpt-4o").supports_function_calling is True
-    assert get_features("anthropic/claude-3-5-sonnet").supports_function_calling is True
-    assert get_features("litellm_proxy/gpt-4o").supports_function_calling is True
-
-
-def test_get_features_case_insensitive():
-    """Test that get_features is case insensitive."""
-    features_lower = get_features("gpt-4o")
-    features_upper = get_features("GPT-4O")
-    features_mixed = get_features("Gpt-4O")
-
-    assert (
-        features_lower.supports_function_calling
-        == features_upper.supports_function_calling
-    )
-    assert (
-        features_lower.supports_reasoning_effort
-        == features_upper.supports_reasoning_effort
-    )
-    assert (
-        features_lower.supports_function_calling
-        == features_mixed.supports_function_calling
-    )
-
-
-def test_get_features_with_version_suffixes():
-    """Test that get_features handles version suffixes correctly."""
-    # Test that version suffixes are handled properly
-    base_features = get_features("claude-3-5-sonnet")
-    versioned_features = get_features("claude-3-5-sonnet-20241022")
-
-    assert (
-        base_features.supports_function_calling
-        == versioned_features.supports_function_calling
-    )
-    assert (
-        base_features.supports_reasoning_effort
-        == versioned_features.supports_reasoning_effort
-    )
-    assert (
-        base_features.supports_prompt_cache == versioned_features.supports_prompt_cache
-    )
-
-
-def test_model_matches_multiple_patterns():
-    """Test model_matches with multiple patterns."""
-    patterns = ["gpt-4*", "claude-3*", "gemini-*"]
-
-    assert model_matches("gpt-4o", patterns) is True
-    assert model_matches("claude-3-5-sonnet", patterns) is True
-    assert model_matches("gemini-1.5-pro", patterns) is True
-    assert model_matches("llama-3.1-70b", patterns) is False
-
-
-def test_model_matches_exact_match():
-    """Test model_matches with exact patterns (no wildcards)."""
-    patterns = ["gpt-4o", "claude-3-5-sonnet"]
-
-    assert model_matches("gpt-4o", patterns) is True
-    assert model_matches("claude-3-5-sonnet", patterns) is True
-    assert model_matches("gpt-4o-mini", patterns) is False
-    assert model_matches("claude-3-haiku", patterns) is False
-
-
-def test_normalize_model_name_edge_cases():
-    """Test normalize_model_name with edge cases."""
-    # Test with multiple slashes
-    assert normalize_model_name("provider/sub/model-name") == "model-name"
-
-    # Test with colons and special characters
-    assert normalize_model_name("provider/model:version:tag") == "model"
-
-    # Test with whitespace and case
-    assert normalize_model_name("  PROVIDER/Model-Name  ") == "model-name"
-
-    # Test with underscores and hyphens
-    assert normalize_model_name("provider/model_name-v1") == "model_name-v1"
-
-
-def test_get_features_unknown_model():
-    """Test get_features with completely unknown model."""
-    features = get_features("completely-unknown-model-12345")
-
-    # Unknown models should have conservative defaults
-    assert features.supports_function_calling is False
-    assert features.supports_reasoning_effort is False
-    assert features.supports_prompt_cache is False
-    assert features.supports_stop_words is True  # Most models support stop words
-
-
-def test_get_features_empty_model():
-    """Test get_features with empty or None model."""
-    features_empty = get_features("")
-    features_none = get_features(None)  # type: ignore[arg-type]
-
-    # Both should return conservative defaults
-    assert features_empty.supports_function_calling is False
-    assert features_none.supports_function_calling is False
-    assert features_empty.supports_reasoning_effort is False
-    assert features_none.supports_reasoning_effort is False

openhands/sdk/tool/__init__.py

@@ -1,30 +0,0 @@
-"""OpenHands runtime package."""
-
-from openhands.sdk.tool.builtins import BUILT_IN_TOOLS, FinishTool, ThinkTool
-from openhands.sdk.tool.schema import (
-    Action,
-    ActionBase,
-    MCPActionBase,
-    Observation,
-    ObservationBase,
-)
-from openhands.sdk.tool.tool import (
-    Tool,
-    ToolAnnotations,
-    ToolExecutor,
-)
-
-
-__all__ = [
-    "Tool",
-    "ToolAnnotations",
-    "ToolExecutor",
-    "ActionBase",
-    "MCPActionBase",
-    "Action",
-    "ObservationBase",
-    "Observation",
-    "FinishTool",
-    "ThinkTool",
-    "BUILT_IN_TOOLS",
-]

openhands/sdk/tool/builtins/__init__.py

@@ -1,34 +0,0 @@
-"""Implementing essential tools that doesn't interact with the environment.
-
-These are built in and are *required* for the agent to work.
-
-For tools that require interacting with the environment, add them to `openhands/tools`.
-"""
-
-from openhands.sdk.tool.builtins.finish import (
-    FinishAction,
-    FinishExecutor,
-    FinishObservation,
-    FinishTool,
-)
-from openhands.sdk.tool.builtins.think import (
-    ThinkAction,
-    ThinkExecutor,
-    ThinkObservation,
-    ThinkTool,
-)
-
-
-BUILT_IN_TOOLS = [FinishTool, ThinkTool]
-
-__all__ = [
-    "BUILT_IN_TOOLS",
-    "FinishTool",
-    "FinishAction",
-    "FinishObservation",
-    "FinishExecutor",
-    "ThinkTool",
-    "ThinkAction",
-    "ThinkObservation",
-    "ThinkExecutor",
-]

openhands/sdk/tool/builtins/finish.py

@@ -1,57 +0,0 @@
-from pydantic import Field
-
-from openhands.sdk.llm.message import ImageContent, TextContent
-from openhands.sdk.tool.tool import (
-    ActionBase,
-    ObservationBase,
-    Tool,
-    ToolAnnotations,
-    ToolExecutor,
-)
-
-
-class FinishAction(ActionBase):
-    message: str = Field(description="Final message to send to the user.")
-
-
-class FinishObservation(ObservationBase):
-    message: str = Field(description="Final message sent to the user.")
-
-    @property
-    def agent_observation(self) -> list[TextContent | ImageContent]:
-        return [TextContent(text=self.message)]
-
-
-TOOL_DESCRIPTION = """Signals the completion of the current task or conversation.
-
-Use this tool when:
-- You have successfully completed the user's requested task
-- You cannot proceed further due to technical limitations or missing information
-
-The message should include:
-- A clear summary of actions taken and their results
-- Any next steps for the user
-- Explanation if you're unable to complete the task
-- Any follow-up questions if more information is needed
-"""
-
-
-class FinishExecutor(ToolExecutor):
-    def __call__(self, action: FinishAction) -> FinishObservation:
-        return FinishObservation(message=action.message)
-
-
-FinishTool = Tool(
-    name="finish",
-    input_schema=FinishAction,
-    output_schema=FinishObservation,
-    description=TOOL_DESCRIPTION,
-    executor=FinishExecutor(),
-    annotations=ToolAnnotations(
-        title="finish",
-        readOnlyHint=True,
-        destructiveHint=False,
-        idempotentHint=True,
-        openWorldHint=False,
-    ),
-)

openhands/sdk/tool/builtins/think.py

@@ -1,60 +0,0 @@
-from pydantic import Field
-
-from openhands.sdk.llm.message import ImageContent, TextContent
-from openhands.sdk.tool.tool import (
-    ActionBase,
-    ObservationBase,
-    Tool,
-    ToolAnnotations,
-    ToolExecutor,
-)
-
-
-class ThinkAction(ActionBase):
-    """Action for logging a thought without making any changes."""
-
-    thought: str = Field(description="The thought to log.")
-
-
-class ThinkObservation(ObservationBase):
-    """Observation returned after logging a thought."""
-
-    content: str = Field(
-        default="Your thought has been logged.", description="Confirmation message."
-    )
-
-    @property
-    def agent_observation(self) -> list[TextContent | ImageContent]:
-        return [TextContent(text=self.content)]
-
-
-THINK_DESCRIPTION = """Use the tool to think about something. It will not obtain new information or make any changes to the repository, but just log the thought. Use it when complex reasoning or brainstorming is needed.
-
-Common use cases:
-1. When exploring a repository and discovering the source of a bug, call this tool to brainstorm several unique ways of fixing the bug, and assess which change(s) are likely to be simplest and most effective.
-2. After receiving test results, use this tool to brainstorm ways to fix failing tests.
-3. When planning a complex refactoring, use this tool to outline different approaches and their tradeoffs.
-4. When designing a new feature, use this tool to think through architecture decisions and implementation details.
-5. When debugging a complex issue, use this tool to organize your thoughts and hypotheses.
-
-The tool simply logs your thought process for better transparency and does not execute any code or make changes."""  # noqa: E501
-
-
-class ThinkExecutor(ToolExecutor):
-    def __call__(self, _: ThinkAction) -> ThinkObservation:
-        return ThinkObservation()
-
-
-ThinkTool = Tool(
-    name="think",
-    description=THINK_DESCRIPTION,
-    input_schema=ThinkAction,
-    output_schema=ThinkObservation,
-    executor=ThinkExecutor(),
-    annotations=ToolAnnotations(
-        readOnlyHint=True,
-        destructiveHint=False,
-        idempotentHint=True,
-        openWorldHint=False,
-    ),
-)

openhands/sdk/tool/schema.py

@@ -1,236 +0,0 @@
-from typing import Annotated, Any, TypeVar
-
-from pydantic import BaseModel, ConfigDict, Field, create_model
-
-from openhands.sdk.llm import ImageContent, TextContent
-from openhands.sdk.tool.security_prompt import (
-    SECURITY_RISK_DESC,
-    SECURITY_RISK_LITERAL,
-)
-from openhands.sdk.utils.discriminated_union import (
-    DiscriminatedUnionMixin,
-    DiscriminatedUnionType,
-)
-
-
-S = TypeVar("S", bound="Schema")
-
-
-def py_type(spec: dict[str, Any]) -> Any:
-    """Map JSON schema types to Python types."""
-    t = spec.get("type")
-    if t == "array":
-        items = spec.get("items", {})
-        inner = py_type(items) if isinstance(items, dict) else Any
-        return list[inner]  # type: ignore[index]
-    if t == "object":
-        return dict[str, Any]
-    _map = {
-        "string": str,
-        "integer": int,
-        "number": float,
-        "boolean": bool,
-    }
-    if t in _map:
-        return _map[t]
-    return Any
-
-
-def _process_schema_node(node, defs):
-    """Recursively process a schema node to simplify and resolve $ref.
-
-    https://www.reddit.com/r/mcp/comments/1kjo9gt/toolinputschema_conversion_from_pydanticmodel/
-    https://gist.github.com/leandromoreira/3de4819e4e4df9422d87f1d3e7465c16
-    """
-    # Handle $ref references
-    if "$ref" in node:
-        ref_path = node["$ref"]
-        if ref_path.startswith("#/$defs/"):
-            ref_name = ref_path.split("/")[-1]
-            if ref_name in defs:
-                # Process the referenced definition
-                return _process_schema_node(defs[ref_name], defs)
-
-    # Start with a new schema object
-    result = {}
-
-    # Copy the basic properties
-    if "type" in node:
-        result["type"] = node["type"]
-
-    # Handle anyOf (often used for optional fields with None)
-    if "anyOf" in node:
-        non_null_types = [t for t in node["anyOf"] if t.get("type") != "null"]
-        if non_null_types:
-            # Process the first non-null type
-            processed = _process_schema_node(non_null_types[0], defs)
-            result.update(processed)
-
-    # Handle description
-    if "description" in node:
-        result["description"] = node["description"]
-
-    # Handle object properties recursively
-    if node.get("type") == "object" and "properties" in node:
-        result["type"] = "object"
-        result["properties"] = {}
-
-        # Process each property
-        for prop_name, prop_schema in node["properties"].items():
-            result["properties"][prop_name] = _process_schema_node(prop_schema, defs)
-
-        # Add required fields if present
-        if "required" in node:
-            result["required"] = node["required"]
-
-    # Handle arrays
-    if node.get("type") == "array" and "items" in node:
-        result["type"] = "array"
-        result["items"] = _process_schema_node(node["items"], defs)
-
-    # Handle enum
-    if "enum" in node:
-        result["enum"] = node["enum"]
-
-    return result
-
-
-class Schema(BaseModel):
-    """Base schema for input action / output observation."""
-
-    model_config = ConfigDict(extra="forbid")
-
-    @classmethod
-    def to_mcp_schema(cls) -> dict[str, Any]:
-        """Convert to JSON schema format compatible with MCP."""
-        full_schema = cls.model_json_schema()
-        # This will get rid of all "anyOf" in the schema,
-        # so it is fully compatible with MCP tool schema
-        return _process_schema_node(full_schema, full_schema.get("$defs", {}))
-
-    @classmethod
-    def from_mcp_schema(
-        cls: type[S], model_name: str, schema: dict[str, Any]
-    ) -> type["S"]:
-        """Create a Schema subclass from an MCP/JSON Schema object.
-
-        For non-required fields, we annotate as `T | None`
-        so explicit nulls are allowed.
-        """
-        assert isinstance(schema, dict), "Schema must be a dict"
-        assert schema.get("type") == "object", "Only object schemas are supported"
-
-        props: dict[str, Any] = schema.get("properties", {}) or {}
-        required = set(schema.get("required", []) or [])
-
-        fields: dict[str, tuple] = {}
-        for fname, spec in props.items():
-            spec = spec if isinstance(spec, dict) else {}
-            tp = py_type(spec)
-
-            # Add description if present
-            desc: str | None = spec.get("description")
-
-            # Required → bare type, ellipsis sentinel
-            # Optional → make nullable via `| None`, default None
-            if fname in required:
-                anno = tp
-                default = ...
-            else:
-                anno = tp | None  # allow explicit null in addition to omission
-                default = None
-
-            fields[fname] = (
-                anno,
-                Field(default=default, description=desc)
-                if desc
-                else Field(default=default),
-            )
-
-        return create_model(model_name, __base__=cls, **fields)  # type: ignore[return-value]
-
-
-class ActionBase(Schema, DiscriminatedUnionMixin):
-    """Base schema for input action."""
-
-    # NOTE: We make it optional since some weaker
-    # LLMs may not be able to fill it out correctly.
-    # https://github.com/All-Hands-AI/OpenHands/issues/10797
-    security_risk: SECURITY_RISK_LITERAL = Field(
-        default="UNKNOWN", description=SECURITY_RISK_DESC
-    )
-
-    @classmethod
-    def to_mcp_schema(cls) -> dict[str, Any]:
-        """Convert to JSON schema format compatible with MCP."""
-        schema = super().to_mcp_schema()
-
-        # We need to move the fields from ActionBase to the END of the properties
-        # We use these properties to generate the llm schema for tool calling
-        # and we want the ActionBase fields to be at the end
-        # e.g. LLM should already outputs the argument for tools
-        # BEFORE it predicts security_risk
-        assert "properties" in schema, "Schema must have properties"
-        for field_name in ActionBase.model_fields.keys():
-            if field_name in schema["properties"]:
-                v = schema["properties"].pop(field_name)
-                schema["properties"][field_name] = v
-        return schema
-
-
-class MCPActionBase(ActionBase):
-    """Base schema for MCP input action."""
-
-    model_config = ConfigDict(extra="allow")
-
-    # Collect all fields from ActionBase and its parents
-    _parent_fields: frozenset[str] = frozenset(
-        fname
-        for base in ActionBase.__mro__
-        if issubclass(base, BaseModel)
-        for fname in {
-            **base.model_fields,
-            **base.model_computed_fields,
-        }.keys()
-    )
-
-    def to_mcp_arguments(self) -> dict:
-        """Dump model excluding parent ActionBase fields.
-
-        This is used to convert this action to MCP tool call arguments.
-        The parent fields (e.g., safety_risk, kind) are not part of the MCP tool schema
-        but are only used for our internal processing.
-        """
-        data = self.model_dump(exclude_none=True)
-        for f in self._parent_fields:
-            data.pop(f, None)
-        return data
-
-
-Action = Annotated[ActionBase, DiscriminatedUnionType[ActionBase]]
-"""Type annotation for values that can be any implementation of ActionBase.
-
-In most situations, this is equivalent to ActionBase. However, when used in Pydantic
-BaseModels as a field annotation, it enables polymorphic deserialization by delaying the
-discriminator resolution until runtime.
-"""
-
-
-class ObservationBase(Schema, DiscriminatedUnionMixin):
-    """Base schema for output observation."""
-
-    model_config = ConfigDict(extra="allow")
-
-    @property
-    def agent_observation(self) -> list[TextContent | ImageContent]:
-        """Get the observation string to show to the agent."""
-        raise NotImplementedError("Subclasses must implement agent_observation")
-
-
-Observation = Annotated[ObservationBase, DiscriminatedUnionType[ObservationBase]]
-"""Type annotation for values that can be any implementation of ObservationBase.
-
-In most situations, this is equivalent to ObservationBase. However, when used in
-Pydantic BaseModels as a field annotation, it enables polymorphic deserialization by
-delaying the discriminator resolution until runtime.
-"""

openhands/sdk/tool/security_prompt.py

@@ -1,5 +0,0 @@
-from typing import Literal
-
-
-SECURITY_RISK_DESC = "The LLM's assessment of the safety risk of this action."
-SECURITY_RISK_LITERAL = Literal["LOW", "MEDIUM", "HIGH", "UNKNOWN"]