rasa-pro 3.13.0.dev20250612__py3-none-any.whl → 3.13.0.dev20250613__py3-none-any.whl

rasa/core/http_interpreter.py

@@ -1,4 +1,3 @@
-import copy
 import logging
 from typing import Any, Dict, Optional, Text
 
@@ -49,7 +48,6 @@ class RasaNLUHttpInterpreter:
         if not self.endpoint_config or self.endpoint_config.url is None:
             structlogger.error(
                 "http.parse.text",
-                text=copy.deepcopy(text),
                 event_info="No rasa NLU server specified!",
             )
             return None
@@ -71,18 +69,16 @@ class RasaNLUHttpInterpreter:
                 if resp.status == 200:
                     return await resp.json()
                 else:
-                    response_text = await resp.text()
                     structlogger.error(
                         "http.parse.text.failure",
-                        text=copy.deepcopy(text),
-                        response_text=copy.deepcopy(response_text),
+                        event_info="Failed to parse text",
                     )
                     return None
-        except Exception:  # skipcq: PYL-W0703
+        except Exception as e:  # skipcq: PYL-W0703
             # need to catch all possible exceptions when doing http requests
             # (timeouts, value errors, parser errors, ...)
             structlogger.exception(
                 "http.parse.text.exception",
-                text=copy.deepcopy(text),
+                event_info=f"Exception occurred while parsing text. Error: {e}",
             )
             return None

rasa/core/jobs.py

@@ -1,12 +1,13 @@
 import asyncio
 import logging
+from typing import Optional
 
 from apscheduler.schedulers.asyncio import AsyncIOScheduler
 from pytz import UnknownTimeZoneError, utc
 
 import rasa.shared.utils.io
 
-__scheduler = None
+__scheduler: Optional[AsyncIOScheduler] = None
 
 logger = logging.getLogger(__name__)
 

rasa/core/nlg/contextual_response_rephraser.py

@@ -5,15 +5,20 @@ from jinja2 import Template
 
 from rasa import telemetry
 from rasa.core.nlg.response import TemplatedNaturalLanguageGenerator
-from rasa.core.nlg.summarize import summarize_conversation
+from rasa.core.nlg.summarize import (
+    _count_multiple_utterances_as_single_turn,
+    summarize_conversation,
+)
 from rasa.shared.constants import (
     LLM_CONFIG_KEY,
+    MAX_COMPLETION_TOKENS_CONFIG_KEY,
     MODEL_CONFIG_KEY,
     MODEL_GROUP_ID_CONFIG_KEY,
     MODEL_NAME_CONFIG_KEY,
     OPENAI_PROVIDER,
     PROMPT_CONFIG_KEY,
     PROVIDER_CONFIG_KEY,
+    TEMPERATURE_CONFIG_KEY,
     TIMEOUT_CONFIG_KEY,
 )
 from rasa.shared.core.domain import KEY_RESPONSES_TEXT, Domain
@@ -53,12 +58,13 @@ RESPONSE_SUMMARISE_CONVERSATION_KEY = "summarize_conversation"
 DEFAULT_REPHRASE_ALL = False
 DEFAULT_SUMMARIZE_HISTORY = True
 DEFAULT_MAX_HISTORICAL_TURNS = 5
+DEFAULT_COUNT_MULTIPLE_UTTERANCES_AS_SINGLE_TURN = True
 
 DEFAULT_LLM_CONFIG = {
     PROVIDER_CONFIG_KEY: OPENAI_PROVIDER,
     MODEL_CONFIG_KEY: DEFAULT_OPENAI_GENERATE_MODEL_NAME,
-    "temperature": 0.3,
-    "max_tokens": DEFAULT_OPENAI_MAX_GENERATED_TOKENS,
+    TEMPERATURE_CONFIG_KEY: 0.3,
+    MAX_COMPLETION_TOKENS_CONFIG_KEY: DEFAULT_OPENAI_MAX_GENERATED_TOKENS,
     TIMEOUT_CONFIG_KEY: 5,
 }
 
@@ -70,6 +76,7 @@ its meaning. Use simple {{language}}.
 Context / previous conversation with the user:
 {{history}}
 
+Last user message:
 {{current_input}}
 
 Suggested AI Response: {{suggested_response}}
@@ -122,6 +129,11 @@ class ContextualResponseRephraser(
             "max_historical_turns", DEFAULT_MAX_HISTORICAL_TURNS
         )
 
