hud-python 0.5.18__tar.gz → 0.5.20__tar.gz

{hud_python-0.5.18 → hud_python-0.5.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hud-python
-Version: 0.5.18
+Version: 0.5.20
 Summary: SDK for the HUD platform.
 Project-URL: Homepage, https://github.com/hud-evals/hud-python
 Project-URL: Bug Tracker, https://github.com/hud-evals/hud-python/issues
@@ -51,7 +51,7 @@ Requires-Dist: toml>=0.10.2
 Requires-Dist: typer>=0.9.0
 Requires-Dist: watchfiles>=0.21.0
 Provides-Extra: agent
-Requires-Dist: anthropic>=0.75; extra == 'agent'
+Requires-Dist: anthropic>=0.78.0; extra == 'agent'
 Requires-Dist: datasets>=2.14.0; extra == 'agent'
 Requires-Dist: google-genai; extra == 'agent'
 Requires-Dist: langchain>=1.1.0; extra == 'agent'
@@ -60,7 +60,7 @@ Requires-Dist: openai-agents; extra == 'agent'
 Requires-Dist: pillow>=11.1.0; extra == 'agent'
 Requires-Dist: tornado>=6.5.2; extra == 'agent'
 Provides-Extra: agents
-Requires-Dist: anthropic>=0.75; extra == 'agents'
+Requires-Dist: anthropic>=0.78.0; extra == 'agents'
 Requires-Dist: datasets>=2.14.0; extra == 'agents'
 Requires-Dist: google-genai; extra == 'agents'
 Requires-Dist: langchain>=1.1.0; extra == 'agents'
@@ -69,9 +69,9 @@ Requires-Dist: openai-agents; extra == 'agents'
 Requires-Dist: pillow>=11.1.0; extra == 'agents'
 Requires-Dist: tornado>=6.5.2; extra == 'agents'
 Provides-Extra: bedrock
-Requires-Dist: anthropic[bedrock]>=0.75; extra == 'bedrock'
+Requires-Dist: anthropic[bedrock]>=0.78.0; extra == 'bedrock'
 Provides-Extra: dev
-Requires-Dist: anthropic>=0.75; extra == 'dev'
+Requires-Dist: anthropic>=0.78.0; extra == 'dev'
 Requires-Dist: datasets>=2.14.0; extra == 'dev'
 Requires-Dist: dotenv>=0.9.9; extra == 'dev'
 Requires-Dist: google-adk; extra == 'dev'
@@ -92,7 +92,7 @@ Requires-Dist: pytest-asyncio; extra == 'dev'
 Requires-Dist: pytest-cov; extra == 'dev'
 Requires-Dist: pytest-mock; extra == 'dev'
 Requires-Dist: pytest>=8.1.1; extra == 'dev'
-Requires-Dist: ruff>=0.11.8; extra == 'dev'
+Requires-Dist: ruff<0.15.0,>=0.11.8; extra == 'dev'
 Requires-Dist: tornado>=6.5.2; extra == 'dev'
 Description-Content-Type: text/markdown
 

{hud_python-0.5.18 → hud_python-0.5.20}/hud/agents/base.py

@@ -88,6 +88,9 @@ class MCPAgent(ABC):
         Returns a NativeToolSpec that can be used to register the tool with
         the provider's native API format.
 
+        When the spec data is a list (model-specific variants), specs are tried in order
+        and the first one whose supports_model() matches wins.
+
         Falls back to legacy name-based detection for backwards compatibility with
         old environments that don't emit native_tools metadata.
 
@@ -101,42 +104,28 @@ class MCPAgent(ABC):
             generic function calling.
         """
         spec: NativeToolSpec | None = None
+        spec_data = None
 
         # First try metadata-based resolution
         if tool.meta:
             native_tools = tool.meta.get("native_tools", {})
-            spec_dict = native_tools.get(self.agent_type().value)
-
-            if spec_dict and isinstance(spec_dict, dict):
-                # Extract known fields and put the rest in extra
-                known_fields = {
-                    "api_type",
-                    "api_name",
-                    "beta",
-                    "hosted",
-                    "role",
-                    "supported_models",
-                }
-                extra = {k: v for k, v in spec_dict.items() if k not in known_fields}
-
-                # Convert supported_models list to tuple for frozen model
-                supported_models_raw = spec_dict.get("supported_models")
-                supported_models: tuple[str, ...] | None = None
-                if supported_models_raw:
-                    supported_models = tuple(supported_models_raw)
-
-                spec = NativeToolSpec(
-                    api_type=spec_dict.get("api_type"),
-                    api_name=spec_dict.get("api_name"),
-                    beta=spec_dict.get("beta"),
-                    hosted=spec_dict.get("hosted", False),
-                    role=spec_dict.get("role"),
-                    supported_models=supported_models,
-                    extra=extra,
-                )
+            spec_data = native_tools.get(self.agent_type().value)
+
+            if isinstance(spec_data, list):
+                # List of specs -- pick first model-matching spec
+                for item in spec_data:
+                    if not isinstance(item, dict):
+                        continue
+                    candidate = _parse_spec_dict(item)
+                    if candidate and candidate.supports_model(self.model):
+                        spec = candidate
+                        break
+            elif isinstance(spec_data, dict):
+                spec = _parse_spec_dict(spec_data)
 
         # Fall back to legacy name-based detection for old environments
-        if spec is None:
+        # Only if metadata didn't contain specs for this agent type at all
+        if spec is None and not spec_data:
             spec = self._legacy_native_spec_fallback(tool)
 
         # Check if current model supports this native spec
@@ -170,23 +159,33 @@ class MCPAgent(ABC):
         The role is used for mutual exclusion - when an agent accepts a tool
         natively, other tools with the same role are excluded.
 
+        Checks metadata first, then falls back to legacy name-based detection
+        so old environments without native_tools metadata still get proper
+        role-based exclusion.
+
         Args:
             tool: MCP Tool object to check
 
         Returns:
             The role string if any native spec defines one, None otherwise
         """
-        if not tool.meta:
-            return None
-
-        native_tools = tool.meta.get("native_tools", {})
-        if not native_tools:
-            return None
-
-        # Check all specs for a role (they should all have the same role)
-        for spec_dict in native_tools.values():
-            if isinstance(spec_dict, dict) and spec_dict.get("role"):
-                return spec_dict["role"]
+        # Check metadata-based specs first
+        if tool.meta:
+            native_tools = tool.meta.get("native_tools", {})
+            if native_tools:
+                # Check all specs for a role (they should all have the same role)
+                for spec_data in native_tools.values():
+                    if isinstance(spec_data, dict) and spec_data.get("role"):
+                        return spec_data["role"]
+                    if isinstance(spec_data, list):
+                        for item in spec_data:
+                            if isinstance(item, dict) and item.get("role"):
+                                return item["role"]
+
+        # Fall back to legacy detection for old environments without metadata
+        legacy_spec = self._legacy_native_spec_fallback(tool)
+        if legacy_spec and legacy_spec.role:
+            return legacy_spec.role
 
         return None
 
@@ -229,6 +228,10 @@ class MCPAgent(ABC):
             else:
                 result.native.append((tool, spec))
 
+        # Collect api_names claimed by native tools to prevent name collisions
+        claimed_api_names = {s.api_name for _, s in result.native if s.api_name}
+        claimed_api_names |= {s.api_name for _, s in result.hosted if s.api_name}
+
         # Second pass: process tools without native specs (generic function tools)
         for tool in tools:
             spec = self.resolve_native_spec(tool)
@@ -242,6 +245,13 @@ class MCPAgent(ABC):
                 result.skipped.append((tool, f"role '{tool_role}' already claimed by native tool"))
                 continue
 
+            # Check if this tool's name collides with a native tool's api_name
+            if tool.name in claimed_api_names:
+                result.skipped.append(
+                    (tool, f"name '{tool.name}' collides with native tool api_name")
+                )
+                continue
+
             result.generic.append(tool)
 
         return result
@@ -723,6 +733,27 @@ class MCPAgent(ABC):
         self.ctx = None
 
 
+def _parse_spec_dict(spec_dict: dict[str, Any]) -> NativeToolSpec | None:
+    """Parse a dict (from MCP meta) into a NativeToolSpec."""
+    if not spec_dict:
+        return None
+    known_fields = {"api_type", "api_name", "beta", "hosted", "role", "supported_models"}
+    extra = {k: v for k, v in spec_dict.items() if k not in known_fields}
+    supported_models_raw = spec_dict.get("supported_models")
+    supported_models: tuple[str, ...] | None = None
+    if supported_models_raw:
+        supported_models = tuple(supported_models_raw)
+    return NativeToolSpec(
+        api_type=spec_dict.get("api_type"),
+        api_name=spec_dict.get("api_name"),
+        beta=spec_dict.get("beta"),
+        hosted=spec_dict.get("hosted", False),
+        role=spec_dict.get("role"),
+        supported_models=supported_models,
+        extra=extra,
+    )
+
+
 def _format_error_result(error_message: str) -> MCPToolResult:
     return MCPToolResult(content=text_to_blocks(error_message), isError=True)
 

{hud_python-0.5.18 → hud_python-0.5.20}/hud/agents/claude.py

@@ -20,6 +20,7 @@ from anthropic.types.beta import (
     BetaTextBlockParam,
     BetaToolBash20250124Param,
     BetaToolComputerUse20250124Param,
+    BetaToolComputerUse20251124Param,
     BetaToolParam,
     BetaToolResultBlockParam,
     BetaToolTextEditor20250728Param,
@@ -71,41 +72,49 @@ class ClaudeAgent(MCPAgent):
 
         Supports old environments that expose tools like 'anthropic_computer',
         'bash', or 'str_replace_based_edit_tool' without native_tools metadata.
+
+        Each tuple is ordered by preference — first name that exists wins.
+        Only returns a spec if this tool IS that preferred match.
         """
-        name = tool.name
+        import fnmatch
+
+        available = {t.name for t in (self._available_tools or [])} | {tool.name}
+        preferred = lambda names: next((n for n in names if n in available), None) == tool.name
 
-        # Check for computer tool patterns
-        for pattern in self._LEGACY_COMPUTER_NAMES:
-            if name == pattern or name.endswith(f"_{pattern}"):
-                logger.debug("Legacy fallback: detected %s as computer tool", name)
+        if preferred(self._LEGACY_COMPUTER_NAMES):
+            logger.debug("Legacy fallback: detected %s as computer tool", tool.name)
+            model_lower = (self.model or "").lower()
+            if any(
+                fnmatch.fnmatch(model_lower, p) for p in ("claude-opus-4-5*", "claude-opus-4-6*")
+            ):
                 return NativeToolSpec(
-                    api_type="computer_20250124",
+                    api_type="computer_20251124",
                     api_name="computer",
-                    beta="computer-use-2025-01-24",
+                    beta="computer-use-2025-11-24",
                     role="computer",
                 )
+            return NativeToolSpec(
+                api_type="computer_20250124",
+                api_name="computer",
+                beta="computer-use-2025-01-24",
+                role="computer",
+            )
 
-        # Check for bash tool patterns
-        for pattern in self._LEGACY_BASH_NAMES:
-            if name == pattern or name.endswith(f"_{pattern}"):
-                logger.debug("Legacy fallback: detected %s as bash tool", name)
-                return NativeToolSpec(
-                    api_type="bash_20250124",
-                    api_name="bash",
-                    beta="computer-use-2025-01-24",
-                    role="shell",
-                )
+        if preferred(self._LEGACY_BASH_NAMES):
+            logger.debug("Legacy fallback: detected %s as bash tool", tool.name)
+            return NativeToolSpec(
+                api_type="bash_20250124",
+                api_name="bash",
+                role="shell",
+            )
 
-        # Check for text editor tool patterns
-        for pattern in self._LEGACY_EDITOR_NAMES:
-            if name == pattern or name.endswith(f"_{pattern}"):
-                logger.debug("Legacy fallback: detected %s as text_editor tool", name)
-                return NativeToolSpec(
-                    api_type="text_editor_20250728",
-                    api_name="str_replace_based_edit_tool",
-                    beta="computer-use-2025-01-24",
-                    role="editor",
-                )
+        if preferred(self._LEGACY_EDITOR_NAMES):
+            logger.debug("Legacy fallback: detected %s as text_editor tool", tool.name)
+            return NativeToolSpec(
+                api_type="text_editor_20250728",
+                api_name="str_replace_based_edit_tool",
+                role="editor",
+            )
 
         return None
 
@@ -142,7 +151,7 @@ class ClaudeAgent(MCPAgent):
         self.has_computer_tool = False
         self.tool_mapping: dict[str, str] = {}
         self.claude_tools: list[BetaToolUnionParam] = []
-        self._required_betas: set[str] = {"fine-grained-tool-streaming-2025-05-14"}
+        self._required_betas: set[str] = set()
 
     def _on_tools_ready(self) -> None:
         """Build Claude-specific tool mappings after tools are discovered."""
@@ -191,7 +200,9 @@ class ClaudeAgent(MCPAgent):
         messages_cached = self._add_prompt_caching(messages)
 
         # betas to use - collected during tool conversion based on native specs
-        betas = list(self._required_betas)
+        # Only pass betas when non-empty; an empty list can produce an empty
+        # anthropic-beta header which the API rejects.
+        betas: list[str] | Omit = list(self._required_betas) if self._required_betas else Omit()
 
         # Bedrock doesn't support .stream() - use create(stream=True) instead
         if isinstance(self.anthropic_client, AsyncAnthropicBedrock):
@@ -331,7 +342,7 @@ class ClaudeAgent(MCPAgent):
         self.has_computer_tool = False
         self.tool_mapping: dict[str, str] = {}
         self.claude_tools: list[BetaToolUnionParam] = []
-        self._required_betas: set[str] = {"fine-grained-tool-streaming-2025-05-14"}
+        self._required_betas: set[str] = set()
 
         categorized = self.categorize_tools()
 
@@ -371,6 +382,7 @@ class ClaudeAgent(MCPAgent):
                 name=tool.name,
                 description=tool.description,
                 input_schema=tool.inputSchema,
+                eager_input_streaming=True,
             )
             self.tool_mapping[tool.name] = tool.name
             self.claude_tools.append(claude_tool)
@@ -387,7 +399,7 @@ class ClaudeAgent(MCPAgent):
         Claude's native tools have fixed names that must be used exactly.
         """
         match spec.api_type:
-            case "computer_20250124":
+            case "computer_20250124" | "computer_20251124":
                 return "computer"
             case "bash_20250124":
                 return "bash"
@@ -407,8 +419,32 @@ class ClaudeAgent(MCPAgent):
             Claude-specific tool parameter
         """
         match spec.api_type:
+            case "computer_20251124":
+                display_width = spec.extra.get("display_width")
+                display_height = spec.extra.get("display_height")
+
+                if display_width is None or display_height is None:
+                    import warnings
+
+                    warnings.warn(
+                        "Computer tool missing display dimensions in native_specs.extra. "
+                        "Falling back to computer_settings. This fallback will be removed "
+                        "in v0.6.0. Update your tool to pass display_width/display_height.",
+                        DeprecationWarning,
+                        stacklevel=2,
+                    )
+                    display_width = display_width or computer_settings.ANTHROPIC_COMPUTER_WIDTH
+                    display_height = display_height or computer_settings.ANTHROPIC_COMPUTER_HEIGHT
+
+                return BetaToolComputerUse20251124Param(
+                    type="computer_20251124",
+                    name="computer",
+                    display_number=1,
+                    display_width_px=display_width,
+                    display_height_px=display_height,
+                    enable_zoom=True,
+                )
             case "computer_20250124":
-                # Get display dimensions from spec.extra, fallback to settings
                 display_width = spec.extra.get("display_width")
                 display_height = spec.extra.get("display_height")
 
@@ -425,7 +461,6 @@ class ClaudeAgent(MCPAgent):
                     display_width = display_width or computer_settings.ANTHROPIC_COMPUTER_WIDTH
                     display_height = display_height or computer_settings.ANTHROPIC_COMPUTER_HEIGHT
 
-                # Claude expects name to be literal "computer"
                 return BetaToolComputerUse20250124Param(
                     type="computer_20250124",
                     name="computer",

{hud_python-0.5.18 → hud_python-0.5.20}/hud/agents/gemini.py

@@ -47,20 +47,22 @@ class GeminiAgent(MCPAgent):
 
         Supports old environments that expose tools like 'gemini_computer'
         without native_tools metadata.
+
+        Each tuple is ordered by preference — first name that exists wins.
+        Only returns a spec if this tool IS that preferred match.
         """
         from hud.tools.native_types import NativeToolSpec
 
-        name = tool.name
+        available = {t.name for t in (self._available_tools or [])} | {tool.name}
+        preferred = lambda names: next((n for n in names if n in available), None) == tool.name
 
-        # Check for computer tool patterns
-        for pattern in self._LEGACY_COMPUTER_NAMES:
-            if name == pattern or name.endswith(f"_{pattern}"):
-                logger.debug("Legacy fallback: detected %s as computer tool", name)
-                return NativeToolSpec(
-                    api_type="computer_use",
-                    api_name="gemini_computer",
-                    role="computer",
-                )
+        if preferred(self._LEGACY_COMPUTER_NAMES):
+            logger.debug("Legacy fallback: detected %s as computer tool", tool.name)
+            return NativeToolSpec(
+                api_type="computer_use",
+                api_name="gemini_computer",
+                role="computer",
+            )
 
         return None
 

{hud_python-0.5.18 → hud_python-0.5.20}/hud/agents/gemini_cua.py

@@ -78,25 +78,27 @@ class GeminiCUAAgent(GeminiAgent):
         return AgentType.GEMINI_CUA
 
     # Legacy tool name patterns for backwards compatibility
-    _LEGACY_COMPUTER_NAMES = ("gemini_computer", "computer_gemini", "computer")
+    _LEGACY_COMPUTER_NAMES = ("gemini_computer", "computer")
 
     def _legacy_native_spec_fallback(self, tool: types.Tool) -> NativeToolSpec | None:
         """Detect Gemini CUA native tools by name for backwards compatibility.
 
         Supports old environments that expose tools like 'gemini_computer'
         without native_tools metadata.
+
+        Each tuple is ordered by preference — first name that exists wins.
+        Only returns a spec if this tool IS that preferred match.
         """
-        name = tool.name
-
-        # Check for computer tool patterns
-        for pattern in self._LEGACY_COMPUTER_NAMES:
-            if name == pattern or name.endswith(f"_{pattern}"):
-                logger.debug("Legacy fallback: detected %s as computer_use tool", name)
-                return NativeToolSpec(
-                    api_type="computer_use",
-                    api_name="gemini_computer",
-                    role="computer",
-                )
+        available = {t.name for t in (self._available_tools or [])} | {tool.name}
+        preferred = lambda names: next((n for n in names if n in available), None) == tool.name
+
+        if preferred(self._LEGACY_COMPUTER_NAMES):
+            logger.debug("Legacy fallback: detected %s as computer_use tool", tool.name)
+            return NativeToolSpec(
+                api_type="computer_use",
+                api_name="gemini_computer",
+                role="computer",
+            )
 
         return None
 

{hud_python-0.5.18 → hud_python-0.5.20}/hud/agents/openai.py

@@ -62,28 +62,28 @@ class OpenAIAgent(MCPAgent):
 
         Supports old environments that expose tools like 'shell' or 'apply_patch'
         without native_tools metadata.
+
+        Each tuple is ordered by preference — first name that exists wins.
+        Only returns a spec if this tool IS that preferred match.
         """
-        name = tool.name
-
-        # Check for shell tool patterns
-        for pattern in self._LEGACY_SHELL_NAMES:
-            if name == pattern or name.endswith(f"_{pattern}"):
-                logger.debug("Legacy fallback: detected %s as shell tool", name)
-                return NativeToolSpec(
-                    api_type="shell",
-                    api_name="shell",
-                    role="shell",
-                )
+        available = {t.name for t in (self._available_tools or [])} | {tool.name}
+        preferred = lambda names: next((n for n in names if n in available), None) == tool.name
+
+        if preferred(self._LEGACY_SHELL_NAMES):
+            logger.debug("Legacy fallback: detected %s as shell tool", tool.name)
+            return NativeToolSpec(
+                api_type="shell",
+                api_name="shell",
+                role="shell",
+            )
 
-        # Check for apply_patch tool patterns
-        for pattern in self._LEGACY_APPLY_PATCH_NAMES:
-            if name == pattern or name.endswith(f"_{pattern}"):
-                logger.debug("Legacy fallback: detected %s as apply_patch tool", name)
-                return NativeToolSpec(
-                    api_type="apply_patch",
-                    api_name="apply_patch",
-                    role="editor",
-                )
+        if preferred(self._LEGACY_APPLY_PATCH_NAMES):
+            logger.debug("Legacy fallback: detected %s as apply_patch tool", tool.name)
+            return NativeToolSpec(
+                api_type="apply_patch",
+                api_name="apply_patch",
+                role="editor",
+            )
 
         return None
 

{hud_python-0.5.18 → hud_python-0.5.20}/hud/agents/operator.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import logging
 from typing import TYPE_CHECKING, Any, ClassVar, Literal
 
 import mcp.types as types
@@ -17,7 +18,7 @@ from openai.types.responses.response_input_param import (
 from openai.types.shared_params.reasoning import Reasoning
 
 from hud.tools.computer.settings import computer_settings
-from hud.tools.native_types import NativeToolSpec  # noqa: TC001
+from hud.tools.native_types import NativeToolSpec
 from hud.types import AgentType, BaseAgentConfig, MCPToolCall, MCPToolResult
 from hud.utils.types import with_signature
 
@@ -25,6 +26,8 @@ from .base import MCPAgent
 from .openai import OpenAIAgent
 from .types import OperatorConfig, OperatorCreateParams
 
+logger = logging.getLogger(__name__)
+
 if TYPE_CHECKING:
     from openai.types.responses.response_computer_tool_call import PendingSafetyCheck
 
@@ -201,3 +204,24 @@ class OperatorAgent(OpenAIAgent):
             if isinstance(content, types.TextContent) and result.isError:
                 self.console.error_log(f"Computer tool error: {content.text}")
         return None
+
+    _LEGACY_COMPUTER_NAMES = ("openai_computer",)
+
+    def _legacy_native_spec_fallback(self, tool: types.Tool) -> NativeToolSpec | None:
+        """Detect Operator native tools by name for backwards compatibility.
+
+        Each tuple is ordered by preference — first name that exists wins.
+        Only returns a spec if this tool IS that preferred match.
+        """
+        available = {t.name for t in (self._available_tools or [])} | {tool.name}
+        preferred = lambda names: next((n for n in names if n in available), None) == tool.name
+
+        if preferred(self._LEGACY_COMPUTER_NAMES):
+            logger.debug("Legacy fallback: detected %s as computer tool", tool.name)
+            return NativeToolSpec(
+                api_type="computer_use_preview",
+                api_name="computer",
+                role="computer",
+            )
+
+        return super()._legacy_native_spec_fallback(tool)