hud-python 0.4.52__py3-none-any.whl → 0.4.54__py3-none-any.whl

hud/datasets/tests/test_runner.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from hud.datasets.runner import _flush_telemetry
+
+
+@pytest.mark.asyncio
+async def test_flush_telemetry():
+    """Test _flush_telemetry function."""
+    with (
+        patch("hud.otel.config.is_telemetry_configured", return_value=True),
+        patch("hud.utils.hud_console.hud_console"),
+        patch("hud.utils.task_tracking.wait_all_tasks", new_callable=AsyncMock) as mock_wait,
+        patch("opentelemetry.trace.get_tracer_provider") as mock_get_provider,
+    ):
+        from opentelemetry.sdk.trace import TracerProvider
+
+        mock_provider = MagicMock(spec=TracerProvider)
+        mock_provider.force_flush.return_value = True
+        mock_get_provider.return_value = mock_provider
+
+        mock_wait.return_value = 5
+
+        await _flush_telemetry()
+
+        mock_wait.assert_called_once()
+        mock_provider.force_flush.assert_called_once_with(timeout_millis=20000)
+
+
+@pytest.mark.asyncio
+async def test_flush_telemetry_no_telemetry():
+    """Test _flush_telemetry when telemetry is not configured."""
+    with (
+        patch("hud.otel.config.is_telemetry_configured", return_value=False),
+        patch("hud.utils.hud_console.hud_console"),
+        patch("hud.utils.task_tracking.wait_all_tasks", new_callable=AsyncMock) as mock_wait,
+        patch("opentelemetry.trace.get_tracer_provider"),
+    ):
+        mock_wait.return_value = 0
+
+        await _flush_telemetry()
+
+        mock_wait.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_flush_telemetry_exception():
+    """Test _flush_telemetry handles exceptions gracefully."""
+    with (
+        patch("hud.otel.config.is_telemetry_configured", return_value=True),
+        patch("hud.utils.hud_console.hud_console"),
+        patch("hud.utils.task_tracking.wait_all_tasks", new_callable=AsyncMock) as mock_wait,
+        patch("opentelemetry.trace.get_tracer_provider") as mock_get_provider,
+    ):
+        from opentelemetry.sdk.trace import TracerProvider
+
+        mock_provider = MagicMock(spec=TracerProvider)
+        mock_provider.force_flush.side_effect = Exception("Flush failed")
+        mock_get_provider.return_value = mock_provider
+
+        mock_wait.return_value = 3
+
+        # Should not raise
+        await _flush_telemetry()
+
+
+@pytest.mark.asyncio
+async def test_flush_telemetry_no_completed_tasks():
+    """Test _flush_telemetry when no tasks were completed."""
+    with (
+        patch("hud.otel.config.is_telemetry_configured", return_value=True),
+        patch("hud.utils.hud_console.hud_console"),
+        patch("hud.utils.task_tracking.wait_all_tasks", new_callable=AsyncMock) as mock_wait,
+        patch("opentelemetry.trace.get_tracer_provider") as mock_get_provider,
+    ):
+        from opentelemetry.sdk.trace import TracerProvider
+
+        mock_provider = MagicMock(spec=TracerProvider)
+        mock_get_provider.return_value = mock_provider
+
+        mock_wait.return_value = 0
+
+        await _flush_telemetry()
+
+        mock_provider.force_flush.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_flush_telemetry_non_sdk_provider():
+    """Test _flush_telemetry with non-SDK TracerProvider."""
+    with (
+        patch("hud.otel.config.is_telemetry_configured", return_value=True),
+        patch("hud.utils.hud_console.hud_console"),
+        patch("hud.utils.task_tracking.wait_all_tasks", new_callable=AsyncMock) as mock_wait,
+        patch("opentelemetry.trace.get_tracer_provider") as mock_get_provider,
+    ):
+        # Return a non-TracerProvider object
+        mock_get_provider.return_value = MagicMock(spec=object)
+
+        mock_wait.return_value = 2
+
+        # Should not raise
+        await _flush_telemetry()

hud/datasets/tests/test_utils.py

