rasa-pro 3.13.0.dev3__py3-none-any.whl → 3.13.0.dev7__py3-none-any.whl

rasa/core/channels/voice_stream/twilio_media_streams.py

@@ -1,7 +1,9 @@
+from __future__ import annotations
+
 import base64
 import json
 import uuid
-from typing import Any, Awaitable, Callable, Dict, Optional, Text, Tuple
+from typing import TYPE_CHECKING, Any, Awaitable, Callable, Dict, Optional, Text, Tuple
 
 import structlog
 from sanic import (  # type: ignore[attr-defined]
@@ -12,7 +14,11 @@ from sanic import (  # type: ignore[attr-defined]
     response,
 )
 
-from rasa.core.channels import UserMessage
+from rasa.core.channels import InputChannel, UserMessage
+from rasa.core.channels.channel import (
+    create_auth_requested_response_provider,
+    requires_basic_auth,
+)
 from rasa.core.channels.voice_ready.utils import CallParameters
 from rasa.core.channels.voice_stream.audio_bytes import RasaAudioBytes
 from rasa.core.channels.voice_stream.call_state import call_state
@@ -25,10 +31,24 @@ from rasa.core.channels.voice_stream.voice_channel import (
     VoiceInputChannel,
     VoiceOutputChannel,
 )
+from rasa.shared.exceptions import RasaException
+
+if TYPE_CHECKING:
+    from twilio.twiml.voice_response import VoiceResponse
 
 logger = structlog.get_logger(__name__)
 
 
+TWILIO_MEDIA_STREAMS_WEBHOOK_PATH = "webhooks/twilio_media_streams/webhook"
+TWILIO_MEDIA_STREAMS_WEBSOCKET_PATH = "webhooks/twilio_media_streams/websocket"
+
+
+CALL_SID_REQUEST_KEY = "CallSid"
+FROM_NUMBER_REQUEST_KEY = "From"
+TO_NUMBER_REQUEST_KEY = "To"
+DIRECTION_REQUEST_KEY = "Direction"
+
+
 def map_call_params(data: Dict[Text, Any]) -> CallParameters:
     """Map the twilio stream parameters to the CallParameters dataclass."""
     stream_sid = data["streamSid"]
@@ -77,6 +97,40 @@ class TwilioMediaStreamsOutputChannel(VoiceOutputChannel):
 
 
 class TwilioMediaStreamsInputChannel(VoiceInputChannel):
+    def __init__(
+        self,
+        server_url: str,
+        asr_config: Dict,
+        tts_config: Dict,
+        monitor_silence: bool = False,
+        username: Optional[Text] = None,
+        password: Optional[Text] = None,
+    ):
+        super().__init__(server_url, asr_config, tts_config, monitor_silence)
+        self.username = username
+        self.password = password
+
+    @classmethod
+    def from_credentials(cls, credentials: Optional[Dict[str, Any]]) -> InputChannel:
+        credentials = credentials or {}
+
+        username = credentials.get("username")
+        password = credentials.get("password")
+        if (username is None) != (password is None):
+            raise RasaException(
+                "In TwilioMediaStreams channel, either both username and password "
+                "or neither should be provided. "
+            )
+
+        return cls(
+            credentials["server_url"],
+            credentials["asr"],
+            credentials["tts"],
+            credentials.get("monitor_silence", False),
+            username=username,
+            password=password,
+        )
+
     @classmethod
     def name(cls) -> str:
         return "twilio_media_streams"
@@ -130,16 +184,6 @@ class TwilioMediaStreamsInputChannel(VoiceInputChannel):
             self.tts_cache,
         )
 
-    def websocket_stream_url(self) -> str:
-        """Returns the websocket stream URL."""
-        # depending on the config value, the url might contain http as a
-        # protocol or not - we'll make sure both work
-        if self.server_url.startswith("http"):
-            base_url = self.server_url.replace("http", "ws")
-        else:
-            base_url = f"wss://{self.server_url}"
-        return f"{base_url}/webhooks/twilio_media_streams/websocket"
-
     def blueprint(
         self, on_new_message: Callable[[UserMessage], Awaitable[Any]]
     ) -> Blueprint:
