rasa-pro 3.14.0.dev6__py3-none-any.whl → 3.14.0.dev8__py3-none-any.whl

rasa/dialogue_understanding/patterns/default_flows_for_patterns.yml

@@ -1,16 +1,17 @@
 version: "3.1"
 responses:
 
-  utter_ask_continue_interrupted_flow:
-    - text: "Would you like to continue with {{ context.previous_flow_name }}?"
+  utter_ask_continue_interrupted_flow_confirmation:
+    - text: "Would you like to continue with {{context.interrupted_flow_options}}?"
+      metadata:
+        rephrase: True
+        template: jinja
+
+  utter_ask_interrupted_flow_to_continue:
+    - text: "Would you like to resume {{context.interrupted_flow_options}}?"
       metadata:
         rephrase: True
         template: jinja
-      buttons:
-        - title: "Yes"
-          payload: "/SetSlots(confirmation_continue_interrupted_flow=true)"
-        - title: "No"
-          payload: "/SetSlots(confirmation_continue_interrupted_flow=false)"
 
   utter_ask_rephrase:
     - text: I’m sorry I am unable to understand you, could you please rephrase?
@@ -86,7 +87,7 @@ responses:
         rephrase: True
 
   utter_inform_hangup:
-    - text: It seems you are not there anymore. I will hang up shortly.
+    - text: I haven’t heard from you, so I’ll end our conversation shortly.
       metadata:
         rephrase: True
 
@@ -129,19 +130,14 @@ slots:
     type: float
     initial_value: 0.0
     max_value: 1000000
-  interrupted_flows:
-    type: list
-  multiple_flows_interrupted:
-    type: bool
-    initial_value: false
-  confirmation_continue_interrupted_flow:
-    type: bool
-    mappings:
-      - type: from_llm
   interrupted_flow_to_continue:
     type: text
     mappings:
       - type: from_llm
+  continue_interrupted_flow_confirmation:
+    type: bool
+    mappings:
+      - type: from_llm
 
 flows:
   pattern_cancel_flow:
@@ -228,10 +224,9 @@ flows:
     description: Conversation repair flow for managing when users switch between different flows
     name: pattern continue interrupted
     steps:
-      - action: action_set_interrupted_flows
       - noop: true
         next:
-          - if: slots.multiple_flows_interrupted
+          - if: context.multiple_flows_interrupted
             then:
               - collect: interrupted_flow_to_continue
                 description: "Fill this slot with the name of the flow the user wants to continue. If the user does not want to continue any of the interrupted flows, fill this slot with 'none'."
@@ -241,19 +236,18 @@ flows:
                       - action: action_continue_interrupted_flow
                         next: END
                   - else:
-                      - action: action_cancel_interrupted_flow
+                      - action: action_cancel_interrupted_flows
                         next: END
           - else:
-            - collect: confirmation_continue_interrupted_flow
+            - collect: continue_interrupted_flow_confirmation
               description: "If the user wants to continue the interrupted flow, fill this slot with true. If the user does not want to continue the interrupted flow, fill this slot with false."
-              utter: utter_ask_continue_interrupted_flow
               next:
-                - if: slots.confirmation_continue_interrupted_flow
+                - if: slots.continue_interrupted_flow_confirmation
                   then:
                     - action: action_continue_interrupted_flow
                       next: END
                 - else:
-                    - action: action_cancel_interrupted_flow
+                    - action: action_cancel_interrupted_flows
                       next: END
 
   pattern_correction:

rasa/dialogue_understanding/processor/command_processor.py

@@ -2,16 +2,22 @@ from typing import Dict, List, Optional, Set, Type
 
 import structlog
 
+from rasa.agents.utils import (
+    is_agent_completed,
+    is_agent_valid,
+)
 from rasa.dialogue_understanding.commands import (
     CancelFlowCommand,
     CannotHandleCommand,
     ChitChatAnswerCommand,
     ClarifyCommand,
     Command,
+    ContinueAgentCommand,
     CorrectedSlot,
     CorrectSlotsCommand,
     FreeFormAnswerCommand,
     RepeatBotMessagesCommand,
+    RestartAgentCommand,
     SetSlotCommand,
     StartFlowCommand,
 )
@@ -461,6 +467,35 @@ def clean_up_commands(
                     "drop_clarify_given_other_commands",
                     command=command,
                 )