@@ -0,0 +1,228 @@
+from __future__ import annotations
+
+from unittest.mock import MagicMock, mock_open, patch
+
+import pytest
+
+from hud.datasets.utils import fetch_system_prompt_from_dataset, save_tasks
+from hud.types import Task
+
+
+@pytest.mark.asyncio
+async def test_fetch_system_prompt_success():
+    """Test successful fetch of system prompt."""
+    with patch("huggingface_hub.hf_hub_download") as mock_download:
+        mock_download.return_value = "/tmp/system_prompt.txt"
+        with patch("builtins.open", mock_open(read_data="Test system prompt")):
+            result = await fetch_system_prompt_from_dataset("test/dataset")
+            assert result == "Test system prompt"
+            mock_download.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_fetch_system_prompt_empty_file():
+    """Test fetch when file is empty."""
+    with patch("huggingface_hub.hf_hub_download") as mock_download:
+        mock_download.return_value = "/tmp/system_prompt.txt"
+        with patch("builtins.open", mock_open(read_data="  \n  ")):
+            result = await fetch_system_prompt_from_dataset("test/dataset")
+            assert result is None
+
+
+@pytest.mark.asyncio
+async def test_fetch_system_prompt_file_not_found():
+    """Test fetch when file doesn't exist."""
+    with patch("huggingface_hub.hf_hub_download") as mock_download:
+        from huggingface_hub.errors import EntryNotFoundError
+
+        mock_download.side_effect = EntryNotFoundError("File not found")
+        result = await fetch_system_prompt_from_dataset("test/dataset")
+        assert result is None
+
+
+@pytest.mark.asyncio
+async def test_fetch_system_prompt_import_error():
+    """Test fetch when huggingface_hub is not installed."""
+    # Mock the import itself to raise ImportError
+    import sys
+
+    with patch.dict(sys.modules, {"huggingface_hub": None}):
+        result = await fetch_system_prompt_from_dataset("test/dataset")
+        assert result is None
+
+
+@pytest.mark.asyncio
+async def test_fetch_system_prompt_general_exception():
+    """Test fetch with general exception."""
+    with patch("huggingface_hub.hf_hub_download") as mock_download:
+        mock_download.side_effect = Exception("Network error")
+        result = await fetch_system_prompt_from_dataset("test/dataset")
+        assert result is None
+
+
+def test_save_tasks_basic():
+    """Test basic save_tasks functionality."""
+    tasks = [
+        {"id": "1", "prompt": "test", "mcp_config": {"key": "value"}},
+        {"id": "2", "prompt": "test2", "mcp_config": {"key2": "value2"}},
+    ]
+
+    with patch("hud.datasets.utils.Dataset") as mock_dataset_class:
+        mock_dataset = MagicMock()
+        mock_dataset_class.from_list.return_value = mock_dataset
+
+        save_tasks(tasks, "test/repo")
+
+        mock_dataset_class.from_list.assert_called_once()
+        call_args = mock_dataset_class.from_list.call_args[0][0]
+        assert len(call_args) == 2
+        # Check that mcp_config was JSON serialized
+        assert isinstance(call_args[0]["mcp_config"], str)
+        mock_dataset.push_to_hub.assert_called_once_with("test/repo")
+
+
+def test_save_tasks_with_specific_fields():
+    """Test save_tasks with specific fields."""
+    tasks = [
+        {"id": "1", "prompt": "test", "mcp_config": {"key": "value"}, "extra": "data"},
+    ]
+
+    with patch("hud.datasets.utils.Dataset") as mock_dataset_class:
+        mock_dataset = MagicMock()
+        mock_dataset_class.from_list.return_value = mock_dataset
+
+        save_tasks(tasks, "test/repo", fields=["id", "prompt"])
+
+        call_args = mock_dataset_class.from_list.call_args[0][0]
+        assert "id" in call_args[0]
+        assert "prompt" in call_args[0]
+        assert "extra" not in call_args[0]
+
+
+def test_save_tasks_with_list_field():
+    """Test save_tasks serializes list fields."""
+    tasks = [
+        {"id": "1", "tags": ["tag1", "tag2"], "count": 5},
+    ]
+
+    with patch("hud.datasets.utils.Dataset") as mock_dataset_class:
+        mock_dataset = MagicMock()
+        mock_dataset_class.from_list.return_value = mock_dataset
+
+        save_tasks(tasks, "test/repo")
+
+        call_args = mock_dataset_class.from_list.call_args[0][0]
+        # List should be JSON serialized
+        assert isinstance(call_args[0]["tags"], str)
+        assert '"tag1"' in call_args[0]["tags"]
+
+
+def test_save_tasks_with_primitive_types():
+    """Test save_tasks handles various primitive types."""
+    tasks = [
+        {
+            "string": "text",
+            "integer": 42,
+            "float": 3.14,
+            "boolean": True,
+            "none": None,
+        },
+    ]
+
+    with patch("hud.datasets.utils.Dataset") as mock_dataset_class:
+        mock_dataset = MagicMock()
+        mock_dataset_class.from_list.return_value = mock_dataset
+
+        save_tasks(tasks, "test/repo")
+
+        call_args = mock_dataset_class.from_list.call_args[0][0]
+        assert call_args[0]["string"] == "text"
+        assert call_args[0]["integer"] == 42
+        assert call_args[0]["float"] == 3.14
+        assert call_args[0]["boolean"] is True
+        assert call_args[0]["none"] == ""  # None becomes empty string
+
+
+def test_save_tasks_with_other_type():
+    """Test save_tasks converts other types to string."""
+
+    class CustomObj:
+        def __str__(self):
+            return "custom_value"
+
+    tasks = [
+        {"id": "1", "custom": CustomObj()},
+    ]
+
+    with patch("hud.datasets.utils.Dataset") as mock_dataset_class:
+        mock_dataset = MagicMock()
+        mock_dataset_class.from_list.return_value = mock_dataset
+
+        save_tasks(tasks, "test/repo")
+
+        call_args = mock_dataset_class.from_list.call_args[0][0]
+        assert call_args[0]["custom"] == "custom_value"
+
+
+def test_save_tasks_rejects_task_objects():
+    """Test save_tasks raises error for Task objects."""
+    task = Task(prompt="test", mcp_config={})
+
+    with pytest.raises(ValueError, match="expects dictionaries, not Task objects"):
+        save_tasks([task], "test/repo")  # type: ignore
+
+
+def test_save_tasks_rejects_task_objects_in_list():
+    """Test save_tasks raises error when Task object is in the list."""
+    tasks = [
+        {"id": "1", "prompt": "test", "mcp_config": {}},
+        Task(prompt="test2", mcp_config={}),  # Task object
+    ]
+
+    with pytest.raises(ValueError, match="Item 1 is a Task object"):
+        save_tasks(tasks, "test/repo")  # type: ignore
+
+
+def test_save_tasks_with_kwargs():
+    """Test save_tasks passes kwargs to push_to_hub."""
+    tasks = [{"id": "1", "prompt": "test"}]
+
+    with patch("hud.datasets.utils.Dataset") as mock_dataset_class:
+        mock_dataset = MagicMock()
+        mock_dataset_class.from_list.return_value = mock_dataset
+
+        save_tasks(tasks, "test/repo", private=True, commit_message="Test commit")
+
+        mock_dataset.push_to_hub.assert_called_once_with(
+            "test/repo", private=True, commit_message="Test commit"
+        )
+
+
+def test_save_tasks_field_not_in_dict():
+    """Test save_tasks handles missing fields gracefully."""
+    tasks = [
+        {"id": "1", "prompt": "test"},
+    ]
+
+    with patch("hud.datasets.utils.Dataset") as mock_dataset_class:
+        mock_dataset = MagicMock()
+        mock_dataset_class.from_list.return_value = mock_dataset
+
+        # Request fields that don't exist
+        save_tasks(tasks, "test/repo", fields=["id", "missing_field"])
+
+        call_args = mock_dataset_class.from_list.call_args[0][0]
+        assert "id" in call_args[0]
+        assert "missing_field" not in call_args[0]
+
+
+def test_save_tasks_empty_list():
+    """Test save_tasks with empty list."""
+    with patch("hud.datasets.utils.Dataset") as mock_dataset_class:
+        mock_dataset = MagicMock()
+        mock_dataset_class.from_list.return_value = mock_dataset
+
+        save_tasks([], "test/repo")
+
+        mock_dataset_class.from_list.assert_called_once_with([])
+        mock_dataset.push_to_hub.assert_called_once()

