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

hud/taskset.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from pathlib import PosixPath
+from typing import TYPE_CHECKING, Any, get_args
 from venv import logger
 
 from pydantic import BaseModel
@@ -9,6 +10,7 @@ from hud.env.environment import create_remote_config
 from hud.server import make_request
 from hud.settings import settings
 from hud.task import Task
+from hud.types import CustomGym, ServerGym
 from hud.utils.config import REMOTE_EVALUATE, REMOTE_SETUP
 
 if TYPE_CHECKING:
@@ -86,16 +88,45 @@ class TaskSet(BaseModel):
         # Convert all tasks to expanded configs
         processed_tasks = []
         for task in self.tasks:
-            setup_config = create_remote_config(None, task.setup, REMOTE_SETUP)[0].args[0]
-            evaluate_config = create_remote_config(None, task.evaluate, REMOTE_EVALUATE)[0].args[0]
+            if task.setup is not None:
+                setup_config = (
+                    create_remote_config(None, task.setup, REMOTE_SETUP)[0].args[0].model_dump()
+                )
+            else:
+                setup_config = None
+            if task.evaluate is not None:
+                evaluate_config = (
+                    create_remote_config(None, task.evaluate, REMOTE_EVALUATE)[0]
+                    .args[0]
+                    .model_dump()
+                )
+            else:
+                evaluate_config = None
+
+            if isinstance(task.gym, CustomGym):
+                if isinstance(task.gym.image_or_build_context, PosixPath):
+                    raise ValueError(
+                        "Local build contexts are not supported for "
+                        "remote tasksets, attach an image or existing "
+                        "gym id."
+                    )
+                gym_str = "docker"
+                image_uri = task.gym.image_or_build_context
+            elif isinstance(task.gym, str) and task.gym in get_args(ServerGym):
+                gym_str = task.gym
+                image_uri = None
+            else:
+                raise ValueError(f"Unknown gym type: {type(task.gym)}")
 
             processed_tasks.append(
                 {
                     "prompt": task.prompt,
-                    "gym": task.gym,
-                    "setup": setup_config.model_dump(),
-                    "evaluate": evaluate_config.model_dump(),
+                    "gym": gym_str,
+                    "setup": setup_config,
+                    "evaluate": evaluate_config,
                     "config": task.config,
+                    "image_uri": image_uri,
+                    "description": task.description,
                 }
             )
 
@@ -113,7 +144,15 @@ class TaskSet(BaseModel):
             "Taskset %s uploaded successfully, see it on app.hud.so/evalsets/%s", name, name
         )
 
-    async def fit(self, agent: Agent | type[Agent]) -> None:
+    def _apply(self, dict: dict[str, Any]) -> None:
+        """
+        Applies a parameter to all tasks in the taskset.
+        """
+        for task in self.tasks:
+            for key, value in dict.items():
+                setattr(task, key, value)
+
+    def fit(self, agent: Agent | type[Agent]) -> None:
         """
         Automatically adapts the taskset to the agent's transfer_gyms.
         """
@@ -121,19 +160,27 @@ class TaskSet(BaseModel):
             agent = agent()
 
         for task in self.tasks:
-            if task.gym is None:
+            if task.gym is None or isinstance(task.gym, CustomGym):
                 continue
             task.gym = agent.transfer_gyms.get(task.gym, task.gym)
 
 
-async def load_taskset(taskset_id: str, api_key: str | None = None) -> TaskSet:
+async def load_taskset(
+    taskset_id: str,
+    api_key: str | None = None,
+    metadata: dict[str, Any] | None = None,
+    load_custom_as_local: bool = False,
+    system_prompt: str | None = None,
+) -> TaskSet:
     """
     Loads a TaskSet by its ID.
 
     Args:
         taskset_id: The ID of the taskset to load
         api_key: Optional API key to use for the request
-
+        metadata: Optional metadata to apply to the taskset
+        load_custom_as_local: Whether to load custom gyms as local
+        system_prompt: Optional system prompt to override the default
     Returns:
         TaskSet: The loaded taskset
     """
