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

rasa/core/channels/studio_chat.py

@@ -93,12 +93,12 @@ class StudioTrackerUpdatePlugin:
         """Remove tasks that have already completed."""
         self.tasks = [task for task in self.tasks if not task.done()]
 
-    @hookimpl  # type: ignore[misc]
+    @hookimpl
     def after_new_user_message(self, tracker: "DialogueStateTracker") -> None:
         """Triggers a tracker update notification after a new user message."""
         self.handle_tracker_update(tracker)
 
-    @hookimpl  # type: ignore[misc]
+    @hookimpl
     def after_action_executed(self, tracker: "DialogueStateTracker") -> None:
         """Triggers a tracker update notification after an action is executed."""
         self.handle_tracker_update(tracker)
@@ -118,7 +118,7 @@ class StudioTrackerUpdatePlugin:
         self.tasks.append(task)
         self._cleanup_tasks()
 
-    @hookimpl  # type: ignore[misc]
+    @hookimpl
     def after_server_stop(self) -> None:
         """Cancels all remaining tasks when the server stops."""
         self._cancel_tasks()
@@ -438,7 +438,7 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
         if sid in self.active_connections:
             del self.active_connections[sid]
 
-    @hookimpl  # type: ignore[misc]
+    @hookimpl
     def after_server_stop(self) -> None:
         """Cleanup background tasks and active connections when the server stops."""
         structlogger.info("studio_chat.after_server_stop.cleanup")
@@ -533,7 +533,7 @@ class StudioVoiceOutputChannel(VoiceOutputChannel):
 
     def create_marker_message(self, recipient_id: str) -> Tuple[str, str]:
         message_id = uuid.uuid4().hex
