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

rasa/builder/jobs.py

@@ -1,9 +1,17 @@
-from typing import Any, Optional
+from typing import Any, Dict, Optional
 
 import structlog
 from sanic import Sanic
 
 from rasa.builder import config
+from rasa.builder.copilot.models import (
+    CopilotContext,
+    FileContent,
+    InternalCopilotRequestChatMessage,
+    LogContent,
+    ResponseCategory,
+    TrainingErrorLog,
+)
 from rasa.builder.exceptions import (
     LLMGenerationError,
     ProjectGenerationError,
@@ -11,6 +19,7 @@ from rasa.builder.exceptions import (
     ValidationError,
 )
 from rasa.builder.job_manager import JobInfo, job_manager
+from rasa.builder.llm_service import llm_service
 from rasa.builder.models import (
     JobStatus,
     JobStatusEvent,
@@ -28,9 +37,14 @@ structlogger = structlog.get_logger()
 
 
 async def push_job_status_event(
-    job: JobInfo, status: JobStatus, message: Optional[str] = None
+    job: JobInfo,
+    status: JobStatus,
+    message: Optional[str] = None,
+    payload: Optional[Dict[str, Any]] = None,
 ) -> None:
-    event = JobStatusEvent.from_status(status=status.value, message=message)
+    event = JobStatusEvent.from_status(
+        status=status.value, message=message, payload=payload
+    )
     job.status = status.value
     await job.put(event)
 
@@ -210,7 +224,7 @@ async def run_template_to_bot_job(
 async def run_replace_all_files_job(
     app: "Sanic",
     job: JobInfo,
-    bot_files: dict,
+    bot_files: Dict[str, Any],
 ) -> None:
     """Run the replace-all-files job in the background.
 
@@ -228,7 +242,7 @@ async def run_replace_all_files_job(
     try:
         project_generator.replace_all_bot_files(bot_files)
 
-        # 1. Validating
+        # Validating
         await push_job_status_event(job, JobStatus.validating)
         training_input = project_generator.get_training_input()
         validation_error = await validate_project(training_input.importer)
@@ -236,12 +250,13 @@ async def run_replace_all_files_job(
             raise ValidationError(validation_error)
         await push_job_status_event(job, JobStatus.validation_success)
 
-        # 2. Training
+        # Training
         await push_job_status_event(job, JobStatus.training)
         agent = await train_and_load_agent(training_input)
         update_agent(agent, app)
         await push_job_status_event(job, JobStatus.train_success)
 
+        # Send final done event
         await push_job_status_event(job, JobStatus.done)
         job_manager.mark_done(job)
 
@@ -257,26 +272,181 @@ async def run_replace_all_files_job(
             included_log_levels=log_levels,
         )
         error_message = exc.get_error_message_with_logs(log_levels=log_levels)
-        await push_job_status_event(
-            job, JobStatus.validation_error, message=error_message
+        # Push error event and start copilot analysis job
+        await push_error_and_start_copilot_analysis(
+            app,
+            job,
+            JobStatus.validation_error,
+            error_message,
+            bot_files,
         )
+
+        # After error mark job as done
         job_manager.mark_done(job, error=error_message)
 
     except TrainingError as exc:
+        error_message = str(exc)
         structlogger.debug(
             "replace_all_files_job.train_error",
             job_id=job.id,
-            error=str(exc),
+            error=error_message,
         )
-        await push_job_status_event(job, JobStatus.train_error, message=str(exc))
-        job_manager.mark_done(job, error=str(exc))
+        # Push error event and start copilot analysis job
+        await push_error_and_start_copilot_analysis(
+            app,
+            job,
+            JobStatus.train_error,
+            error_message,
+            bot_files,
+        )
+
+        # After error mark job as done
+        job_manager.mark_done(job, error=error_message)
 
     except Exception as exc:
         # Capture full traceback for anything truly unexpected
+        error_message = str(exc)
         structlogger.exception(
             "replace_all_files_job.unexpected_error",
             job_id=job.id,
+            error=error_message,
+        )
+
+        # Push error event and start copilot analysis job
+        await push_error_and_start_copilot_analysis(
+            app,
+            job,
+            JobStatus.error,
+            error_message,
+            bot_files,
+        )
+
+        # After error mark job as done
+        job_manager.mark_done(job, error=str(exc))
+
+
+async def push_error_and_start_copilot_analysis(
+    app: "Sanic",
+    original_job: JobInfo,
+    original_job_status: JobStatus,
+    error_message: str,
+    bot_files: Dict[str, Any],
+) -> None:
+    """Start a copilot analysis job and notify the client.
+
+    Creates a copilot analysis job and sends the new job ID to the client. The new
+    job runs in the background.
+
+    Args:
+        app: The Sanic application instance
+        original_job: The original job that failed
+        original_job_status: The status of the job that failed
+        error_message: The error message to analyze
+        bot_files: The bot files to include in analysis
+    """
+    # Create a copilot analysis job. Send the new job ID to the client and
+    # run the Copilot Analysis job in the background.
+    message = "Failed to train the assistant. Starting copilot analysis."
+
+    copilot_job = job_manager.create_job()
+    # Push the error status event for the original job
+    await push_job_status_event(
+        original_job,
+        original_job_status,
+        message=message,
+        payload={"copilot_job_id": copilot_job.id},
+    )
+    # Run the copilot analysis job in the background
+    app.add_task(
+        run_copilot_training_error_analysis_job(
+            app, copilot_job, error_message, bot_files
+        )
+    )
+    structlogger.debug(
+        f"update_files_job.{original_job_status.value}.copilot_analysis_start",
+        event_info=message,
+        job_id=original_job.id,
+        error=error_message,
+        copilot_job_id=copilot_job.id,
+    )
+
+
+async def run_copilot_training_error_analysis_job(
+    app: "Sanic",
+    job: JobInfo,
+    training_error_message: str,
+    bot_files: Dict[str, Any],
+) -> None:
+    """Run copilot training error analysis job."""
+    await push_job_status_event(job, JobStatus.received)
+
+    try:
+        # Create message content blocks with log content and available files
+        log_content_block = LogContent(
+            type="log", content=training_error_message, context="training_error"
+        )
+        file_content_blocks = [
+            FileContent(type="file", file_path=file_path, file_content=file_content)
+            for file_path, file_content in bot_files.items()
+        ]
+        context = CopilotContext(
+            tracker_context=None,  # No conversation context needed
+            copilot_chat_history=[
+                InternalCopilotRequestChatMessage(
+                    role="internal_copilot_request",
+                    content=[log_content_block, *file_content_blocks],
+                    response_category=ResponseCategory.TRAINING_ERROR_LOG_ANALYSIS,
+                )
+            ],
+        )
+
+        # Generate copilot response
+        copilot_client = llm_service.instantiate_copilot()
+        (
+            original_stream,
+            generation_context,
+        ) = await copilot_client.generate_response(context)
+
+        copilot_response_handler = llm_service.instantiate_handler(
+            config.COPILOT_HANDLER_ROLLING_BUFFER_SIZE
+        )
+        intercepted_stream = copilot_response_handler.handle_response(original_stream)
+
+        # Stream the copilot response as job events
+        async for token in intercepted_stream:
+            # Send each token as a job event using the same format as /copilot endpoint
+            await push_job_status_event(
+                job, JobStatus.copilot_analyzing, payload=token.sse_data
+            )
+
+        # Send references (if any) as part of copilot_analyzing stream
+        if generation_context.relevant_documents:
+            reference_section = copilot_response_handler.extract_references(
+                generation_context.relevant_documents
+            )
+            await push_job_status_event(
+                job, JobStatus.copilot_analyzing, payload=reference_section.sse_data
+            )
+
+        # Send original error log as part of copilot_analyzing stream
+        training_error_log = TrainingErrorLog(logs=[log_content_block])
+        await push_job_status_event(
+            job, JobStatus.copilot_analyzing, payload=training_error_log.sse_data
+        )
+
+        # Send success status
+        await push_job_status_event(job, JobStatus.copilot_analysis_success)
+
+        await push_job_status_event(job, JobStatus.done)
+        job_manager.mark_done(job)
+
+    except Exception as exc:
+        structlogger.exception(
+            "copilot_training_error_analysis_job.error",
+            job_id=job.id,
             error=str(exc),
         )
-        await push_job_status_event(job, JobStatus.error, message=str(exc))
+        await push_job_status_event(
+            job, JobStatus.copilot_analysis_error, message=str(exc)
+        )
         job_manager.mark_done(job, error=str(exc))

rasa/builder/models.py

@@ -136,12 +136,14 @@ class JobStatusEvent(ServerSentEvent):
         cls,
         status: str,
         message: Optional[str] = None,
+        payload: Optional[Dict[str, Any]] = None,
     ) -> "JobStatusEvent":
         """Factory for job-status events.
 
         Args:
             status: The job status (e.g. "training", "train_success").
             message: Optional error message for error events.
+            payload: Optional additional payload data to include in the event.
 
         Returns:
             A JobStatusEvent instance with the appropriate event type and data.
@@ -150,11 +152,13 @@ class JobStatusEvent(ServerSentEvent):
             ServerSentEventType.error if message else ServerSentEventType.progress
         )
 
-        payload: Dict[str, Any] = {"status": status}
+        event_payload: Dict[str, Any] = {"status": status}
         if message:
-            payload["message"] = message
+            event_payload["message"] = message
+        if payload:
+            event_payload.update(payload)
 
-        return cls(event=event_type.value, data=payload)
+        return cls(event=event_type.value, data=event_payload)
 
 
 class ValidationResult(BaseModel):
@@ -193,6 +197,11 @@ class JobStatus(str, Enum):
     validation_success = "validation_success"
     validation_error = "validation_error"
 
+    copilot_analysis_start = "copilot_analysis_start"
+    copilot_analyzing = "copilot_analyzing"
+    copilot_analysis_success = "copilot_analysis_success"
+    copilot_analysis_error = "copilot_analysis_error"
+
 
 class JobCreateResponse(BaseModel):
     job_id: str = Field(...)

rasa/builder/service.py

@@ -532,7 +532,19 @@ async def get_bot_files(request: Request) -> HTTPResponse:
     "**Error Events (can occur at any time):**\n"
     "- `validation_error` - Bot configuration files are invalid\n"
     "- `train_error` - Files updated but training failed\n"
+    "- `copilot_analysis_start` - Copilot analysis started (includes `copilot_job_id` "
+    "in payload)\n"
     "- `error` - Unexpected error occurred\n\n"
+    "**Copilot Analysis Events:**\n"
+    "When training or validation fails, a separate copilot analysis job is "
+    "automatically started. The `copilot_analysis_start` event includes a "
+    "`copilot_job_id` in the payload.\nConnect to `/job-events/<copilot_job_id>` to "
+    "receive the following events:\n"
+    "- `copilot_analyzing` - Copilot is analyzing errors and providing suggestions. "
+    "Uses the same SSE event payload format as the `/copilot` endpoint with `content`, "
+    "`response_category`, and `completeness` fields.\n"
+    "- `copilot_analysis_success` - Copilot analysis completed with references.\n"
+    "- `copilot_analysis_error` - Copilot analysis failed\n\n"
     "**Usage:**\n"
     "1. Send POST request with Content-Type: application/json\n"
     "2. The response will be a JSON object `{job_id: ...}`\n"
@@ -1042,7 +1054,8 @@ async def copilot(request: Request) -> None:
             # Offload telemetry logging to a background task
             request.app.add_task(
                 asyncio.to_thread(
-                    telemetry.log_user_turn, req.last_message.get_text_content()
+                    telemetry.log_user_turn,
+                    req.last_message.get_flattened_text_content(),
                 )
             )
 
@@ -1159,7 +1172,7 @@ async def copilot(request: Request) -> None:
                 system_message=generation_context.system_message,
                 chat_history=generation_context.chat_history,
                 last_user_message=(
-                    req.last_message.get_text_content()
+                    req.last_message.get_flattened_text_content()
                     if (req.last_message and req.last_message.role == ROLE_USER)
                     else None
                 ),

rasa/core/brokers/kafka.py

@@ -12,6 +12,7 @@ import structlog
 
 import rasa.shared.utils.common
 from rasa.core.brokers.broker import EventBroker
+from rasa.core.constants import KAFKA_SERVICE_NAME
 from rasa.core.exceptions import KafkaProducerInitializationError
 from rasa.core.iam_credentials_providers.credentials_provider_protocol import (
     IAMCredentialsProviderInput,
@@ -99,7 +100,10 @@ class KafkaEventBroker(EventBroker):
         self.queue_size = kwargs.get("queue_size")
         self.ssl_check_hostname = "https" if ssl_check_hostname else None
         self.iam_credentials_provider = create_iam_credentials_provider(
-            IAMCredentialsProviderInput(service_name=SupportedServiceType.EVENT_BROKER)
+            IAMCredentialsProviderInput(
+                service_type=SupportedServiceType.EVENT_BROKER,
+                service_name=KAFKA_SERVICE_NAME,
+            )
         )
 
         # PII management attributes

rasa/core/concurrent_lock_store.py

@@ -6,6 +6,9 @@ from typing import Deque, Optional, Text
 import structlog
 from pydantic import ValidationError
 
+from rasa.core.iam_credentials_providers.credentials_provider_protocol import (
+    SupportedServiceType,
+)
 from rasa.core.lock import Ticket, TicketLock
 from rasa.core.lock_store import (
     DEFAULT_SOCKET_TIMEOUT_IN_SECONDS,
@@ -108,6 +111,7 @@ class ConcurrentRedisLockStore(LockStore):
             redis_config = RedisConfig(
                 host=host,
                 port=port,
+                service_type=SupportedServiceType.LOCK_STORE,
                 db=db,
                 username=username,
                 password=password,
@@ -150,32 +154,45 @@ class ConcurrentRedisLockStore(LockStore):
                 ),
             )
 
-    def _get_keys_by_pattern(self, pattern: Text) -> list:
-        """Get keys by pattern, using SCAN for cluster mode and KEYS for others."""
-        if self.deployment_mode == DeploymentMode.CLUSTER.value:
-            # In cluster mode, use SCAN to get keys more reliably
-            keys = []
-            cursor = 0
-
-            while True:
-                try:
-                    cursor, batch_keys = self.red.scan(cursor, match=pattern, count=100)
-                    keys.extend(batch_keys)
+    def _scan_cluster_keys(self, pattern: Text) -> list:
+        """Scan keys in cluster mode with proper cursor handling."""
+        keys = []
+        cursor = 0
+
+        while True:
+            try:
+                cursor, batch_keys = self.red.scan(cursor, match=pattern, count=100)
+                keys.extend(batch_keys)
+
+                if isinstance(cursor, dict):
+                    # cursor is a dict mapping each node to its scan position. e.g
+                    # {'127.0.0.1:7000': 0, '127.0.0.1:7001': 5, '127.0.0.1:7002': 0}
+                    # A cursor value of 0 means that node has finished scanning
+                    # When all nodes show 0, the entire cluster scan is complete
+                    if all(v == 0 for v in cursor.values()):
+                        break
+                else:
+                    # if scan is complete
                     if cursor == 0:
                         break
-                except Exception as e:
-                    structlogger.warning(
-                        "concurrent_redis_lock_store._get_keys_by_pattern.scan_interrupted",
-                        event_info=f"SCAN interrupted in cluster mode: {e}. "
-                        f"Returning {len(keys)} keys found so far.",
-                    )
-                    break
-        else:
-            # Standard and sentinel modes use KEYS
-            keys = self.red.keys(pattern)
+
+            except Exception as e:
+                structlogger.warning(
+                    "concurrent_redis_lock_store._get_keys_by_pattern.scan_interrupted",
+                    event_info=f"SCAN interrupted in cluster mode: {e}. "
+                    f"Returning {len(keys)} keys found so far.",
+                )
+                break
 
         return keys
 
+    def _get_keys_by_pattern(self, pattern: Text) -> list:
+        """Get keys by pattern, using SCAN for cluster mode and KEYS for others."""
+        if self.deployment_mode == DeploymentMode.CLUSTER.value:
+            return self._scan_cluster_keys(pattern)
+        else:
+            return self.red.keys(pattern)
+
     def issue_ticket(
         self, conversation_id: Text, lock_lifetime: float = LOCK_LIFETIME
     ) -> int:

rasa/core/constants.py

@@ -123,3 +123,9 @@ SQL_TRACKER_STORE_SSL_ROOT_CERTIFICATE_ENV_VAR_NAME = (
     "SQL_TRACKER_STORE_SSL_ROOT_CERTIFICATE"
 )
 AWS_ELASTICACHE_CLUSTER_NAME_ENV_VAR_NAME = "AWS_ELASTICACHE_CLUSTER_NAME"
+RDS_SQL_DB_AWS_IAM_ENABLED_ENV_VAR_NAME = "RDS_SQL_DB_AWS_IAM_ENABLED"
+ELASTICACHE_REDIS_AWS_IAM_ENABLED_ENV_VAR_NAME = "ELASTICACHE_REDIS_AWS_IAM_ENABLED"
+KAFKA_MSK_AWS_IAM_ENABLED_ENV_VAR_NAME = "KAFKA_MSK_AWS_IAM_ENABLED"
+SQL_SERVICE_NAME = "sql"
+REDIS_SERVICE_NAME = "redis"
+KAFKA_SERVICE_NAME = "kafka"

rasa/core/iam_credentials_providers/aws_iam_credentials_providers.py

@@ -1,7 +1,7 @@
 import os
 import threading
 import time
-from typing import Optional, Tuple
+from typing import Dict, Optional, Tuple
 from urllib.parse import ParseResult, urlencode, urlunparse
 
 import boto3
@@ -14,6 +14,14 @@ from botocore.session import get_session
 from botocore.signers import RequestSigner
 from cachetools import TTLCache, cached
 
+from rasa.core.constants import (
+    ELASTICACHE_REDIS_AWS_IAM_ENABLED_ENV_VAR_NAME,
+    KAFKA_MSK_AWS_IAM_ENABLED_ENV_VAR_NAME,
+    KAFKA_SERVICE_NAME,
+    RDS_SQL_DB_AWS_IAM_ENABLED_ENV_VAR_NAME,
+    REDIS_SERVICE_NAME,
+    SQL_SERVICE_NAME,
+)
 from rasa.core.iam_credentials_providers.credentials_provider_protocol import (
     IAMCredentialsProvider,
     IAMCredentialsProviderInput,
@@ -24,6 +32,25 @@ from rasa.shared.exceptions import ConnectionException
 
 structlogger = structlog.get_logger(__name__)
 
+SERVICE_CONFIG: Dict[Tuple[SupportedServiceType, str], str] = {
+    (
+        SupportedServiceType.TRACKER_STORE,
+        SQL_SERVICE_NAME,
+    ): RDS_SQL_DB_AWS_IAM_ENABLED_ENV_VAR_NAME,
+    (
+        SupportedServiceType.TRACKER_STORE,
+        REDIS_SERVICE_NAME,
+    ): ELASTICACHE_REDIS_AWS_IAM_ENABLED_ENV_VAR_NAME,
+    (
+        SupportedServiceType.EVENT_BROKER,
+        KAFKA_SERVICE_NAME,
+    ): KAFKA_MSK_AWS_IAM_ENABLED_ENV_VAR_NAME,
+    (
+        SupportedServiceType.LOCK_STORE,
+        REDIS_SERVICE_NAME,
+    ): ELASTICACHE_REDIS_AWS_IAM_ENABLED_ENV_VAR_NAME,
+}
+
 
 class AWSRDSIAMCredentialsProvider(IAMCredentialsProvider):
     """Generates temporary credentials for AWS RDS using IAM roles."""
@@ -203,21 +230,59 @@ class AWSElasticacheRedisIAMCredentialsProvider(redis.CredentialProvider):
             return TemporaryCredentials()
 
 
+def is_iam_enabled(provider_input: "IAMCredentialsProviderInput") -> bool:
+    """Checks if IAM authentication is enabled for the given service."""
+    service_type = provider_input.service_type
+    service_name = provider_input.service_name
+    iam_enabled_env_var_name = SERVICE_CONFIG.get((service_type, service_name))
+
+    if not iam_enabled_env_var_name:
+        structlogger.warning(
+            "rasa.core.aws_iam_credentials_providers.is_iam_enabled.unsupported_service",
+            event_info=f"IAM authentication check requested for unsupported service: "
+            f"{service_name}",
+        )
+        return False
+
+    return os.getenv(iam_enabled_env_var_name, "false").lower() == "true"
+
+
 def create_aws_iam_credentials_provider(
     provider_input: "IAMCredentialsProviderInput",
 ) -> Optional["IAMCredentialsProvider"]:
     """Factory function to create an AWS IAM credentials provider."""
-    if provider_input.service_name == SupportedServiceType.TRACKER_STORE:
+    iam_enabled = is_iam_enabled(provider_input)
+    if not iam_enabled:
+        structlogger.debug(
+            "rasa.core.aws_iam_credentials_providers.create_provider.iam_not_enabled",
+            event_info=f"IAM authentication not enabled for service: "
+            f"{provider_input.service_type}",
+        )
+        return None
+
+    if (
+        provider_input.service_type == SupportedServiceType.TRACKER_STORE
+        and provider_input.service_name == SQL_SERVICE_NAME
+    ):
         return AWSRDSIAMCredentialsProvider(
             username=provider_input.username,
             host=provider_input.host,
             port=provider_input.port,
         )
 
-    if provider_input.service_name == SupportedServiceType.EVENT_BROKER:
+    if (
+        provider_input.service_type == SupportedServiceType.TRACKER_STORE
+        and provider_input.service_name == REDIS_SERVICE_NAME
+    ):
+        return AWSElasticacheRedisIAMCredentialsProvider(
+            username=provider_input.username,
+            cluster_name=provider_input.cluster_name,
+        )
+
+    if provider_input.service_type == SupportedServiceType.EVENT_BROKER:
         return AWSMSKafkaIAMCredentialsProvider()
 
-    if provider_input.service_name == SupportedServiceType.LOCK_STORE:
+    if provider_input.service_type == SupportedServiceType.LOCK_STORE:
         return AWSElasticacheRedisIAMCredentialsProvider(
             username=provider_input.username,
             cluster_name=provider_input.cluster_name,

rasa/core/iam_credentials_providers/credentials_provider_protocol.py

@@ -47,7 +47,8 @@ class SupportedServiceType(Enum):
 class IAMCredentialsProviderInput(BaseModel):
     """Input data for creating an IAM credentials provider."""
 
-    service_name: SupportedServiceType
+    service_type: SupportedServiceType
+    service_name: str
     username: Optional[str] = None
     host: Optional[str] = None
     port: Optional[int] = None

rasa/core/lock_store.py

@@ -18,6 +18,9 @@ from pydantic import (
 
 import rasa.shared.utils.common
 from rasa.core.constants import DEFAULT_LOCK_LIFETIME, IAM_CLOUD_PROVIDER_ENV_VAR_NAME
+from rasa.core.iam_credentials_providers.credentials_provider_protocol import (
+    SupportedServiceType,
+)
 from rasa.core.lock import TicketLock
 from rasa.core.redis_connection_factory import (
     DeploymentMode,
@@ -336,6 +339,7 @@ class RedisLockStore(LockStore):
             redis_config = RedisConfig(
                 host=str(self.config.host),
                 port=self.config.port,
+                service_type=SupportedServiceType.LOCK_STORE,
                 db=self.config.db,
                 username=self.config.username,
                 password=self.config.password,

rasa/core/redis_connection_factory.py

@@ -6,7 +6,10 @@ import redis
 import structlog
 from pydantic import BaseModel, ConfigDict
 
-from rasa.core.constants import AWS_ELASTICACHE_CLUSTER_NAME_ENV_VAR_NAME
+from rasa.core.constants import (
+    AWS_ELASTICACHE_CLUSTER_NAME_ENV_VAR_NAME,
+    REDIS_SERVICE_NAME,
+)
 from rasa.core.iam_credentials_providers.credentials_provider_protocol import (
     IAMCredentialsProvider,
     IAMCredentialsProviderInput,
@@ -65,6 +68,7 @@ class RedisConfig(BaseModel):
 
     host: Text = "localhost"
     port: int = 6379
+    service_type: SupportedServiceType
     username: Optional[Text] = None
     password: Optional[Text] = None
     use_ssl: bool = False
@@ -117,7 +121,8 @@ class RedisConnectionFactory:
 
         iam_credentials_provider = create_iam_credentials_provider(
             IAMCredentialsProviderInput(
-                service_name=SupportedServiceType.LOCK_STORE,
+                service_type=config.service_type,
+                service_name=REDIS_SERVICE_NAME,
                 username=config.username,
                 cluster_name=os.getenv(AWS_ELASTICACHE_CLUSTER_NAME_ENV_VAR_NAME),
             )

rasa/core/tracker_stores/redis_tracker_store.py

@@ -8,6 +8,9 @@ from pydantic import ValidationError
 
 import rasa.shared
 from rasa.core.brokers.broker import EventBroker
+from rasa.core.iam_credentials_providers.credentials_provider_protocol import (
+    SupportedServiceType,
+)
 from rasa.core.redis_connection_factory import (
     DeploymentMode,
     RedisConfig,
@@ -54,6 +57,7 @@ class RedisTrackerStore(TrackerStore, SerializedTrackerAsText):
             config = RedisConfig(
                 host=host,
                 port=port,
+                service_type=SupportedServiceType.TRACKER_STORE,
                 db=db,
                 username=username,
                 password=password,

rasa/core/tracker_stores/sql_tracker_store.py

@@ -27,6 +27,7 @@ from rasa.core.constants import (
     POSTGRESQL_MAX_OVERFLOW,
     POSTGRESQL_POOL_SIZE,
     POSTGRESQL_SCHEMA,
+    SQL_SERVICE_NAME,
     SQL_TRACKER_STORE_SSL_MODE_ENV_VAR_NAME,
     SQL_TRACKER_STORE_SSL_ROOT_CERTIFICATE_ENV_VAR_NAME,
 )
@@ -229,7 +230,8 @@ class SQLTrackerStore(TrackerStore, SerializedTrackerAsText):
 
         iam_credentials_provider = create_iam_credentials_provider(
             IAMCredentialsProviderInput(
-                service_name=SupportedServiceType.TRACKER_STORE,
+                service_type=SupportedServiceType.TRACKER_STORE,
+                service_name=SQL_SERVICE_NAME,
                 username=username,
                 host=host,
                 port=port,

rasa/version.py

@@ -1,3 +1,3 @@
 # this file will automatically be changed,
 # do not add anything but the version number here!
-__version__ = "3.14.0rc1"
+__version__ = "3.14.0rc2"