@@ -149,13 +196,33 @@ async def load_taskset(taskset_id: str, api_key: str | None = None) -> TaskSet:
 
     logger.info(f"Taskset {taskset_id} loaded successfully")
 
-    return TaskSet.model_validate(
+    tasks = data["evalset"]
+    for task in tasks:
+        if system_prompt:
+            task["system_prompt"] = system_prompt
+        if task["gym"] == "docker":
+            if "image_uri" not in task:
+                raise ValueError(
+                    "No `image_uri` key found. This taskset may be "
+                    "incompatible with your version of HUD SDK."
+                )
+
+            task["gym"] = CustomGym(
+                location="local" if load_custom_as_local else "remote",
+                image_or_build_context=task["image_uri"],
+            )
+
+    taskset = TaskSet.model_validate(
         {
             "id": taskset_id,
-            "tasks": data["evalset"],
+            "tasks": tasks,
         }
     )
 
+    taskset._apply({"metadata": metadata})
+
+    return taskset
+
 
 def load_from_inspect(dataset: Dataset) -> TaskSet:
     """

hud/telemetry/context.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import contextvars
 import logging
+from collections import defaultdict
 from datetime import datetime
 from typing import Any, TypeVar
 
@@ -11,7 +12,6 @@ from hud.telemetry.mcp_models import (
     MCPNotificationCall,
     MCPRequestCall,
     MCPResponseCall,
-    MCPTelemetryRecord,
     StatusType,
 )
 
@@ -21,9 +21,8 @@ logger = logging.getLogger("hud.telemetry")
 current_task_run_id: contextvars.ContextVar[str | None] = contextvars.ContextVar(
     "current_task_run_id", default=None
 )
-mcp_calls_buffer: contextvars.ContextVar[list[BaseMCPCall] | None] = contextvars.ContextVar(
-    "mcp_calls_buffer", default=None
-)
+# NEW: Global dictionary for buffering, keyed by task_run_id
+_GLOBAL_MCP_CALL_BUFFERS: defaultdict[str, list[BaseMCPCall]] = defaultdict(list)
 is_root_trace: contextvars.ContextVar[bool] = contextvars.ContextVar("is_root_trace", default=False)
 
 # Maximum buffer size before automatic flush
@@ -35,51 +34,37 @@ T = TypeVar("T", bound=BaseMCPCall)
 
 def get_current_task_run_id() -> str | None:
     """Get the task_run_id for the current trace context."""
-    value = current_task_run_id.get()
-    # Convert empty string sentinel back to None
-    return None if value == "" else value
+    return current_task_run_id.get()
 
 
 def set_current_task_run_id(task_run_id: str | None) -> None:
     """Set the task_run_id for the current trace context."""
-    # Handle None value by using empty string as sentinel
-    value_to_set = "" if task_run_id is None else task_run_id
-    current_task_run_id.set(value_to_set)
+    current_task_run_id.set(task_run_id)
 
 
 def buffer_mcp_call(record: BaseMCPCall | dict[str, Any]) -> None:
-    """
-    Add an MCP call to the buffer for the current trace.
-
-    Args:
-        record: Either a Pydantic model instance or dictionary with MCP call data
-    """
-    # Only buffer if we have an active trace
     task_run_id = get_current_task_run_id()
-    if task_run_id is not None and task_run_id != "":
-        buffer = mcp_calls_buffer.get()
-        if buffer is None:
-            buffer = []
 
-        # Convert dictionary to proper model if needed
-        if isinstance(record, dict):
-            record = BaseMCPCall.from_dict(record)
+    if not task_run_id:
+        logger.warning(
+            "BUFFER_MCP_CALL: No task_run_id. Skipping buffer for %s", type(record).__name__
+        )
+        return
 
-        # Ensure the record has the current task_run_id
-        if record.task_run_id != task_run_id:
-            # Create a copy with the current task_run_id
-            record_dict = record.model_dump()
-            record_dict["task_run_id"] = task_run_id
-            record = BaseMCPCall.from_dict(record_dict)
+    # Ensure 'record' is a Pydantic model instance from here
+    if isinstance(record, dict):
+        try:
+            record_model = BaseMCPCall.from_dict(record)
+            record = record_model
+        except Exception as e_conv:
+            logger.exception("BUFFER_MCP_CALL: Failed to convert dict to BaseMCPCall: %s", e_conv)
+            return
 
-        # Add to buffer
-        buffer.append(record)
-        mcp_calls_buffer.set(buffer)
+    _GLOBAL_MCP_CALL_BUFFERS[task_run_id].append(record)
+    buffer_len = len(_GLOBAL_MCP_CALL_BUFFERS[task_run_id])
 
-        # Auto-flush if buffer gets too large
-        if len(buffer) >= MAX_BUFFER_SIZE:
-            logger.debug("MCP calls buffer reached size %d, auto-flushing", len(buffer))
-            flush_buffer(export=True)
+    if buffer_len >= MAX_BUFFER_SIZE:
+        flush_buffer(export=True)
 
 
 def flush_buffer(export: bool = False) -> list[BaseMCPCall]:
@@ -92,25 +77,16 @@ def flush_buffer(export: bool = False) -> list[BaseMCPCall]:
     Returns:
         The list of buffered MCP calls
     """
-    buffer = mcp_calls_buffer.get()
-    if buffer is None:
-        buffer = []
-    # Reset buffer to empty list
-    mcp_calls_buffer.set([])
-
-    if export and buffer and len(buffer) > 0:
-        task_id = buffer[0].task_run_id if buffer else None
-        if task_id:
-            logger.debug("Exporting %d MCP calls for task run %s", len(buffer), task_id)
-            # Create a telemetry record for export
-            _telemetry_record = MCPTelemetryRecord(task_run_id=task_id, records=buffer)
-            # In the future, we could call an export function here
-            # For now, just log that we have telemetry
-            logger.debug("MCP telemetry record created with %d calls", len(buffer))
-        else:
-            logger.warning("No task_run_id found in buffer, skipping export")
-
-    return buffer
+    task_run_id = get_current_task_run_id()
+    if not task_run_id:
+        logger.warning("FLUSH_BUFFER: No current task_run_id. Cannot flush.")
+        return []
+
+    buffer_for_task = _GLOBAL_MCP_CALL_BUFFERS.pop(
+        task_run_id, []
+    )  # Get and remove the list for this task
+
+    return buffer_for_task  # Return the flushed items
 
 
 def create_request_record(
@@ -150,6 +126,7 @@ def create_response_record(
         is_error=is_error,
         **kwargs,
     )
+
     buffer_mcp_call(record)
     return record
 
@@ -189,5 +166,4 @@ def create_manual_test_record(**custom_data: Any) -> MCPManualTestCall | None:
 def reset_context() -> None:
     """Reset all telemetry context variables. Useful for test isolation."""
     set_current_task_run_id(None)
-    mcp_calls_buffer.set([])
     is_root_trace.set(False)

hud/telemetry/exporter.py

@@ -298,12 +298,10 @@ async def _export_trace_payload_async(payload: dict[str, Any]) -> None:
         "telemetry": payload.get("mcp_calls", []),
     }
 
-    # Ensure mcp_calls is not empty if that's a requirement, or send as is. For now, send as is.
-    # if not data_to_send["mcp_calls"]:
-    #     logger.debug("No MCP calls in payload for task run %s, skipping specific export if "
-    #                  "desired.", task_run_id)
-    #     # Depending on backend, might not want to send empty mcp_calls list, or it's fine.
+    await send_telemetry_to_server(task_run_id, data_to_send)
 
+
+async def send_telemetry_to_server(task_run_id: str, data: dict[str, Any]) -> None:
     telemetry_url = f"{settings.base_url}/v2/task_runs/{task_run_id}/telemetry-upload"
 
     try:
@@ -320,7 +318,7 @@ async def _export_trace_payload_async(payload: dict[str, Any]) -> None:
             )
             response = await client.post(
                 telemetry_url,
-                json=data_to_send,  # Send the structured attributes and mcp_calls
+                json=data,  # Send the structured attributes and mcp_calls
                 headers=headers,
                 timeout=30.0,
             )

