Agents

from hud.agents import MCPAgent

async def initialize(task: str | Task | None = None) -> None
    """Initialize agent with task-specific configuration."""

async def run(prompt_or_task: str | Task | dict[str, Any], max_steps: int = 10) -> Trace
    """Run agent with prompt or task. Returns Trace with results."""

async def call_tools(tool_call: MCPToolCall | list[MCPToolCall]) -> list[MCPToolResult]
    """Execute tool calls through MCP client."""

def get_available_tools() -> list[types.Tool]
    """Get filtered list of available tools (excludes lifecycle)."""

def get_tool_schemas() -> list[dict]
    """Get tool schemas formatted for the model."""

async def get_system_messages() -> list[Any]
    """Get system prompt formatted for the model."""

async def get_response(messages: list[Any]) -> AgentResponse
    """Get model response including tool calls."""

async def format_blocks(blocks: list[ContentBlock]) -> list[Any]
    """Format content blocks into model messages."""

async def format_tool_results(tool_calls: list[MCPToolCall], 
                            tool_results: list[MCPToolResult]) -> list[Any]
    """Format tool results for the model."""

from hud.agents import ClaudeAgent

agent = ClaudeAgent(
    model="claude-3-5-sonnet-20241022",
    max_tokens=8192
)

result = await agent.run(
    Task(
        prompt="Navigate to example.com",
        mcp_config={"server": {...}},
        evaluate_tool={"name": "evaluate", "arguments": {...}}
    )
)

from hud.agents import OperatorAgent

from hud.agents import GenericOpenAIChatAgent

# Use with local LLM
from openai import AsyncOpenAI

client = AsyncOpenAI(
    base_url="http://localhost:11434/v1",  # Ollama
    api_key="not-needed"
)

agent = GenericOpenAIChatAgent(
    model_client=client,
    model="llama3.1"
)

from hud.agents import LangChainAgent

from langchain_anthropic import ChatAnthropic

model = ChatAnthropic(model="claude-3-opus-20240229")
agent = LangChainAgent(model=model)

from hud.agents import ArtHUDAgent

from hud.agents.misc import ResponseAgent

class MyResponseAgent(ResponseAgent):
    async def determine_response(self, agent_output: str) -> str:
        if "task complete" in agent_output.lower():
            return "STOP"
        return "Continue with the next step"

from hud.types import AgentResponse

@dataclass
class AgentResponse:
    content: str | None = None
    tool_calls: list[MCPToolCall] | None = None
    done: bool = False

from hud.types import MCPToolCall

class MCPToolCall(BaseModel):
    name: str
    arguments: dict[str, Any] = {}

from hud.types import MCPToolResult

class MCPToolResult(BaseModel):
    content: list[ContentBlock]
    structuredContent: dict[str, Any] | None = None
    isError: bool = False

from hud.types import Trace

class Trace(BaseModel):
    reward: float = 0.0
    done: bool = True
    content: str | None = None
    isError: bool = False
    info: dict[str, Any] = {}
    steps: list[TraceStep] = []

from hud.agents import ClaudeAgent
from hud.clients import MCPClient

# Manual client creation
client = MCPClient({
    "server": {
        "command": "docker",
        "args": ["run", "-i", "my-env:latest"]
    }
})

agent = ClaudeAgent(mcp_client=client)
await agent.initialize()

# Run with string prompt
result = await agent.run("Click the submit button", max_steps=5)
print(f"Result: {result.content}")
print(f"Success: {not result.isError}")

from hud.agents import OperatorAgent
from hud.datasets import Task

# No client needed - auto-created from task
agent = OperatorAgent()

task = Task(
    prompt="Find the price of the product",
    mcp_config={
        "browser": {
            "url": "mcp://mcp.hud.so/v3/mcp",
            "headers": {
                "Authorization": "Bearer ${HUD_API_KEY}",
                "Mcp-Image": "hudpython/hud-browser:latest"
            }
        }
    },
    setup_tool={
        "name": "setup",
        "arguments": {"url": "https://example.com"}
    },
    evaluate_tool={
        "name": "evaluate", 
        "arguments": {"check": "price_found"}
    }
)

# Client created automatically
result = await agent.run(task, max_steps=20)
print(f"Reward: {result.reward}")

from hud.agents import MCPAgent
from hud.types import AgentResponse
import hud

class MyCustomAgent(MCPAgent):
    metadata = {"custom": "metadata"}
    
    async def get_system_messages(self) -> list[dict]:
        return [{
            "role": "system",
            "content": self.system_prompt
        }]
    
    @hud.instrument(span_type="agent", record_args=False, record_result=True)
    async def get_response(self, messages: list[dict]) -> AgentResponse:
        # Your LLM call here
        response = await self.llm.chat(messages)
        
        return AgentResponse(
            content=response.content,
            tool_calls=[
                MCPToolCall(name=tc.name, arguments=tc.args)
                for tc in response.tool_calls
            ],
            done=response.stop_reason == "stop"
        )
    
    async def format_blocks(self, blocks: list[ContentBlock]) -> list[dict]:
        content = []
        for block in blocks:
            if block.type == "text":
                content.append({"type": "text", "text": block.text})
            elif block.type == "image":
                content.append({
                    "type": "image",
                    "image": {"data": block.data, "format": "png"}
                })
        
        return [{"role": "user", "content": content}]
    
    async def format_tool_results(self, tool_calls, tool_results) -> list[dict]:
        return [{
            "role": "tool",
            "content": result.content,
            "tool_call_id": call.name
        } for call, result in zip(tool_calls, tool_results)]