rasa-pro 3.14.0.dev20250901__py3-none-any.whl → 3.14.0rc1__py3-none-any.whl

rasa/shared/utils/mcp/server_connection.py

@@ -0,0 +1,247 @@
+"""MCP server connection utilities."""
+
+import asyncio
+import warnings
+from contextlib import AsyncExitStack, asynccontextmanager
+from typing import Any, AsyncIterator, ClassVar, Dict, List, Optional
+
+import structlog
+from httpx import HTTPStatusError
+from mcp import ClientSession
+from mcp.client.streamable_http import streamablehttp_client
+
+from rasa.shared.agents.auth.agent_auth_manager import AgentAuthManager
+from rasa.shared.agents.auth.auth_strategy import AgentAuthStrategy
+from rasa.shared.exceptions import AuthenticationError
+
+structlogger = structlog.get_logger()
+
+
+# Suppress RuntimeWarning about unawaited coroutines when MCP server is not reachable.
+warnings.filterwarnings(
+    "ignore",
+    message=".*BaseEventLoop.create_server.*was never awaited.*",
+    category=RuntimeWarning,
+)
+
+
+class MCPServerConnection:
+    """
+    Manages connection to an MCP server, with optional authentication.
+
+    This class handles:
+    - Connection establishment and cleanup
+    - Session lifecycle management
+    - Authentication via AgentAuthManager (API Key, OAuth2, mTLS, etc.)
+    """
+
+    # Timeout for ping operations in seconds
+    PING_TIMEOUT_SECONDS = 3.0
+
+    _SUPPORTED_SERVER_TYPES: ClassVar[List[str]] = ["http", "https"]
+
+    def __init__(
+        self,
+        server_name: str,
+        server_url: str,
+        server_type: str,
+        auth_manager: Optional[AgentAuthManager] = None,
+    ):
+        """
+        Initialize the MCP server connection.
+
+        Args:
+            server_name: Server name to identify the server
+            server_url: Server URL
+            server_type: Server type (currently only 'http' is supported)
+            auth_manager: Optional AgentAuthManager instance for this connection
+        """
+        self.server_name = server_name
+        self.server_url = server_url
+        self.server_type = server_type
+        self._auth_manager = auth_manager
+        self.session: Optional[ClientSession] = None
+        self.exit_stack: Optional[AsyncExitStack] = None
+
+    @classmethod
+    def from_config(cls, server_config: Dict[str, Any]) -> "MCPServerConnection":
+        """Initialize the MCP server connection from a configuration dictionary."""
+        auth_config = server_config.get("additional_params")
+        _auth_manager = AgentAuthManager.load_auth(auth_config)
+        return cls(
+            server_config["name"],
+            server_config["url"],
+            server_config.get("type", "http"),
+            _auth_manager,
+        )
+
+    @staticmethod
+    @asynccontextmanager
+    async def open_mcp_session(
+        url: str, auth_strategy: Optional[AgentAuthStrategy] = None
+    ) -> AsyncIterator[ClientSession]:
+        """
+        Open a streamable MCP session, ensuring that initialization
+        completes before yielding.
+        """
+        async with streamablehttp_client(url, auth=auth_strategy) as (
+            read_stream,
+            write_stream,
+            _,
+        ):
+            async with ClientSession(read_stream, write_stream) as session:
+                await session.initialize()  # handshake done here
+                yield session
+
+    async def connect(self) -> None:
+        """Establish connection to the MCP server.
+
+        Raises:
+            ValueError: If the server type is not supported.
+            ConnectionError: If connection fails.
+            AuthenticationError: If authentication fails.
+        """
+        if self.server_type not in self._SUPPORTED_SERVER_TYPES:
+            raise ValueError(f"Unsupported server type: {self.server_type}")
+
+        # Create a new exit stack for this connection to avoid task boundary issues
+        self.exit_stack = AsyncExitStack()
+
+        try:
+            # Get authentication strategy that adheres to httpx.Auth.
+            auth_strategy = (
+                self._auth_manager.get_auth() if self._auth_manager else None
+            )
+
+            # Register the wrapped context manager in the stack
+            self.session = await self.exit_stack.enter_async_context(
+                self.open_mcp_session(self.server_url, auth_strategy)
+            )
+
+        except Exception as eg:
+            for exc in getattr(eg, "exceptions", [eg]):
+                event_info = (
+                    f"Failed to connect to MCP server `{self.server_name}`: {exc!s}"
+                )
+                if isinstance(exc, HTTPStatusError):
+                    status_code = exc.response.status_code
+                    structlogger.error(
+                        "mcp_server_connection.connect.http_status_error",
+                        event_info=event_info,
+                        server_name=self.server_name,
+                        server_url=self.server_url,
+                        status_code=status_code,
+                        response_text=exc.response.reason_phrase,
+                    )
+                    await self._cleanup()
+                    if status_code in [400, 401, 403]:
+                        raise AuthenticationError(eg) from eg
+                    else:
+                        raise ConnectionError(eg) from eg
+                else:
+                    structlogger.error(
+                        "mcp_server_connection.connect.other_exception",
+                        event_info=event_info,
+                        server_name=self.server_name,
+                        server_url=self.server_url,
+                        error=str(exc),
+                    )
+            await self._cleanup()
+            raise ConnectionError(eg) from eg
+
+        except asyncio.CancelledError as e:
+            event_info = f"Connection to MCP server `{self.server_name}` was cancelled."
+            structlogger.error(
+                "mcp_server_connection.connect.connection_cancelled",
+                event_info=event_info,
+                server_name=self.server_name,
+                server_url=self.server_url,
+            )
+            # Clean up on cancellation
+            await self._cleanup()
+            raise ConnectionError(e) from e
+
+    async def ensure_active_session(self) -> ClientSession:
+        """
+        Ensure an active session is available.
+
+        If no session exists or the current session is inactive,
+        a new connection will be established.
+
+        Returns:
+            Active ClientSession instance.
+        """
+        if self.session is None:
+            await self.connect()
+            structlogger.info(
+                "mcp_server_connection.ensure_active_session.no_session",
+                server_name=self.server_name,
+                server_url=self.server_url,
+                event_info=(
+                    "No session found, connecting to the server "
+                    f"`{self.server_name}` @ `{self.server_url}`"
+                ),
+            )
+        if self.session:
+            try:
+                # Add timeout to prevent hanging when MCP server is down
+                await asyncio.wait_for(
+                    self.session.send_ping(), timeout=self.PING_TIMEOUT_SECONDS
+                )
+            except asyncio.TimeoutError as e:
+                structlogger.error(
+                    "mcp_server_connection.ensure_active_session.ping_timeout",
+                    server_name=self.server_name,
+                    server_url=self.server_url,
+                    event_info=(
+                        "Ping timed out, Server not reachable - "
+                        f"`{self.server_name}` @ `{self.server_url}`"
+                    ),
+                )
+                raise e
+            except Exception as e:
+                structlogger.warning(
+                    "mcp_server_connection.ensure_active_session.ping_failed",
+                    error=str(e),
+                    server_name=self.server_name,
+                    server_url=self.server_url,
+                    event_info=(
+                        "Ping failed, trying to reconnect to the server "
+                        f"`{self.server_name}` @ `{self.server_url}`"
+                    ),
+                )
+                # Cleanup existing session
+                await self.close()
+                # Attempt to reconnect now
+                await self.connect()
+                structlogger.info(
+                    "mcp_server_connection.ensure_active_session.reconnected",
+                    server_name=self.server_name,
+                    server_url=self.server_url,
+                    event_info=(
+                        "Reconnected to the server "
+                        f"`{self.server_name}` @ `{self.server_url}`"
+                    ),
+                )
+        assert self.session is not None  # Ensures type for mypy
+        return self.session
+
+    async def close(self) -> None:
+        """Close the connection and clean up resources."""
+        await self._cleanup()
+
+    async def _cleanup(self) -> None:
+        """Internal cleanup method to safely close resources."""
+        if self.exit_stack:
+            try:
+                await self.exit_stack.aclose()
+            except Exception as e:
+                # Log cleanup errors but don't raise them
+                structlogger.warning(
+                    "mcp_server_connection.cleanup.failed",
+                    server_name=self.server_name,
+                    error=str(e),
+                )
+            finally:
+                self.exit_stack = None
+                self.session = None