hud/otel/tests/__init__.py

@@ -1 +0,0 @@
-"""Tests for OpenTelemetry integration."""

hud/otel/tests/test_instrumentation.py

@@ -0,0 +1,207 @@
+from __future__ import annotations
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from hud.otel.instrumentation import (
+    _patch_get_error_type,
+    _patch_mcp_instrumentation,
+    install_mcp_instrumentation,
+)
+
+
+def test_install_mcp_instrumentation_success():
+    """Test successful installation of MCP instrumentation."""
+    mock_provider = MagicMock()
+
+    with (
+        patch("opentelemetry.instrumentation.mcp.instrumentation"),
+        patch(
+            "opentelemetry.instrumentation.mcp.instrumentation.McpInstrumentor"
+        ) as mock_instrumentor_class,
+        patch("hud.otel.instrumentation._patch_mcp_instrumentation"),
+    ):
+        mock_instrumentor = MagicMock()
+        mock_instrumentor_class.return_value = mock_instrumentor
+
+        install_mcp_instrumentation(mock_provider)
+
+        mock_instrumentor.instrument.assert_called_once_with(tracer_provider=mock_provider)
+
+
+def test_install_mcp_instrumentation_import_error():
+    """Test installation handles ImportError gracefully."""
+    mock_provider = MagicMock()
+
+    # Mock the import to raise ImportError
+    import sys
+
+    with patch.dict(sys.modules, {"opentelemetry.instrumentation.mcp.instrumentation": None}):
+        # Should not raise
+        install_mcp_instrumentation(mock_provider)
+
+
+def test_install_mcp_instrumentation_general_exception():
+    """Test installation handles general exceptions gracefully."""
+    mock_provider = MagicMock()
+
+    with (
+        patch("opentelemetry.instrumentation.mcp.instrumentation"),
+        patch(
+            "opentelemetry.instrumentation.mcp.instrumentation.McpInstrumentor"
+        ) as mock_instrumentor_class,
+    ):
+        mock_instrumentor_class.side_effect = Exception("Unexpected error")
+
+        # Should not raise
+        install_mcp_instrumentation(mock_provider)
+
+
+def test_patch_mcp_instrumentation_success():
+    """Test successful patching of MCP instrumentation."""
+    with (
+        patch("opentelemetry.instrumentation.mcp.instrumentation.McpInstrumentor") as mock_class,
+        patch("hud.otel.instrumentation._patch_get_error_type"),
+    ):
+        mock_class._transport_wrapper = None
+
+        _patch_mcp_instrumentation()
+
+        # Should have set the _transport_wrapper
+        assert mock_class._transport_wrapper is not None
+
+
+def test_patch_mcp_instrumentation_exception():
+    """Test patching handles exceptions gracefully."""
+    with patch(
+        "opentelemetry.instrumentation.mcp.instrumentation.McpInstrumentor",
+        side_effect=Exception("Error"),
+    ):
+        # Should not raise
+        _patch_mcp_instrumentation()
+
+
+def test_patch_get_error_type_success():
+    """Test successful patching of get_error_type."""
+    with patch("opentelemetry.instrumentation.mcp.instrumentation") as mock_mcp_inst:
+        mock_mcp_inst.get_error_type = None
+
+        _patch_get_error_type()
+
+        # Should have set get_error_type
+        assert mock_mcp_inst.get_error_type is not None
+
+
+def test_patch_get_error_type_exception():
+    """Test patching get_error_type handles exceptions."""
+    with patch(
+        "opentelemetry.instrumentation.mcp.instrumentation", side_effect=ImportError("Not found")
+    ):
+        # Should not raise
+        _patch_get_error_type()
+
+
+def test_patched_get_error_type_valid_4xx():
+    """Test patched get_error_type with valid 4xx status code."""
+    with patch("opentelemetry.instrumentation.mcp.instrumentation") as mock_mcp_inst:
+        _patch_get_error_type()
+
+        patched_func = mock_mcp_inst.get_error_type
+
+        # Test with a valid 4xx error
+        result = patched_func("Error 404 not found")
+        assert result == "NOT_FOUND"
+
+
+def test_patched_get_error_type_valid_5xx():
+    """Test patched get_error_type with valid 5xx status code."""
+    with patch("opentelemetry.instrumentation.mcp.instrumentation") as mock_mcp_inst:
+        _patch_get_error_type()
+
+        patched_func = mock_mcp_inst.get_error_type
+
+        # Test with a valid 5xx error
+        result = patched_func("Error 500 internal server error")
+        assert result == "INTERNAL_SERVER_ERROR"
+
+
+def test_patched_get_error_type_invalid_status():
+    """Test patched get_error_type with invalid status code."""
+    with patch("opentelemetry.instrumentation.mcp.instrumentation") as mock_mcp_inst:
+        _patch_get_error_type()
+
+        patched_func = mock_mcp_inst.get_error_type
+
+        # Test with an invalid HTTP status code (e.g., 499 doesn't exist in HTTPStatus)
+        result = patched_func("Error 499 custom error")
+        # Should return the name even if it's not a standard HTTPStatus
+        assert result is None or isinstance(result, str)
+
+
+def test_patched_get_error_type_no_status():
+    """Test patched get_error_type with no status code."""
+    with patch("opentelemetry.instrumentation.mcp.instrumentation") as mock_mcp_inst:
+        _patch_get_error_type()
+
+        patched_func = mock_mcp_inst.get_error_type
+
+        result = patched_func("Error message without status code")
+        assert result is None
+
+
+def test_patched_get_error_type_non_string():
+    """Test patched get_error_type with non-string input."""
+    with patch("opentelemetry.instrumentation.mcp.instrumentation") as mock_mcp_inst:
+        _patch_get_error_type()
+
+        patched_func = mock_mcp_inst.get_error_type
+
+        result = patched_func(None)
+        assert result is None
+
+        result = patched_func(123)
+        assert result is None
+
+
+def test_patched_get_error_type_3xx_ignored():
+    """Test patched get_error_type ignores 3xx codes."""
+    with patch("opentelemetry.instrumentation.mcp.instrumentation") as mock_mcp_inst:
+        _patch_get_error_type()
+
+        patched_func = mock_mcp_inst.get_error_type
+
+        result = patched_func("Error 301 moved")
+        assert result is None
+
+
+@pytest.mark.asyncio
+async def test_transport_wrapper_three_values():
+    """Test transport wrapper handles 3-value tuple."""
+    with (
+        patch("opentelemetry.instrumentation.mcp.instrumentation.McpInstrumentor") as mock_class,
+        patch("hud.otel.instrumentation._patch_get_error_type"),
+    ):
+        mock_class._transport_wrapper = None
+
+        _patch_mcp_instrumentation()
+
+        # Get the patched wrapper
+        wrapper_func = mock_class._transport_wrapper
+        assert wrapper_func is not None
+
+
+@pytest.mark.asyncio
+async def test_transport_wrapper_two_values():
+    """Test transport wrapper handles 2-value tuple."""
+    with (
+        patch("opentelemetry.instrumentation.mcp.instrumentation.McpInstrumentor") as mock_class,
+        patch("hud.otel.instrumentation._patch_get_error_type"),
+    ):
+        mock_class._transport_wrapper = None
+
+        _patch_mcp_instrumentation()
+
+        # Get the patched wrapper
+        wrapper_func = mock_class._transport_wrapper
+        assert wrapper_func is not None