+
+        # Keep the Restart agent commands only if the command is referencing
+        # a valid agent that was already completed
+        elif isinstance(command, RestartAgentCommand):
+            if not is_agent_valid(command.agent_id):
+                structlogger.debug(
+                    "command_processor.clean_up_commands.skip_restart_agent_invalid_agent",
+                    agent_id=command.agent_id,
+                    command=command,
+                )
+            elif not is_agent_completed(tracker, command.agent_id):
+                structlogger.debug(
+                    "command_processor.clean_up_commands.skip_restart_agent_not_completed",
+                    agent_id=command.agent_id,
+                    command=command,
+                )
+            else:
+                clean_commands.append(command)
+
+        # Clean up Continue agent commands if there is currently no active agent
+        elif isinstance(command, ContinueAgentCommand):
+            if not tracker.stack.agent_is_active():
+                structlogger.debug(
+                    "command_processor.clean_up_commands.skip_continue_agent_no_active_agent",
+                    command=command,
+                )
+            else:
+                clean_commands.append(command)
+
         else:
             clean_commands.append(command)
 

rasa/dialogue_understanding/stack/utils.py

@@ -17,6 +17,9 @@ from rasa.shared.core.flows.steps.constants import END_STEP
 from rasa.shared.core.flows.steps.continuation import ContinueFlowStep
 
 if typing.TYPE_CHECKING:
+    from rasa.dialogue_understanding.patterns.continue_interrupted import (
+        ContinueInterruptedPatternFlowStackFrame,
+    )
     from rasa.shared.core.trackers import DialogueStateTracker
 
 
@@ -171,10 +174,40 @@ def user_flows_on_the_stack(dialogue_stack: DialogueStack) -> Set[str]:
     All user flows that are currently on the stack.
     """
     return {
-        f.flow_id for f in dialogue_stack.frames if isinstance(f, UserFlowStackFrame)
+        frame.flow_id
+        for frame in user_frames_on_the_stack(
+            dialogue_stack, ignore_call_and_link_frames=False
+        )
     }
 
 
+def user_frames_on_the_stack(
+    dialogue_stack: DialogueStack, ignore_call_and_link_frames: bool = True
+) -> List[UserFlowStackFrame]:
+    """Get all user frames that are currently on the stack.
+
+    Args:
+        dialogue_stack: The dialogue stack.
+        ignore_call_and_link_frames: Whether to ignore user frames of type `call`
+            and `link`. By default, these frames are ignored.
+
+    Returns:
+    All user frames that are currently on the stack.
+    """
+    return [
+        frame
+        for frame in dialogue_stack.frames
+        if isinstance(frame, UserFlowStackFrame)
+        and (
+            not ignore_call_and_link_frames
+            or (
+                frame.frame_type != FlowStackFrameType.CALL
+                and frame.frame_type != FlowStackFrameType.LINK
+            )
+        )
+    ]
+
+
 def end_top_user_flow(stack: DialogueStack) -> DialogueStack:
     """Ends all frames on top of the stack including the topmost user frame.
 