+        self.count_multiple_utterances_as_single_turn = self.nlg_endpoint.kwargs.get(
+            "count_multiple_utterances_as_single_turn",
+            DEFAULT_COUNT_MULTIPLE_UTTERANCES_AS_SINGLE_TURN,
+        )
+
         self.llm_config = resolve_model_client_config(
             self.nlg_endpoint.kwargs.get(LLM_CONFIG_KEY),
             ContextualResponseRephraser.__name__,
@@ -258,8 +270,16 @@ class ContextualResponseRephraser(
         Returns:
         The history for the prompt.
         """
+        # Count multiple utterances by bot/user as single turn in conversation history
+        turns_wrapper = (
+            _count_multiple_utterances_as_single_turn
+            if self.count_multiple_utterances_as_single_turn
+            else None
+        )
         llm = llm_factory(self.llm_config, DEFAULT_LLM_CONFIG)
-        return await summarize_conversation(tracker, llm, max_turns=5)
+        return await summarize_conversation(
+            tracker, llm, max_turns=5, turns_wrapper=turns_wrapper
+        )
 
     async def rephrase(
         self,
@@ -281,19 +301,26 @@ class ContextualResponseRephraser(
 
         prompt_template_text = self._template_for_response_rephrasing(response)
 
-        # Retrieve inputs for the dynamic prompt
-        latest_message = self._last_message_if_human(tracker)
-        current_input = f"{USER}: {latest_message}" if latest_message else ""
+        # Last user message (=current input) should always be in prompt if available
+        last_message_by_user = getattr(tracker.latest_message, "text", "")
+        current_input = (
+            f"{USER}: {last_message_by_user}" if last_message_by_user else ""
+        )
 
         # Only summarise conversation history if flagged
         if self.summarize_history:
             history = await self._create_history(tracker)
         else:
-            # make sure the transcript/history contains the last user utterance
+            # Count multiple utterances by bot/user as single turn
+            turns_wrapper = (
+                _count_multiple_utterances_as_single_turn
+                if self.count_multiple_utterances_as_single_turn
+                else None
+            )
             max_turns = max(self.max_historical_turns, 1)
-            history = tracker_as_readable_transcript(tracker, max_turns=max_turns)
-            # the history already contains the current input
-            current_input = ""
+            history = tracker_as_readable_transcript(
+                tracker, max_turns=max_turns, turns_wrapper=turns_wrapper
+            )
 
         prompt = Template(prompt_template_text).render(
             history=history,

rasa/core/nlg/generator.py

@@ -292,7 +292,6 @@ def _evaluate_predicate(constraint: str, filled_slots: Dict[Text, Any]) -> bool:
         structlogger.error(
             "rasa.core.nlg.generator.evaluate_conditional_response_predicate.error",
             predicate=constraint,
-            document=document,
             error=str(e),
         )
         return False

rasa/core/nlg/interpolator.py

@@ -1,4 +1,3 @@
-import copy
 import logging
 import re
 from typing import Any, Dict, List, Text, Union
@@ -70,9 +69,9 @@ def interpolate_format_template(response: Text, values: Dict[Text, Text]) -> Tex
         )
         structlogger.exception(
             "interpolator.interpolate.text",
-            response=copy.deepcopy(response),
             placeholder_key=e.args[0],
             event_info=event_info,
+            error=str(e),
         )
         return response
 
@@ -98,9 +97,9 @@ def interpolate_jinja_template(response: Text, values: Dict[Text, Any]) -> Text:
         )
         structlogger.exception(
             "interpolator.interpolate.text",
-            response=copy.deepcopy(response),
             placeholder_key=e.args[0],
             event_info=event_info,
+            error=str(e),
         )
         return response
 

rasa/core/nlg/summarize.py

@@ -1,4 +1,5 @@
-from typing import Optional
+from itertools import groupby
+from typing import Callable, List, Optional
 
 import structlog
 from jinja2 import Template
@@ -23,20 +24,49 @@ SUMMARY_PROMPT_TEMPLATE = Template(_DEFAULT_SUMMARIZER_TEMPLATE)
 MAX_TURNS_DEFAULT = 20
 
 
+def _count_multiple_utterances_as_single_turn(transcript: List[str]) -> List[str]:
+    """Counts multiple utterances as a single turn.
+
+    Args:
+        transcript: the lines of the transcript
+
+    Returns:
+        transcript: with multiple utterances counted as a single turn
+    """
+    if not transcript:
+        return []
+
+    def get_speaker_label(line: str) -> str:
+        return line.partition(": ")[0] if ": " in line else ""
+
+    modified_transcript = [
+        f"{speaker}: {' '.join(line.partition(': ')[2] for line in group)}"
+        for speaker, group in groupby(transcript, key=get_speaker_label)
+        if speaker
+    ]
+
+    return modified_transcript
+
+
 def _create_summarization_prompt(
-    tracker: DialogueStateTracker, max_turns: Optional[int]
+    tracker: DialogueStateTracker,
+    max_turns: Optional[int],
+    turns_wrapper: Optional[Callable[[List[str]], List[str]]],
 ) -> str:
     """Creates an LLM prompt to summarize the conversation in the tracker.
 
     Args:
         tracker: tracker of the conversation to be summarized
         max_turns: maximum number of turns to summarize
+        turns_wrapper: optional function to wrap the turns
 
 
     Returns:
         The prompt to summarize the conversation.
     """
-    transcript = tracker_as_readable_transcript(tracker, max_turns=max_turns)
+    transcript = tracker_as_readable_transcript(
+        tracker, max_turns=max_turns, turns_wrapper=turns_wrapper
+    )
     return SUMMARY_PROMPT_TEMPLATE.render(
         conversation=transcript,
     )
@@ -46,6 +76,7 @@ async def summarize_conversation(
     tracker: DialogueStateTracker,
     llm: LLMClient,
     max_turns: Optional[int] = MAX_TURNS_DEFAULT,
+    turns_wrapper: Optional[Callable[[List[str]], List[str]]] = None,
 ) -> str:
     """Summarizes the dialogue using the LLM.
 
@@ -53,11 +84,12 @@ async def summarize_conversation(
         tracker: the tracker to summarize
         llm: the LLM to use for summarization
         max_turns: maximum number of turns to summarize
+        turns_wrapper: optional function to wrap the turns
 
     Returns:
         The summary of the dialogue.
     """
-    prompt = _create_summarization_prompt(tracker, max_turns)
+    prompt = _create_summarization_prompt(tracker, max_turns, turns_wrapper)
     try:
         llm_response = await llm.acompletion(prompt)
         summarization = llm_response.choices[0].strip()
@@ -66,6 +98,8 @@ async def summarize_conversation(
         )
         return summarization
     except Exception as e:
-        transcript = tracker_as_readable_transcript(tracker, max_turns=max_turns)
+        transcript = tracker_as_readable_transcript(
+            tracker, max_turns=max_turns, turns_wrapper=turns_wrapper
+        )
         structlogger.error("summarization.error", error=e)
         return transcript