hud/server/tests/test_server_extra.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import asyncio
+import sys
 from contextlib import asynccontextmanager, suppress
 
 import anyio
@@ -98,6 +99,7 @@ async def test_last_shutdown_handler_wins(patch_stdio):
     server_mod._sigterm_received = False  # type: ignore[attr-defined]
 
 
+@pytest.mark.skipif(sys.platform == "win32", reason="asyncio.add_signal_handler is Unix-only")
 def test__run_with_sigterm_registers_handlers_when_enabled(monkeypatch: pytest.MonkeyPatch):
     """
     Verify that _run_with_sigterm attempts to register SIGTERM/SIGINT handlers

hud/shared/exceptions.py

@@ -185,11 +185,42 @@ class HudRequestError(HudException):
         self.response_text = response_text
         self.response_headers = response_headers
         # Compute default hints from status code if none provided
-        if hints is None and status_code in (401, 403, 429):
+        if hints is None and status_code in (401, 402, 403, 429):
             try:
-                from hud.shared.hints import HUD_API_KEY_MISSING, RATE_LIMIT_HIT  # type: ignore
-
-                if status_code in (401, 403):
+                from hud.shared.hints import (  # type: ignore
+                    CREDITS_EXHAUSTED,
+                    HUD_API_KEY_MISSING,
+                    PRO_PLAN_REQUIRED,
+                    RATE_LIMIT_HIT,
+                )
+
+                if status_code == 402:
+                    hints = [CREDITS_EXHAUSTED]
+                elif status_code == 403:
+                    # Default 403 to auth unless the message clearly indicates Pro plan
+                    combined_text = (message or "").lower()
+                    try:
+                        if response_text:
+                            combined_text += "\n" + str(response_text).lower()
+                    except Exception:  # noqa: S110
+                        pass
+                    try:
+                        if response_json and isinstance(response_json, dict):
+                            detail = response_json.get("detail")
+                            if isinstance(detail, str):
+                                combined_text += "\n" + detail.lower()
+                    except Exception:  # noqa: S110
+                        pass
+
+                    mentions_pro = (
+                        "pro plan" in combined_text
+                        or "requires pro" in combined_text
+                        or "pro mode" in combined_text
+                        or combined_text.strip().startswith("pro ")
+                    )
+
+                    hints = [PRO_PLAN_REQUIRED] if mentions_pro else [HUD_API_KEY_MISSING]
+                elif status_code == 401:
                     hints = [HUD_API_KEY_MISSING]
                 elif status_code == 429:
                     hints = [RATE_LIMIT_HIT]

hud/shared/hints.py

@@ -61,6 +61,31 @@ RATE_LIMIT_HIT = Hint(
     context=["network"],
 )
 
+# Billing / plan upgrade
+PRO_PLAN_REQUIRED = Hint(
+    title="Pro plan required",
+    message="This feature requires Pro.",
+    tips=[
+        "Upgrade your plan to continue",
+    ],
+    docs_url="https://hud.so/project/billing",
+    command_examples=None,
+    code="PRO_PLAN_REQUIRED",
+    context=["billing", "plan"],
+)
+
+CREDITS_EXHAUSTED = Hint(
+    title="Credits exhausted",
+    message="Your credits are exhausted.",
+    tips=[
+        "Top up credits or upgrade your plan",
+    ],
+    docs_url="https://hud.so/project/billing",
+    command_examples=None,
+    code="CREDITS_EXHAUSTED",
+    context=["billing", "credits"],
+)
+
 TOOL_NOT_FOUND = Hint(
     title="Tool not found",
     message="Requested tool doesn't exist.",

hud/shared/requests.py

@@ -18,7 +18,11 @@ from hud.shared.exceptions import (
     HudRequestError,
     HudTimeoutError,
 )
-from hud.shared.hints import HUD_API_KEY_MISSING, RATE_LIMIT_HIT
+from hud.shared.hints import (
+    CREDITS_EXHAUSTED,
+    HUD_API_KEY_MISSING,
+    RATE_LIMIT_HIT,
+)
 
 # Set up logger
 logger = logging.getLogger("hud.http")
@@ -137,9 +141,13 @@ async def make_request(
                 raise HudTimeoutError(f"Request timed out: {e!s}") from None
             except httpx.HTTPStatusError as e:
                 err = HudRequestError.from_httpx_error(e)
-                if getattr(err, "status_code", None) == 429 and RATE_LIMIT_HIT not in err.hints:
+                code = getattr(err, "status_code", None)
+                if code == 429 and RATE_LIMIT_HIT not in err.hints:
                     logger.debug("Attaching RATE_LIMIT hint to 429 error")
                     err.hints.append(RATE_LIMIT_HIT)
+                elif code == 402 and CREDITS_EXHAUSTED not in err.hints:
+                    logger.debug("Attaching CREDITS_EXHAUSTED hint to 402 error")
+                    err.hints.append(CREDITS_EXHAUSTED)
                 raise err from None
             except httpx.RequestError as e:
                 if attempt <= max_retries:
@@ -234,9 +242,13 @@ def make_request_sync(
                 raise HudTimeoutError(f"Request timed out: {e!s}") from None
             except httpx.HTTPStatusError as e:
                 err = HudRequestError.from_httpx_error(e)
-                if getattr(err, "status_code", None) == 429 and RATE_LIMIT_HIT not in err.hints:
+                code = getattr(err, "status_code", None)
+                if code == 429 and RATE_LIMIT_HIT not in err.hints:
                     logger.debug("Attaching RATE_LIMIT hint to 429 error")
                     err.hints.append(RATE_LIMIT_HIT)
+                elif code == 402 and CREDITS_EXHAUSTED not in err.hints:
+                    logger.debug("Attaching CREDITS_EXHAUSTED hint to 402 error")
+                    err.hints.append(CREDITS_EXHAUSTED)
                 raise err from None
             except httpx.RequestError as e:
                 if attempt <= max_retries: