hud-python 0.2.3__py3-none-any.whl → 0.2.5__py3-none-any.whl

hud/telemetry/tests/test_trace.py

@@ -0,0 +1,270 @@
+from __future__ import annotations
+
+import asyncio
+import uuid
+from unittest.mock import MagicMock
+
+import pytest
+
+from hud.telemetry._trace import (
+    init_telemetry,
+    register_trace,
+    trace,
+)
+from hud.telemetry.context import get_current_task_run_id as actual_get_current_task_run_id
+from hud.telemetry.context import is_root_trace as actual_is_root_trace
+from hud.telemetry.context import reset_context
+from hud.telemetry.context import set_current_task_run_id as actual_set_current_task_run_id
+
+
+@pytest.fixture(autouse=True)
+def reset_telemetry_context_fixture():
+    """Ensures telemetry context is reset before and after each test in this file."""
+    reset_context()
+    yield
+    reset_context()
+
+
+class TestInitTelemetry:
+    """Test telemetry initialization."""
+
+    def test_init_telemetry(self, mocker):
+        """Test telemetry initialization calls registry.install_all."""
+        mock_registry = mocker.patch("hud.telemetry._trace.registry", autospec=True)
+        init_telemetry()
+        mock_registry.install_all.assert_called_once()
+
+
+class TestTrace:
+    """Test the trace context manager."""
+
+    def test_trace_basic(self, mocker):
+        """Test basic trace functionality and context setting."""
+        mock_flush = mocker.patch(
+            "hud.telemetry._trace.flush_buffer", return_value=[], autospec=True
+        )
+        mock_submit_loop = mocker.patch(
+            "hud.telemetry._trace.submit_to_worker_loop", return_value=MagicMock(), autospec=True
+        )
+
+        initial_root_state = actual_is_root_trace.get()
+
+        with trace() as task_run_id:
+            assert isinstance(task_run_id, str)
+            uuid.UUID(task_run_id)
+            assert actual_get_current_task_run_id() == task_run_id
+            assert actual_is_root_trace.get() is True
+
+        assert actual_get_current_task_run_id() is None
+        assert actual_is_root_trace.get() == initial_root_state
+        mock_flush.assert_called_once()
+        mock_submit_loop.assert_not_called()
+
+    def test_trace_with_name_and_attributes(self, mocker):
+        """Test trace with name and attributes, checking they are passed on."""
+        mock_mcp_calls = [MagicMock()]
+        mock_flush = mocker.patch(
+            "hud.telemetry._trace.flush_buffer", return_value=mock_mcp_calls, autospec=True
+        )
+        mock_submit_loop = mocker.patch(
+            "hud.telemetry._trace.submit_to_worker_loop", return_value=MagicMock(), autospec=True
+        )
+
+        trace_name = "test_trace_with_data"
+        attrs = {"key": "value", "number": 42}
+
+        with trace(name=trace_name, attributes=attrs) as task_run_id:
+            assert isinstance(task_run_id, str)
+
+        mock_flush.assert_called_once()
+        mock_submit_loop.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_trace_with_mcp_calls_exports(self, mocker):
+        """Test trace with MCP calls exports telemetry with correct data."""
+        mock_mcp_calls = [MagicMock(), MagicMock()]
+        mock_flush = mocker.patch(
+            "hud.telemetry._trace.flush_buffer", return_value=mock_mcp_calls, autospec=True
+        )
+        mock_submit_loop = mocker.patch(
+            "hud.telemetry._trace.submit_to_worker_loop", return_value=MagicMock(), autospec=True
+        )
+
+        async def mock_export(*args, **kwargs):
+            return None
+
+        mock_export_actual_coro = mocker.patch(
+            "hud.telemetry._trace.exporter.export_telemetry",
+            side_effect=mock_export,
+        )
+
+        test_attrs = {"custom_attr": "test_val"}
+        test_name = "mcp_export_test"
+
+        with trace(name=test_name, attributes=test_attrs) as task_run_id:
+            pass
+
+        mock_flush.assert_called_once()
+        mock_submit_loop.assert_called_once()
+
+        mock_export_actual_coro.assert_called_once()
+        args, kwargs = mock_export_actual_coro.call_args
+        assert kwargs["task_run_id"] == task_run_id
+        assert kwargs["mcp_calls"] == mock_mcp_calls
+        assert kwargs["trace_attributes"]["trace_name"] == test_name
+        assert kwargs["trace_attributes"]["custom_attr"] == "test_val"
+        assert "start_time" in kwargs["trace_attributes"]
+        assert "end_time" in kwargs["trace_attributes"]
+        assert "duration" in kwargs["trace_attributes"]
+        assert kwargs["trace_attributes"]["is_root"] is True
+
+    def test_trace_nested(self, mocker):
+        """Test nested traces, verifying context restoration and root trace logic."""
+        actual_set_current_task_run_id(None)
+        actual_is_root_trace.set(False)
+
+        mock_flush_internal = mocker.patch(
+            "hud.telemetry._trace.flush_buffer", return_value=[], autospec=True
+        )
+        mock_submit_loop_internal = mocker.patch(
+            "hud.telemetry._trace.submit_to_worker_loop", return_value=MagicMock(), autospec=True
+        )
+
+        assert actual_get_current_task_run_id() is None
+        assert actual_is_root_trace.get() is False
+
+        with trace(name="outer") as outer_id:
+            assert actual_get_current_task_run_id() == outer_id
+            assert actual_is_root_trace.get() is True
+            with trace(name="inner") as inner_id:
+                assert actual_get_current_task_run_id() == inner_id
+                assert actual_is_root_trace.get() is False
+                assert outer_id != inner_id
+            assert actual_get_current_task_run_id() == outer_id
+            assert actual_is_root_trace.get() is True
+
+        assert actual_get_current_task_run_id() is None
+        assert actual_is_root_trace.get() is False
+        assert mock_flush_internal.call_count == 2
+        mock_submit_loop_internal.assert_not_called()
+
+    def test_trace_exception_handling(self, mocker):
+        """Test trace handles exceptions properly and restores context."""
+        initial_task_id_before_trace = "pre_existing_id_123"
+        initial_root_state_before_trace = True
+        actual_set_current_task_run_id(initial_task_id_before_trace)
+        actual_is_root_trace.set(initial_root_state_before_trace)
+
+        mock_flush = mocker.patch(
+            "hud.telemetry._trace.flush_buffer", return_value=[], autospec=True
+        )
+        mock_submit_loop = mocker.patch(
+            "hud.telemetry._trace.submit_to_worker_loop", return_value=MagicMock(), autospec=True
+        )
+
+        with pytest.raises(ValueError, match="Test exception"), trace(name="trace_with_exception"):
+            assert actual_get_current_task_run_id() != initial_task_id_before_trace
+            assert actual_is_root_trace.get() is False
+            raise ValueError("Test exception")
+
+        mock_flush.assert_called_once()
+        assert actual_get_current_task_run_id() == initial_task_id_before_trace
+        assert actual_is_root_trace.get() == initial_root_state_before_trace
+        mock_submit_loop.assert_not_called()
+
+
+class TestRegisterTrace:
+    """Test the register_trace decorator."""
+
+    def test_register_trace_sync_function(self, mocker):
+        mock_trace_context_manager = mocker.patch("hud.telemetry._trace.trace", autospec=True)
+        mock_trace_context_manager.return_value.__enter__.return_value = "mocked_task_id"
+        mock_trace_context_manager.return_value.__exit__.return_value = None
+
+        @register_trace(name="test_func_sync")
+        def sync_function(x, y):
+            return x + y
+
+        result = sync_function(1, 2)
+        assert result == 3
+        mock_trace_context_manager.assert_called_once_with(name="test_func_sync", attributes=None)
+
+    def test_register_trace_async_function(self, mocker):
+        mock_trace_context_manager = mocker.patch("hud.telemetry._trace.trace", autospec=True)
+        mock_trace_context_manager.return_value.__enter__.return_value = "mocked_task_id"
+        mock_trace_context_manager.return_value.__exit__.return_value = None
+
+        @register_trace(name="test_func_async")
+        async def async_function(x, y):
+            return x + y
+
+        async def run_test():
+            result = await async_function(1, 2)
+            assert result == 3
+            mock_trace_context_manager.assert_called_once_with(
+                name="test_func_async", attributes=None
+            )
+
+        asyncio.run(run_test())
+
+    def test_register_trace_with_attributes(self, mocker):
+        """Test register_trace with attributes."""
+        mock_trace_context_manager = mocker.patch("hud.telemetry._trace.trace", autospec=True)
+
+        class _MockTraceContextManager:
+            def __enter__(self):
+                return "task_id"
+
+            def __exit__(self, exc_type, exc_value, traceback):
+                return None
+
+        mock_trace_context_manager.return_value = _MockTraceContextManager()
+
+        attrs = {"operation": "add"}
+
+        @register_trace(name="test_func", attributes=attrs)
+        def func_with_attrs(x):
+            return x * 2
+
+        result = func_with_attrs(5)
+        assert result == 10
+        mock_trace_context_manager.assert_called_once_with(name="test_func", attributes=attrs)
+
+    def test_register_trace_without_name(self, mocker):
+        """Test register_trace uses function name when name not provided."""
+        mock_trace_context_manager = mocker.patch("hud.telemetry._trace.trace", autospec=True)
+        mock_trace_context_manager.return_value.__enter__.return_value = "task_id"
+        mock_trace_context_manager.return_value.__exit__.return_value = None
+
+        @register_trace()
+        def my_function():
+            return "result"
+
+        result = my_function()
+        assert result == "result"
+        mock_trace_context_manager.assert_called_once_with(name="my_function", attributes=None)
+
+    def test_register_trace_preserves_function_metadata(self):
+        """Test register_trace preserves original function metadata."""
+
+        @register_trace(name="test")
+        def original_function():
+            """Original docstring."""
+
+        assert original_function.__name__ == "original_function"
+        assert original_function.__doc__ == "Original docstring."
+
+    def test_register_trace_exception_propagation(self, mocker):
+        """Test register_trace propagates exceptions."""
+        mock_trace_context_manager = mocker.patch("hud.telemetry._trace.trace", autospec=True)
+        mock_trace_context_manager.return_value.__enter__.return_value = "task_id"
+        mock_trace_context_manager.return_value.__exit__.return_value = None
+
+        @register_trace()
+        def failing_function():
+            raise RuntimeError("Test error")
+
+        with pytest.raises(RuntimeError, match="Test error"):
+            failing_function()
+
+        mock_trace_context_manager.assert_called_once()

