rasa-pro 3.10.16__py3-none-any.whl → 3.11.0__py3-none-any.whl

rasa/cli/train.py

@@ -1,33 +1,25 @@
 import argparse
 import asyncio
-import os
 import sys
 from pathlib import Path
 from typing import Dict, List, Optional, Text, Union
 
 import structlog
-from tarsafe import TarSafe
 
 import rasa.cli.arguments.train as train_arguments
 import rasa.cli.utils
 import rasa.core.utils
 import rasa.utils.common
-from rasa.api import train as train_all
 from rasa.cli import SubParsersAction
-from rasa.core import ContextualResponseRephraser
 from rasa.core.nlg.generator import NaturalLanguageGenerator
 from rasa.core.train import do_compare_training
-from rasa.engine.validation import validate_api_type_config_key_usage
-from rasa.nlu.persistor import get_persistor
 from rasa.shared.constants import (
     CONFIG_MANDATORY_KEYS,
     CONFIG_MANDATORY_KEYS_CORE,
     CONFIG_MANDATORY_KEYS_NLU,
     DEFAULT_DATA_PATH,
     DEFAULT_DOMAIN_PATHS,
-    LLM_CONFIG_KEY,
 )
-from rasa.shared.exceptions import RasaException
 from rasa.shared.importers.importer import TrainingDataImporter
 
 structlogger = structlog.getLogger(__name__)