@@ -235,13 +268,19 @@ def get_collect_steps_excluding_ask_before_filling_for_active_flow(
 
 def is_continue_interrupted_flow_active(stack: DialogueStack) -> bool:
     """Check if the continue interrupted flow is active."""
+    return get_active_continue_interrupted_pattern_frame(stack) is not None
+
+
+def get_active_continue_interrupted_pattern_frame(
+    stack: DialogueStack,
+) -> Optional["ContinueInterruptedPatternFlowStackFrame"]:
     from rasa.dialogue_understanding.patterns.continue_interrupted import (
         ContinueInterruptedPatternFlowStackFrame,
     )
 
     for frame in reversed(stack.frames):
         if isinstance(frame, ContinueInterruptedPatternFlowStackFrame):
-            return True
+            return frame
         if isinstance(frame, UserFlowStackFrame):
-            return False
-    return False
+            return None
+    return None

rasa/dialogue_understanding/utils.py

@@ -1,9 +1,9 @@
+import typing
 from contextlib import contextmanager
 from typing import Any, Dict, Generator, List, Optional, Text
 
 import structlog
 
-from rasa.dialogue_understanding.commands import Command, NoopCommand, SetSlotCommand
 from rasa.dialogue_understanding.constants import (
     RASA_RECORD_COMMANDS_AND_PROMPTS_ENV_VAR_NAME,
 )
@@ -23,6 +23,9 @@ from rasa.shared.nlu.training_data.message import Message
 from rasa.shared.providers.llm.llm_response import LLMResponse
 from rasa.utils.common import get_bool_env_variable
 
+if typing.TYPE_CHECKING:
+    from rasa.dialogue_understanding.commands import Command
+
 record_commands_and_prompts = get_bool_env_variable(
     RASA_RECORD_COMMANDS_AND_PROMPTS_ENV_VAR_NAME, False
 )
@@ -41,7 +44,7 @@ def set_record_commands_and_prompts() -> Generator:
 
 
 def add_commands_to_message_parse_data(
-    message: Message, component_name: str, commands: List[Command]
+    message: Message, component_name: str, commands: List["Command"]
 ) -> None:
     """Add commands to the message parse data.
 
@@ -144,6 +147,11 @@ def _handle_via_nlu_in_coexistence(
     tracker: Optional[DialogueStateTracker], message: Message
 ) -> bool:
     """Check if the message should be handled by the NLU subsystem in coexistence mode."""  # noqa: E501
+    from rasa.dialogue_understanding.commands import (
+        NoopCommand,
+        SetSlotCommand,
+    )
+
     if not tracker:
         return False
 
@@ -156,8 +164,7 @@ def _handle_via_nlu_in_coexistence(
             "utils.handle_via_nlu_in_coexistence"
             ".tracker_missing_route_session_to_calm_slot",
             event_info=(
-                f"Tracker doesn't have the '{ROUTE_TO_CALM_SLOT}' slot."
-                f"Routing to CALM."
+                f"Tracker doesn't have the '{ROUTE_TO_CALM_SLOT}' slot.Routing to CALM."
             ),
             route_session_to_calm=commands,
         )
@@ -218,3 +225,16 @@ def _handle_via_nlu_in_coexistence(
         commands=commands,
     )
     return False
+
+
+def assemble_options_string(names: List[str], conjunction: str = "and") -> str:
+    """Concatenate options to a human-readable string."""
+    option_message = ""
+    for i, name in enumerate(names):
+        if i == 0:
+            option_message += name
+        elif i == len(names) - 1:
+            option_message += f" {conjunction} {name}"
+        else:
+            option_message += f", {name}"
+    return option_message

rasa/engine/graph.py

@@ -69,6 +69,7 @@ class SchemaNode:
 
     def matches_type(self, node_type: Type, include_subtypes: bool = True) -> bool:
         """Checks if schema node's 'uses' is of specified node type.
+
         By default, it also checks for subtypes of the specified node type.
         """
         return (self.uses is node_type) or (
@@ -171,6 +172,7 @@ class GraphSchema:
 
     def has_node(self, node_type: Type, include_subtypes: bool = True) -> bool:
         """Checks if the graph schema contains a node of the specified node type.
+
         By default, it also checks for subtypes of the specified node type.
         """
         for node in self.nodes.values():
@@ -181,7 +183,7 @@ class GraphSchema:
     def count_nodes_of_a_given_type(
         self, node_type: Type, include_subtypes: bool = True
     ) -> int:
-        """Counts the number of the nodes of specified class"""
+        """Counts the number of the nodes of specified class."""
         counter = 0
         for node in self.nodes.values():
             if (node.uses is node_type) or (
@@ -353,6 +355,7 @@ class ExecutionContext:
 
     def has_node(self, node_type: Type, include_subtypes: bool = True) -> bool:
         """Checks if the graph node of the given type is present in the graph schema.
+
         By default, it also checks for subtypes of the specified node type.
         """
         return self.graph_schema.has_node(node_type, include_subtypes)
@@ -555,6 +558,7 @@ class GraphNode:
                 structlogger.error(
                     "graph.node.error_running_component",
                     node_name=self._node_name,
+                    error=str(e),
                 )
                 raise
 

rasa/engine/recipes/default_components.py

@@ -1,7 +1,8 @@
 from rasa.core.policies.enterprise_search_policy import EnterpriseSearchPolicy
 from rasa.core.policies.flow_policy import FlowPolicy
 from rasa.core.policies.intentless_policy import IntentlessPolicy
-from rasa.core.policies.memoization import AugmentedMemoizationPolicy
+from rasa.core.policies.memoization import AugmentedMemoizationPolicy, MemoizationPolicy
+from rasa.core.policies.rule_policy import RulePolicy
 from rasa.dialogue_understanding.coexistence.intent_based_router import (
     IntentBasedRouter,
 )
@@ -10,6 +11,7 @@ from rasa.dialogue_understanding.generator import (
     LLMCommandGenerator,
 )
 from rasa.dialogue_understanding.generator.nlu_command_adapter import NLUCommandAdapter
+from rasa.engine.graph import GraphComponent
 from rasa.nlu.classifiers.fallback_classifier import FallbackClassifier
 from rasa.nlu.classifiers.keyword_intent_classifier import KeywordIntentClassifier
 from rasa.nlu.classifiers.logistic_regression_classifier import (
@@ -17,6 +19,7 @@ from rasa.nlu.classifiers.logistic_regression_classifier import (
 )
 from rasa.nlu.classifiers.mitie_intent_classifier import MitieIntentClassifier
 from rasa.nlu.classifiers.sklearn_intent_classifier import SklearnIntentClassifier
+from rasa.nlu.extractors.crf_entity_extractor import CRFEntityExtractor
 from rasa.nlu.extractors.duckling_entity_extractor import DucklingEntityExtractor
 from rasa.nlu.extractors.entity_synonyms import EntitySynonymMapper
 from rasa.nlu.extractors.mitie_entity_extractor import MitieEntityExtractor
@@ -37,10 +40,30 @@ from rasa.nlu.tokenizers.spacy_tokenizer import SpacyTokenizer
 from rasa.nlu.tokenizers.whitespace_tokenizer import WhitespaceTokenizer
 from rasa.nlu.utils.mitie_utils import MitieNLP
 from rasa.nlu.utils.spacy_utils import SpacyNLP
+from rasa.shared.utils.common import conditional_import
+
+# Conditional imports for TensorFlow-dependent components
+TEDPolicy, TED_POLICY_AVAILABLE = conditional_import(
+    "rasa.core.policies.ted_policy", "TEDPolicy"
+)
+UnexpecTEDIntentPolicy, UNEXPECTED_INTENT_POLICY_AVAILABLE = conditional_import(
+    "rasa.core.policies.unexpected_intent_policy", "UnexpecTEDIntentPolicy"
+)
+DIETClassifier, DIET_CLASSIFIER_AVAILABLE = conditional_import(
+    "rasa.nlu.classifiers.diet_classifier", "DIETClassifier"
+)
+ConveRTFeaturizer, CONVERT_FEATURIZER_AVAILABLE = conditional_import(
+    "rasa.nlu.featurizers.dense_featurizer.convert_featurizer", "ConveRTFeaturizer"
+)
+LanguageModelFeaturizer, LANGUAGE_MODEL_FEATURIZER_AVAILABLE = conditional_import(
+    "rasa.nlu.featurizers.dense_featurizer.lm_featurizer", "LanguageModelFeaturizer"
+)
+ResponseSelector, RESPONSE_SELECTOR_AVAILABLE = conditional_import(
+    "rasa.nlu.selectors.response_selector", "ResponseSelector"
+)
 
 DEFAULT_COMPONENTS = [
     # Message Classifiers
-    # DIETClassifier,
     FallbackClassifier,
     KeywordIntentClassifier,
     MitieIntentClassifier,
@@ -51,9 +74,8 @@ DEFAULT_COMPONENTS = [
     LLMBasedRouter,
     IntentBasedRouter,
     # Response Selectors
-    # ResponseSelector,
     # Message Entity Extractors
-    # CRFEntityExtractor,
+    CRFEntityExtractor,
     DucklingEntityExtractor,
     EntitySynonymMapper,
     MitieEntityExtractor,
@@ -61,11 +83,9 @@ DEFAULT_COMPONENTS = [
     RegexEntityExtractor,
     # Message Feauturizers
     LexicalSyntacticFeaturizer,
-    # ConveRTFeaturizer,
     MitieFeaturizer,
     SpacyFeaturizer,
     CountVectorsFeaturizer,
-    # LanguageModelFeaturizer,
     RegexFeaturizer,
     # Tokenizers
     JiebaTokenizer,
@@ -76,12 +96,60 @@ DEFAULT_COMPONENTS = [
     MitieNLP,
     SpacyNLP,
     # Dialogue Management Policies
-    # TEDPolicy,
-    # UnexpecTEDIntentPolicy,
-    # RulePolicy,
-    # MemoizationPolicy,
+    RulePolicy,
+    MemoizationPolicy,
     AugmentedMemoizationPolicy,
     FlowPolicy,
     EnterpriseSearchPolicy,
     IntentlessPolicy,
 ]
+
+
+class ComponentInserter:
+    """Manages insertion of components at specific positions with index adjustment."""
+
+    def __init__(self, insertion_points: dict[str, int]):
+        self.insertion_points = insertion_points
+        self.insertion_counts = {category: 0 for category in insertion_points}
+
+    def insert_if_available(
+        self, component: GraphComponent, is_available: bool, category: str
+    ) -> None:
+        """Insert a component at the appropriate position if available."""
+        if is_available and component is not None:
+            # Calculate the adjusted index based on insertions in earlier categories
+            adjusted_index = self.insertion_points[category]
+            for cat, count in self.insertion_counts.items():
+                if self.insertion_points[cat] < self.insertion_points[category]:
+                    adjusted_index += count
+
+            DEFAULT_COMPONENTS.insert(adjusted_index, component)
+            self.insertion_counts[category] += 1
+
+
+# Define insertion points by component category to preserve order
+INSERTION_POINTS = {
+    "classifiers": 1,
+    "response_selectors": 11,
+    "featurizers": 20,
+    "policies": 35,
+}
+
+# Create inserter instance
+inserter = ComponentInserter(INSERTION_POINTS)
+
+# Conditionally add TensorFlow-dependent components
+inserter.insert_if_available(DIETClassifier, DIET_CLASSIFIER_AVAILABLE, "classifiers")
+inserter.insert_if_available(
+    ResponseSelector, RESPONSE_SELECTOR_AVAILABLE, "response_selectors"
+)
+inserter.insert_if_available(
+    ConveRTFeaturizer, CONVERT_FEATURIZER_AVAILABLE, "featurizers"
+)
+inserter.insert_if_available(
+    LanguageModelFeaturizer, LANGUAGE_MODEL_FEATURIZER_AVAILABLE, "featurizers"
+)
+inserter.insert_if_available(TEDPolicy, TED_POLICY_AVAILABLE, "policies")
+inserter.insert_if_available(
+    UnexpecTEDIntentPolicy, UNEXPECTED_INTENT_POLICY_AVAILABLE, "policies"
+)

rasa/engine/recipes/default_recipe.py

@@ -5,6 +5,7 @@ import dataclasses
 import enum
 import logging
 import math
+import sys
 from enum import Enum
 from typing import Any, Callable, Dict, List, Optional, Set, Text, Tuple, Type, Union
 
@@ -180,7 +181,14 @@ class DefaultV1Recipe(Recipe):
     @classmethod
     def _from_registry(cls, name: Text) -> RegisteredComponent:
         # Importing all the default Rasa components will automatically register them
-        from rasa.engine.recipes.default_components import DEFAULT_COMPONENTS  # noqa
+        from rasa.engine.recipes.default_components import (
+            CONVERT_FEATURIZER_AVAILABLE,
+            DIET_CLASSIFIER_AVAILABLE,
+            LANGUAGE_MODEL_FEATURIZER_AVAILABLE,
+            RESPONSE_SELECTOR_AVAILABLE,
+            TED_POLICY_AVAILABLE,
+            UNEXPECTED_INTENT_POLICY_AVAILABLE,
+        )
 
         if name in cls._registered_components:
             return cls._registered_components[name]
@@ -190,6 +198,38 @@ class DefaultV1Recipe(Recipe):
             if clazz.__name__ in cls._registered_components:
                 return cls._registered_components[clazz.__name__]
 
+        # Check Python version compatibility for TensorFlow components
+        # TensorFlow support was removed for Python 3.12+ due to compatibility issues
+        if sys.version_info >= (3, 12):
+            raise InvalidConfigException(
+                f"{name} is not available on Python 3.12+. "
+                "TensorFlow support has been removed for Python 3.12+ versions. "
+                "Please use Python 3.11 or earlier for TensorFlow-based components. "
+            )
+
+        # Check for TensorFlow components that failed to load
+        # because conditional module import of those components did not succeed
+        tensorflow_component_availability = {
+            "DIETClassifier": DIET_CLASSIFIER_AVAILABLE,
+            "TEDPolicy": TED_POLICY_AVAILABLE,
+            "UnexpecTEDIntentPolicy": UNEXPECTED_INTENT_POLICY_AVAILABLE,
+            "ResponseSelector": RESPONSE_SELECTOR_AVAILABLE,
+            "ConveRTFeaturizer": CONVERT_FEATURIZER_AVAILABLE,
+            "LanguageModelFeaturizer": LANGUAGE_MODEL_FEATURIZER_AVAILABLE,
+        }
+
+        if name in tensorflow_component_availability:
+            # TensorFlow-dependent component failed to load
+            # if TensorFlow is not available
+            if not tensorflow_component_availability[name]:
+                raise InvalidConfigException(
+                    f"{name} requires TensorFlow. "
+                    "Please install it with: "
+                    "`pip install rasa[tensorflow]`. "
+                    "If using poetry, install it with "
+                    "`poetry install --extras tensorflow`."
+                )
+
         raise InvalidConfigException(
             f"Can't load class for name '{name}'. Please make sure to provide "
             f"a valid name or module path and to register it using the "

rasa/engine/storage/local_model_storage.py

@@ -1,14 +1,16 @@
 from __future__ import annotations
 
 import logging
+import os
 import shutil
 import sys
+import tarfile
 import tempfile
 import uuid
 from contextlib import contextmanager
 from datetime import datetime
 from pathlib import Path
-from typing import Generator, Optional, Text, Tuple, Union
+from typing import Callable, Generator, List, Optional, Text, Tuple, Union
 
 from tarsafe import TarSafe
 
@@ -57,6 +59,35 @@ def windows_safe_temporary_directory(
             yield temporary_directory
 
 
+def filter_normpath(member: tarfile.TarInfo, dest_path: str) -> tarfile.TarInfo:
+    """Normalize tar member paths for safe extraction"""
+    if member.name:
+        member.name = os.path.normpath(member.name)
+    return member
+
+
+FilterFunction = Callable[[tarfile.TarInfo, str], Optional[tarfile.TarInfo]]
+
+
+def create_combined_filter(existing_filter: Optional[FilterFunction]) -> FilterFunction:
+    """Create a filter that combines existing filter with path normalization"""
+
+    def combined_filter(
+        member: tarfile.TarInfo, dest_path: str
+    ) -> Optional[tarfile.TarInfo]:
+        """Apply existing filter first, then path normalization"""
+        if existing_filter is not None:
+            filtered_member = existing_filter(member, dest_path)
+            if filtered_member is None:
+                return None  # Rejected by existing filter
+            member = filtered_member  # Use the filtered result
+
+        # Apply our path normalization
+        return filter_normpath(member, dest_path)
+
+    return combined_filter
+
+
 class LocalModelStorage(ModelStorage):
     """Stores and provides output of `GraphComponents` on local disk."""
 
@@ -122,9 +153,29 @@ class LocalModelStorage(ModelStorage):
                 # this restriction in environments where it's not possible
                 # to override this behavior, mostly for internal policy reasons
                 # reference: https://stackoverflow.com/a/49102229
-                tar.extractall(f"\\\\?\\{temporary_directory}")
+                try:
+                    # Use extraction filter to normalize paths for compatibility
+                    # before trying the \\?\ prefix approach first
+                    prev_filter = getattr(tar, "extraction_filter", None)
+                    tar.extraction_filter = create_combined_filter(prev_filter)
+                    tar.extractall(
+                        f"\\\\?\\{temporary_directory}",
+                        members=yield_safe_members(tar.getmembers()),
+                    )
+                except Exception:
+                    # Fallback for Python versions with tarfile security fix
+                    logger.warning(
+                        "Failed to extract model archive with long path support. "
+                        "Falling back to regular extraction."
+                    )
+                    tar.extractall(
+                        temporary_directory,
+                        members=yield_safe_members(tar.getmembers()),
+                    )
             else:
-                tar.extractall(temporary_directory)
+                tar.extractall(
+                    temporary_directory, members=yield_safe_members(tar.getmembers())
+                )
         LocalModelStorage._assert_not_rasa2_archive(temporary_directory)
 
     @staticmethod
@@ -244,3 +295,32 @@ class LocalModelStorage(ModelStorage):
             core_target=model_configuration.core_target,
             nlu_target=model_configuration.nlu_target,
         )
+
+
+def yield_safe_members(
+    members: List[tarfile.TarInfo],
+) -> Generator[tarfile.TarInfo, None, None]:
+    """
+    Filter function for tar.extractall members parameter.
+    Validates each member and yields only safe ones.
+
+    Args:
+        members: Iterator of TarInfo objects from tar.getmembers()
+
+    Yields:
+        TarInfo: Safe members to extract
+    """
+    for member in members:
+        # Skip absolute paths
+        if Path(member.name).is_absolute():
+            continue
+
+        # Skip paths with directory traversal sequences
+        if ".." in member.name or "\\.." in member.name:
+            continue
+
+        # Skip special file types unless you need them
+        if member.isdev() or member.issym():
+            continue
+
+        yield member