-        marker_data = {"marker": message_id}
+        marker_data: Dict[str, Any] = {"marker": message_id}
 
         # Include comprehensive latency information if available
         latency_data = {
@@ -548,7 +548,7 @@ class StudioVoiceOutputChannel(VoiceOutputChannel):
 
         # Add latency data to marker if any metrics are available
         if latency_data:
-            marker_data["latency"] = latency_data  # type: ignore[assignment]
+            marker_data["latency"] = latency_data
 
         return json.dumps(marker_data), message_id
 

rasa/core/channels/telegram.py

@@ -4,6 +4,9 @@ import typing
 from copy import deepcopy
 from typing import Any, Awaitable, Callable, Dict, List, Optional, Text
 
+# Import aiogram at module level to raise error if not installed
+from aiogram import Bot
+from aiogram.types import Message, Update
 from sanic import Blueprint, response
 from sanic.request import Request
 from sanic.response import HTTPResponse
@@ -28,15 +31,7 @@ class TelegramOutput(OutputChannel):
         return "telegram"
 
     def __init__(self, access_token: Optional[Text]) -> None:
-        try:
-            from aiogram import Bot
-
-            self.bot = Bot(access_token)
-        except ImportError:
-            raise ImportError(
-                "To use the Telegram channel, please install the aiogram package "
-                "with 'pip install aiogram'"
-            )
+        self.bot = Bot(access_token)
 
     async def send_text_message(
         self, recipient_id: Text, text: Text, **kwargs: Any

rasa/core/channels/voice_stream/genesys.py

@@ -275,7 +275,7 @@ class GenesysInputChannel(VoiceInputChannel):
 
     def handle_ping(self, ws: Websocket, message: dict) -> None:
         """Handle ping message from Genesys."""
-        response = {
+        response: Dict[str, Any] = {
             "version": "2",
             "type": "pong",
             "seq": self._get_next_sequence(),

rasa/core/channels/voice_stream/tts/deepgram.py

@@ -0,0 +1,140 @@
+import os
+from dataclasses import dataclass
+from typing import AsyncIterator, Dict, Optional
+from urllib.parse import urlencode
+
+import aiohttp
+import orjson
+import structlog
+from aiohttp import ClientConnectorError, ClientTimeout, WSMsgType
+
+from rasa.core.channels.voice_stream.audio_bytes import RasaAudioBytes
+from rasa.core.channels.voice_stream.tts.tts_engine import (
+    TTSEngine,
+    TTSEngineConfig,
+    TTSError,
+)
+from rasa.shared.constants import DEEPGRAM_API_KEY_ENV_VAR
+from rasa.shared.exceptions import ConnectionException
+
+structlogger = structlog.get_logger()
+
+
+@dataclass
+class DeepgramTTSConfig(TTSEngineConfig):
+    model_id: Optional[str] = None
+    endpoint: Optional[str] = None
+
+
+class DeepgramTTS(TTSEngine[DeepgramTTSConfig]):
+    session: Optional[aiohttp.ClientSession] = None
+    required_env_vars = (DEEPGRAM_API_KEY_ENV_VAR,)
+    ws: Optional[aiohttp.ClientWebSocketResponse] = None
+
+    def __init__(self, config: Optional[DeepgramTTSConfig] = None):
+        super().__init__(config)
+        timeout = ClientTimeout(total=self.config.timeout)
+        # Have to create this class-shared session lazily at run time otherwise
+        # the async event loop doesn't work
+        if self.__class__.session is None or self.__class__.session.closed:
+            self.__class__.session = aiohttp.ClientSession(timeout=timeout)
+
+    @staticmethod
+    def get_request_headers(config: DeepgramTTSConfig) -> dict[str, str]:
+        deepgram_api_key = os.environ[DEEPGRAM_API_KEY_ENV_VAR]
+        return {
+            "Authorization": f"Token {deepgram_api_key!s}",
+        }
+
+    async def close_connection(self) -> None:
+        """Close WebSocket connection if it exists."""
+        if self.ws and not self.ws.closed:
+            await self.ws.close()
+            self.ws = None
+
+    def get_websocket_url(self, config: DeepgramTTSConfig) -> str:
+        """Build WebSocket URL with query parameters."""
+        base_url = config.endpoint
+        query_params = {
+            "model": config.model_id,
+            "encoding": "mulaw",
+            "sample_rate": "8000",
+        }
+        return f"{base_url}?{urlencode(query_params)}"
+
+    async def synthesize(
+        self, text: str, config: Optional[DeepgramTTSConfig] = None
+    ) -> AsyncIterator[RasaAudioBytes]:
+        """Generate speech from text using Deepgram WebSocket TTS API."""
+        config = self.config.merge(config)
+        headers = self.get_request_headers(config)
+        ws_url = self.get_websocket_url(config)
+
+        if self.session is None:
+            raise ConnectionException("Client session is not initialized")
+
+        try:
+            self.ws = await self.session.ws_connect(
+                ws_url,
+                headers=headers,
+                timeout=float(self.config.timeout),
+            )
+            await self.ws.send_json(
+                {
+                    "type": "Speak",
+                    "text": text,
+                }
+            )
+            await self.ws.send_json({"type": "Flush"})
+            async for msg in self.ws:
+                if msg.type == WSMsgType.BINARY:
+                    # Binary data is the raw audio
+                    yield self.engine_bytes_to_rasa_audio_bytes(msg.data)
+                elif msg.type == WSMsgType.TEXT:
+                    # Handle control messages if needed
+                    data = orjson.loads(msg.data)
+                    if data.get("type") == "Close":
+                        break
+                    elif data.get("type") == "Flushed":
+                        break  # End of stream
+                elif msg.type == WSMsgType.CLOSED:
+                    break
+                elif msg.type == WSMsgType.ERROR:
+                    structlogger.error(
+                        "deepgram.synthesize.ws.error", error=str(msg.data)
+                    )
+                    raise TTSError(f"WebSocket error: {msg.data}")
+
+            # Send a close message
+            if self.ws and not self.ws.closed:
+                await self.ws.send_json({"type": "Close"})
+
+        except ClientConnectorError as e:
+            structlogger.error("deepgram.synthesize.ws.connection_error", error=str(e))
+            raise TTSError(f"Failed to connect to Deepgram TTS service: {e}")
+        except TimeoutError as e:
+            structlogger.error("deepgram.synthesize.ws.timeout", error=str(e))
+            raise TTSError(f"Connection to Deepgram TTS service timed out: {e}")
+        except Exception as e:
+            structlogger.error("deepgram.synthesize.ws.error", error=str(e))
+            raise TTSError(f"Error during TTS synthesis: {e}")
+        finally:
+            # Ensure connection is closed
+            await self.close_connection()
+
+    def engine_bytes_to_rasa_audio_bytes(self, chunk: bytes) -> RasaAudioBytes:
+        """Convert the generated tts audio bytes into rasa audio bytes."""
+        # WebSocket returns raw audio bytes directly
+        return RasaAudioBytes(chunk)
+
+    @staticmethod
+    def get_default_config() -> DeepgramTTSConfig:
+        return DeepgramTTSConfig(
+            model_id="aura-2-andromeda-en",
+            endpoint="wss://api.deepgram.com/v1/speak",
+            timeout=30,
+        )
+
+    @classmethod
+    def from_config_dict(cls, config: Dict) -> "DeepgramTTS":
+        return cls(DeepgramTTSConfig.from_dict(config))

rasa/core/channels/voice_stream/twilio_media_streams.py

@@ -14,6 +14,9 @@ from sanic import (  # type: ignore[attr-defined]
     response,
 )
 
+# Import twilio at module level to raise error if not installed
+from twilio.twiml.voice_response import VoiceResponse
+
 from rasa.core.channels import UserMessage
 from rasa.core.channels.channel import (
     create_auth_requested_response_provider,
@@ -145,7 +148,8 @@ class TwilioMediaStreamsInputChannel(VoiceInputChannel):
         """Get the sender ID for the channel.
 
         Twilio Media Streams uses the Stream ID as Sender ID because
-        it is required in OutputChannel.send_text_message to send messages."""
+        it is required in OutputChannel.send_text_message to send messages.
+        """
         return call_parameters.stream_id  # type: ignore[return-value]
 
     def channel_bytes_to_rasa_audio_bytes(self, input_bytes: bytes) -> RasaAudioBytes:

rasa/core/channels/voice_stream/voice_channel.py

@@ -38,6 +38,7 @@ from rasa.core.channels.voice_stream.call_state import (
 )
 from rasa.core.channels.voice_stream.tts.azure import AzureTTS
 from rasa.core.channels.voice_stream.tts.cartesia import CartesiaTTS
+from rasa.core.channels.voice_stream.tts.deepgram import DeepgramTTS
 from rasa.core.channels.voice_stream.tts.tts_cache import TTSCache
 from rasa.core.channels.voice_stream.tts.tts_engine import TTSEngine, TTSError
 from rasa.core.channels.voice_stream.util import (
@@ -133,6 +134,8 @@ def tts_engine_from_config(tts_config: Dict) -> TTSEngine:
         return AzureTTS.from_config_dict(tts_config)
     elif name.lower() == "cartesia":
         return CartesiaTTS.from_config_dict(tts_config)
+    elif name.lower() == "deepgram":
+        return DeepgramTTS.from_config_dict(tts_config)
     else:
         mark_as_beta_feature("Custom TTS Engine")
         try:

rasa/core/{available_endpoints.py → config/available_endpoints.py}

@@ -1,9 +1,12 @@
 from __future__ import annotations
 
 import dataclasses
+from pathlib import Path
 from typing import Any, Dict, List, Optional, Union
 
-from rasa.shared.constants import DEFAULT_ENDPOINTS_PATH
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+from rasa.core.constants import MCP_SERVERS_KEY
 from rasa.shared.core.constants import (
     GLOBAL_SILENCE_TIMEOUT_DEFAULT_VALUE,
     GLOBAL_SILENCE_TIMEOUT_KEY,
@@ -57,14 +60,46 @@ class InteractionHandlingConfig:
         )
 
 
+class MCPServerConfig(BaseModel):
+    model_config = ConfigDict(extra="allow")
+    name: str = Field(..., description="The name of the MCP server.")
+    url: str = Field(..., description="The URL of the MCP server.")
+    type: str = Field(..., description="The type of the MCP server.")
+    additional_params: Optional[Dict[str, Any]] = Field(
+        default_factory=dict, description="Additional parameters for the MCP server."
+    )
+
+    @model_validator(mode="after")
+    def validate_type(self) -> MCPServerConfig:
+        # validate that type is "http"
+        if self.type not in ["http", "https"]:
+            raise ValueError(f"Invalid MCP server type: {self.type}")
+        # validate that name and url are not empty
+        if not self.name or not self.url:
+            raise ValueError("Name and URL cannot be empty")
+        return self
+
+    @model_validator(mode="before")
+    def collect_additional_params(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        base_fields = {"name", "url", "type"}
+        extras = {k: v for k, v in values.items() if k not in base_fields}
+        if extras:
+            values["additional_params"] = extras
+            # remove them from top level so Pydantic doesn’t complain
+            for k in extras:
+                values.pop(k)
+        return values
+
+
 class AvailableEndpoints:
     """Collection of configured endpoints."""
 
     _instance = None
 
     @classmethod
-    def read_endpoints(cls, endpoint_file: str) -> AvailableEndpoints:
+    def read_endpoints(cls, endpoint_file: Path) -> AvailableEndpoints:
         """Read the different endpoints from a yaml file."""
+
         nlg = read_endpoint_config(endpoint_file, endpoint_type="nlg")
         nlu = read_endpoint_config(endpoint_file, endpoint_type="nlu")
         action = read_endpoint_config(endpoint_file, endpoint_type="action_endpoint")
@@ -75,6 +110,14 @@ class AvailableEndpoints:
         lock_store = read_endpoint_config(endpoint_file, endpoint_type="lock_store")
         event_broker = read_endpoint_config(endpoint_file, endpoint_type="event_broker")
         vector_store = read_endpoint_config(endpoint_file, endpoint_type="vector_store")
+        raw_mcp_servers = read_property_config_from_endpoints_file(
+            endpoint_file, property_name=MCP_SERVERS_KEY
+        )
+        mcp_servers = (
+            [MCPServerConfig(**server) for server in raw_mcp_servers]
+            if raw_mcp_servers
+            else None
+        )
         model_groups = read_property_config_from_endpoints_file(
             endpoint_file, property_name="model_groups"
         )
@@ -89,6 +132,7 @@ class AvailableEndpoints:
         )
 
         return cls(
+            endpoint_file,
             nlg,
             nlu,
             action,
@@ -97,6 +141,7 @@ class AvailableEndpoints:
             lock_store,
             event_broker,
             vector_store,
+            mcp_servers,
             model_groups,
             privacy,
             interaction_handling,
@@ -104,6 +149,7 @@ class AvailableEndpoints:
 
     def __init__(
         self,
+        config_file_path: Optional[Path] = None,
         nlg: Optional[EndpointConfig] = None,
         nlu: Optional[EndpointConfig] = None,
         action: Optional[EndpointConfig] = None,
@@ -112,6 +158,7 @@ class AvailableEndpoints:
         lock_store: Optional[EndpointConfig] = None,
         event_broker: Optional[EndpointConfig] = None,
         vector_store: Optional[EndpointConfig] = None,
+        mcp_servers: Optional[List[MCPServerConfig]] = None,
         model_groups: Optional[List[Dict[str, Any]]] = None,
         privacy: Optional[Dict[str, Any]] = None,
         interaction_handling: InteractionHandlingConfig = InteractionHandlingConfig(
@@ -119,6 +166,7 @@ class AvailableEndpoints:
         ),
     ) -> None:
         """Create an `AvailableEndpoints` object."""
+        self.config_file_path = config_file_path
         self.model = model
         self.action = action
         self.nlu = nlu
@@ -127,20 +175,7 @@ class AvailableEndpoints:
         self.lock_store = lock_store
         self.event_broker = event_broker
         self.vector_store = vector_store
+        self.mcp_servers = mcp_servers
         self.model_groups = model_groups
         self.privacy = privacy
         self.interaction_handling = interaction_handling
-
-    @classmethod
-    def get_instance(
-        cls, endpoint_file: Optional[str] = DEFAULT_ENDPOINTS_PATH
-    ) -> AvailableEndpoints:
-        """Get the singleton instance of AvailableEndpoints."""
-        # Ensure that the instance is initialized only once.
-        if cls._instance is None:
-            cls._instance = cls.read_endpoints(endpoint_file)
-        return cls._instance
-
-    @classmethod
-    def reset_instance(cls) -> None:
-        cls._instance = None

rasa/core/config/configuration.py

@@ -0,0 +1,260 @@
+from __future__ import annotations
+
+import dataclasses
+from pathlib import Path
+from typing import Literal, Optional
+
+import structlog
+
+from rasa.cli.validation.config_path_validation import get_validated_path
+from rasa.core.config.available_endpoints import AvailableEndpoints
+from rasa.core.config.credentials import CredentialsConfig
+from rasa.core.config.message_procesing_config import MessageProcessingConfig
+from rasa.shared.constants import (
+    DEFAULT_CONFIG_PATH,
+    DEFAULT_CREDENTIALS_PATH,
+    DEFAULT_ENDPOINTS_PATH,
+)
+
+logger = structlog.get_logger(__name__)
+
+
+@dataclasses.dataclass
+class ValidatedConfigPaths:
+    credentials_path: Optional[Path] = None
+    endpoints_path: Optional[Path] = None
+    message_processing_config_path: Optional[Path] = None
+
+
+@dataclasses.dataclass
+class ConfigPath:
+    target: Optional[Path] = None
+    type: Literal["credentials", "endpoints", "config"] = "endpoints"
+    alternative_targets: list[Path] = dataclasses.field(default_factory=list)
+    default_path: str = ""
+
+    @staticmethod
+    def _validate(
+        config_path: ConfigPath, can_be_missing: bool = True
+    ) -> Optional[Path]:
+        validated_path = get_validated_path(
+            config_path.target,
+            config_path.type,
+            config_path.alternative_targets,
+            can_be_missing,
+        )
+
+        if validated_path is None and can_be_missing:
+            logger.debug(
+                f"No {config_path.type} configuration file found. "
+                f"Proceeding without {config_path.type} configuration."
+            )
+
+        if isinstance(validated_path, str):
+            validated_path = Path(validated_path)
+
+        return validated_path
+
+
+@dataclasses.dataclass
+class CredentialsConfigPath(ConfigPath):
+    def __init__(self, target: Optional[Path] = None):
+        super().__init__(
+            target=target,
+            type="credentials",
+            alternative_targets=[Path(DEFAULT_CREDENTIALS_PATH)],
+            default_path=DEFAULT_CREDENTIALS_PATH,
+        )
+
+    @staticmethod
+    def validate(
+        target_config_path: Optional[Path] = None, can_be_missing: bool = True
+    ) -> Optional[Path]:
+        config_path = CredentialsConfigPath(target=target_config_path)
+        return ConfigPath._validate(config_path, can_be_missing)
+
+    @staticmethod
+    def default_file_path() -> Path:
+        return Path(DEFAULT_CREDENTIALS_PATH)
+
+    @staticmethod
+    def at_path(
+        root_path: Path,
+    ) -> Path:
+        return root_path / CredentialsConfigPath.default_file_path()
+
+
+@dataclasses.dataclass
+class EndpointsConfigPath(ConfigPath):
+    def __init__(self, target: Optional[Path] = None):
+        super().__init__(
+            target=target,
+            type="endpoints",
+            alternative_targets=[Path(DEFAULT_ENDPOINTS_PATH)],
+            default_path=DEFAULT_ENDPOINTS_PATH,
+        )
+
+    @staticmethod
+    def validate(
+        target_config_path: Optional[Path] = None, can_be_missing: bool = True
+    ) -> Optional[Path]:
+        config_path = EndpointsConfigPath(target=target_config_path)
+        return ConfigPath._validate(config_path, can_be_missing)
+
+    @staticmethod
+    def default_file_path() -> Path:
+        return Path(DEFAULT_ENDPOINTS_PATH)
+
+    @staticmethod
+    def at_path(
+        root_path: Path,
+    ) -> Path:
+        return root_path / EndpointsConfigPath.default_file_path()
+
+
+@dataclasses.dataclass
+class MessageProcessingConfigPath(ConfigPath):
+    def __init__(self, target: Optional[Path] = None):
+        super().__init__(
+            target=target,
+            type="config",
+            alternative_targets=[Path(DEFAULT_CONFIG_PATH)],
+            default_path=DEFAULT_CONFIG_PATH,
+        )
+
+    @staticmethod
+    def validate(
+        target_config_path: Optional[Path] = None, can_be_missing: bool = True
+    ) -> Optional[Path]:
+        config_path = MessageProcessingConfigPath(target=target_config_path)
+        return ConfigPath._validate(config_path, can_be_missing)
+
+    @staticmethod
+    def default_file_path() -> Path:
+        return Path(DEFAULT_CONFIG_PATH)
+
+    @staticmethod
+    def at_path(
+        root_path: Path,
+    ) -> Path:
+        return root_path / MessageProcessingConfigPath.default_file_path()
+
+
+class Configuration:
+    _instance: Optional[Configuration] = None
+
+    def __init__(
+        self,
+        endpoints: AvailableEndpoints,
+        credentials: Optional[CredentialsConfig] = None,
+        message_processing_config: Optional[MessageProcessingConfig] = None,
+    ):
+        self.credentials = credentials
+        self.endpoints = endpoints
+        self.message_processing_config = message_processing_config
+
+    @classmethod
+    def initialise_empty(cls) -> Configuration:
+        if cls._instance is None:
+            cls._instance = Configuration(
+                credentials=None,
+                endpoints=AvailableEndpoints(),
+                message_processing_config=None,
+            )
+        return cls._instance
+
+    @classmethod
+    def initialise_endpoints(cls, endpoints_path: Path) -> Configuration:
+        logger.debug(
+            "configuration.initialise_endpoints.start", endpoints_path=endpoints_path
+        )
+
+        validated_endpoints_path = EndpointsConfigPath.validate(endpoints_path)
+        endpoints = (
+            AvailableEndpoints.read_endpoints(validated_endpoints_path)
+            if validated_endpoints_path
+            else AvailableEndpoints()
+        )
+        if cls._instance is None:
+            cls._instance = Configuration(
+                endpoints=endpoints, credentials=None, message_processing_config=None
+            )
+        else:
+            cls._instance.endpoints = endpoints
+        return cls._instance
+
+    @classmethod
+    def initialise_empty_endpoints(cls) -> Configuration:
+        logger.debug("configuration.initialise_empty_endpoints.start")
+        if cls._instance is None:
+            cls._instance = Configuration(
+                endpoints=AvailableEndpoints(),
+                credentials=None,
+                message_processing_config=None,
+            )
+        else:
+            cls._instance.endpoints = AvailableEndpoints()
+        return cls._instance
+
+    @classmethod
+    def initialise_message_processing(
+        cls, message_processing_config_path: Path
+    ) -> Configuration:
+        logger.debug(
+            "configuration.initialise_message_processing.start",
+            message_processing_config_path=message_processing_config_path,
+        )
+        validated_message_processing_path = MessageProcessingConfigPath.validate(
+            message_processing_config_path
+        )
+        message_processing_config = (
+            MessageProcessingConfig.load_from_file(validated_message_processing_path)
+            if validated_message_processing_path
+            else None
+        )
+        if cls._instance is None:
+            cls._instance = Configuration(
+                message_processing_config=message_processing_config,
+                credentials=None,
+                endpoints=AvailableEndpoints(),
+            )
+        else:
+            cls._instance.message_processing_config = message_processing_config
+        return cls._instance
+
+    @classmethod
+    def initialise_credentials(cls, credentials_path: Path) -> Configuration:
+        logger.debug(
+            "configuration.initialise_credentials.start",
+            credentials_path=credentials_path,
+        )
+
+        validated_credentials_path = CredentialsConfigPath.validate(credentials_path)
+
+        credentials = (
+            CredentialsConfig.load_from_file(validated_credentials_path)
+            if validated_credentials_path
+            else None
+        )
+        if cls._instance is None:
+            cls._instance = Configuration(
+                credentials=credentials,
+                endpoints=AvailableEndpoints(),
+                message_processing_config=None,
+            )
+        else:
+            cls._instance.credentials = credentials
+        return cls._instance
+
+    @classmethod
+    def get_instance(cls) -> Configuration:
+        if cls._instance is None:
+            raise Exception(
+                "Configuration not initialized. "
+                "Call appropriate 'initialise' methods to "
+                "load the config when Rasa Pro starts: "
+                "initialise_endpoints(), "
+                "initialise_credentials(), "
+                "initialise_message_processing()"
+            )
+        return cls._instance

rasa/core/config/credentials.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict
+
+from rasa.shared.utils.yaml import read_config_file
+
+
+class CredentialsConfig:
+    def __init__(
+        self, channels: Dict[str, Dict[str, Any]], config_file_path: Path
+    ) -> None:
+        self.channels = channels
+        self.config_file_path = config_file_path
+
+    @classmethod
+    def load_from_file(cls, file_path: Path) -> CredentialsConfig:
+        credentials_dict = read_config_file(file_path)
+        return cls(credentials_dict, file_path)