hud-python 0.4.22__py3-none-any.whl → 0.4.24__py3-none-any.whl

hud/agents/base.py

@@ -11,7 +11,7 @@ from typing import TYPE_CHECKING, Any, ClassVar, Literal
 import mcp.types as types
 
 from hud.types import AgentResponse, MCPToolCall, MCPToolResult, Trace
-from hud.utils.design import HUDDesign
+from hud.utils.hud_console import HUDConsole
 from hud.utils.mcp import MCPConfigPatch, patch_mcp_config, setup_hud_telemetry
 
 if TYPE_CHECKING:
@@ -37,7 +37,7 @@ class MCPAgent(ABC):
       and automatic marking of lifecycle tools (setup/evaluate) from a `Task`.
     - Messaging: system prompt handling, optional inclusion of setup output on
       the first turn, and control over initial screenshots.
-    - Telemetry & UX: standardized logging/printing via `HUDDesign` and optional
+    - Telemetry & UX: standardized logging/printing via `HUDConsole` and optional
       automatic tracing (`auto_trace`).
 
     Subclasses implement provider-specific formatting and response fetching
@@ -92,13 +92,11 @@ class MCPAgent(ABC):
         self._auto_created_client = False  # Track if we created the client
 
         self.model_name = model_name
-        self.design = HUDDesign(logger=logger)
-
-        self.metadata = {}
+        self.console = HUDConsole(logger=logger)
 
         # Set verbose mode if requested
         if verbose:
-            self.design.set_verbose(True)
+            self.console.set_verbose(True)
 
         # Filtering
         self.allowed_tools = allowed_tools
@@ -133,7 +131,7 @@ class MCPAgent(ABC):
 
             self.mcp_client = MCPClient(mcp_config=task.mcp_config)
             self._auto_created_client = True
-            self.design.info_log("Auto-created MCPClient from task.mcp_config")
+            self.console.info_log("Auto-created MCPClient from task.mcp_config")
 
         # Ensure we have a client
         if self.mcp_client is None:
@@ -170,7 +168,7 @@ class MCPAgent(ABC):
         await self._filter_tools()
 
         num_tools = len(self._available_tools)
