hud 0.6.19.dev2__tar.gz → 0.6.20__tar.gz

{hud-0.6.19.dev2 → hud-0.6.20}/.gitignore

@@ -71,3 +71,9 @@ experiments/
 !.codex/environments/
 .codex/environments/*
 !.codex/environments/environment.toml
+
+# Runtime fixtures and dependency locks for featured environment templates.
+!environments/featured/**/uv.lock
+!environments/featured/file-analysis/fixtures/*.csv
+!environments/featured/libbet/games/test/
+!environments/featured/libbet/games/test/**

{hud-0.6.19.dev2 → hud-0.6.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hud
-Version: 0.6.19.dev2
+Version: 0.6.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

{hud-0.6.19.dev2 → hud-0.6.20}/hud/agents/claude/agent.py

@@ -30,6 +30,7 @@ from anthropic.types.beta import (
     BetaPlainTextSourceParam,
     BetaRequestDocumentBlockParam,
     BetaTextBlockParam,
+    BetaThinkingConfigParam,
     BetaToolChoiceAutoParam,
     BetaToolResultBlockParam,
     BetaToolUnionParam,
@@ -69,6 +70,7 @@ _STREAM_MAX_ATTEMPTS = 3
 _STREAM_RETRY_BASE_DELAY_SECONDS = 1.0
 _STREAM_RETRY_MAX_DELAY_SECONDS = 5.0
 _STREAM_JITTER = SystemRandom()
+_THINKING_BINDING_BETA = "thinking-binding-controls-2026-08-01"
 
 
 def _stream_retry_delay(attempt: int, error: Exception) -> float:
@@ -232,6 +234,7 @@ class ClaudeAgent(ToolAgent[BetaMessageParam, ClaudeConfig]):
         tools: list[BetaToolUnionParam],
         tool_choice: BetaToolChoiceAutoParam,
         betas: list[str] | Omit,
+        thinking: BetaThinkingConfigParam | Omit,
     ) -> BetaMessage:
         attempt = 1
         while True:
@@ -245,6 +248,7 @@ class ClaudeAgent(ToolAgent[BetaMessageParam, ClaudeConfig]):
                     tools=tools,
                     tool_choice=tool_choice,
                     betas=betas,
+                    thinking=thinking,
                 ) as stream:
                     stream_opened = True
                     async for _ in stream:
@@ -294,6 +298,17 @@ class ClaudeAgent(ToolAgent[BetaMessageParam, ClaudeConfig]):
         required_betas = {
             beta for tool in state.tools.values() if (beta := getattr(tool.spec, "beta", None))
         }
+        thinking_payload = dict(self.config.thinking) if self.config.thinking is not None else None
+        if self.config.max_tool_result_images is not None:
+            self._prune_tool_result_images(state.messages, self.config.max_tool_result_images)
+            required_betas.add(_THINKING_BINDING_BETA)
+            assert thinking_payload is not None
+            thinking_payload["block_binding"] = {"prefix_mismatch_behavior": "drop_block"}
+        thinking = (
+            cast("BetaThinkingConfigParam", thinking_payload)
+            if thinking_payload is not None
+            else Omit()
+        )
         betas: list[str] | Omit = list(required_betas) if required_betas else Omit()
         tool_choice = BetaToolChoiceAutoParam(type="auto", disable_parallel_tool_use=True)
         tools = cast("list[BetaToolUnionParam]", list(state.params))
@@ -315,6 +330,7 @@ class ClaudeAgent(ToolAgent[BetaMessageParam, ClaudeConfig]):
                         tools=tools,
                         tool_choice=tool_choice,
                         betas=betas,
+                        thinking=thinking,
                     )
                 else:
                     client = cast("AsyncAnthropic", self.anthropic_client)
@@ -325,6 +341,7 @@ class ClaudeAgent(ToolAgent[BetaMessageParam, ClaudeConfig]):
                         tools=tools,
                         tool_choice=tool_choice,
                         betas=betas,
+                        thinking=thinking,
                     )
 
                 state.messages.append(
@@ -371,6 +388,35 @@ class ClaudeAgent(ToolAgent[BetaMessageParam, ClaudeConfig]):
 
         return self.message_to_agent_step(response, citations_enabled=citations_enabled)
 
+    @staticmethod
+    def _prune_tool_result_images(messages: list[BetaMessageParam], limit: int) -> None:
+        retained = 0
+        removed = 0
+        for message in reversed(messages):
+            content = message["content"]
+            if not isinstance(content, list):
+                continue
+            for block in reversed(content):
+                if not isinstance(block, dict) or block.get("type") != "tool_result":
+                    continue
+                result_content = block.get("content")
+                if not isinstance(result_content, list):
+                    continue
+                result_content = cast("list[ClaudeToolResultContent]", result_content)
+                for index in range(len(result_content) - 1, -1, -1):
+                    image = result_content[index]
+                    if not isinstance(image, dict) or image.get("type") != "image":
+                        continue
+                    retained += 1
+                    if retained > limit:
+                        result_content[index] = BetaTextBlockParam(
+                            type="text",
+                            text="[Earlier tool-result image omitted by image-history policy.]",
+                        )
+                        removed += 1
+        if removed:
+            logger.info("Removed %d older tool-result images; retaining %d", removed, limit)
+
     @classmethod
     def message_to_agent_step(
         cls,

{hud-0.6.19.dev2 → hud-0.6.20}/hud/agents/claude/sdk/agent.py

@@ -119,7 +119,6 @@ class ClaudeCLIAgent(Agent[ClaudeCLIConfig]):
                 else:
                     raise ValueError("HUD_API_KEY is required for HUD gateway routing")
                 env["CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS"] = "1"
-                env["DISABLE_AUTO_COMPACT"] = "1"
                 # Alias every model tier so background requests never bypass the gateway.
                 env["ANTHROPIC_DEFAULT_SONNET_MODEL"] = self.config.model
                 env["ANTHROPIC_DEFAULT_OPUS_MODEL"] = self.config.model
@@ -141,6 +140,8 @@ class ClaudeCLIAgent(Agent[ClaudeCLIConfig]):
             ]
             if self.config.max_steps > 0:
                 args.append(f"--max-turns={self.config.max_steps}")
+            if self.config.reasoning_effort is not None:
+                args.extend(["--effort", self.config.reasoning_effort])
             if self.config.system_prompt:
                 args.extend(["--system-prompt", self.config.system_prompt])
             for tool in self.config.allowed_tools:

{hud-0.6.19.dev2 → hud-0.6.20}/hud/agents/claude/sdk/events.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import json
+import logging
 from typing import TYPE_CHECKING
 
 import mcp.types as mcp_types
@@ -16,6 +17,8 @@ from hud.utils.time import now_iso
 if TYPE_CHECKING:
     from hud.eval.run import Run
 
+logger = logging.getLogger(__name__)
+
 
 class ClaudeEvents:
     """Translate Claude CLI stream messages into canonical HUD steps."""
@@ -58,22 +61,51 @@ class ClaudeEvents:
                     raw_result = block.get("content")
                     raw_items = raw_result if isinstance(raw_result, list) else [raw_result]
                     content: list[mcp_types.ContentBlock] = []
-                    for item in raw_items:
+                    for index, item in enumerate(raw_items):
                         if isinstance(item, str):
                             content.append(mcp_types.TextContent(type="text", text=item))
-                        elif item["type"] == "text":
-                            content.append(mcp_types.TextContent(type="text", text=item["text"]))
-                        elif item["type"] == "image":
-                            source = item["source"]
-                            content.append(
-                                mcp_types.ImageContent(
-                                    type="image",
-                                    data=source["data"],
-                                    mimeType=source["media_type"],
+                            continue
+                        match item["type"]:
+                            case "text":
+                                content.append(
+                                    mcp_types.TextContent(type="text", text=item["text"])
+                                )
+                            case "image":
+                                source = item["source"]
+                                content.append(
+                                    mcp_types.ImageContent(
+                                        type="image",
+                                        data=source["data"],
+                                        mimeType=source["media_type"],
+                                    )
+                                )
+                            case "document" if item["source"]["type"] in ("base64", "text"):
+                                # The CLI's Read on a PDF.
+                                source = item["source"]
+                                uri = f"document://{call_id}/{index}"
+                                resource: mcp_types.ResourceContents = (
+                                    mcp_types.BlobResourceContents(
+                                        uri=uri,
+                                        mimeType=source.get("media_type"),
+                                        blob=source["data"],
+                                    )
+                                    if source["type"] == "base64"
+                                    else mcp_types.TextResourceContents(
+                                        uri=uri,
+                                        mimeType=source.get("media_type"),
+                                        text=source["data"],
+                                    )
+                                )
+                                content.append(
+                                    mcp_types.EmbeddedResource(type="resource", resource=resource)
+                                )
+                            case kind:
+                                logger.warning("unsupported Claude tool result block: %s", kind)
+                                content.append(
+                                    mcp_types.TextContent(
+                                        type="text", text=f"[unsupported {kind} block]"
+                                    )
                                 )
-                            )
-                        else:
-                            raise ValueError(f"unsupported Claude tool result block: {item!r}")
 
                     self.run.record(
                         ToolStep(
@@ -111,16 +143,31 @@ class ClaudeEvents:
                         trace.extra[key] = value
 
     def finish(self, *, returncode: int, stderr: str) -> None:
+        """Fail the rollout unless the CLI delivered a complete terminal result.
+
+        A nonzero exit after a result event is only recorded on the trace when
+        stderr is empty; the CLI exits that way after successful runs.
+        """
         trace = self.run.trace
-        error = self.error
         if returncode != 0:
             trace.extra["returncode"] = returncode
-            error = stderr.strip() or f"claude CLI exited with return code {returncode}"
+
+        reported = stderr.strip()
+        if self.error is not None:
+            error = self.error
         elif not self.saw_result:
-            error = "claude CLI exited without a result event"
+            error = reported or (
+                f"claude CLI exited with return code {returncode}"
+                if returncode != 0
+                else "claude CLI exited without a result event"
+            )
+        elif returncode != 0 and reported:
+            error = reported
         elif self.pending_calls:
             missing = ", ".join(sorted(self.pending_calls))
             error = f"claude CLI exited without results for tool calls: {missing}"
+        else:
+            error = None
 
         if error is not None and stderr:
             trace.extra["stderr"] = stderr

{hud-0.6.19.dev2 → hud-0.6.20}/hud/agents/codex/agent.py

@@ -246,6 +246,10 @@ class CodexCLIAgent(Agent[CodexCLIConfig]):
             "--model",
             self.config.model,
         ]
+        if self.config.reasoning_effort is not None:
+            args.extend(
+                ["-c", f"model_reasoning_effort={json.dumps(self.config.reasoning_effort)}"]
+            )
 
         if connection is not None or routes_to_gateway("openai", gateway=self.config.gateway):
             if connection is not None:

{hud-0.6.19.dev2 → hud-0.6.20}/hud/agents/gemini/agent.py

@@ -35,6 +35,26 @@ from .tools import (
 logger = logging.getLogger(__name__)
 
 
+def _bound_text(text: str, limit: int) -> str:
+    """Keep ``limit`` characters of ``text``, weighted to its tail.
+
+    The kept span is announced so the model can re-run the call scoped to what
+    it needs rather than treating the remainder as absent.
+    """
+    if limit <= 0 or len(text) <= limit:
+        return text
+    head_chars = limit // 5
+    tail_chars = limit - head_chars
+    omitted = len(text) - limit
+    return (
+        f"Output too large: showing the first {head_chars} and last {tail_chars} "
+        f"characters, {omitted} omitted. Re-run scoped to the part you need.\n"
+        f"{text[:head_chars]}\n\n"
+        f"... [{omitted} characters omitted] ...\n\n"
+        f"{text[-tail_chars:]}"
+    )
+
+
 class GeminiAgent(ToolAgent[genai_types.Content, GeminiConfig]):
     """Gemini agent. Drives SSH (coding/filesystem), RFB (computer), and MCP capabilities."""
 
@@ -67,6 +87,7 @@ class GeminiAgent(ToolAgent[genai_types.Content, GeminiConfig]):
         self.thinking_level = config.thinking_level
         self.include_thoughts = config.include_thoughts
         self.excluded_predefined_functions = list(config.excluded_predefined_functions)
+        self.max_tool_result_chars = config.max_tool_result_chars
         self.max_recent_turn_with_screenshots = (
             gemini_agent_settings.MAX_RECENT_TURN_WITH_SCREENSHOTS
         )
@@ -95,6 +116,8 @@ class GeminiAgent(ToolAgent[genai_types.Content, GeminiConfig]):
             (c.text for c in result.content if isinstance(c, mcp_types.TextContent)),
             None,
         )
+        if text is not None:
+            text = _bound_text(text, self.max_tool_result_chars)
         response: dict[str, Any] = (
             {"error": text or "Tool execution failed"} if result.isError else {"success": True}
         )

{hud-0.6.19.dev2 → hud-0.6.20}/hud/agents/tests/test_claude_agent.py

@@ -8,23 +8,33 @@ import base64
 import random
 import struct
 import zlib
+from contextlib import AsyncExitStack
 from io import BytesIO
 from types import SimpleNamespace
-from typing import Any, cast
+from typing import TYPE_CHECKING, Any, cast
 from unittest.mock import AsyncMock, Mock, call
 
+import fastmcp
 import httpx
 import httpx2
+import mcp.types as mcp_types
 import pytest
-from anthropic import APIStatusError
+from anthropic import APIStatusError, Omit
+from fastmcp.tools import ToolResult
 from mcp.types import ImageContent
 from PIL import Image
+from pydantic import ValidationError
 
 from hud.agents.claude.agent import ClaudeAgent
 from hud.agents.claude.tools.computer import ClaudeComputerTool
 from hud.agents.tool_agent import RunState
-from hud.capabilities import RFBClient
-from hud.types import MCPToolCall, MCPToolResult
+from hud.agents.types import ClaudeConfig, ToolStep
+from hud.capabilities import Capability, MCPClient, RFBClient
+from hud.settings import settings
+from hud.types import MCPToolCall, MCPToolResult, Trace
+
+if TYPE_CHECKING:
+    from hud.eval.run import Run
 
 
 class FakeStream:
@@ -53,8 +63,10 @@ class FakeMessages:
     def __init__(self, *outcomes: Any) -> None:
         self._outcomes = list(outcomes)
         self.calls = 0
+        self.requests: list[dict[str, Any]] = []
 
-    def stream(self, **_kwargs: Any) -> FakeStream:
+    def stream(self, **kwargs: Any) -> FakeStream:
+        self.requests.append(kwargs)
         outcome = self._outcomes[self.calls]
         self.calls += 1
         return FakeStream(outcome)
@@ -461,3 +473,124 @@ def test_claude_preserves_computer_screenshot_coordinate_space() -> None:
     source = result["content"][0]["source"]
     assert source["media_type"] == "image/png"
     assert base64.b64decode(source["data"]) == data
+
+
+@pytest.mark.parametrize("limit", [None, 1])
+async def test_image_history_preserves_tool_results_and_thinking(
+    limit: int | None, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    monkeypatch.setattr(settings, "telemetry_enabled", False)
+    buffer = BytesIO()
+    Image.new("RGB", (32, 24), "white").save(buffer, format="PNG")
+    image = ImageContent(
+        type="image", mimeType="image/png", data=base64.b64encode(buffer.getvalue()).decode()
+    )
+    server = fastmcp.FastMCP("screenshots")
+
+    @server.tool
+    def screenshot() -> ToolResult:
+        """Capture the current screen."""
+        return ToolResult(content=[mcp_types.TextContent(type="text", text="screen"), image])
+
+    client = FakeAnthropic(
+        *(
+            _final(
+                SimpleNamespace(
+                    type="thinking", thinking=f"reason-{turn}", signature=f"sig-{turn}"
+                ),
+                SimpleNamespace(type="tool_use", id=f"shot-{turn}", name="screenshot", input={}),
+                stop_reason="tool_use",
+            )
+            for turn in (1, 2)
+        ),
+        _final(SimpleNamespace(type="text", text="done", citations=None), stop_reason="end_turn"),
+    )
+    config = ClaudeConfig(
+        model="claude-test",
+        model_client=client,
+        max_steps=3,
+        max_tool_result_images=limit,
+        thinking={"type": "adaptive"} if limit is not None else None,
+    )
+    restored = ClaudeConfig.model_validate(config.model_dump(mode="json"))
+    assert restored.max_tool_result_images == limit
+    assert restored.thinking == config.thinking
+    async with fastmcp.Client(server) as mcp_client:
+        cap = Capability.mcp(name="screenshots", url="https://tools.invalid/mcp")
+        connection = MCPClient(cap, mcp_client, AsyncExitStack())
+        trace = Trace()
+        run = cast(
+            "Run",
+            SimpleNamespace(
+                trace=trace,
+                record=trace.record,
+                client=SimpleNamespace(
+                    manifest=SimpleNamespace(bindings=[cap]),
+                    open=AsyncMock(return_value=connection),
+                ),
+                prompt_messages=[
+                    mcp_types.PromptMessage(
+                        role="user", content=mcp_types.TextContent(type="text", text="go")
+                    )
+                ],
+            ),
+        )
+        await ClaudeAgent(config)(run)
+
+    assert trace.status == "completed"
+    requests = client.beta.messages.requests
+    assert len(requests) == 3
+    for request in requests:
+        if limit is None:
+            assert isinstance(request.get("thinking", Omit()), Omit)
+            assert isinstance(request.get("betas", Omit()), Omit)
+        else:
+            assert "thinking-binding-controls-2026-08-01" in request["betas"]
+            assert request["thinking"] == {
+                "type": "adaptive",
+                "block_binding": {"prefix_mismatch_behavior": "drop_block"},
+            }
+    messages = requests[-1]["messages"]
+    results = [message["content"][0] for message in messages[2::2]]
+    assert [result["tool_use_id"] for result in results] == ["shot-1", "shot-2"]
+    assert [result["content"][0]["text"] for result in results] == ["screen", "screen"]
+    assert [result["content"][1]["type"] for result in results] == (
+        ["image", "image"] if limit is None else ["text", "image"]
+    )
+    assert [
+        (message["content"][0].thinking, message["content"][0].signature)
+        for message in messages[1::2]
+    ] == [("reason-1", "sig-1"), ("reason-2", "sig-2")]
+    for step in trace.steps:
+        if isinstance(step, ToolStep):
+            assert step.result is not None
+            recorded_image = step.result.content[1]
+            assert isinstance(recorded_image, ImageContent)
+            assert recorded_image.data == image.data
+
+
+@pytest.mark.parametrize("thinking", [None, {"type": "disabled"}])
+def test_image_history_requires_enabled_thinking(thinking: dict[str, str] | None) -> None:
+    with pytest.raises(ValidationError, match="requires explicit adaptive or enabled thinking"):
+        ClaudeConfig.model_validate({"max_tool_result_images": 1, "thinking": thinking})
+
+
+@pytest.mark.parametrize(
+    ("max_tokens", "budget_tokens"),
+    [(16384, 16384), (16384, 16385), (2048, 2048), (2048, 2049)],
+)
+def test_enabled_thinking_budget_must_be_below_max_tokens(
+    max_tokens: int, budget_tokens: int
+) -> None:
+    with pytest.raises(ValidationError, match="budget_tokens must be less than max_tokens"):
+        ClaudeConfig(
+            max_tokens=max_tokens, thinking={"type": "enabled", "budget_tokens": budget_tokens}
+        )
+
+
+@pytest.mark.parametrize("max_tokens", [1025, 2048])
+def test_enabled_thinking_budget_below_max_tokens_is_allowed(max_tokens: int) -> None:
+    config = ClaudeConfig(
+        max_tokens=max_tokens, thinking={"type": "enabled", "budget_tokens": max_tokens - 1}
+    )
+    assert config.thinking == {"type": "enabled", "budget_tokens": max_tokens - 1}

{hud-0.6.19.dev2 → hud-0.6.20}/hud/agents/tests/test_claude_cli_agent.py

@@ -21,11 +21,12 @@ from unittest.mock import AsyncMock, Mock
 
 import fastmcp
 import pytest
-from mcp.types import ImageContent, TextContent
+from mcp.types import BlobResourceContents, EmbeddedResource, ImageContent, TextContent
 
 from hud.agents import create_agent
 from hud.agents.claude.sdk import computer_mcp
 from hud.agents.claude.sdk.agent import ClaudeCLIAgent
+from hud.agents.claude.sdk.events import ClaudeEvents
 from hud.agents.tests.cli_fakes import FakeClient as _FakeClient
 from hud.agents.tests.cli_fakes import FakeProcess as _FakeStreamProcess
 from hud.agents.tests.cli_fakes import fake_run as _fake_run
@@ -57,7 +58,7 @@ async def test_command_follows_explicit_gateway_routing(monkeypatch: pytest.Monk
     assert f"ANTHROPIC_BASE_URL={settings.hud_gateway_url}" in gateway
     assert "ANTHROPIC_API_KEY=hud-key" in gateway
     assert "CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS=1" in gateway
-    assert "DISABLE_AUTO_COMPACT=1" in gateway
+    assert "DISABLE_AUTO_COMPACT" not in gateway
     assert "ANTHROPIC_API_KEY=anthropic-key" in provider
     assert "ANTHROPIC_BASE_URL" not in provider
     assert "CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS" not in provider
@@ -141,7 +142,6 @@ async def test_windows_command_encodes_environment_and_arguments(
     script = base64.b64decode(encoded).decode("utf-16-le")
     assert "$env:ANTHROPIC_API_KEY='hud&key''s'" in script
     assert "$env:CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS='1'" in script
-    assert "$env:DISABLE_AUTO_COMPACT='1'" in script
     assert "'--system-prompt' 'don''t $expand'" in script
     assert "Get-Content -Raw -Encoding UTF8 '.hud_input.jsonl' | & 'claude'" in script
     assert "'--input-format=stream-json'" in script
@@ -264,6 +264,16 @@ async def _sent_command(
     return command
 
 
+async def test_command_passes_the_configured_reasoning_effort() -> None:
+    command = await _sent_command(ClaudeCLIAgent(ClaudeCLIConfig(reasoning_effort="max")))
+    assert "--effort max" in command
+
+
+async def test_command_omits_effort_when_unconfigured() -> None:
+    command = await _sent_command(ClaudeCLIAgent(ClaudeCLIConfig()))
+    assert "--effort" not in command
+
+
 async def test_exec_on_windows_writes_batch_and_execs_via_cmd() -> None:
     sink: dict[str, bytes] = {}
     conn = _FakeConn(sink, _FakeStreamProcess(_STREAM_JSON))
@@ -477,6 +487,20 @@ async def test_exec_nonzero_exit_with_result_stream_remains_an_error() -> None:
     assert "messages" not in run.trace.extra
 
 
+async def test_exec_nonzero_exit_with_result_stream_and_no_stderr_is_graded() -> None:
+    """The CLI exits nonzero after a successful result; the run stays gradeable."""
+    sink: dict[str, bytes] = {}
+    conn = _FakeConn(sink, _FakeStreamProcess(_STREAM_JSON, exit_status=1))
+    ssh = _ssh_with_conn("bash", conn)
+
+    run = _fake_run()
+    await run_claude(ClaudeCLIConfig(), run, ssh=ssh, prompt="x")
+
+    assert run.trace.content == "done"
+    assert run.trace.extra["returncode"] == 1
+    assert "stderr" not in run.trace.extra
+
+
 async def test_exec_zero_exit_without_result_event_is_an_error() -> None:
     sink: dict[str, bytes] = {}
     stdout = _STREAM_JSON.rsplit('{"type":"result"', 1)[0]
@@ -833,3 +857,64 @@ async def test_concurrent_runs_keep_their_ssh_state_isolated() -> None:
         "second"
     )
     assert run_a.trace.content == run_b.trace.content == "done"
+
+
+def test_events_record_document_and_unknown_tool_result_blocks() -> None:
+    """A PDF Read returns a document block; neither it nor an unknown block ends the run."""
+    run = _fake_run()
+    events = ClaudeEvents(run, started_at="2026-01-01T00:00:00Z")
+    events.consume(
+        json.dumps(
+            {
+                "type": "assistant",
+                "message": {
+                    "id": "msg-1",
+                    "type": "message",
+                    "role": "assistant",
+                    "model": "claude-test",
+                    "content": [{"type": "tool_use", "id": "tool-1", "name": "Read", "input": {}}],
+                    "stop_reason": "tool_use",
+                    "stop_sequence": None,
+                    "usage": {"input_tokens": 1, "output_tokens": 1},
+                },
+            }
+        )
+    )
+    events.consume(
+        json.dumps(
+            {
+                "type": "user",
+                "message": {
+                    "content": [
+                        {
+                            "type": "tool_result",
+                            "tool_use_id": "tool-1",
+                            "content": [
+                                {
+                                    "type": "document",
+                                    "source": {
+                                        "type": "base64",
+                                        "media_type": "application/pdf",
+                                        "data": "JVBERi0=",
+                                    },
+                                },
+                                {"type": "novelty", "payload": 1},
+                            ],
+                        }
+                    ]
+                },
+            }
+        )
+    )
+
+    tool = cast("ToolStep", run.steps[1])
+    assert tool.result is not None
+    document, unknown = tool.result.content
+    assert isinstance(document, EmbeddedResource)
+    assert isinstance(document.resource, BlobResourceContents)
+    assert document.resource.mimeType == "application/pdf"
+    assert document.resource.blob == "JVBERi0="
+    assert str(document.resource.uri) == "document://tool-1/0"
+    assert isinstance(unknown, TextContent)
+    assert unknown.text == "[unsupported novelty block]"
+    assert events.error is None

{hud-0.6.19.dev2 → hud-0.6.20}/hud/agents/tests/test_codex_cli_agent.py

@@ -97,6 +97,16 @@ _STREAM_JSON = (
 )
 
 
+async def test_command_passes_the_configured_reasoning_effort() -> None:
+    command = await _sent_command(CodexCLIConfig(reasoning_effort="max"))
+    assert 'model_reasoning_effort="max"' in command
+
+
+async def test_command_omits_reasoning_effort_when_unconfigured() -> None:
+    command = await _sent_command(CodexCLIConfig())
+    assert "model_reasoning_effort" not in command
+
+
 async def test_command_follows_explicit_gateway_routing(monkeypatch: pytest.MonkeyPatch) -> None:
     monkeypatch.setattr(settings, "api_key", "hud-key")
     monkeypatch.setattr(settings, "openai_api_key", "openai-key")