@@ -151,22 +195,20 @@ class TwilioMediaStreamsInputChannel(VoiceInputChannel):
             return response.json({"status": "ok"})
 
         @blueprint.route("/webhook", methods=["POST"])
+        @requires_basic_auth(
+            username=self.username,
+            password=self.password,
+            auth_request_provider=create_auth_requested_response_provider(
+                realm=TWILIO_MEDIA_STREAMS_WEBHOOK_PATH
+            ),
+        )
         async def receive(request: Request) -> HTTPResponse:
-            from twilio.twiml.voice_response import Connect, VoiceResponse
-
-            voice_response = VoiceResponse()
-            start = Connect()
-            stream = start.stream(url=self.websocket_stream_url())
-            # pass information about the call to the webhook - so we can
-            # store it in the input channel
-            stream.parameter(name="call_id", value=request.form.get("CallSid", None))
-            stream.parameter(name="user_phone", value=request.form.get("From", None))
-            stream.parameter(name="bot_phone", value=request.form.get("To", None))
-            stream.parameter(
-                name="direction", value=request.form.get("Direction", None)
-            )
+            voice_response = self._build_twilio_response(request)
 
-            voice_response.append(start)
+            logger.debug(
+                "twilio_media_streams.webhook.twilio_response",
+                twilio_response=str(voice_response),
+            )
 
             return response.text(str(voice_response), content_type="text/xml")
 
@@ -175,3 +217,36 @@ class TwilioMediaStreamsInputChannel(VoiceInputChannel):
             await self.run_audio_streaming(on_new_message, ws)
 
         return blueprint
+
+    def _websocket_stream_url(self) -> str:
+        """Returns the websocket stream URL."""
+        # depending on the config value, the url might contain http as a
+        # protocol or not - we'll make sure both work
+        if self.server_url.startswith("http"):
+            base_url = self.server_url.replace("http", "ws")
+        else:
+            base_url = f"wss://{self.server_url}"
+        return f"{base_url}/{TWILIO_MEDIA_STREAMS_WEBSOCKET_PATH}"
+
+    def _build_twilio_response(self, request: Request) -> VoiceResponse:
+        from twilio.twiml.voice_response import Connect, VoiceResponse
+
+        voice_response = VoiceResponse()
+        start = Connect()
+        stream = start.stream(url=self._websocket_stream_url())
+        # pass information about the call to the webhook - so we can
+        # store it in the input channel
+        stream.parameter(
+            name="call_id", value=request.form.get(CALL_SID_REQUEST_KEY, None)
+        )
+        stream.parameter(
+            name="user_phone", value=request.form.get(FROM_NUMBER_REQUEST_KEY, None)
+        )
+        stream.parameter(
+            name="bot_phone", value=request.form.get(TO_NUMBER_REQUEST_KEY, None)
+        )
+        stream.parameter(
+            name="direction", value=request.form.get(DIRECTION_REQUEST_KEY, None)
+        )
+        voice_response.append(start)
+        return voice_response

rasa/core/channels/voice_stream/voice_channel.py

@@ -42,6 +42,11 @@ from rasa.utils.io import remove_emojis
 
 logger = structlog.get_logger(__name__)
 
+# define constants for the voice channel
+USER_CONVERSATION_SESSION_END = "/session_end"
+USER_CONVERSATION_SESSION_START = "/session_start"
+USER_CONVERSATION_SILENCE_TIMEOUT = "/silence_timeout"
+
 
 @dataclass
 class VoiceChannelAction:
@@ -189,6 +194,7 @@ class VoiceOutputChannel(OutputChannel):
         collected_audio_bytes = RasaAudioBytes(b"")
         seconds_marker = -1
         last_sent_offset = 0