hud/types.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import enum
 from pathlib import Path
-from typing import Any, Literal, TypeAlias
+from typing import Literal, TypeAlias
 
 from pydantic import BaseModel
 
@@ -12,38 +12,22 @@ class CustomGym(BaseModel):
     Public environment specification with a dockerfile and controller.
 
     If the location is remote, the env will be created on the server.
-    If the location is dev, the env will be created locally via docker.
+    If the location is local, the env will be created locally via docker.
 
     The dockerfile can be specified directly or automatically found in the controller_source_dir.
     If neither is provided, an error will be raised during validation.
     """
 
     type: Literal["public"] = "public"
-    dockerfile: str | None = None
     location: Literal["local", "remote"]
-    ports: list[int] | None = None
-    # If path, then it is a development environment on the local computer
-    # If none, then the controller must be installed in the environment through the dockerfile
-    # Can be provided as a string or Path object
-    controller_source_dir: str | Path | None = None
-
-    def model_post_init(self, __context: Any, /) -> None:
-        """Validate and set up dockerfile if not explicitly provided."""
-        # Convert string path to Path object if needed
-        if isinstance(self.controller_source_dir, str):
-            self.controller_source_dir = Path(self.controller_source_dir)
-
-        if self.dockerfile is None:
-            if self.controller_source_dir is None:
-                raise ValueError("Either dockerfile or controller_source_dir must be provided")
-
-            # Look for Dockerfile in the controller_source_dir
-            dockerfile_path = self.controller_source_dir / "Dockerfile"
-            if not dockerfile_path.exists():
-                raise ValueError(f"Dockerfile not found in {self.controller_source_dir}")
-
-            # Read the Dockerfile content
-            self.dockerfile = dockerfile_path.read_text()
+    # A. If path, then it is a docker build context on the local computer.
+    #    If the location is local, docker build will be used to create the image.
+    #    If the location is remote, we will build the image remotely.
+    #    The controller will be automatically installed and kept in sync with local changes
+    #    as long as a pyproject.toml is present at the root of the folder.
+    # B. If string, then it is the uri of the docker image to use.
+    #    The controller must already be installed in the image.
+    image_or_build_context: str | Path
 
 
 class EnvironmentStatus(str, enum.Enum):

hud/utils/common.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import io
 import logging
 import tarfile
+import zipfile
 from typing import TYPE_CHECKING, Any, TypedDict
 
 from pydantic import BaseModel
@@ -22,6 +23,7 @@ class FunctionConfig(BaseModel):
     args: list[Any]  # Must be json serializable
 
     id: str | None = None  # Optional id for remote execution
+    metadata: dict[str, Any] | None = None  # Optional metadata for telemetry
 
     def __len__(self) -> int:
         return len(self.args)
@@ -33,11 +35,12 @@ class FunctionConfig(BaseModel):
         return iter(self.args)
 
     def __str__(self) -> str:
-        return f"{self.function}: {', '.join(str(arg) for arg in self.args)}"
+        return f"FC: {self.function}: {', '.join(str(arg) for arg in self.args)} ({self.metadata})"
 
 
 # Type alias for the shorthand config, which just converts to function name and args
-ShorthandConfig = tuple[str | dict[str, Any] | list[str] | list[dict[str, Any]], ...]
+BasicType = str | int | float | bool | None
+ShorthandConfig = tuple[BasicType | dict[str, Any] | list[BasicType] | list[dict[str, Any]], ...]
 
 # Type alias for multiple config formats
 FunctionConfigs = (
@@ -62,6 +65,11 @@ class Observation(BaseModel):
     screenshot: str | None = None  # base64 string png
     text: str | None = None
 
+    def __str__(self) -> str:
+        return f"""Observation(screenshot={
+            self.screenshot[:100] if self.screenshot else "None"
+        }..., text={self.text}...)"""
+
 
 class ExecuteResult(TypedDict):
     """