hud/telemetry/instrumentation/mcp.py

@@ -31,9 +31,6 @@ from hud.telemetry.mcp_models import DirectionType, MCPCallType, MCPManualTestCa
 
 logger = logging.getLogger(__name__)
 
-# Ensure no OTel imports remain
-# from opentelemetry import context as otel_context, propagate # Should be removed
-
 
 class MCPInstrumentor:
     """

hud/telemetry/tests/test_context.py

@@ -140,9 +140,13 @@ class TestMCPCallBuffer:
 
         # Flush should return all calls from both tasks
         result = flush_buffer()
-        assert len(result) == 2
-        assert result[0] == mock_call_1
-        assert result[1] == mock_call_2
+        assert len(result) == 1
+        assert result[0] == mock_call_2
+
+        set_current_task_run_id("task-1")
+        result2 = flush_buffer()
+        assert len(result2) == 1
+        assert result2[0] == mock_call_1
 
     def test_buffer_mcp_call_without_task_id(self):
         """Test adding MCP call when no task run ID is set."""

hud/trajectory.py

@@ -6,6 +6,8 @@ import datetime
 from IPython.display import HTML, Markdown, display
 from pydantic import BaseModel, Field
 
+from .adapters.common.types import LogType
+
 
 class TrajectoryStep(BaseModel):
     """Model representing a single task run's trajectory information."""