@@ -44,7 +36,7 @@ def add_subparser(
     """
     train_parser = subparsers.add_parser(
         "train",
-        help="Trains a Rasa model using your CALM flows, NLU data and stories.",
+        help="Trains a Rasa model using your NLU data and stories.",
         parents=parents,
         formatter_class=argparse.ArgumentDefaultsHelpFormatter,
     )
@@ -78,12 +70,6 @@ def add_subparser(
 def _check_nlg_endpoint_validity(endpoint: Union[Path, str]) -> None:
     try:
         endpoints = rasa.core.utils.read_endpoints_from_path(endpoint)
-        if endpoints.nlg is not None:
-            validate_api_type_config_key_usage(
-                endpoints.nlg.kwargs,
-                LLM_CONFIG_KEY,
-                ContextualResponseRephraser.__name__,
-            )
         NaturalLanguageGenerator.create(endpoints.nlg)
     except Exception as e:
         structlogger.error(
@@ -97,37 +83,6 @@ def _check_nlg_endpoint_validity(endpoint: Union[Path, str]) -> None:
         sys.exit(1)
 
 
-def retrieve_and_unpack_bot_config_from_remote_storage(
-    args: argparse.Namespace,
-) -> None:
-    """Retrieve and unpack bot config from remote storage.
-
-    Bot config is retrieved from remote storage and unpacked
-    to the current working directory.
-    """
-    persistor = get_persistor(args.remote_storage)
-    if persistor is None:
-        raise RasaException(
-            f"Could not find a persistor for "
-            f"the storage type '{args.remote_storage}'."
-        )
-
-    current_working_directory = os.getcwd()
-
-    persistor.retrieve(args.remote_bot_config_path, current_working_directory)
-
-    remote_bot_config_tar_file_name = os.path.basename(args.remote_bot_config_path)
-
-    with TarSafe.open(remote_bot_config_tar_file_name, "r:gz") as tar:
-        tar.extractall(path=current_working_directory)
-
-    structlogger.debug(
-        "rasa.train.retrieve_and_unpack_bot_config.remove_downloaded_archive",
-        training_data_path=args.remote_bot_config_path,
-    )
-    os.remove(Path(current_working_directory).joinpath(remote_bot_config_tar_file_name))
-
-
 def run_training(args: argparse.Namespace, can_exit: bool = False) -> Optional[Text]:
     """Trains a model.
 
@@ -139,9 +94,7 @@ def run_training(args: argparse.Namespace, can_exit: bool = False) -> Optional[T
     Returns:
         Path to a trained model or `None` if training was not successful.
     """
-    # retrieve and unpack bot_config from remote storage
-    if hasattr(args, "remote_bot_config_path") and args.remote_bot_config_path:
-        retrieve_and_unpack_bot_config_from_remote_storage(args)
+    from rasa.api import train as train_all
 
     domain = rasa.cli.utils.get_validated_path(
         args.domain, "domain", DEFAULT_DOMAIN_PATHS, none_is_valid=True
@@ -157,16 +110,20 @@ def run_training(args: argparse.Namespace, can_exit: bool = False) -> Optional[T
         for f in args.data
     ]
 
+    training_data_importer = TrainingDataImporter.load_from_config(
+        domain_path=domain, training_data_paths=args.data, config_path=config
+    )
+
     if not args.skip_validation:
         structlogger.info(
             "cli.train.run_training",
             event_info="Started validating domain and training data...",
         )
-        importer = TrainingDataImporter.load_from_config(
-            domain_path=domain, training_data_paths=args.data, config_path=config
-        )
+
         rasa.cli.utils.validate_files(
-            args.fail_on_validation_warnings, args.validation_max_history, importer
+            args.fail_on_validation_warnings,
+            args.validation_max_history,
+            training_data_importer,
         )
 
     training_result = train_all(
@@ -185,6 +142,8 @@ def run_training(args: argparse.Namespace, can_exit: bool = False) -> Optional[T
         model_to_finetune=_model_for_finetuning(args),
         finetuning_epoch_fraction=args.epoch_fraction,
         remote_storage=args.remote_storage,
+        file_importer=training_data_importer,
+        keep_local_model_copy=args.keep_local_model_copy,
     )
     if training_result.code != 0 and can_exit:
         sys.exit(training_result.code)
@@ -243,6 +202,7 @@ def run_core_training(args: argparse.Namespace) -> Optional[Text]:
                 additional_arguments=additional_arguments,
                 model_to_finetune=_model_for_finetuning(args),
                 finetuning_epoch_fraction=args.epoch_fraction,
+                keep_local_model_copy=args.keep_local_model_copy,
             )
         )
     else:
@@ -284,6 +244,7 @@ def run_nlu_training(args: argparse.Namespace) -> Optional[Text]:
             domain=args.domain,
             model_to_finetune=_model_for_finetuning(args),
             finetuning_epoch_fraction=args.epoch_fraction,
+            keep_local_model_copy=args.keep_local_model_copy,
         )
     )
 

rasa/cli/utils.py

@@ -1,32 +1,30 @@
+import json
 import argparse
+import structlog
 import importlib
-import json
 import os
 import sys
 import time
 from pathlib import Path
 from types import FrameType
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Text, Union, overload
-
+from typing import Any, Dict, List, Optional, TYPE_CHECKING, Text, Union, overload
 import randomname
-import structlog
 
 import rasa.shared.utils.cli
 import rasa.shared.utils.io
-from rasa import telemetry
+from rasa.shared.importers.importer import TrainingDataImporter
 from rasa.shared.constants import (
     ASSISTANT_ID_DEFAULT_VALUE,
     ASSISTANT_ID_KEY,
     DEFAULT_CONFIG_PATH,
 )
-from rasa.shared.importers.importer import TrainingDataImporter
+from rasa import telemetry
 from rasa.shared.utils.yaml import read_config_file
 from rasa.utils.io import write_yaml
 
 if TYPE_CHECKING:
     from questionary import Question
     from typing_extensions import Literal
-
     from rasa.validator import Validator
 
 structlogger = structlog.get_logger()
@@ -307,7 +305,7 @@ def _validate_domain(validator: "Validator") -> bool:
     valid_forms_in_stories_rules = validator.verify_forms_in_stories_rules()
     valid_form_slots = validator.verify_form_slots()
     valid_slot_mappings = validator.verify_slot_mappings()
-    valid_responses = validator.check_for_no_empty_paranthesis_in_responses()
+    valid_responses = validator.check_for_no_empty_parenthesis_in_responses()
     valid_buttons = validator.validate_button_payloads()
     return (
         valid_domain_validity
@@ -472,10 +470,15 @@ def get_e2e_results_file_name(
 ) -> str:
     """Returns the name of the e2e results file."""
     if results_output_path.is_dir():
-        file_name = str(results_output_path) + f"/e2e_results_{result_type}.yml"
+        file_name = results_output_path / f"e2e_results_{result_type}.yml"
     else:
         parent = results_output_path.parent
         stem = results_output_path.stem
-        file_name = str(parent) + f"/{stem}_{result_type}.yml"
+        file_name = parent / f"{stem}_{result_type}.yml"
+
+    return str(file_name)
+
 
-    return file_name
+def is_skip_validation_flag_set() -> bool:
+    """Checks if the skip validation flag is set."""
+    return "--skip-validation" in sys.argv

rasa/cli/x.py

@@ -1,25 +1,25 @@
 import argparse
 import asyncio
 import logging
-from pathlib import Path
 import signal
+from pathlib import Path
 from typing import Iterable, List, Optional, Text, Tuple, Union
 
 import aiohttp
 import ruamel.yaml as yaml
 
+import rasa.cli.utils
+import rasa.shared.utils.cli
+import rasa.shared.utils.io
+import rasa.utils.common
+import rasa.utils.io
 from rasa.cli import SubParsersAction
 from rasa.cli.arguments import x as arguments
-import rasa.cli.utils
+from rasa.core.utils import AvailableEndpoints
 from rasa.shared.constants import (
     DEFAULT_CREDENTIALS_PATH,
     DEFAULT_ENDPOINTS_PATH,
 )
-from rasa.core.utils import AvailableEndpoints
-import rasa.shared.utils.cli
-import rasa.shared.utils.io
-import rasa.utils.common
-import rasa.utils.io
 from rasa.shared.utils.yaml import read_config_file
 
 logger = logging.getLogger(__name__)

rasa/constants.py

@@ -18,7 +18,7 @@ CONFIG_TELEMETRY_ID = "rasa_user_id"
 CONFIG_TELEMETRY_ENABLED = "enabled"
 CONFIG_TELEMETRY_DATE = "date"
 
-MINIMUM_COMPATIBLE_VERSION = "3.10.12"
+MINIMUM_COMPATIBLE_VERSION = "3.11.0rc1"
 
 GLOBAL_USER_CONFIG_PATH = os.path.expanduser("~/.config/rasa/global.yml")
 
@@ -39,5 +39,7 @@ ENV_CPU_INTRA_OP_CONFIG = "TF_INTRA_OP_PARALLELISM_THREADS"
 
 MODEL_ARCHIVE_EXTENSION = "tar.gz"
 
+DEFAULT_BUCKET_NAME = "rasa-models"
+
 HTTP_STATUS_FORBIDDEN = 403
 HTTP_STATUS_NOT_FOUND = 404

rasa/core/actions/action.py

@@ -13,6 +13,8 @@ from typing import (
     cast,
 )
 
+from jsonschema import Draft202012Validator
+
 import rasa.core
 import rasa.shared.utils.io
 from rasa.core.actions.custom_action_executor import (
@@ -101,7 +103,6 @@ if TYPE_CHECKING:
     from rasa.core.nlg import NaturalLanguageGenerator
     from rasa.shared.core.events import IntentPrediction
 
-
 logger = logging.getLogger(__name__)
 
 
@@ -112,6 +113,8 @@ def default_actions(action_endpoint: Optional[EndpointConfig] = None) -> List["A
     from rasa.core.actions.action_trigger_chitchat import ActionTriggerChitchat
     from rasa.core.actions.action_trigger_search import ActionTriggerSearch
     from rasa.core.actions.two_stage_fallback import TwoStageFallbackAction
+    from rasa.core.actions.action_hangup import ActionHangup
+    from rasa.core.actions.action_repeat_bot_messages import ActionRepeatBotMessages
     from rasa.dialogue_understanding.patterns.cancel import ActionCancelFlow
     from rasa.dialogue_understanding.patterns.clarify import ActionClarifyFlows
     from rasa.dialogue_understanding.patterns.correction import ActionCorrectFlowSlot
@@ -138,6 +141,8 @@ def default_actions(action_endpoint: Optional[EndpointConfig] = None) -> List["A
         ActionTriggerSearch(),
         ActionTriggerChitchat(),
         ActionResetRouting(),
+        ActionHangup(),
+        ActionRepeatBotMessages(),
     ]
 
 
@@ -721,6 +726,77 @@ class ActionDeactivateLoop(Action):
         return [ActiveLoop(None), SlotSet(REQUESTED_SLOT, None)]
 
 
+class RemoteActionJSONValidator:
+    """
+    A validator class for ensuring that the JSON response from a custom action executor
+    adheres to the expected schema.
+    """
+
+    @staticmethod
+    def action_response_format_spec() -> Dict[Text, Any]:
+        """Expected response schema for an Action endpoint.
+
+        Used for validation of the response returned from the
+        Action endpoint.
+
+        Returns:
+            Dict[Text, Any]: A dictionary representing the JSON schema for validation.
+        """
+        schema = {
+            "type": "object",
+            "properties": {
+                "events": EVENTS_SCHEMA,
+                "responses": {"type": "array", "items": {"type": "object"}},
+            },
+        }
+        return schema
+
+    @classmethod
+    def validate(cls, result: Dict[Text, Any]) -> bool:
+        """
+        Validate the given JSON result against the expected Action response schema.
+
+        This method uses a cached JSON schema validator to check if the provided result
+        conforms to the predefined schema.
+
+        Args:
+            result (Dict[Text, Any]): The JSON response to validate.
+
+        Returns:
+            bool: True if validation is successful.
+
+        Raises:
+            ValidationError: If the JSON response does not conform to the schema.
+        """
+        from jsonschema import ValidationError
+
+        try:
+            validator = cls.get_action_response_validator()
+            validator.validate(
+                result, RemoteActionJSONValidator.action_response_format_spec()
+            )
+            return True
+        except ValidationError as e:
+            e.message += (
+                f". Failed to validate Action server response from API, "
+                f"make sure your response from the Action endpoint is valid. "
+                f"For more information about the format visit "
+                f"{DOCS_BASE_URL}/custom-actions"
+            )
+            raise e
+
+    @classmethod
+    @lru_cache(maxsize=1)
+    def get_action_response_validator(cls) -> Draft202012Validator:
+        """
+        Retrieve a cached JSON schema validator for the Action response schema.
+
+        Returns:
+            Draft202012Validator: An instance of the JSON schema validator.
+        """
+        return Draft202012Validator(cls.action_response_format_spec())
+
+
 class RemoteAction(Action):
     def __init__(
         self,
@@ -779,37 +855,6 @@ class RemoteAction(Action):
             f"Found url '{self.action_endpoint.url}'."
         )
 
-    @staticmethod
-    def action_response_format_spec() -> Dict[Text, Any]:
-        """Expected response schema for an Action endpoint.
-
-        Used for validation of the response returned from the
-        Action endpoint.
-        """
-        schema = {
-            "type": "object",
-            "properties": {
-                "events": EVENTS_SCHEMA,
-                "responses": {"type": "array", "items": {"type": "object"}},
-            },
-        }
-        return schema
-
-    def _validate_action_result(self, result: Dict[Text, Any]) -> bool:
-        from jsonschema import ValidationError, validate
-
-        try:
-            validate(result, self.action_response_format_spec())
-            return True
-        except ValidationError as e:
-            e.message += (
-                f". Failed to validate Action server response from API, "
-                f"make sure your response from the Action endpoint is valid. "
-                f"For more information about the format visit "
-                f"{DOCS_BASE_URL}/custom-actions"
-            )
-            raise e
-
     @staticmethod
     async def _utter_responses(
         responses: List[Dict[Text, Any]],
@@ -861,7 +906,6 @@ class RemoteAction(Action):
             domain=domain,
             tracker=tracker,
         )
-        self._validate_action_result(response)
 
         events_json = response.get("events", [])
         responses = response.get("responses", [])

rasa/core/actions/action_hangup.py

@@ -0,0 +1,29 @@
+from typing import Optional, Dict, Any, List
+
+from rasa.core.actions.action import Action
+from rasa.core.channels import OutputChannel
+from rasa.core.nlg import NaturalLanguageGenerator
+from rasa.shared.core.constants import ACTION_HANGUP
+from rasa.shared.core.domain import Domain
+from rasa.shared.core.events import Event, SessionEnded
+from rasa.shared.core.trackers import DialogueStateTracker
+
+
+class ActionHangup(Action):
+    """Action which hangs up the call."""
+
+    def name(self) -> str:
+        """Return the name of the action."""
+        return ACTION_HANGUP
+
+    async def run(
+        self,
+        output_channel: OutputChannel,
+        nlg: NaturalLanguageGenerator,
+        tracker: DialogueStateTracker,
+        domain: Domain,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> List[Event]:
+        """Ask the output channel to hang up the call."""
+        await output_channel.hangup(tracker.sender_id)
+        return [SessionEnded(metadata={"_reason": "hangup"})]

rasa/core/actions/action_repeat_bot_messages.py

@@ -0,0 +1,89 @@
+from typing import Optional, Dict, Any, List
+
+from rasa.core.actions.action import Action
+from rasa.core.channels import OutputChannel
+from rasa.core.nlg import NaturalLanguageGenerator
+from rasa.dialogue_understanding.patterns.collect_information import (
+    CollectInformationPatternFlowStackFrame,
+)
+from rasa.dialogue_understanding.patterns.repeat import (
+    RepeatBotMessagesPatternFlowStackFrame,
+)
+from rasa.dialogue_understanding.patterns.user_silence import (
+    UserSilencePatternFlowStackFrame,
+)
+from rasa.shared.core.constants import ACTION_REPEAT_BOT_MESSAGES
+from rasa.shared.core.domain import Domain
+from rasa.shared.core.events import Event, BotUttered, UserUttered
+from rasa.shared.core.trackers import DialogueStateTracker
+
+
+class ActionRepeatBotMessages(Action):
+    """Action to repeat bot messages"""
+
+    def name(self) -> str:
+        """Return the name of the action."""
+        return ACTION_REPEAT_BOT_MESSAGES
+
+    def _get_last_bot_events(self, tracker: DialogueStateTracker) -> List[Event]:
+        """Get the last consecutive bot events before the most recent user message.
+
+        This function scans the dialogue history in reverse to find the last sequence of
+        bot responses that occurred without any user interruption. It filters out all
+        non-utterance events and stops when it encounters a user message after finding
+        bot messages.
+
+        Args:
+            tracker: DialogueStateTracker containing the conversation events.
+
+        Returns:
+            List[Event]: A list of consecutive BotUttered events that occurred
+                most recently, in chronological order. Returns an empty list
+                if no bot messages are found or if the last message was from
+                the user.
+
+        Example:
+            For events: [User1, Bot1, Bot2, User2, Bot4, Bot5, User3]
+            Returns: [Bot4, Bot5] (the last two bot events)
+            The elif condition doesn't break when it sees User3 event.
+            But it does at User2 event.
+        """
+        # Skip action if we are in a collect information step whose
+        # default behavior is to repeat anyways
+        top_frame = tracker.stack.top(
+            lambda frame: isinstance(frame, RepeatBotMessagesPatternFlowStackFrame)
+            or isinstance(frame, UserSilencePatternFlowStackFrame)
+        )
+        if isinstance(top_frame, CollectInformationPatternFlowStackFrame):
+            return []
+        # filter user and bot events
+        filtered = [
+            e for e in tracker.events if isinstance(e, (BotUttered, UserUttered))
+        ]
+        bot_events: List[Event] = []
+
+        # find the last BotUttered events
+        for e in reversed(filtered):
+            if isinstance(e, BotUttered):
+                # insert instead of append because the list is reversed
+                bot_events.insert(0, e)
+
+            # stop if a UserUttered event is found
+            # only if we have collected some bot events already
+            # this condition skips the first N UserUttered events
+            elif bot_events:
+                break
+
+        return bot_events
+
+    async def run(
+        self,
+        output_channel: OutputChannel,
+        nlg: NaturalLanguageGenerator,
+        tracker: DialogueStateTracker,
+        domain: Domain,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> List[Event]:
+        """Send the last bot messages to the channel again"""
+        bot_events = self._get_last_bot_events(tracker)
+        return bot_events

rasa/core/actions/e2e_stub_custom_action_executor.py

@@ -61,8 +61,12 @@ class E2EStubCustomActionExecutor(CustomActionExecutor):
         domain: "Domain",
         include_domain: bool = False,
     ) -> Dict[Text, Any]:
+        from rasa.core.actions.action import RemoteActionJSONValidator
+
         structlogger.debug(
             "action.e2e_stub_custom_action_executor.run",
             action_name=self.action_name,
         )
-        return self.stub_custom_action.as_dict()
+        response = self.stub_custom_action.as_dict()
+        RemoteActionJSONValidator.validate(response)
+        return response

rasa/core/actions/http_custom_action_executor.py

@@ -66,6 +66,8 @@ class HTTPCustomActionExecutor(CustomActionExecutor):
         Raises:
             RasaException: If an error occurs while making the HTTP request.
         """
+        from rasa.core.actions.action import RemoteActionJSONValidator
+
         try:
             logger.debug(
                 "Calling action endpoint to run action '{}'.".format(self.action_name)
@@ -80,6 +82,8 @@ class HTTPCustomActionExecutor(CustomActionExecutor):
             if response is None:
                 response = {}
 
+            RemoteActionJSONValidator.validate(response)
+
             return response
 
         except ClientResponseError as e:

rasa/core/agent.py

@@ -19,6 +19,7 @@ from rasa.core.exceptions import AgentNotReady
 from rasa.core.http_interpreter import RasaNLUHttpInterpreter
 from rasa.core.lock_store import InMemoryLockStore, LockStore
 from rasa.core.nlg import NaturalLanguageGenerator, TemplatedNaturalLanguageGenerator
+from rasa.core.persistor import StorageType
 from rasa.core.policies.policy import PolicyPrediction
 from rasa.core.processor import MessageProcessor
 from rasa.core.tracker_store import (
@@ -28,7 +29,6 @@ from rasa.core.tracker_store import (
 )
 from rasa.core.utils import AvailableEndpoints
 from rasa.exceptions import ModelNotFound
-from rasa.nlu.persistor import StorageType
 from rasa.nlu.utils import is_url
 from rasa.shared.constants import DEFAULT_SENDER_ID
 from rasa.shared.core.domain import Domain
@@ -544,7 +544,7 @@ class Agent:
 
     def load_model_from_remote_storage(self, model_name: Text) -> None:
         """Loads an Agent from remote storage."""
-        from rasa.nlu.persistor import get_persistor
+        from rasa.core.persistor import get_persistor
 
         persistor = get_persistor(self.remote_storage)
 

rasa/core/brokers/kafka.py

@@ -2,6 +2,8 @@ import asyncio
 import os
 import json
 import logging
+from functools import cached_property
+
 import structlog
 import threading
 from asyncio import AbstractEventLoop
@@ -270,7 +272,7 @@ class KafkaEventBroker(EventBroker):
         if self.producer:
             self.producer.flush()
 
-    @rasa.shared.utils.common.lazy_property
+    @cached_property
     def rasa_environment(self) -> Optional[Text]:
         """Get value of the `RASA_ENVIRONMENT` environment variable."""
         return os.environ.get("RASA_ENVIRONMENT", "RASA_ENVIRONMENT_NOT_SET")

rasa/core/brokers/pika.py

@@ -1,6 +1,8 @@
 import asyncio
 import json
 import logging
+from functools import cached_property
+
 import structlog
 import os
 import ssl
@@ -333,7 +335,7 @@ class PikaEventBroker(EventBroker):
             delivery_mode=aio_pika.DeliveryMode.PERSISTENT,
         )
 
-    @rasa.shared.utils.common.lazy_property
+    @cached_property
     def rasa_environment(self) -> Optional[Text]:
         """Get value of the `RASA_ENVIRONMENT` environment variable."""
         return os.environ.get("RASA_ENVIRONMENT")

rasa/core/channels/__init__.py

@@ -21,13 +21,16 @@ from rasa.core.channels.rocketchat import RocketChatInput
 from rasa.core.channels.slack import SlackInput
 from rasa.core.channels.telegram import TelegramInput
 from rasa.core.channels.twilio import TwilioInput
-from rasa.core.channels.twilio_voice import TwilioVoiceInput
-from rasa.core.channels.voice_aware.jambonz import JambonzVoiceAwareInput
+from rasa.core.channels.voice_ready.twilio_voice import TwilioVoiceInput
+from rasa.core.channels.voice_ready.jambonz import JambonzVoiceReadyInput
+from rasa.core.channels.voice_ready.audiocodes import AudiocodesInput
+from rasa.core.channels.voice_stream.browser_audio import BrowserAudioInputChannel
 from rasa.core.channels.webexteams import WebexTeamsInput
 from rasa.core.channels.hangouts import HangoutsInput
-from rasa.core.channels.audiocodes import AudiocodesInput
-from rasa.core.channels.development_inspector import DevelopmentInspectInput
 from rasa.core.channels.vier_cvg import CVGInput
+from rasa.core.channels.voice_stream.twilio_media_streams import (
+    TwilioMediaStreamsInputChannel,
+)
 
 input_channel_classes: List[Type[InputChannel]] = [
     CmdlineInput,
@@ -46,9 +49,10 @@ input_channel_classes: List[Type[InputChannel]] = [
     WebexTeamsInput,
     HangoutsInput,
     AudiocodesInput,
-    DevelopmentInspectInput,
     CVGInput,
-    JambonzVoiceAwareInput,
+    JambonzVoiceReadyInput,
+    TwilioMediaStreamsInputChannel,
+    BrowserAudioInputChannel,
 ]
 
 # Mapping from an input channel name to its class to allow name based lookup.