-        self.design.success_log(
+        self.console.success_log(
             f"Agent initialized with {num_tools} available tools (after filtering)"
         )
 
@@ -209,6 +207,7 @@ class MCPAgent(ABC):
             else:
                 raise TypeError(f"prompt_or_task must be str or Task, got {type(prompt_or_task)}")
         except Exception as e:
+            # Always return a Trace object for any exception
             if self._is_connection_error(e):
                 # Return error trace for connection failures
                 return Trace(
@@ -217,7 +216,15 @@ class MCPAgent(ABC):
                     content=self._get_connection_error_message(e),
                     isError=True,
                 )
-            raise
+            else:
+                # Return error trace for any other exception
+                return Trace(
+                    reward=0.0,
+                    done=True,
+                    content=f"Task failed with error: {e}",
+                    isError=True,
+                    info={"error": str(e)},
+                )
         finally:
             # Cleanup auto-created resources
             await self._cleanup()
@@ -245,7 +252,7 @@ class MCPAgent(ABC):
 
             # Execute the setup tool and append the initial observation to the context
             if task.setup_tool is not None:
-                self.design.progress_log(f"Setting up tool phase: {task.setup_tool}")
+                self.console.progress_log(f"Setting up tool phase: {task.setup_tool}")
                 results = await self.call_tools(task.setup_tool)
                 if any(result.isError for result in results):
                     raise RuntimeError(f"{results}")
@@ -259,39 +266,58 @@ class MCPAgent(ABC):
             prompt_result = await self._run_context(start_context, max_steps=max_steps)
 
         except Exception as e:
-            self.design.error_log(f"Task execution failed: {e}")
+            self.console.error_log(f"Task execution failed: {e}")
             # Create an error result but don't return yet - we still want to evaluate
             prompt_result = Trace(reward=0.0, done=True, content=str(e), isError=True)
             prompt_result.populate_from_context()
 
-        # Always evaluate if we have a prompt result and evaluate tool
-        if prompt_result is not None and task.evaluate_tool is not None:
+        # Always evaluate if we have evaluate tool, regardless of errors
+        if task.evaluate_tool is not None:
             try:
-                self.design.progress_log(f"Evaluating tool phase: {task.evaluate_tool}")
+                self.console.progress_log(f"Evaluating tool phase: {task.evaluate_tool}")
                 results = await self.call_tools(task.evaluate_tool)
 
                 if any(result.isError for result in results):
-                    raise RuntimeError(f"{results}")
-
-                # Extract reward and content from evaluation
-                if results:
-                    reward = find_reward(results[0])
-                    eval_content = find_content(results[0])
-
-                    # Update the prompt result with evaluation reward
-                    prompt_result.reward = reward
-
-                    # Update the prompt result with evaluation content (if available)
-                    if eval_content:
-                        # Prompt result may already have final response content, so we append to it
-                        if prompt_result.content:
-                            prompt_result.content += "\n\n" + eval_content
+                    self.console.warning_log(f"Evaluate tool returned error: {results}")
+                    # Still extract what we can from the error response
+                    if prompt_result is None:
+                        prompt_result = Trace(
+                            reward=0.0,
+                            done=True,
+                            content="Task failed before evaluation",
+                            isError=True,
+                        )
+                    prompt_result.reward = 0.0  # Default to 0 on error
+                else:
+                    # Extract reward and content from evaluation
+                    if results:
+                        reward = find_reward(results[0])
+                        eval_content = find_content(results[0])
+
+                        # Update the prompt result with evaluation reward
+                        if prompt_result is None:
+                            prompt_result = Trace(
+                                reward=reward, done=True, content=eval_content or "", isError=False
+                            )
                         else:
-                            prompt_result.content = eval_content
+                            prompt_result.reward = reward
+
+                            # Update the prompt result with evaluation content (if available)
+                            if eval_content:
+                                # Prompt result may already have final response content,
+                                # so we append to it
+                                if prompt_result.content:
+                                    prompt_result.content += "\n\n" + eval_content
+                                else:
+                                    prompt_result.content = eval_content
 
             except Exception as e:
-                self.design.error_log(f"Evaluation phase failed: {e}")
-                # Continue with the prompt result even if evaluation failed
+                self.console.error_log(f"Evaluation phase failed: {e}")
+                # Ensure we have a result even if evaluation failed
+                if prompt_result is None:
+                    prompt_result = Trace(
+                        reward=0.0, done=True, content=f"Evaluation failed: {e}", isError=True
+                    )
 
         return (
             prompt_result
@@ -321,21 +347,21 @@ class MCPAgent(ABC):
 
             # Add initial context
             messages.extend(await self.format_message(context))
-            self.design.debug(f"Messages: {messages}")
+            self.console.debug(f"Messages: {messages}")
 
             step_count = 0
             while max_steps == -1 or step_count < max_steps:
                 step_count += 1
                 if max_steps == -1:
-                    self.design.debug(f"Step {step_count} (unlimited)")
+                    self.console.debug(f"Step {step_count} (unlimited)")
                 else:
-                    self.design.debug(f"Step {step_count}/{max_steps}")
+                    self.console.debug(f"Step {step_count}/{max_steps}")
 
                 try:
                     # 1. Get model response
                     response = await self.get_response(messages)
 
-                    self.design.debug(f"Agent:\n{response}")
+                    self.console.debug(f"Agent:\n{response}")
 
                     # Check if we should stop
                     if response.done or not response.tool_calls:
@@ -347,16 +373,16 @@ class MCPAgent(ABC):
                                     response.content
                                 )
                             except Exception as e:
-                                self.design.warning_log(f"ResponseAgent failed: {e}")
+                                self.console.warning_log(f"ResponseAgent failed: {e}")
                         if decision == "STOP":
                             # Try to submit response through lifecycle tool
                             await self._maybe_submit_response(response, messages)
 
-                            self.design.debug("Stopping execution")
+                            self.console.debug("Stopping execution")
                             final_response = response
                             break
                         else:
-                            self.design.debug("Continuing execution")
+                            self.console.debug("Continuing execution")
                             messages.extend(await self.format_message(decision))
                             continue
 
@@ -378,21 +404,21 @@ class MCPAgent(ABC):
                     for call, result in zip(tool_calls, tool_results, strict=False):
                         step_info += f"\n{call}\n{result}"
 
-                    self.design.info_log(step_info)
+                    self.console.info_log(step_info)
 
                 except Exception as e:
-                    self.design.error_log(f"Step failed: {e}")
+                    self.console.error_log(f"Step failed: {e}")
                     error = str(e)
                     break
 
         except KeyboardInterrupt:
-            self.design.warning_log("Agent execution interrupted by user")
+            self.console.warning_log("Agent execution interrupted by user")
             error = "Interrupted by user"
         except asyncio.CancelledError:
-            self.design.warning_log("Agent execution cancelled")
+            self.console.warning_log("Agent execution cancelled")
             error = "Cancelled"
         except Exception as e:
-            self.design.error_log(f"Unexpected error: {e}")
+            self.console.error_log(f"Unexpected error: {e}")
             error = str(e)
 
         # Build result
@@ -433,17 +459,17 @@ class MCPAgent(ABC):
         results: list[MCPToolResult] = []
         for tc in tool_call:
             try:
-                self.design.debug(f"Calling tool: {tc}")
+                self.console.debug(f"Calling tool: {tc}")
                 results.append(await self.mcp_client.call_tool(tc))
             except TimeoutError as e:
-                self.design.error_log(f"Tool execution timed out: {e}")
+                self.console.error_log(f"Tool execution timed out: {e}")
                 try:
                     await self.mcp_client.shutdown()
                 except Exception as close_err:
-                    self.design.debug(f"Failed to close MCP client cleanly: {close_err}")
+                    self.console.debug(f"Failed to close MCP client cleanly: {close_err}")
                 raise
             except Exception as e:
-                self.design.error_log(f"Tool execution failed: {e}")
+                self.console.error_log(f"Tool execution failed: {e}")
                 results.append(_format_error_result(str(e)))
         return results
 
@@ -575,7 +601,7 @@ class MCPAgent(ABC):
 
             # Add to lifecycle tools if found
             if response_tool_name and response_tool_name not in self.lifecycle_tools:
-                self.design.debug(f"Auto-detected '{response_tool_name}' tool as a lifecycle tool")
+                self.console.debug(f"Auto-detected '{response_tool_name}' tool as a lifecycle tool")
                 self.response_tool_name = response_tool_name
                 self.lifecycle_tools.append(response_tool_name)
 
@@ -599,7 +625,7 @@ class MCPAgent(ABC):
             messages: The current message history (will be modified in-place)
         """
         if self.response_tool_name:
-            self.design.debug(f"Calling response lifecycle tool: {self.response_tool_name}")
+            self.console.debug(f"Calling response lifecycle tool: {self.response_tool_name}")
             try:
                 # Call the response tool with the agent's response
                 response_tool_call = MCPToolCall(
@@ -614,9 +640,9 @@ class MCPAgent(ABC):
                 messages.extend(response_messages)
 
                 # Mark the task as done
-                self.design.debug("Response lifecycle tool executed, marking task as done")
+                self.console.debug("Response lifecycle tool executed, marking task as done")
             except Exception as e:
-                self.design.error_log(f"Response lifecycle tool failed: {e}")
+                self.console.error_log(f"Response lifecycle tool failed: {e}")
 
     async def _setup_config(self, mcp_config: dict[str, dict[str, Any]]) -> None:
         """Inject metadata into the metadata of the initialize request."""
@@ -670,9 +696,9 @@ class MCPAgent(ABC):
         if self._auto_trace_cm:
             try:
                 self._auto_trace_cm.__exit__(None, None, None)
-                self.design.debug("Closed auto-created trace")
+                self.console.debug("Closed auto-created trace")
             except Exception as e:
-                self.design.warning_log(f"Failed to close auto-created trace: {e}")
+                self.console.warning_log(f"Failed to close auto-created trace: {e}")
             finally:
                 self._auto_trace_cm = None
 
@@ -680,9 +706,9 @@ class MCPAgent(ABC):
         if self._auto_created_client and self.mcp_client:
             try:
                 await self.mcp_client.shutdown()
-                self.design.debug("Closed auto-created MCPClient")
+                self.console.debug("Closed auto-created MCPClient")
             except Exception as e:
-                self.design.warning_log(f"Failed to close auto-created client: {e}")
+                self.console.warning_log(f"Failed to close auto-created client: {e}")
             finally:
                 self.mcp_client = None
                 self._auto_created_client = False
@@ -715,13 +741,13 @@ class MCPAgent(ABC):
         if self._is_connection_error(e):
             msg = self._get_connection_error_message(e)
             # Always show connection errors, not just when logging is enabled
-            self.design.error(f"❌ {msg}")
-            self.design.info("💡 Make sure the MCP server is started before running the agent.")
+            self.console.error(f"❌ {msg}")
+            self.console.info("💡 Make sure the MCP server is started before running the agent.")
 
             # For localhost, provide specific instructions
             error_str = str(e).lower()
             if "localhost" in error_str or "127.0.0.1" in error_str:
-                self.design.info("   Run 'hud dev' in another terminal to start the MCP server")
+                self.console.info("   Run 'hud dev' in another terminal to start the MCP server")
 
             raise RuntimeError(msg) from e
         raise

hud/agents/claude.py

@@ -196,7 +196,11 @@ class ClaudeAgent(MCPAgent):
                 response = await self.anthropic_client.beta.messages.create(**create_kwargs)
                 break
             except BadRequestError as e:
-                if e.message.startswith("prompt is too long"):
+                if (
+                    "prompt is too long" in str(e)
+                    or "request_too_large" in str(e)
+                    or e.status_code == 413
+                ):
                     logger.warning("Prompt too long, truncating message history")
                     # Keep first message and last 20 messages
                     if len(current_messages) > 21:

hud/agents/grounded_openai.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import json
-from typing import Any
+from typing import Any, ClassVar
 
 from hud import instrument
 from hud.tools.grounding import GroundedComputerTool, Grounder, GrounderConfig
@@ -26,6 +26,8 @@ class GroundedOpenAIChatAgent(GenericOpenAIChatAgent):
     - Grounding model (Qwen2-VL etc) handles visual element detection
     """
 
+    metadata: ClassVar[dict[str, Any]] = {}
+
     def __init__(
         self,
         *,

hud/agents/misc/response_agent.py

@@ -16,7 +16,7 @@ class ResponseAgent:
     based on the agent's final response message.
     """
 
-    def __init__(self, api_key: str | None = None) -> None:
+    def __init__(self, api_key: str | None = None, model: str = "gpt-4o") -> None:
         self.api_key = api_key or settings.openai_api_key or os.environ.get("OPENAI_API_KEY")
         if not self.api_key:
             raise ValueError(
@@ -24,6 +24,7 @@ class ResponseAgent:
             )
 
         self.client = AsyncOpenAI(api_key=self.api_key)
+        self.model = model
 
         self.system_prompt = """
         You are an assistant that helps determine the appropriate response to an agent's message.
@@ -54,7 +55,7 @@ class ResponseAgent:
         """
         try:
             response = await self.client.chat.completions.create(
-                model="gpt-5-nano",
+                model=self.model,
                 messages=[
                     {"role": "system", "content": self.system_prompt},
                     {

hud/agents/openai.py

@@ -204,7 +204,7 @@ class OperatorAgent(MCPAgent):
                         break
 
                 if not latest_screenshot:
-                    self.design.warning_log("No screenshot provided for response to action")
+                    self.console.warning_log("No screenshot provided for response to action")
                     return AgentResponse(
                         content="No screenshot available for next action",
                         tool_calls=[],
@@ -327,7 +327,7 @@ class OperatorAgent(MCPAgent):
                 for content in result.content:
                     if isinstance(content, types.TextContent):
                         # Don't add error text as input_text, just track it
-                        self.design.error_log(f"Tool error: {content.text}")
+                        self.console.error_log(f"Tool error: {content.text}")
                     elif isinstance(content, types.ImageContent):
                         # Even error results might have images
                         latest_screenshot = content.data

hud/agents/openai_chat_generic.py

@@ -17,7 +17,7 @@ from __future__ import annotations
 
 import json
 import logging
-from typing import TYPE_CHECKING, Any, cast
+from typing import TYPE_CHECKING, Any, ClassVar, cast
 
 import mcp.types as types
 
@@ -36,6 +36,8 @@ logger = logging.getLogger(__name__)
 class GenericOpenAIChatAgent(MCPAgent):
     """MCP-enabled agent that speaks the OpenAI *chat.completions* protocol."""
 
+    metadata: ClassVar[dict[str, Any]] = {}
+
     def __init__(
         self,
         *,

hud/cli/__init__.py

@@ -184,7 +184,7 @@ def debug(
         hud debug . --max-phase 3               # Stop after phase 3
     """
     # Import here to avoid circular imports
-    from hud.utils.design import HUDDesign
+    from hud.utils.hud_console import HUDConsole
 
     from .utils.environment import (
         build_environment,
@@ -193,7 +193,7 @@ def debug(
         is_environment_directory,
     )
 
-    design = HUDDesign()
+    hud_console = HUDConsole()
 
     # Determine the command to run
     command = None
@@ -227,7 +227,7 @@ def debug(
             image_name, source = get_image_name(directory)
 
             if source == "auto":
-                design.info(f"Auto-generated image name: {image_name}")
+                hud_console.info(f"Auto-generated image name: {image_name}")
 
             # Build if requested or if image doesn't exist
             if build or not image_exists(image_name):
@@ -263,20 +263,20 @@ def debug(
     phases_completed = asyncio.run(debug_mcp_stdio(command, logger, max_phase=max_phase))
 
     # Show summary using design system
-    from hud.utils.design import HUDDesign
+    from hud.utils.hud_console import HUDConsole
 
-    design = HUDDesign()
+    hud_console = HUDConsole()
 
-    design.info("")  # Empty line
-    design.section_title("Debug Summary")
+    hud_console.info("")  # Empty line
+    hud_console.section_title("Debug Summary")
 
     if phases_completed == max_phase:
-        design.success(f"All {max_phase} phases completed successfully!")
+        hud_console.success(f"All {max_phase} phases completed successfully!")
         if max_phase == 5:
-            design.info("Your MCP server is fully functional and ready for production use.")
+            hud_console.info("Your MCP server is fully functional and ready for production use.")
     else:
-        design.warning(f"Completed {phases_completed} out of {max_phase} phases")
-        design.info("Check the errors above for troubleshooting.")
+        hud_console.warning(f"Completed {phases_completed} out of {max_phase} phases")
+        hud_console.info("Check the errors above for troubleshooting.")
 
     # Exit with appropriate code
     if phases_completed < max_phase:
@@ -831,9 +831,9 @@ def eval(
     ),
 ) -> None:
     """🚀 Run evaluation on datasets or individual tasks with agents."""
-    from hud.utils.design import HUDDesign
+    from hud.utils.hud_console import HUDConsole
 
-    design = HUDDesign()
+    hud_console = HUDConsole()
 
     # If no source provided, look for task/eval JSON files in current directory
     if source is None:
@@ -863,30 +863,30 @@ def eval(
         json_files = sorted(set(json_files))
 
         if not json_files:
-            design.error(
+            hud_console.error(
                 "No source provided and no task/eval JSON files found in current directory"
             )
-            design.info(
+            hud_console.info(
                 "Usage: hud eval <source> or create a task JSON file "
                 "(e.g., task.json, eval_config.json)"
             )
             raise typer.Exit(1)
         elif len(json_files) == 1:
             source = str(json_files[0])
-            design.info(f"Found task file: {source}")
+            hud_console.info(f"Found task file: {source}")
         else:
             # Multiple files found, let user choose
-            design.info("Multiple task files found:")
-            file_choice = design.select(
+            hud_console.info("Multiple task files found:")
+            file_choice = hud_console.select(
                 "Select a task file to run:",
                 choices=[str(f) for f in json_files],
             )
             source = file_choice
-            design.success(f"Selected: {source}")
+            hud_console.success(f"Selected: {source}")
 
     # If no agent specified, prompt for selection
     if agent is None:
-        agent = design.select(
+        agent = hud_console.select(
             "Select an agent to use:",
             choices=[
                 {"name": "Claude 4 Sonnet", "value": "claude"},
@@ -898,14 +898,14 @@ def eval(
     # Validate agent choice
     valid_agents = ["claude", "openai"]
     if agent not in valid_agents:
-        design.error(f"Invalid agent: {agent}. Must be one of: {', '.join(valid_agents)}")
+        hud_console.error(f"Invalid agent: {agent}. Must be one of: {', '.join(valid_agents)}")
         raise typer.Exit(1)
 
     # Import eval_command lazily to avoid importing agent dependencies
     try:
         from .eval import eval_command
     except ImportError as e:
-        design.error(
+        hud_console.error(
             "Evaluation dependencies are not installed. "
             "Please install with: pip install 'hud-python[agent]'"
         )
@@ -962,6 +962,16 @@ def hf(
 
 def main() -> None:
     """Main entry point for the CLI."""
+    # Handle --version flag before Typer parses args
+    if "--version" in sys.argv:
+        try:
+            from hud import __version__
+
+            console.print(f"HUD CLI version: [cyan]{__version__}[/cyan]")
+        except ImportError:
+            console.print("HUD CLI version: [cyan]unknown[/cyan]")
+        return
+
     try:
         # Show header for main help
         if len(sys.argv) == 1 or (len(sys.argv) == 2 and sys.argv[1] in ["--help", "-h"]):
@@ -995,9 +1005,9 @@ def main() -> None:
         except Exception:
             exit_code = 1
         if exit_code != 0:
-            from hud.utils.design import design
+            from hud.utils.hud_console import hud_console
 
-            design.info(SUPPORT_HINT)
+            hud_console.info(SUPPORT_HINT)
         raise
     except Exception:
         raise