rasa/shared/utils/mcp/utils.py

@@ -0,0 +1,20 @@
+"""MCP utilities."""
+
+
+def mcp_server_exists(mcp_server: str) -> bool:
+    """Check if an MCP server exists in the configured endpoints.
+
+    Args:
+        mcp_server: The name of the MCP server to check.
+
+    Returns:
+        True if the MCP server exists, False otherwise.
+    """
+    from rasa.core.config.configuration import Configuration
+
+    endpoints = Configuration.get_instance().endpoints
+    if (mcp_server_list := endpoints.mcp_servers) is None:
+        return False
+
+    mcp_server_names = [server.name for server in mcp_server_list]
+    return mcp_server in mcp_server_names

rasa/shared/utils/schemas/events.py

@@ -160,6 +160,43 @@ FLOW_CANCELLED = {
         "step_id": {"type": "string"},
     }
 }
+AGENT_STARTED = {
+    "properties": {
+        "event": {"const": "agent_started"},
+        "agent_id": {"type": "string"},
+        "flow_id": {"type": "string"},
+    }
+}
+AGENT_COMPLETED = {
+    "properties": {
+        "event": {"const": "agent_completed"},
+        "agent_id": {"type": "string"},
+        "flow_id": {"type": "string"},
+        "status": {"type": "string"},
+    }
+}
+AGENT_INTERRUPTED = {
+    "properties": {
+        "event": {"const": "agent_interrupted"},
+        "agent_id": {"type": "string"},
+        "flow_id": {"type": "string"},
+    }
+}
+AGENT_RESUMED = {
+    "properties": {
+        "event": {"const": "agent_resumed"},
+        "agent_id": {"type": "string"},
+        "flow_id": {"type": "string"},
+    }
+}
+AGENT_CANCELLED = {
+    "properties": {
+        "event": {"const": "agent_cancelled"},
+        "agent_id": {"type": "string"},
+        "flow_id": {"type": "string"},
+        "reason": {"type": "string"},
+    }
+}
 DIALOGUE_STACK_UPDATED = {
     "properties": {"event": {"const": "stack"}, "update": {"type": "string"}}
 }