@@ -107,6 +115,18 @@ def directory_to_tar_bytes(directory_path: Path) -> bytes:
     return output.getvalue()
 
 
+def directory_to_zip_bytes(context_dir: Path) -> bytes:
+    """Zip a directory and return the zip archive as bytes."""
+    output = io.BytesIO()
+    with zipfile.ZipFile(output, "w", zipfile.ZIP_DEFLATED) as zipf:
+        for file_path in context_dir.rglob("*"):
+            if file_path.is_file():
+                rel_path = file_path.relative_to(context_dir)
+                logger.debug("Adding %s to zip archive", rel_path)
+                zipf.write(str(file_path), arcname=str(rel_path))
+    return output.getvalue()
+
+
 async def get_gym_id(gym_name_or_id: str) -> str:
     """
     Get the gym ID for a given gym name or ID.

hud/utils/misc.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+from hud.server import make_request
+from hud.settings import settings
+
+if TYPE_CHECKING:
+    from hud.env.environment import Environment  # Import Environment for type hinting
+
+logger = logging.getLogger(__name__)
+
+
+async def upload_env_telemetry(
+    environment: Environment,
+    results: Any,
+    api_key: str | None = None,
+) -> None:
+    """
+    Sends telemetry data (results from a cloud runner) to the HUD telemetry upload endpoint.
+    """
+    environment_id = environment.client.env_id  # type: ignore
+
+    if not api_key:
+        api_key = settings.api_key
+
+    if not api_key:
+        raise ValueError("API key must be provided either as an argument or set in hud.settings.")
+
+    endpoint_url = f"{settings.base_url}/v2/environments/{environment_id}/telemetry-upload"
+
+    request_payload = {
+        "results": {
+            "steps": results,
+        }
+    }
+
+    logger.debug("Sending telemetry to %s for env_id: %s", endpoint_url, environment_id)
+
+    try:
+        await make_request(
+            method="POST",
+            url=endpoint_url,
+            json=request_payload,
+            api_key=api_key,
+        )
+        logger.info("Successfully uploaded telemetry for environment_id: %s", environment_id)
+    except Exception as e:
+        logger.error(
+            "Failed to upload telemetry for environment_id: %s. Error: %s", environment_id, e
+        )
+        raise

hud/utils/tests/test_version.py

@@ -5,4 +5,4 @@ def test_import():
     """Test that the package can be imported."""
     import hud
 
-    assert hud.__version__ == "0.2.3"
+    assert hud.__version__ == "0.2.5"

hud/version.py

@@ -0,0 +1,7 @@
+"""
+Version information for the HUD SDK.
+"""
+
+from __future__ import annotations
+
+__version__ = "0.2.5"

{hud_python-0.2.3.dist-info → hud_python-0.2.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hud-python
-Version: 0.2.3
+Version: 0.2.5
 Summary: SDK for the HUD evaluation platform.
 Project-URL: Homepage, https://github.com/hud-evals/hud-sdk
 Project-URL: Bug Tracker, https://github.com/hud-evals/hud-sdk/issues
@@ -38,11 +38,13 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: <3.14,>=3.10
 Requires-Dist: aiodocker>=0.24.0
 Requires-Dist: anthropic
+Requires-Dist: dotenv>=0.9.9
 Requires-Dist: httpx<1,>=0.23.0
 Requires-Dist: inspect-ai>=0.3.80
 Requires-Dist: ipykernel
 Requires-Dist: langchain
 Requires-Dist: langchain-openai
+Requires-Dist: mcp
 Requires-Dist: numpy
 Requires-Dist: openai
 Requires-Dist: pillow>=11.1.0
@@ -50,6 +52,7 @@ Requires-Dist: pydantic-settings<3,>=2
 Requires-Dist: pydantic<3,>=2
 Requires-Dist: textdistance<5,>=4.5.0
 Requires-Dist: toml>=0.10.2
+Requires-Dist: wrapt>=1.14.0
 Provides-Extra: dev
 Requires-Dist: anthropic; extra == 'dev'
 Requires-Dist: dotenv; extra == 'dev'
@@ -66,15 +69,68 @@ Requires-Dist: pytest<9,>=8.1.1; extra == 'dev'
 Requires-Dist: ruff==0.11.8; extra == 'dev'
 Description-Content-Type: text/markdown
 
-# HUD
+<div align="left">
+  <img src="https://raw.githubusercontent.com/hud-evals/hud-sdk/main/docs/logo/hud_logo.svg" alt="HUD" width="150" style="margin-bottom: 20px;"/>
+</div>
+
+<h3>
+Create, evaluate, and improve AI agents across web browsers, desktop environments, and custom scenarios.
+</h3>
+
+> ### 🚀 Are you a startup building agents?
+> 
+> [📅 Hop on a call ](https://cal.com/jay-ram-z6st6w/demo) or [📧 founders@hud.so](mailto:founders@hud.so)
+> 
+> We're here to help with eval strategies, custom environments, or improving your agent architecture!
 
-A Python SDK for creating, evaluating, and benchmarking agent interactions with web browsers and OS environments.
 
 > **Early Release Notice**: This SDK is currently in early release status. The API is evolving and may change in future releases as we gather feedback and improve functionality.
 
 [![PyPI version](https://img.shields.io/pypi/v/hud-python)](https://pypi.org/project/hud-python/)
 
-[📚 Documentation](https://documentation.hud.so) | [🏠 Homepage](https://hud.so)
+## ✨ What You Can Do
+
+**Evaluate Existing Benchmarks**
+```python
+from hud import load_taskset, run_job, ClaudeAgent
+
+taskset = await load_taskset("WebVoyager")  # or GAIA, OSWorld-Ubuntu, Mind2Web
+job = await run_job(ClaudeAgent, taskset, "my-evaluation")
+```
+
+**Create Custom Tasks**
+```python
+from hud.task import Task
+
+task = Task(
+    prompt="Find and book the cheapest flight from NYC to Paris",
+    gym="hud-browser",
+    setup=("goto", "https://kayak.com"),
+    evaluate=("page_contains", "confirmation")
+)
+```
+
+**Build Custom Environments**
+```python
+from hud.types import CustomGym
+
+# Launch any website as an environment
+custom_gym = CustomGym(
+    image_or_build_context="nginx:alpine",
+    location="local"
+)
+
+# Or create complex Docker environments - see environments/ folder for examples
+```
+
+**Trace Tool Calls Alongside HUD Environments (or Independently)**
+```python
+import hud
+
+with hud.trace("my-agent-run"):
+    # Your agent code here - MCP calls automatically captured
+    result = await agent.run(task)
+```
 
 ## API Key Setup
 
@@ -119,7 +175,7 @@ async def main():
     # Create environment using the gym module
     env = await gym.make(task)
     
-    # Initialize Operator agent (API key is loaded automatically)
+    # Initialize Claude agent (API key is loaded automatically)
     agent = ClaudeAgent()
     
     # Agent loop with predict and step functions
@@ -137,7 +193,6 @@ async def main():
 
 if __name__ == "__main__":
     asyncio.run(main())
-
 ```
 
 Alternatively, run a full evaluation set via the ```run_job``` command:
@@ -145,32 +200,45 @@ Alternatively, run a full evaluation set via the ```run_job``` command:
 ```python
 from hud import load_taskset, run_job, ClaudeAgent
 
-# load
+# Load a benchmark
 taskset = load_taskset("GAIA")
 
-# evaluate
+# Evaluate
 job = await run_job(ClaudeAgent, taskset, "test-gaia-job")
 
-# get results OR view them in app.hud.so
+# Get results OR view them in app.hud.so
 print(await job.get_analytics())
 ```
 
+## Ready-to-Use TaskSets
+
+- **WebVoyager** - Web navigation and interaction
+- **Mind2Web** - Complex web application tasks  
+- **GAIA** - Question answering and reasoning
+- **OSWorld-Ubuntu** - Desktop interaction
+- **hud-samples** - Getting started examples
+
+## Community
+
+**Contributing Custom Environments**
+
+Add your environment to the `environments/` folder and submit a PR! Examples:
+- `environments/novnc_ubuntu/` - Ubuntu with VNC access 
+- `environments/pokemon_controller/` - Pokemon emulator environment (In Development)
+- `environments/qa_controller/` - Lightweight app sample
+
+See [Custom Environments Guide](https://docs.hud.so/environment-creation) for details.
+
 ## Documentation Sections
 
 Explore the core concepts and features of the SDK:
 
-*   **[Tasks and TaskSets](https://documentation.hud.so/concepts/task)**: Define goals, context, setup, and evaluation criteria for agent scenarios. This includes both interactive and **question-answering (QA)** style tasks.
-*   **[Environments](https://documentation.hud.so/concepts/environment)**: Understand the browser and OS runtimes where agents interact.
-*   **[Agents](https://documentation.hud.so/concepts/agent)**: Learn about the agent architecture (Claude, Operator) and how they process observations and predict actions.
-*   **[Adapters](https://documentation.hud.so/concepts/adapter)**: See how actions and observations are translated between agents and environments.
-*   **[Jobs](https://documentation.hud.so/concepts/job)**: Group related runs for analysis and viewing on the HUD platform.
-*   **[Trajectories](https://documentation.hud.so/concepts/trajectory)**: Understand the recorded data from each agent run.
-*   **Advanced Topics**:
-    *   **[CLA Action Details](https://documentation.hud.so/advanced/cla-details)**: Explore the standardized action format.
-    *   **[Custom Environments](https://documentation.hud.so/advanced/custom-environments)**: Build your own Docker-based local or remote environments.
-    *   **[Advanced Environment Control](https://documentation.hud.so/advanced/environment-control)**: Use `invoke`, `execute`, and `_setup` for finer control.
-
-*   **[Full API Reference](https://documentation.hud.so/api-reference/gym)**: Detailed specifications for all modules and classes.
+*   **[Task Creation](https://docs.hud.so/task-creation)**: Build custom evaluation scenarios with setup and evaluation criteria.
+*   **[Environments](https://docs.hud.so/environments/browser)**: Understand browser environments and create custom Docker-based environments.
+*   **[Agents](https://docs.hud.so/concepts/agent)**: Learn about the agent architecture (Claude, Operator) and how they process observations and predict actions.
+*   **[Jobs](https://docs.hud.so/concepts/job)**: Group related runs for analysis and viewing on the HUD platform.
+*   **[MCP Telemetry](https://docs.hud.so/telemetry/mcp)**: Automatic tracing of Model Context Protocol interactions.
+*   **[Full API Reference](https://docs.hud.so/api-reference/gym)**: Detailed specifications for all modules and classes.
 
 ## [Examples](examples/)
 
@@ -183,7 +251,7 @@ We recommend you first take a look at the example notebooks showing how to use t
 
 ## Documentation
 
-For comprehensive guides, examples, and API reference, visit [our docs](https://documentation.hud.so/introduction)
+For comprehensive guides, examples, and API reference, visit [our docs](https://docs.hud.so/introduction)
 
 ## License