@@ -13,6 +15,7 @@ class TrajectoryStep(BaseModel):
     observation_url: str | None = None
     observation_text: str | None = None
     actions: list[dict]
+    logs: LogType | None = None
     start_timestamp: str | None = None
     end_timestamp: str | None = None
 

hud/types.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import enum
 from pathlib import Path
-from typing import Literal, TypeAlias
+from typing import Any, Literal, TypeAlias
 
 from pydantic import BaseModel
 
@@ -28,6 +28,9 @@ class CustomGym(BaseModel):
     # 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
+    # host_config will be passed to the docker client when creating the environment.
+    # refer to official docker api documentation for available configs.
+    host_config: dict[str, Any] | None = None
 
 
 class EnvironmentStatus(str, enum.Enum):
@@ -48,7 +51,30 @@ class EnvironmentStatus(str, enum.Enum):
 
 
 # Available HUD gyms
-ServerGym: TypeAlias = Literal["qa", "hud-browser", "hud-ubuntu", "OSWorld-Ubuntu"]
+ServerGym: TypeAlias = Literal["qa", "hud-browser", "OSWorld-Ubuntu", "docker"]
 
 # Gyms can be either custom or server-side
 Gym: TypeAlias = CustomGym | ServerGym
+
+
+# Metadata keys for the environment.
+# partial: Whether the environment evaluator should give partial grades.
+# eval_model: The model to use for evaluation when running a VLM. Wraps langchain.
+# agent_name: The name of the agent that was used for running this task.
+ServerMetadataKeys: TypeAlias = Literal["partial", "eval_model", "agent_name"]
+MetadataKeys: TypeAlias = str | ServerMetadataKeys
+
+
+# Dictionary of sensitive data (only supported for hud-browser environments)
+# key: website name or page identifier
+# value: Dictionary of credentials for the sensitive data
+# Example:
+# {
+#     "google.com": {
+#         "google_username": "my_username",
+#         "google_password": "my_password"
+#     }
+# }
+# The agent only has access to the key of the credential, not the value. (i.e. google_username)
+# The value is only available to the environment. (i.e. my_username)
+SensitiveData: TypeAlias = dict[str, dict[str, str]]

hud/utils/agent.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from hud.task import Task
+
+AGENT_PROMPT = (
+    "You are an AI agent whose goal is to accomplish the ultimate task following the instructions."
+)
+
+
+def format_agent_prompt(environment_prompt: str | None, task: Task | None) -> str:
+    """
+    Format the agent prompt with the environment prompt and the task prompt.
+    """
+    prompt = AGENT_PROMPT
+
+    # User-provided system prompt takes precedence over environment prompt
+    if task and task.system_prompt:
+        prompt += f"\n\n{task.system_prompt}"
+    elif environment_prompt:
+        prompt += f"\n\n{environment_prompt}"
+
+    if task:
+        if task.sensitive_data:
+            prompt += "\n\nHere are placeholders for sensitive data for each domain:"
+            for domain, credentials in task.sensitive_data.items():
+                prompt += f"\n{domain}: "
+                placeholders = [f"{key}" for key in credentials]
+                prompt += f"{', '.join(placeholders)}"
+            prompt += "\n\nYou can type these placeholders to enter the sensitive data when needed."
+
+        if task.prompt:
+            prompt += f"\n\n{task.prompt}"
+
+    return prompt