@@ -204,6 +241,11 @@ EVENT_SCHEMA = {
         FLOW_RESUMED,
         FLOW_COMPLETED,
         FLOW_CANCELLED,
+        AGENT_STARTED,
+        AGENT_COMPLETED,
+        AGENT_INTERRUPTED,
+        AGENT_RESUMED,
+        AGENT_CANCELLED,
         DIALOGUE_STACK_UPDATED,
         ROUTING_SESSION_ENDED,
         SESSION_ENDED,

rasa/shared/utils/yaml.py

@@ -335,7 +335,9 @@ class YamlValidationException(YamlException, ValueError):
                     )
                     if found_lc:
                         return line_offset
-                    return this_line + line_offset
+                    if this_line is not None:
+                        return this_line + line_offset
+                    return line_offset
                 return line
             elif isinstance(current, list) and head.isdigit():
                 return (

rasa/studio/pull/pull.py

@@ -8,6 +8,7 @@ import structlog
 
 import rasa.cli.utils
 import rasa.shared.utils.cli
+from rasa.cli.validation.config_path_validation import get_validated_path
 from rasa.shared.constants import (
     DEFAULT_CONFIG_PATH,
     DEFAULT_DATA_PATH,
@@ -140,7 +141,7 @@ def _prepare_data_and_domain_paths(args: argparse.Namespace) -> Tuple[Path, Path
         A tuple containing the domain path and a data path.
     """
     # Prepare domain path.
-    domain_path = rasa.cli.utils.get_validated_path(
+    domain_path = get_validated_path(
         args.domain, "domain", DEFAULT_DOMAIN_PATHS, none_is_valid=True
     )
     domain_or_default_path = args.domain or DEFAULT_DOMAIN_PATH
@@ -152,7 +153,7 @@ def _prepare_data_and_domain_paths(args: argparse.Namespace) -> Tuple[Path, Path
     if isinstance(domain_path, str):
         domain_path = Path(domain_path)
 
-    data_path = rasa.cli.utils.get_validated_path(
+    data_path = get_validated_path(
         args.data, "data", DEFAULT_DATA_PATH, none_is_valid=True
     )
 

rasa/studio/train.py

@@ -4,13 +4,15 @@ import sys
 from pathlib import Path
 from typing import Any, List, Optional
 
-import rasa.cli.utils
-import rasa.shared.utils.cli
 from rasa.cli.train import (
     _model_for_finetuning,
     extract_core_additional_arguments,
     extract_nlu_additional_arguments,
 )
+from rasa.cli.validation.config_path_validation import (
+    get_validated_config,
+    get_validated_path,
+)
 from rasa.shared.constants import (
     CONFIG_MANDATORY_KEYS,
     DEFAULT_DATA_PATH,
@@ -41,10 +43,10 @@ def handle_train(args: argparse.Namespace) -> Optional[str]:
     else:
         handler.request_all_data()
 
-    domain = rasa.cli.utils.get_validated_path(
+    domain = get_validated_path(
         args.domain, "domain", DEFAULT_DOMAIN_PATH, none_is_valid=True
     )
-    config = rasa.cli.utils.get_validated_config(args.config, CONFIG_MANDATORY_KEYS)
+    config = get_validated_config(args.config, CONFIG_MANDATORY_KEYS)
     data_form_studio, data_original = import_data_from_studio(
         handler, domain, args.data
     )
@@ -58,9 +60,7 @@ def handle_train(args: argparse.Namespace) -> Optional[str]:
     )
 
     training_files = [
-        rasa.cli.utils.get_validated_path(
-            f, "data", DEFAULT_DATA_PATH, none_is_valid=True
-        )
+        get_validated_path(f, "data", DEFAULT_DATA_PATH, none_is_valid=True)
         for f in args.data
     ]
     training_files.extend(studio_training_files)
@@ -68,6 +68,7 @@ def handle_train(args: argparse.Namespace) -> Optional[str]:
     training_result = train_all(
         domain=str(domain_file),
         config=config,
+        endpoints=args.endpoints,
         training_files=args.data,
         output=args.out,
         dry_run=args.dry_run,

rasa/studio/upload.py

@@ -12,6 +12,7 @@ import rasa.cli.telemetry
 import rasa.cli.utils
 import rasa.shared.utils.cli
 import rasa.shared.utils.io
+from rasa.cli.validation.config_path_validation import get_validated_path
 from rasa.shared.constants import (
     CONFIG_LANGUAGE_KEY,
     CONFIG_LLM_KEY,
@@ -155,13 +156,9 @@ def handle_upload(args: argparse.Namespace) -> None:
 
     structlogger.info("rasa.studio.upload.loading_data", event_info="Loading data...")
 
-    args.domain = rasa.cli.utils.get_validated_path(
-        args.domain, "domain", DEFAULT_DOMAIN_PATHS
-    )
+    args.domain = get_validated_path(args.domain, "domain", DEFAULT_DOMAIN_PATHS)
 
-    args.config = rasa.cli.utils.get_validated_path(
-        args.config, "config", DEFAULT_CONFIG_PATH
-    )
+    args.config = get_validated_path(args.config, "config", DEFAULT_CONFIG_PATH)
 
     config = read_yaml_file(args.config, expand_env_vars=False)
     assistant_name = args.assistant_name or _get_assistant_name(config)

rasa/telemetry.py

@@ -31,7 +31,6 @@ from rasa.constants import (
     CONFIG_TELEMETRY_ENABLED,
     CONFIG_TELEMETRY_ID,
 )
-from rasa.engine.storage.local_model_storage import LocalModelStorage
 from rasa.privacy.privacy_config import AnonymizationType, PrivacyConfig
 from rasa.shared.constants import (
     ASSISTANT_ID_KEY,
@@ -50,6 +49,7 @@ from rasa.shared.constants import (
     UTTER_ASK_PREFIX,
 )
 from rasa.shared.core.flows import Flow
+from rasa.shared.core.flows.flows_list import FlowsList
 from rasa.shared.core.flows.steps import (
     CallFlowStep,
     CollectInformationFlowStep,
@@ -61,9 +61,9 @@ from rasa.utils import common as rasa_utils
 
 if typing.TYPE_CHECKING:
     from rasa.core.agent import Agent
-    from rasa.core.available_endpoints import AvailableEndpoints
     from rasa.core.brokers.broker import EventBroker
     from rasa.core.channels.channel import InputChannel
+    from rasa.core.config.available_endpoints import AvailableEndpoints
     from rasa.core.tracker_stores.tracker_store import TrackerStore
     from rasa.e2e_test.e2e_test_case import Fixture, Metadata, TestCase
     from rasa.shared.importers.importer import TrainingDataImporter
@@ -1056,7 +1056,7 @@ def track_model_training(
         "policies": config.get(CONFIG_POLICIES_KEY),
         "train_schema": config.get(CONFIG_TRAIN_SCHEMA),
         "predict_schema": config.get(CONFIG_PREDICT_SCHEMA),
-        "model_groups": rasa.core.utils.AvailableEndpoints.get_instance().model_groups,
+        "model_groups": rasa.core.config.configuration.Configuration.get_instance().endpoints.model_groups,  # noqa: E501
         "api_health_check_enabled": (
             os.getenv(
                 LLM_API_HEALTH_CHECK_ENV_VAR, LLM_API_HEALTH_CHECK_DEFAULT_VALUE
@@ -1083,6 +1083,7 @@ def track_model_training(
         "num_regexes": len(nlu_data.regex_features),
         "is_finetuning": is_finetuning,
         "recipe": config.get(CONFIG_RECIPE_KEY),
+        "agents": _collect_agent_configuration(flows),
     }
 
     flow_statistics = _collect_flow_statistics(flows.underlying_flows)
@@ -1125,6 +1126,67 @@ def track_model_training(
     )
 
 
+def _collect_agent_configuration(flows: FlowsList) -> Dict[str, Any]:
+    agent_data: Dict[str, Any] = {}
+
+    from rasa.core.available_agents import AvailableAgents
+    from rasa.core.config.configuration import Configuration
+
+    agents = AvailableAgents.get_instance().agents
+    mcp_servers = Configuration.get_instance().endpoints.mcp_servers
+
+    if not agents and not mcp_servers:
+        return agent_data
+
+    agent_data["usage"] = []
+
+    for flow in flows.underlying_flows:
+        for step in flow.steps:
+            if isinstance(step, CallFlowStep):
+                if flows.flow_by_id(step.call) is not None:
+                    continue
+
+                if step.is_calling_mcp_tool():
+                    agent_data["usage"].append(
+                        {
+                            "flow": flow.id,
+                            "mcp_tool": step.call,
+                            "mcp_server": step.mcp_server,
+                            "mapping": step.mapping,
+                        }
+                    )
+
+                if step.is_calling_agent():
+                    if step.exit_if:
+                        agent_data["usage"].append(
+                            {
+                                "flow": flow.id,
+                                "agent": step.call,
+                                "exit_if": step.exit_if,
+                            }
+                        )
+                    else:
+                        agent_data["usage"].append(
+                            {
+                                "flow": flow.id,
+                                "agent": step.call,
+                            }
+                        )
+
+    # dump mcp_servers and agents as json and exclude any values that are None
+    if mcp_servers:
+        agent_data["mcp_servers"] = [
+            mcp_server.model_dump(exclude_none=True) for mcp_server in mcp_servers
+        ]
+    if agents:
+        agent_data["agents"] = [
+            {agent_name: agent_info.model_dump(exclude_none=True)}
+            for agent_name, agent_info in agents.items()
+        ]
+
+    return agent_data
+
+
 def _collect_flow_statistics(flows: List[Flow]) -> Dict[str, Any]:
     """Collects some statistics about the flows, such as number of specific steps."""
     data = {
@@ -1430,7 +1492,7 @@ def track_server_start(
         number_of_workers: number of used Sanic workers
         is_api_enabled: whether the rasa API server is enabled
     """
-    from rasa.core.available_endpoints import AvailableEndpoints
+    from rasa.core.config.available_endpoints import AvailableEndpoints
 
     def project_fingerprint_and_assistant_id_from_model(
         _model_directory: Optional[Text],
@@ -1441,7 +1503,9 @@ def track_server_start(
 
         try:
             model_archive = model.get_local_model(_model_directory)
-            metadata = LocalModelStorage.metadata_from_archive(model_archive)
+            metadata = rasa.engine.storage.local_model_storage.LocalModelStorage.metadata_from_archive(  # noqa: E501
+                model_archive
+            )
 
             return metadata.project_fingerprint, metadata.assistant_id
         except Exception:

rasa/tracing/config.py

@@ -6,7 +6,6 @@ import os
 from typing import Any, Dict, Optional, Text
 
 import grpc
-from opentelemetry.exporter.jaeger.thrift import JaegerExporter
 from opentelemetry.exporter.otlp.proto.grpc.metric_exporter import OTLPMetricExporter
 from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
 from opentelemetry.metrics import set_meter_provider
@@ -16,6 +15,9 @@ from opentelemetry.sdk.resources import SERVICE_NAME, Resource
 from opentelemetry.sdk.trace import TracerProvider
 from opentelemetry.sdk.trace.export import BatchSpanProcessor
 
+from rasa.agents.protocol.a2a.a2a_agent import A2AAgent
+from rasa.agents.protocol.mcp.mcp_open_agent import MCPOpenAgent
+from rasa.agents.protocol.mcp.mcp_task_agent import MCPTaskAgent
 from rasa.core.actions.custom_action_executor import (
     CustomActionExecutor,
     RetryCustomActionExecutor,
@@ -93,6 +95,9 @@ def configure_tracing(tracer_provider: Optional[TracerProvider]) -> None:
         if custom_action_executor_class != RetryCustomActionExecutor:
             custom_action_executor_subclasses.append(custom_action_executor_class)
 
+    # All agent classes to instrument (protocol agent classes)
+    agent_classes = [MCPOpenAgent, MCPTaskAgent, A2AAgent]
+
     instrumentation.instrument(
         tracer_provider=tracer_provider,
         agent_class=Agent,
@@ -114,6 +119,7 @@ def configure_tracing(tracer_provider: Optional[TracerProvider]) -> None:
         multi_step_llm_command_generator_class=MultiStepLLMCommandGenerator,
         custom_action_executor_subclasses=custom_action_executor_subclasses,
         flow_retrieval_class=FlowRetrieval,
+        subagent_classes=agent_classes,
     )
 
 
@@ -172,19 +178,35 @@ class TracerConfigurer(abc.ABC):
 
 
 class JaegerTracerConfigurer(TracerConfigurer):
-    """The `TracerConfigurer` for a Jaeger backend."""
+    """The `TracerConfigurer` for a Jaeger backend.
+
+    This class maintains backward compatibility with the old Jaeger configuration format
+    while internally using OTLP to avoid protobuf compatibility issues.
+    """
 
     @classmethod
     def configure_from_endpoint_config(cls, cfg: EndpointConfig) -> TracerProvider:
-        """Configure tracing for Jaeger.
+        """Configure tracing for Jaeger using OTLP under the hood.
 
-        This will read the Jaeger-specific configuration from the `EndpointConfig` and
-        create a corresponding `TracerProvider` that exports to the given Jaeger
-        backend.
+        This maintains backward compatibility with the old Jaeger configuration format
+        while using OTLP internally to avoid protobuf compatibility issues.
 
         :param cfg: The configuration to be read for configuring tracing.
         :return: The configured `TracerProvider`.
         """
+        # Extract Jaeger-specific configuration
+        jaeger_config = cls._extract_config(cfg)
+
+        # Map Jaeger configuration to OTLP endpoint
+        otlp_endpoint = f"http://{jaeger_config['agent_host_name']}:{jaeger_config.get('agent_port', 4317)}"  # noqa: E501
+
+        # Create OTLP exporter with Jaeger-compatible configuration
+        otlp_exporter = OTLPSpanExporter(
+            endpoint=otlp_endpoint,
+            insecure=True,  # Jaeger typically runs without TLS in development
+            headers=cls._build_headers(jaeger_config),
+        )
+
         provider = TracerProvider(
             resource=Resource.create(
                 {
@@ -195,19 +217,17 @@ class JaegerTracerConfigurer(TracerConfigurer):
             )
         )
 
-        jaeger_exporter = JaegerExporter(
-            **cls._extract_config(cfg), udp_split_oversized_batches=True
-        )
         logger.info(
-            f"Registered {cfg.type} endpoint for tracing. Traces will be exported to"
-            f" {jaeger_exporter.agent_host_name}:{jaeger_exporter.agent_port}"
+            f"Registered {cfg.type} endpoint for tracing using OTLP. "
+            f"Traces will be exported to {otlp_endpoint}."
         )
-        provider.add_span_processor(BatchSpanProcessor(jaeger_exporter))
+        provider.add_span_processor(BatchSpanProcessor(otlp_exporter))
 
         return provider
 
     @classmethod
     def _extract_config(cls, cfg: EndpointConfig) -> Dict[str, Any]:
+        """Extract Jaeger configuration parameters."""
         return {
             "agent_host_name": (cfg.kwargs.get("host", "localhost")),
             "agent_port": (cfg.kwargs.get("port", 6831)),
@@ -215,6 +235,19 @@ class JaegerTracerConfigurer(TracerConfigurer):
             "password": cfg.kwargs.get("password"),
         }
 
+    @classmethod
+    def _build_headers(cls, jaeger_config: Dict[str, Any]) -> Optional[Dict[str, str]]:
+        """Build OTLP headers from Jaeger authentication config."""
+        headers = {}
+        if jaeger_config.get("username") and jaeger_config.get("password"):
+            import base64
+
+            credentials = base64.b64encode(
+                f"{jaeger_config['username']}:{jaeger_config['password']}".encode()
+            ).decode()
+            headers["Authorization"] = f"Basic {credentials}"
+        return headers if headers else None
+
 
 class OTLPCollectorConfigurer(TracerConfigurer):
     """The `TracerConfigurer` for an OTLP collector backend."""