rasa-pro 3.9.18__py3-none-any.whl → 3.10.4__py3-none-any.whl

rasa/studio/download.py

@@ -210,8 +210,8 @@ def _handle_download_no_overwrite(
     if domain_path.is_dir():
         studio_domain_path = domain_path / STUDIO_DOMAIN_FILENAME
         new_domain_data = data_handler.combine_domains(
-            data_from_studio.get_domain().as_dict(),
-            data_original.get_domain().as_dict(),
+            data_from_studio.get_user_domain().as_dict(),
+            data_original.get_user_domain().as_dict(),
         )
         studio_domain = Domain.from_dict(new_domain_data)
         if not studio_domain.is_empty():
@@ -219,7 +219,9 @@ def _handle_download_no_overwrite(
         else:
             logger.warning("No additional domain data found.")
     elif domain_path.is_file():
-        domain_merged = data_original.get_domain().merge(data_from_studio.get_domain())
+        domain_merged = data_original.get_user_domain().merge(
+            data_from_studio.get_user_domain()
+        )
         domain_merged.persist(domain_path)
 
     if len(data_paths) == 1 and data_paths[0].is_file():
@@ -230,7 +232,9 @@ def _handle_download_no_overwrite(
             )
             data_nlu.persist_nlu(data_path)
         if handler.has_flows():
-            data_flows = data_original.get_flows().merge(data_from_studio.get_flows())
+            data_flows = data_original.get_user_flows().merge(
+                data_from_studio.get_user_flows()
+            )
             YamlFlowsWriter.dump(data_flows.underlying_flows, data_path)
 
     elif len(data_paths) == 1 and data_paths[0].is_dir():
@@ -276,8 +280,8 @@ def _persist_flows_diff(
 ) -> None:
     """Creates a new flows file from the diff of original and studio data."""
     new_flows_data = data_handler.create_new_flows_from_diff(
-        data_from_studio.get_flows().underlying_flows,
-        data_original.get_flows().underlying_flows,
+        data_from_studio.get_user_flows().underlying_flows,
+        data_original.get_user_flows().underlying_flows,
     )
     if new_flows_data:
         YamlFlowsWriter.dump(new_flows_data, data_path)
@@ -317,11 +321,13 @@ def _handle_download_with_overwrite(
     )
 
     if domain_path.is_file():
-        domain_merged = data_from_studio.get_domain().merge(data_original.get_domain())
+        domain_merged = data_from_studio.get_user_domain().merge(
+            data_original.get_user_domain()
+        )
         domain_merged.persist(domain_path)
     elif domain_path.is_dir():
         default = domain_path / Path(STUDIO_DOMAIN_FILENAME)
-        studio_domain = data_from_studio.get_domain()
+        studio_domain = data_from_studio.get_user_domain()
 
         paths = get_domain_path(domain_path, data_from_studio, mapper)
 
@@ -358,8 +364,8 @@ def _handle_download_with_overwrite(
             )
             nlu_data_merged.persist_nlu(data_paths[0])
         if handler.has_flows():
-            flows_data_merged = data_from_studio.get_flows().merge(
-                data_original.get_flows()
+            flows_data_merged = data_from_studio.get_user_flows().merge(
+                data_original.get_user_flows()
             )
             YamlFlowsWriter.dump(flows_data_merged.underlying_flows, data_paths[0])
     elif len(data_paths) == 1 and data_paths[0].is_dir():
@@ -374,12 +380,12 @@ def _handle_download_with_overwrite(
                 nlu_data = nlu_data.merge(nlu_file.get_nlu_data())
             pretty_write_nlu_yaml(read_yaml(nlu_data.nlu_as_yaml()), paths["nlu_path"])
         if handler.has_flows():
-            flows_data = data_from_studio.get_flows()
+            flows_data = data_from_studio.get_user_flows()
             if paths["flow_path"].exists():
                 flows_file = TrainingDataImporter.load_from_dict(
                     training_data_paths=[str(paths["flow_path"])]
                 )
-                flows_data = flows_data.merge(flows_file.get_flows())
+                flows_data = flows_data.merge(flows_file.get_user_flows())
             YamlFlowsWriter.dump(flows_data.underlying_flows, paths["flow_path"])
     else:
         #  TODO: we are not handling the case of multiple data paths?
@@ -407,7 +413,7 @@ def get_training_path(
     for intent in data_original.get_nlu_data().intents:
         for path in mapper.get_file(intent, "intents").get("training", []):
             nlu_paths.add(path)
-    flows = [flow.id for flow in data_original.get_flows().underlying_flows]
+    flows = [flow.id for flow in data_original.get_user_flows().underlying_flows]
     for flow in flows:
         for path in mapper.get_file(flow, "flows").get("training", []):
             flow_paths.add(path)

rasa/studio/train.py

@@ -20,19 +20,18 @@ from rasa.shared.core.flows.yaml_flows_io import YamlFlowsWriter
 from rasa.shared.importers.importer import TrainingDataImporter
 from rasa.shared.utils.yaml import read_yaml, write_yaml
 from rasa.studio import data_handler
-from rasa.utils.common import get_temp_dir_name
-
 from rasa.studio.config import StudioConfig
 from rasa.studio.data_handler import (
     StudioDataHandler,
     import_data_from_studio,
 )
+from rasa.utils.common import get_temp_dir_name
 
 logger = logging.getLogger(__name__)
 
 
 def handle_train(args: argparse.Namespace) -> Optional[str]:
-    from rasa import train as train_all
+    from rasa.api import train as train_all
 
     handler = StudioDataHandler(
         studio_config=StudioConfig.read_config(), assistant_name=args.assistant_name[0]

rasa/studio/upload.py

@@ -151,7 +151,7 @@ def upload_calm_assistant(args: argparse.Namespace, endpoint: str) -> StudioResu
 
     # Prepare config and domain
     config = importer.get_config()
-    domain_from_files = importer.get_domain().as_dict()
+    domain_from_files = importer.get_user_domain().as_dict()
     endpoints_from_files = read_yaml_file(args.endpoints)
     config_from_files = read_yaml_file(args.config)
 
@@ -188,8 +188,7 @@ def upload_calm_assistant(args: argparse.Namespace, endpoint: str) -> StudioResu
         training_data_paths=training_data_paths
     )
 
-    user_flows = flow_importer.get_flows().user_flows
-    flows = list(user_flows)
+    flows = list(flow_importer.get_user_flows())
 
     # We instantiate the TrainingDataImporter again on purpose to avoid
     # adding patterns to domain's actions. More info https://t.ly/W8uuc

rasa/telemetry.py

@@ -122,8 +122,6 @@ TELEMETRY_INTENTLESS_POLICY_TRAINING_COMPLETED_EVENT = (
     "Intentless Policy Training Completed"
 )
 TELEMETRY_INTENTLESS_POLICY_PREDICT_EVENT = "Intentless Policy Predicted"
-TELEMETRY_LLM_INTENT_PREDICT_EVENT = "LLM Intent Predicted"
-TELEMETRY_LLM_INTENT_TRAIN_COMPLETED_EVENT = "LLM Intent Training Completed"
 TELEMETRY_E2E_TEST_RUN_STARTED_EVENT = "E2E Test Run Started"
 TELEMETRY_ENTERPRISE_SEARCH_POLICY_TRAINING_STARTED_EVENT = (
     "Enterprise Search Policy Training Started"
@@ -172,6 +170,11 @@ TRACING_BACKEND = "tracing_backend"
 METRICS_BACKEND = "metrics_backend"
 VERSION = "version"
 
+# E2E test conversion
+TELEMETRY_E2E_TEST_CONVERSION_EVENT = "E2E Test Conversion Completed"
+E2E_TEST_CONVERSION_FILE_TYPE = "file_type"
+E2E_TEST_CONVERSION_TEST_CASE_COUNT = "test_case_count"
+
 
 def print_telemetry_reporting_info() -> None:
     """Print telemetry information to std out."""
@@ -1078,6 +1081,7 @@ def _get_llm_command_generator_config(config: Dict[str, Any]) -> Optional[Dict]:
     retrieval is enabled, and flow retrieval embedding model.
     """
     from rasa.shared.constants import (
+        EMBEDDINGS_CONFIG_KEY,
         MODEL_CONFIG_KEY,
         MODEL_NAME_CONFIG_KEY,
     )
@@ -1116,13 +1120,17 @@ def _get_llm_command_generator_config(config: Dict[str, Any]) -> Optional[Dict]:
         llm_model_name = (
             llm_config.get(MODEL_CONFIG_KEY)
             or llm_config.get(MODEL_NAME_CONFIG_KEY)
-            or DEFAULT_LLM_CONFIG[MODEL_NAME_CONFIG_KEY]
+            or DEFAULT_LLM_CONFIG[MODEL_CONFIG_KEY]
         )
         flow_retrieval_config = component.get(FLOW_RETRIEVAL_KEY, {})
         flow_retrieval_enabled = flow_retrieval_config.get("active", True)
+        flow_retrieval_embeddings_config = flow_retrieval_config.get(
+            EMBEDDINGS_CONFIG_KEY, DEFAULT_EMBEDDINGS_CONFIG
+        )
         flow_retrieval_embedding_model_name = (
-            flow_retrieval_config.get("embeddings", DEFAULT_EMBEDDINGS_CONFIG).get(
-                "model"
+            (
+                flow_retrieval_embeddings_config.get(MODEL_NAME_CONFIG_KEY)
+                or flow_retrieval_embeddings_config.get(MODEL_CONFIG_KEY)
             )
             if flow_retrieval_enabled
             else None
@@ -1439,6 +1447,76 @@ def track_markers_parsed_count(
     )
 
 
+def extract_assertion_type_counts(
+    input_test_cases: List["TestCase"],
+) -> typing.Tuple[bool, Dict[str, Any]]:
+    """Extracts the total count of different assertion types from the test cases."""
+    from rasa.e2e_test.assertions import AssertionType
+
+    uses_assertions = False
+
+    flow_started_count = 0
+    flow_completed_count = 0
+    flow_cancelled_count = 0
+    pattern_clarification_contains_count = 0
+    action_executed_count = 0
+    slot_was_set_count = 0
+    slot_was_not_set_count = 0
+    bot_uttered_count = 0
+    generative_response_is_relevant_count = 0
+    generative_response_is_grounded_count = 0
+
+    for test_case in input_test_cases:
+        for step in test_case.steps:
+            assertions = step.assertions if step.assertions else []
+            for assertion in assertions:
+                if assertion.type == AssertionType.ACTION_EXECUTED.value:
+                    action_executed_count += 1
+                elif assertion.type == AssertionType.SLOT_WAS_SET.value:
+                    slot_was_set_count += 1
+                elif assertion.type == AssertionType.SLOT_WAS_NOT_SET.value:
+                    slot_was_not_set_count += 1
+                elif assertion.type == AssertionType.BOT_UTTERED.value:
+                    bot_uttered_count += 1
+                elif (
+                    assertion.type
+                    == AssertionType.GENERATIVE_RESPONSE_IS_RELEVANT.value
+                ):
+                    generative_response_is_relevant_count += 1
+                elif (
+                    assertion.type
+                    == AssertionType.GENERATIVE_RESPONSE_IS_GROUNDED.value
+                ):
+                    generative_response_is_grounded_count += 1
+                elif assertion.type == AssertionType.FLOW_STARTED.value:
+                    flow_started_count += 1
+                elif assertion.type == AssertionType.FLOW_COMPLETED.value:
+                    flow_completed_count += 1
+                elif assertion.type == AssertionType.FLOW_CANCELLED.value:
+                    flow_cancelled_count += 1
+                elif (
+                    assertion.type == AssertionType.PATTERN_CLARIFICATION_CONTAINS.value
+                ):
+                    pattern_clarification_contains_count += 1
+
+                uses_assertions = True
+
+    result = {
+        "flow_started_count": flow_started_count,
+        "flow_completed_count": flow_completed_count,
+        "flow_cancelled_count": flow_cancelled_count,
+        "pattern_clarification_contains_count": pattern_clarification_contains_count,
+        "action_executed_count": action_executed_count,
+        "slot_was_set_count": slot_was_set_count,
+        "slot_was_not_set_count": slot_was_not_set_count,
+        "bot_uttered_count": bot_uttered_count,
+        "generative_response_is_relevant_count": generative_response_is_relevant_count,
+        "generative_response_is_grounded_count": generative_response_is_grounded_count,
+    }
+
+    return uses_assertions, result
+
+
 @ensure_telemetry_enabled
 def track_e2e_test_run(
     input_test_cases: List["TestCase"],
@@ -1446,15 +1524,26 @@ def track_e2e_test_run(
     input_metadata: List["Metadata"],
 ) -> None:
     """Track an end-to-end test run."""
+    properties = {
+        "number_of_test_cases": len(input_test_cases),
+        "number_of_fixtures": len(input_fixtures),
+        "uses_fixtures": len(input_fixtures) > 0,
+        "uses_metadata": len(input_metadata) > 0,
+        "number_of_metadata": len(input_metadata),
+    }
+
+    uses_assertions, assertion_type_counts = extract_assertion_type_counts(
+        input_test_cases
+    )
+
+    properties.update({"uses_assertions": uses_assertions})
+
+    if uses_assertions:
+        properties.update(assertion_type_counts)
+
     _track(
         TELEMETRY_E2E_TEST_RUN_STARTED_EVENT,
-        {
-            "number_of_test_cases": len(input_test_cases),
-            "number_of_fixtures": len(input_fixtures),
-            "uses_fixtures": len(input_fixtures) > 0,
-            "uses_metadata": len(input_metadata) > 0,
-            "number_of_metadata": len(input_metadata),
-        },
+        properties,
     )
 
 
@@ -1523,52 +1612,6 @@ def track_intentless_policy_predict(
     )
 
 
-@ensure_telemetry_enabled
-def track_llm_intent_predict(
-    embeddings_type: Optional[str],
-    embeddings_model: Optional[str],
-    llm_type: Optional[str],
-    llm_model: Optional[str],
-) -> None:
-    """Track when a user predicts an intent using the llm intent classifier."""
-    _track(
-        TELEMETRY_LLM_INTENT_PREDICT_EVENT,
-        {
-            "embeddings_type": embeddings_type,
-            "embeddings_model": embeddings_model,
-            "llm_type": llm_type,
-            "llm_model": llm_model,
-        },
-    )
-
-
-@ensure_telemetry_enabled
-def track_llm_intent_train_completed(
-    embeddings_type: Optional[str],
-    embeddings_model: Optional[str],
-    llm_type: Optional[str],
-    llm_model: Optional[str],
-    fallback_intent: Optional[str],
-    custom_prompt_template: Optional[str],
-    number_of_examples: int,
-    number_of_available_intents: int,
-) -> None:
-    """Track when a user trains the llm intent classifier."""
-    _track(
-        TELEMETRY_LLM_INTENT_TRAIN_COMPLETED_EVENT,
-        {
-            "embeddings_type": embeddings_type,
-            "embeddings_model": embeddings_model,
-            "llm_type": llm_type,
-            "llm_model": llm_model,
-            "fallback_intent": fallback_intent,
-            "custom_prompt_template": custom_prompt_template,
-            "number_of_examples": number_of_examples,
-            "number_of_available_intents": number_of_available_intents,
-        },
-    )
-
-
 @ensure_telemetry_enabled
 def identify_endpoint_config_traits(
     endpoints_file: Optional[Text],
@@ -1735,3 +1778,15 @@ def track_conversation_count(conversation_count: int, tracked_month: datetime) -
             "month": tracked_month.month,
         },
     )
+
+
+@ensure_telemetry_enabled
+def track_e2e_test_conversion_completed(file_type: str, test_case_count: int) -> None:
+    """Track the used input file type for E2E test conversion."""
+    _track(
+        TELEMETRY_E2E_TEST_CONVERSION_EVENT,
+        {
+            E2E_TEST_CONVERSION_FILE_TYPE: file_type,
+            E2E_TEST_CONVERSION_TEST_CASE_COUNT: test_case_count,
+        },
+    )

rasa/tracing/config.py

@@ -20,7 +20,6 @@ from rasa.core.actions.custom_action_executor import (
     CustomActionExecutor,
     RetryCustomActionExecutor,
 )
-from rasa.core.actions.grpc_custom_action_executor import GRPCCustomActionExecutor
 from rasa.core.agent import Agent
 from rasa.core.processor import MessageProcessor
 from rasa.core.tracker_store import TrackerStore
@@ -45,10 +44,11 @@ from rasa.tracing.constants import (
     ENDPOINTS_ROOT_CERTIFICATES_KEY,
     ENDPOINTS_METRICS_KEY,
 )
-from rasa.tracing.instrumentation import instrumentation
 from rasa.tracing.metric_instrument_provider import MetricInstrumentProvider
 from rasa.utils.endpoints import EndpointConfig, read_endpoint_config
 
+from rasa.tracing.instrumentation import instrumentation
+
 TRACING_SERVICE_NAME = os.environ.get("TRACING_SERVICE_NAME", "rasa")
 
 logger = logging.getLogger(__name__)
@@ -107,7 +107,6 @@ def configure_tracing(tracer_provider: Optional[TracerProvider]) -> None:
         vector_store_subclasses=vector_store_subclasses,
         nlu_command_adapter_class=NLUCommandAdapter,
         endpoint_config_class=EndpointConfig,
-        grpc_custom_action_executor_class=GRPCCustomActionExecutor,
         single_step_llm_command_generator_class=SingleStepLLMCommandGenerator,
         multi_step_llm_command_generator_class=MultiStepLLMCommandGenerator,
         custom_action_executor_subclasses=custom_action_executor_subclasses,

rasa/tracing/instrumentation/attribute_extractors.py

@@ -7,6 +7,7 @@ import tiktoken
 from numpy import ndarray
 from rasa_sdk.grpc_py import action_webhook_pb2
 
+from rasa.core.actions.action import DirectCustomActionExecutor
 from rasa.core.actions.grpc_custom_action_executor import GRPCCustomActionExecutor
 from rasa.core.actions.http_custom_action_executor import HTTPCustomActionExecutor
 from rasa.core.agent import Agent
@@ -20,6 +21,13 @@ from rasa.dialogue_understanding.commands import Command
 from rasa.dialogue_understanding.stack.dialogue_stack import DialogueStack
 from rasa.engine.graph import ExecutionContext, GraphModelConfiguration, GraphNode
 from rasa.engine.training.graph_trainer import GraphTrainer
+from rasa.shared.constants import (
+    EMBEDDINGS_CONFIG_KEY,
+    MODEL_CONFIG_KEY,
+    PROVIDER_CONFIG_KEY,
+    TIMEOUT_CONFIG_KEY,
+    DEPLOYMENT_CONFIG_KEY,
+)
 from rasa.shared.core.constants import REQUESTED_SLOT
 from rasa.shared.core.domain import Domain
 from rasa.shared.core.events import DialogueStackUpdated, Event
@@ -27,7 +35,9 @@ from rasa.shared.core.flows import Flow, FlowsList, FlowStep
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.importers.importer import TrainingDataImporter
 from rasa.shared.nlu.constants import INTENT_NAME_KEY, SET_SLOT_COMMAND
-from rasa.shared.utils.llm import combine_custom_and_default_config
+from rasa.shared.utils.llm import (
+    combine_custom_and_default_config,
+)
 from rasa.tracing.constants import (
     PROMPT_TOKEN_LENGTH_ATTRIBUTE_NAME,
     REQUEST_BODY_SIZE_IN_BYTES_ATTRIBUTE_NAME,
@@ -249,10 +259,7 @@ def extract_attrs_for_graph_trainer(
     }
 
 
-def extract_headers(
-    message: UserMessage,
-    **kwargs: Any,
-) -> Any:
+def extract_headers(message: UserMessage, **kwargs: Any) -> Any:
     """Extract the headers from the `UserMessage`."""
     if message.headers:
         return message.headers
@@ -304,18 +311,15 @@ def extract_llm_config(self: Any, default_llm_config: Dict[str, Any]) -> Dict[st
 
     attributes = {
         "class_name": self.__class__.__name__,
-        "llm_model": str(config.get("model", llm_property.get("model_name"))),
-        "llm_type": str(llm_property.get("_type")),
-        "embeddings": json.dumps(config.get("embeddings", {})),
+        "llm_model": str(llm_property.get(MODEL_CONFIG_KEY)),
+        "llm_type": str(llm_property.get(PROVIDER_CONFIG_KEY)),
+        "embeddings": json.dumps(config.get(EMBEDDINGS_CONFIG_KEY, {})),
         "llm_temperature": str(llm_property.get("temperature")),
-        "request_timeout": str(llm_property.get("request_timeout")),
+        "request_timeout": str(llm_property.get(TIMEOUT_CONFIG_KEY)),
     }
 
-    if "model" in llm_property:
-        attributes["llm_model"] = str(llm_property.get("model"))
-
-    if "engine" in llm_property:
-        attributes["llm_engine"] = str(llm_property.get("engine"))
+    if DEPLOYMENT_CONFIG_KEY in llm_property:
+        attributes["llm_engine"] = str(llm_property.get(DEPLOYMENT_CONFIG_KEY))
 
     return attributes
 
@@ -643,16 +647,24 @@ def extend_attributes_with_prompt_tokens_length(
 
 
 def extract_attrs_for_custom_action_executor_run(
-    self: Union[HTTPCustomActionExecutor, GRPCCustomActionExecutor],
+    self: Union[
+        HTTPCustomActionExecutor, GRPCCustomActionExecutor, DirectCustomActionExecutor
+    ],
     tracker: DialogueStateTracker,
     domain: Domain,
     include_domain: bool = False,
 ) -> Dict[str, Any]:
+    actions_module, url = None, None
+    if hasattr(self, "action_endpoint"):
+        url = self.action_endpoint.url
+        actions_module = self.action_endpoint.actions_module
+
     attrs: Dict[str, Any] = {
         "class_name": self.__class__.__name__,
-        "action_name": self.action_name if hasattr(self, "action_name") else "None",
+        "action_name": self.action_name,
         "sender_id": tracker.sender_id,
-        "url": self.action_endpoint.url if hasattr(self, "action_endpoint") else "None",
+        "url": str(url),
+        "actions_module": str(actions_module),
     }
     return attrs
 

rasa/tracing/instrumentation/instrumentation.py

@@ -20,10 +20,10 @@ from typing import (
 
 from multidict import MultiDict
 from opentelemetry.context import Context
+
 from opentelemetry.sdk.trace import TracerProvider
 from opentelemetry.trace import SpanKind, Tracer
 from opentelemetry.trace.propagation.tracecontext import TraceContextTextMapPropagator
-
 from rasa.core.actions.action import Action, RemoteAction, CustomActionExecutor
 from rasa.core.actions.custom_action_executor import RetryCustomActionExecutor
 from rasa.core.actions.grpc_custom_action_executor import GRPCCustomActionExecutor
@@ -48,13 +48,11 @@ from rasa.dialogue_understanding.generator import (
 from rasa.dialogue_understanding.generator.nlu_command_adapter import NLUCommandAdapter
 from rasa.engine.graph import GraphNode
 from rasa.engine.training.graph_trainer import GraphTrainer
-from rasa.shared.core.domain import Domain
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.nlu.constants import SET_SLOT_COMMAND
 from rasa.shared.nlu.training_data.message import Message
 from rasa.tracing.constants import REQUEST_BODY_SIZE_IN_BYTES_ATTRIBUTE_NAME
-from rasa.tracing.instrumentation import attribute_extractors
 from rasa.tracing.instrumentation.intentless_policy_instrumentation import (
     _instrument_extract_ai_responses,
     _instrument_generate_answer,
@@ -70,6 +68,9 @@ from rasa.tracing.instrumentation.metrics import (
 )
 from rasa.utils.endpoints import concat_url, EndpointConfig
 
+from rasa.tracing.instrumentation import attribute_extractors
+
+
 # The `TypeVar` representing the return type for a function to be wrapped.
 S = TypeVar("S")
 # The `TypeVar` representing the type of the argument passed to the function to be
@@ -307,7 +308,6 @@ def instrument(
     vector_store_subclasses: Optional[List[Type[InformationRetrievalType]]] = None,
     nlu_command_adapter_class: Optional[Type[NLUCommandAdapterType]] = None,
     endpoint_config_class: Optional[Type[EndpointConfigType]] = None,
-    grpc_custom_action_executor_class: Optional[Type[GRPCCustomActionExecutor]] = None,
     single_step_llm_command_generator_class: Optional[
         Type[SingleStepLLMCommandGeneratorType]
     ] = None,
@@ -354,9 +354,6 @@ def instrument(
         `None` is given, no `NLUCommandAdapter` will be instrumented.
     :param endpoint_config_class: The `EndpointConfig` to be instrumented. If
         `None` is given, no `EndpointConfig` will be instrumented.
-    :param grpc_custom_action_executor_class: The `GRPCCustomActionExecution` to be
-        instrumented. If `None` is given, no `GRPCCustomActionExecution`
-        will be instrumented.
     :param single_step_llm_command_generator_class: The `SingleStepLLMCommandGenerator`
         to be instrumented. If `None` is given, no `SingleStepLLMCommandGenerator` will
         be instrumented.
@@ -584,14 +581,6 @@ def instrument(
             endpoint_config_class,
         )
 
-    if grpc_custom_action_executor_class is not None and not class_is_instrumented(
-        grpc_custom_action_executor_class
-    ):
-        _instrument_grpc_custom_action_executor(
-            tracer_provider.get_tracer(grpc_custom_action_executor_class.__module__),
-            grpc_custom_action_executor_class,
-        )
-
     if custom_action_executor_subclasses:
         for custom_action_executor_subclass in custom_action_executor_subclasses:
             if (
@@ -1107,38 +1096,6 @@ def _instrument_endpoint_config(
     logger.debug(f"Instrumented '{endpoint_config_class.__name__}.request'.")
 
 
-def _instrument_grpc_custom_action_executor(
-    tracer: Tracer, grpc_custom_action_executor_class: Type[GRPCCustomActionExecutor]
-) -> None:
-    """Instrument the `run` method of the `GRPCCustomActionExecutor` class.
-
-    Args:
-        tracer: The `Tracer` that shall be used for tracing.
-        grpc_custom_action_executor_class: The `GRPCCustomActionExecutor` to
-            be instrumented.
-    """
-
-    def tracing_grpc_custom_action_executor_wrapper(fn: Callable) -> Callable:
-        @functools.wraps(fn)
-        async def wrapper(
-            self: Type[GRPCCustomActionExecutor],
-            tracker: Type[DialogueStateTracker],
-            domain: Type[Domain],
-            include_domain: bool = False,
-        ) -> bool:
-            TraceContextTextMapPropagator().inject(self.action_endpoint.headers)
-            result = await fn(self, tracker, domain, include_domain)
-            return result
-
-        return wrapper
-
-    grpc_custom_action_executor_class.run = tracing_grpc_custom_action_executor_wrapper(  # type: ignore[assignment]
-        grpc_custom_action_executor_class.run
-    )
-
-    logger.debug(f"Instrumented '{grpc_custom_action_executor_class.__name__}.run.")
-
-
 def _mangled_instrumented_boolean_attribute_name(instrumented_class: Type) -> Text:
     # see https://peps.python.org/pep-0008/#method-names-and-instance-variables
     # and https://stackoverflow.com/a/50401073