hud/utils/common.py

@@ -6,6 +6,7 @@ import tarfile
 import zipfile
 from typing import TYPE_CHECKING, Any, TypedDict
 
+from pathspec import PathSpec
 from pydantic import BaseModel
 
 from hud.server.requests import make_request
@@ -67,8 +68,8 @@ class Observation(BaseModel):
 
     def __str__(self) -> str:
         return f"""Observation(screenshot={
-            self.screenshot[:100] if self.screenshot else "None"
-        }..., text={self.text}...)"""
+            f"{self.screenshot[:100]}..." if self.screenshot else "None"
+        }, text={f"{self.text[:100]}..." if self.text else "None"})"""
 
 
 class ExecuteResult(TypedDict):
@@ -86,44 +87,159 @@ class ExecuteResult(TypedDict):
     exit_code: int
 
 
-def directory_to_tar_bytes(directory_path: Path) -> bytes:
+# ---------------------------------------------------------------------------
+# Helper functions for handling ignore patterns
+# ---------------------------------------------------------------------------
+
+
+def _read_ignore_file(file_path: Path) -> list[str]:
+    """Return patterns from *file_path* (ignoring blanks / comments)."""
+    if not file_path.exists():
+        return []
+
+    patterns: list[str] = []
+    for line in file_path.read_text().splitlines():
+        stripped = line.strip()
+        if not stripped or stripped.startswith("#"):
+            continue
+        patterns.append(stripped)
+    return patterns
+
+
+def _gather_ignore_patterns(root_dir: Path, filename: str) -> list[str]:
+    """Collect *filename* patterns throughout *root_dir* respecting hierarchy.
+
+    For a nested ignore file located at ``sub/dir/.gitignore`` containing the
+    pattern ``foo/``, the returned pattern will be ``sub/dir/foo/`` so that it
+    is evaluated relative to *root_dir* when passed to ``PathSpec``.
     """
-    Converts a directory to a tar archive and returns it as bytes.
+    gathered: list[str] = []
+
+    root_dir = root_dir.resolve()
+
+    for ignore_file in root_dir.rglob(filename):
+        prefix = ignore_file.parent.relative_to(root_dir).as_posix()
+        base_prefix = "" if prefix == "." else prefix
+
+        for pat in _read_ignore_file(ignore_file):
+            negate = pat.startswith("!")
+            pat_body = pat[1:] if negate else pat
+
+            # Leading slash means relative to the directory the ignore file is
+            # located in - remove it so we can prepend *prefix* below.
+            if pat_body.startswith("/"):
+                pat_body = pat_body.lstrip("/")
 
-    This function creates a tar archive of the specified directory in memory,
-    without writing to a temporary file on disk.
+            full_pattern = f"{base_prefix}/{pat_body}" if base_prefix else pat_body
+            if negate:
+                full_pattern = f"!{full_pattern}"
 
-    Args:
-        path: Path to the directory to convert
+            gathered.append(full_pattern)
 
-    Returns:
-        Bytes of the tar archive
+    return gathered
+
+
+def _compile_pathspec(
+    directory: Path,
+    *,
+    respect_gitignore: bool,
+    respect_dockerignore: bool,
+    respect_hudignore: bool,
+) -> PathSpec | None:
+    """Compile a ``PathSpec`` from all relevant ignore files under *directory*.
+
+    In addition to the standard ``.gitignore`` and ``.dockerignore`` files we now
+    recognise a project-specific ``.hudignore`` file that shares the same pattern
+    syntax. Each file can be toggled independently through the corresponding
+    ``respect_*`` keyword argument.
+    """
+    patterns: list[str] = []
+
+    if respect_gitignore:
+        patterns.extend(_gather_ignore_patterns(directory, ".gitignore"))
+    if respect_dockerignore:
+        patterns.extend(_gather_ignore_patterns(directory, ".dockerignore"))
+    if respect_hudignore:
+        patterns.extend(_gather_ignore_patterns(directory, ".hudignore"))
+
+    if not patterns:
+        return None
+
+    return PathSpec.from_lines("gitwildmatch", patterns)
+
+
+def _iter_files(
+    directory: Path,
+    *,
+    respect_gitignore: bool,
+    respect_dockerignore: bool,
+    respect_hudignore: bool,
+) -> Iterator[tuple[Path, Path]]:
+    """Yield ``(file_path, relative_path)`` while respecting ignore files."""
+    spec = _compile_pathspec(
+        directory,
+        respect_gitignore=respect_gitignore,
+        respect_dockerignore=respect_dockerignore,
+        respect_hudignore=respect_hudignore,
+    )
+
+    for file_path in directory.rglob("*"):
+        if not file_path.is_file():
+            continue
+        rel_path = file_path.relative_to(directory)
+        rel_str = rel_path.as_posix()
+        if spec and spec.match_file(rel_str):
+            continue
+        yield file_path, rel_path
+
+
+def directory_to_tar_bytes(
+    directory_path: Path,
+    *,
+    respect_gitignore: bool = False,
+    respect_dockerignore: bool = False,
+    respect_hudignore: bool = True,
+) -> bytes:
+    """
+    Converts a directory to a tar archive and returns it as bytes.
+
+    By default the archive respects ignore rules defined in ``.gitignore``,
+    ``.dockerignore`` and ``.hudignore`` (each can be disabled via kwargs).
     """
     output = io.BytesIO()
 
     with tarfile.open(fileobj=output, mode="w") as tar:
-        # Walk through the directory
-        for file_path in directory_path.rglob("*"):
-            if file_path.is_file():
-                # Calculate relative path for the archive
-                rel_path = file_path.relative_to(directory_path)
-                logger.debug("Adding %s to tar archive", rel_path)
-                tar.add(file_path, arcname=str(rel_path))
-
-    # Get the bytes from the BytesIO object
+        for file_path, rel_path in _iter_files(
+            directory_path,
+            respect_gitignore=respect_gitignore,
+            respect_dockerignore=respect_dockerignore,
+            respect_hudignore=respect_hudignore,
+        ):
+            logger.debug("Adding %s to tar archive", rel_path)
+            tar.add(file_path, arcname=str(rel_path))
+
     output.seek(0)
     return output.getvalue()
 
 
-def directory_to_zip_bytes(context_dir: Path) -> bytes:
-    """Zip a directory and return the zip archive as bytes."""
+def directory_to_zip_bytes(
+    context_dir: Path,
+    *,
+    respect_gitignore: bool = False,
+    respect_dockerignore: bool = False,
+    respect_hudignore: bool = True,
+) -> bytes:
+    """Zip *context_dir* and return the zip archive as bytes, respecting ignore rules."""
     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))
+        for file_path, rel_path in _iter_files(
+            context_dir,
+            respect_gitignore=respect_gitignore,
+            respect_dockerignore=respect_dockerignore,
+            respect_hudignore=respect_hudignore,
+        ):
+            logger.debug("Adding %s to zip archive", rel_path)
+            zipf.write(str(file_path), arcname=str(rel_path))
     return output.getvalue()
 
 

hud/utils/config.py

@@ -103,6 +103,17 @@ def expand_config(config: FunctionConfigs) -> list[FunctionConfig]:
 
         return [FunctionConfig(function=function_name, args=args)]
 
+    if isinstance(config, list):
+        result = []
+        for item in config:
+            if isinstance(item, tuple) and len(item) >= 1 and isinstance(item[0], str):
+                function_name = item[0]
+                args = list(item[1:]) if len(item) > 1 else []
+                result.append(FunctionConfig(function=function_name, args=args))
+            else:
+                raise ValueError(f"Invalid list item configuration: {item}")
+        return result
+
     # Unknown configuration type
     error_msg = f"Unknown configuration type: {type(config)}"
     logger.error(error_msg)