+        logger.debug("voice_channel.sending_audio", text=text)
 
         # Send start marker before first chunk
         try:
@@ -334,7 +340,7 @@ class VoiceInputChannel(InputChannel):
     ) -> None:
         output_channel = self.create_output_channel(channel_websocket, tts_engine)
         message = UserMessage(
-            "/session_start",
+            USER_CONVERSATION_SESSION_START,
             output_channel,
             call_parameters.stream_id,
             input_channel=self.name(),
@@ -393,6 +399,9 @@ class VoiceInputChannel(InputChannel):
                     await asr_engine.send_audio_chunks(channel_action.audio_bytes)
                 elif isinstance(channel_action, EndConversationAction):
                     # end stream event came from the other side
+                    await self.handle_disconnect(
+                        channel_websocket, on_new_message, tts_engine, call_parameters
+                    )
                     break
 
         async def receive_asr_events() -> None:
@@ -462,10 +471,27 @@ class VoiceInputChannel(InputChannel):
         elif isinstance(e, UserSilence):
             output_channel = self.create_output_channel(voice_websocket, tts_engine)
             message = UserMessage(
-                "/silence_timeout",
+                USER_CONVERSATION_SILENCE_TIMEOUT,
                 output_channel,
                 call_parameters.stream_id,
                 input_channel=self.name(),
                 metadata=asdict(call_parameters),
             )
             await on_new_message(message)
+
+    async def handle_disconnect(
+        self,
+        channel_websocket: Websocket,
+        on_new_message: Callable[[UserMessage], Awaitable[Any]],
+        tts_engine: TTSEngine,
+        call_parameters: CallParameters,
+    ) -> None:
+        """Handle disconnection from the channel."""
+        output_channel = self.create_output_channel(channel_websocket, tts_engine)
+        message = UserMessage(
+            text=USER_CONVERSATION_SESSION_END,
+            output_channel=output_channel,
+            sender_id=call_parameters.stream_id,
+            input_channel=self.name(),
+        )
+        await on_new_message(message)

rasa/core/concurrent_lock_store.py

@@ -1,9 +1,10 @@
 import json
-import logging
 import time
 from collections import deque
 from typing import Deque, Optional, Text
 
+import structlog
+
 from rasa.core.lock import Ticket, TicketLock
 from rasa.core.lock_store import (
     DEFAULT_SOCKET_TIMEOUT_IN_SECONDS,
@@ -19,7 +20,7 @@ DEFAULT_PORT = 6379
 
 DEFAULT_HOSTNAME = "localhost"
 
-logger = logging.getLogger(__name__)
+structlogger = structlog.getLogger(__name__)
 
 LAST_ISSUED_TICKET_NUMBER_SUFFIX = "last_issued_ticket_number"
 
@@ -105,7 +106,10 @@ class ConcurrentRedisLockStore(LockStore):
 
         self.key_prefix = DEFAULT_CONCURRENT_REDIS_LOCK_STORE_KEY_PREFIX
         if key_prefix:
-            logger.debug(f"Setting non-default redis key prefix: '{key_prefix}'.")
+            structlogger.debug(
+                "concurrent_redis_lock_store._set_key_prefix.non_default_key_prefix",
+                event_info=f"Setting non-default redis key prefix: '{key_prefix}'.",
+            )
             self._set_key_prefix(key_prefix)
 
         super().__init__()
@@ -116,9 +120,13 @@ class ConcurrentRedisLockStore(LockStore):
                 key_prefix + ":" + DEFAULT_CONCURRENT_REDIS_LOCK_STORE_KEY_PREFIX
             )
         else:
-            logger.warning(
-                f"Omitting provided non-alphanumeric redis key prefix: '{key_prefix}'. "
-                f"Using default '{self.key_prefix}' instead."
+            structlogger.warning(
+                "concurrent_redis_lock_store._set_key_prefix.default_instead_of_invalid_key_prefix",
+                event_info=(
+                    f"Omitting provided non-alphanumeric "
+                    f"redis key prefix: '{key_prefix}'. "
+                    f"Using default '{self.key_prefix}' instead."
+                ),
             )
 
     def issue_ticket(
@@ -129,7 +137,10 @@ class ConcurrentRedisLockStore(LockStore):
         It's configured with `lock_lifetime` and associated with `conversation_id`.
         Creates a new lock if none is found.
         """
-        logger.debug(f"Issuing ticket for conversation '{conversation_id}'.")
+        structlogger.debug(
+            "concurrent_redis_lock_store.issue_ticket",
+            event_info=f"Issuing ticket for conversation '{conversation_id}'.",
+        )
         try:
             lock = self.get_or_create_lock(conversation_id)
             lock.remove_expired_tickets()
@@ -164,9 +175,12 @@ class ConcurrentRedisLockStore(LockStore):
         redis_keys = self.red.keys(pattern)
 
         if not redis_keys:
-            logger.debug(
-                f"The lock store does not contain any key-value "
-                f"items for conversation '{conversation_id}'."
+            structlogger.debug(
+                "concurrent_redis_lock_store.delete_lock_key_not_found",
+                event_info=(
+                    f"The lock store does not contain any key-value "
+                    f"items for conversation '{conversation_id}'."
+                ),
             )
             return None
 

rasa/core/evaluation/marker_tracker_loader.py

@@ -2,7 +2,7 @@ import random
 from typing import Any, AsyncIterator, Iterable, List, Optional, Text
 
 import rasa.shared.utils.io
-from rasa.core.tracker_store import TrackerStore
+from rasa.core.tracker_stores.tracker_store import TrackerStore
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.exceptions import RasaException
 

rasa/core/exporter.py

@@ -10,7 +10,7 @@ import rasa.shared.utils.io
 from rasa.core.brokers.broker import EventBroker
 from rasa.core.brokers.pika import PikaEventBroker
 from rasa.core.constants import RASA_EXPORT_PROCESS_ID_HEADER_NAME
-from rasa.core.tracker_store import TrackerStore
+from rasa.core.tracker_stores.tracker_store import TrackerStore
 from rasa.exceptions import (
     NoConversationsInTrackerStoreError,
     NoEventsToMigrateError,

rasa/core/lock_store.py

@@ -2,18 +2,27 @@ from __future__ import annotations
 
 import asyncio
 import json
-import logging
 import os
 from contextlib import asynccontextmanager
-from typing import AsyncGenerator, Dict, Optional, Text, Union
+from typing import Any, AsyncGenerator, Dict, Literal, Optional, Text, Union
+
+import structlog
+from pydantic import (
+    AnyUrl,
+    BaseModel,
+    Field,
+    NonNegativeInt,
+    model_validator,
+)
 
 import rasa.shared.utils.common
 from rasa.core.constants import DEFAULT_LOCK_LIFETIME
 from rasa.core.lock import TicketLock
 from rasa.shared.exceptions import ConnectionException, RasaException
+from rasa.shared.utils.io import raise_deprecation_warning
 from rasa.utils.endpoints import EndpointConfig
 
-logger = logging.getLogger(__name__)
+structlogger = structlog.getLogger(__name__)
 
 
 def _get_lock_lifetime() -> int:
@@ -76,7 +85,10 @@ class LockStore:
 
         Creates a new lock if none is found.
         """
-        logger.debug(f"Issuing ticket for conversation '{conversation_id}'.")
+        structlogger.debug(
+            "lock_store.issue_ticket",
+            event_info=f"Issuing ticket for conversation '{conversation_id}'.",
+        )
         try:
             lock = self.get_or_create_lock(conversation_id)
             ticket = lock.issue_ticket(lock_lifetime)
@@ -109,7 +121,10 @@ class LockStore:
     async def _acquire_lock(
         self, conversation_id: Text, ticket: int, wait_time_in_seconds: float
     ) -> TicketLock:
-        logger.debug(f"Acquiring lock for conversation '{conversation_id}'.")
+        structlogger.debug(
+            "lock_store._acquiring_lock_for_conversation",
+            event_info=f"Acquiring lock for conversation '{conversation_id}'.",
+        )
         while True:
             # fetch lock in every iteration because lock might no longer exist
             lock = self.get_lock(conversation_id)
@@ -120,16 +135,22 @@ class LockStore:
 
             # acquire lock if it isn't locked
             if not lock.is_locked(ticket):
-                logger.debug(f"Acquired lock for conversation '{conversation_id}'.")
+                structlogger.debug(
+                    "lock_store._acquired_lock_for_conversation",
+                    event_info=f"Acquired lock for conversation '{conversation_id}'.",
+                )
                 return lock
 
             items_before_this = ticket - (lock.now_serving or 0)
 
-            logger.debug(
-                f"Failed to acquire lock for conversation ID '{conversation_id}' "
-                f"because {items_before_this} other item(s) for this "
-                f"conversation ID have to be finished processing first. "
-                f"Retrying in {wait_time_in_seconds} seconds ..."
+            structlogger.debug(
+                "lock_store._retrying_lock_acquisition",
+                event_info=(
+                    f"Failed to acquire lock for conversation ID '{conversation_id}' "
+                    f"because {items_before_this} other item(s) for this "
+                    f"conversation ID have to be finished processing first. "
+                    f"Retrying in {wait_time_in_seconds} seconds ..."
+                ),
             )
 
             # sleep and update lock
@@ -186,9 +207,99 @@ class LockStore:
     @staticmethod
     def _log_deletion(conversation_id: Text, deletion_successful: bool) -> None:
         if deletion_successful:
-            logger.debug(f"Deleted lock for conversation '{conversation_id}'.")
+            structlogger.debug(
+                "lock_store._deleted_lock_for_conversation",
+                event_info=f"Deleted lock for conversation '{conversation_id}'.",
+            )
         else:
-            logger.debug(f"Could not delete lock for conversation '{conversation_id}'.")
+            structlogger.debug(
+                "lock_store._failed_to_delete_lock_for_conversation",
+                event_info=(
+                    f"Could not delete lock for conversation '{conversation_id}'."
+                ),
+            )
+
+
+class RedisLockStoreConfig(BaseModel):
+    host: Union[AnyUrl, Literal["localhost"]] = Field(
+        default="localhost", description="The host of the redis server."
+    )
+    port: NonNegativeInt = Field(
+        default=6379, ge=0, le=65535, description="The port of the redis server."
+    )
+    db: NonNegativeInt = Field(
+        default=0,
+        ge=0,
+        description="The name of the database within Redis "
+        "which should be used by Rasa",
+    )
+    username: Optional[str] = Field(
+        default=None,
+        description="The username which should be used for "
+        "authentication with the Redis database.",
+    )
+    password: Optional[str] = Field(
+        default=None,
+        description="The username which should be used for "
+        "authentication with the Redis database.",
+    )
+    use_ssl: bool = Field(
+        default=False,
+        serialization_alias="ssl",
+        description="True if SSL should be used for the connection to Redis.",
+    )
+    ssl_certfile: Optional[str] = Field(
+        default=None,
+        description="Path to the SSL certificate file.",
+    )
+    ssl_keyfile: Optional[str] = Field(
+        default=None, description="Path to the SSL private key file."
+    )
+    ssl_ca_certs: Optional[str] = Field(
+        default=None, description="Path to the SSL CA certificate file."
+    )
+    key_prefix: Optional[str] = Field(
+        default=None,
+        description="Prefix to prepend to all keys "
+        "used by the lock store. Must be alphanumeric.",
+    )
+    socket_timeout: float = Field(
+        default=DEFAULT_SOCKET_TIMEOUT_IN_SECONDS,
+        description="Timeout in seconds after which an exception "
+        "will be raised in case Redis doesn't respond "
+        "within `socket_timeout` seconds.",
+    )
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_url_and_host_properties(cls, data: Any) -> Any:
+        if isinstance(data, dict):
+            if bool(data.get("url", None)) and bool(data.get("host", None)):
+                raise RasaException(
+                    "You cannot specify both 'url' and 'host' in the Redis lock store "
+                    "configuration. Please use only one of them."
+                )
+
+            if data.get("url", None):
+                raise_deprecation_warning(
+                    "The 'url' property in the redis lock store "
+                    "configuration is deprecated. Please use 'host' instead."
+                )
+                data["host"] = data.pop("url")
+        return data
+
+    @model_validator(mode="after")
+    def verify_username_password(self) -> RedisLockStoreConfig:
+        if bool(self.username) ^ bool(self.password):
+            raise ValueError(
+                f"Expected username and password. "
+                f"Found: username: {'<has value>' if self.username else '<N/A>'}, "
+                f"password: {'<has value>' if self.password else '<N/A>'}"
+            )
+        return self
+
+    def to_strict_redis(self) -> Dict[str, Any]:
+        return self.model_dump(by_alias=True, exclude={"key_prefix"})
 
 
 class RedisLockStore(LockStore):
@@ -196,57 +307,28 @@ class RedisLockStore(LockStore):
 
     def __init__(
         self,
-        host: Text = "localhost",
-        port: int = 6379,
-        db: int = 1,
-        username: Optional[Text] = None,
-        password: Optional[Text] = None,
-        use_ssl: bool = False,
-        ssl_certfile: Optional[Text] = None,
-        ssl_keyfile: Optional[Text] = None,
-        ssl_ca_certs: Optional[Text] = None,
-        key_prefix: Optional[Text] = None,
-        socket_timeout: float = DEFAULT_SOCKET_TIMEOUT_IN_SECONDS,
+        config: RedisLockStoreConfig = RedisLockStoreConfig(),
     ) -> None:
         """Create a lock store which uses Redis for persistence.
 
         Args:
-            host: The host of the redis server.
-            port: The port of the redis server.
-            db: The name of the database within Redis which should be used by Rasa
-                Open Source.
-            username: The username which should be used for authentication with the
-                Redis database.
-            password: The password which should be used for authentication with the
-                Redis database.
-            use_ssl: `True` if SSL should be used for the connection to Redis.
-            ssl_certfile: Path to the SSL certificate file.
-            ssl_keyfile: Path to the SSL private key file.
-            ssl_ca_certs: Path to the SSL CA certificate file.
-            key_prefix: prefix to prepend to all keys used by the lock store. Must be
-                alphanumeric.
-            socket_timeout: Timeout in seconds after which an exception will be raised
-                in case Redis doesn't respond within `socket_timeout` seconds.
+            config: Redis lock store configuration.
         """
         import redis
 
-        self.red = redis.StrictRedis(
-            host=host,
-            port=int(port),
-            db=int(db),
-            username=username,
-            password=password,
-            ssl=use_ssl,
-            ssl_certfile=ssl_certfile,
-            ssl_keyfile=ssl_keyfile,
-            ssl_ca_certs=ssl_ca_certs,
-            socket_timeout=socket_timeout,
-        )
+        self.config = config
+        self.red = redis.StrictRedis(**self.config.to_strict_redis())
 
         self.key_prefix = DEFAULT_REDIS_LOCK_STORE_KEY_PREFIX
-        if key_prefix:
-            logger.debug(f"Setting non-default redis key prefix: '{key_prefix}'.")
-            self._set_key_prefix(key_prefix)
+        if self.config.key_prefix:
+            structlogger.debug(
+                "redis_lock_store._set_key_prefix.non_default_key_prefix",
+                event_info=(
+                    f"Setting non-default "
+                    f"redis key prefix: '{self.config.key_prefix}'.",
+                ),
+            )
+            self._set_key_prefix(self.config.key_prefix)
 
         super().__init__()
 
@@ -254,9 +336,13 @@ class RedisLockStore(LockStore):
         if isinstance(key_prefix, str) and key_prefix.isalnum():
             self.key_prefix = key_prefix + ":" + DEFAULT_REDIS_LOCK_STORE_KEY_PREFIX
         else:
-            logger.warning(
-                f"Omitting provided non-alphanumeric redis key prefix: '{key_prefix}'. "
-                f"Using default '{self.key_prefix}' instead."
+            structlogger.warning(
+                "redis_lock_store._set_key_prefix.default_instead_of_invalid_key_prefix",
+                event_info=(
+                    f"Omitting provided non-alphanumeric "
+                    f"redis key prefix: '{key_prefix}'. "
+                    f"Using default '{self.key_prefix}' instead."
+                ),
             )
 
     def get_lock(self, conversation_id: Text) -> Optional[TicketLock]:
@@ -313,7 +399,9 @@ def _create_from_endpoint_config(
 
         lock_store: LockStore = InMemoryLockStore()
     elif endpoint_config.type == "redis":
-        lock_store = RedisLockStore(host=endpoint_config.url, **endpoint_config.kwargs)
+        config = RedisLockStoreConfig.model_validate(endpoint_config.to_dict())
+
+        lock_store = RedisLockStore(config)
     elif endpoint_config.type == "concurrent_redis":
         from rasa.core.concurrent_lock_store import ConcurrentRedisLockStore
 
@@ -321,7 +409,10 @@ def _create_from_endpoint_config(
     else:
         lock_store = _load_from_module_name_in_endpoint_config(endpoint_config)
 
-    logger.debug(f"Connected to lock store '{lock_store.__class__.__name__}'.")
+    structlogger.debug(
+        "lock_store._create_from_endpoint_config.lock_store_connected",
+        event_info=f"Connected to lock store '{lock_store.__class__.__name__}'.",
+    )
 
     return lock_store
 

rasa/core/nlg/contextual_response_rephraser.py

@@ -8,12 +8,14 @@ from rasa.core.nlg.response import TemplatedNaturalLanguageGenerator
 from rasa.core.nlg.summarize import summarize_conversation
 from rasa.shared.constants import (
     LLM_CONFIG_KEY,
+    MAX_COMPLETION_TOKENS_CONFIG_KEY,
     MODEL_CONFIG_KEY,
     MODEL_GROUP_ID_CONFIG_KEY,
     MODEL_NAME_CONFIG_KEY,
     OPENAI_PROVIDER,
     PROMPT_CONFIG_KEY,
     PROVIDER_CONFIG_KEY,
+    TEMPERATURE_CONFIG_KEY,
     TIMEOUT_CONFIG_KEY,
 )
 from rasa.shared.core.domain import KEY_RESPONSES_TEXT, Domain
@@ -57,8 +59,8 @@ DEFAULT_MAX_HISTORICAL_TURNS = 5
 DEFAULT_LLM_CONFIG = {
     PROVIDER_CONFIG_KEY: OPENAI_PROVIDER,
     MODEL_CONFIG_KEY: DEFAULT_OPENAI_GENERATE_MODEL_NAME,
-    "temperature": 0.3,
-    "max_tokens": DEFAULT_OPENAI_MAX_GENERATED_TOKENS,
+    TEMPERATURE_CONFIG_KEY: 0.3,
+    MAX_COMPLETION_TOKENS_CONFIG_KEY: DEFAULT_OPENAI_MAX_GENERATED_TOKENS,
     TIMEOUT_CONFIG_KEY: 5,
 }
 

rasa/core/nlg/summarize.py

@@ -3,7 +3,7 @@ from typing import Optional
 import structlog
 from jinja2 import Template
 
-from rasa.core.tracker_store import DialogueStateTracker
+from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.providers.llm.llm_client import LLMClient
 from rasa.shared.utils.llm import (
     tracker_as_readable_transcript,