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

rasa/core/utils.py

@@ -1,23 +1,31 @@
-import json
 import logging
 import os
-from decimal import Decimal
 from pathlib import Path
-from typing import Any, Dict, Optional, Set, Text, Tuple, Union
+from socket import SOCK_DGRAM, SOCK_STREAM
+from typing import Any, Dict, Optional, Set, TYPE_CHECKING, Text, Tuple, Union
 
 import numpy as np
+from sanic import Sanic
 
+import rasa.cli.utils as cli_utils
 import rasa.shared.utils.io
 from rasa.constants import DEFAULT_SANIC_WORKERS, ENV_SANIC_WORKERS
-from rasa.shared.constants import DEFAULT_ENDPOINTS_PATH, TCP_PROTOCOL
-
+from rasa.core.constants import (
+    DOMAIN_GROUND_TRUTH_METADATA_KEY,
+    UTTER_SOURCE_METADATA_KEY,
+    ACTIVE_FLOW_METADATA_KEY,
+    STEP_ID_METADATA_KEY,
+)
 from rasa.core.lock_store import LockStore, RedisLockStore, InMemoryLockStore
+from rasa.shared.constants import DEFAULT_ENDPOINTS_PATH, TCP_PROTOCOL
+from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.utils.endpoints import EndpointConfig, read_endpoint_config
-from sanic import Sanic
-from socket import SOCK_DGRAM, SOCK_STREAM
-import rasa.cli.utils as cli_utils
 from rasa.utils.io import write_yaml
 
+if TYPE_CHECKING:
+    from rasa.core.nlg import NaturalLanguageGenerator
+    from rasa.shared.core.domain import Domain
+
 logger = logging.getLogger(__name__)
 
 
@@ -163,6 +171,8 @@ def is_limit_reached(num_messages: int, limit: Optional[int]) -> bool:
 class AvailableEndpoints:
     """Collection of configured endpoints."""
 
+    _instance = None
+
     @classmethod
     def read_endpoints(cls, endpoint_file: Text) -> "AvailableEndpoints":
         """Read the different endpoints from a yaml file."""
@@ -209,6 +219,14 @@ class AvailableEndpoints:
         self.event_broker = event_broker
         self.vector_store = vector_store
 
+    @classmethod
+    def get_instance(cls, endpoint_file: Optional[Text] = None) -> "AvailableEndpoints":
+        """Get the singleton instance of AvailableEndpoints."""
+        # Ensure that the instance is initialized only once.
+        if cls._instance is None:
+            cls._instance = cls.read_endpoints(endpoint_file)
+        return cls._instance
+
 
 def read_endpoints_from_path(
     endpoints_path: Optional[Union[Path, Text]] = None,
@@ -226,55 +244,7 @@ def read_endpoints_from_path(
     endpoints_config_path = cli_utils.get_validated_path(
         endpoints_path, "endpoints", DEFAULT_ENDPOINTS_PATH, True
     )
-    return AvailableEndpoints.read_endpoints(endpoints_config_path)
-
-
-def replace_floats_with_decimals(obj: Any, round_digits: int = 9) -> Any:
-    """Convert all instances in `obj` of `float` to `Decimal`.
-
-    Args:
-        obj: Input object.
-        round_digits: Rounding precision of `Decimal` values.
-
-    Returns:
-        Input `obj` with all `float` types replaced by `Decimal`s rounded to
-        `round_digits` decimal places.
-    """
-
-    def _float_to_rounded_decimal(s: Text) -> Decimal:
-        return Decimal(s).quantize(Decimal(10) ** -round_digits)
-
-    return json.loads(json.dumps(obj), parse_float=_float_to_rounded_decimal)
-
-
-class DecimalEncoder(json.JSONEncoder):
-    """`json.JSONEncoder` that dumps `Decimal`s as `float`s."""
-
-    def default(self, obj: Any) -> Any:
-        """Get serializable object for `o`.
-
-        Args:
-            obj: Object to serialize.
-
-        Returns:
-            `obj` converted to `float` if `o` is a `Decimals`, else the base class
-            `default()` method.
-        """
-        if isinstance(obj, Decimal):
-            return float(obj)
-        return super().default(obj)
-
-
-def replace_decimals_with_floats(obj: Any) -> Any:
-    """Convert all instances in `obj` of `Decimal` to `float`.
-
-    Args:
-        obj: A `List` or `Dict` object.
-
-    Returns:
-        Input `obj` with all `Decimal` types replaced by `float`s.
-    """
-    return json.loads(json.dumps(obj, cls=DecimalEncoder))
+    return AvailableEndpoints.get_instance(endpoints_config_path)
 
 
 def _lock_store_is_multi_worker_compatible(
@@ -337,3 +307,32 @@ def number_of_sanic_workers(lock_store: Union[EndpointConfig, LockStore, None])
         f"configuration has been found."
     )
     return _log_and_get_default_number_of_workers()
+
+
+def add_bot_utterance_metadata(
+    message: Dict[str, Any],
+    domain_response_name: str,
+    nlg: "NaturalLanguageGenerator",
+    domain: "Domain",
+    tracker: Optional[DialogueStateTracker],
+) -> Dict[str, Any]:
+    """Add metadata to the bot message."""
+    message["utter_action"] = domain_response_name
+
+    utter_source = message.get(UTTER_SOURCE_METADATA_KEY)
+    if utter_source is None:
+        utter_source = nlg.__class__.__name__
+        message[UTTER_SOURCE_METADATA_KEY] = utter_source
+
+    if tracker:
+        message[ACTIVE_FLOW_METADATA_KEY] = tracker.active_flow
+        message[STEP_ID_METADATA_KEY] = tracker.current_step_id
+
+    if utter_source in ["IntentlessPolicy", "ContextualResponseRephraser"]:
+        message[DOMAIN_GROUND_TRUTH_METADATA_KEY] = [
+            response.get("text")
+            for response in domain.responses.get(domain_response_name, [])
+            if response.get("text") is not None
+        ]
+
+    return message

rasa/dialogue_understanding/coexistence/llm_based_router.py

@@ -1,10 +1,12 @@
 from __future__ import annotations
+
 import importlib
 from typing import Any, Dict, List, Optional
 
 import structlog
 from jinja2 import Template
 
+import rasa.shared.utils.io
 from rasa.dialogue_understanding.coexistence.constants import (
     CALM_ENTRY,
     NLU_ENTRY,
@@ -18,25 +20,32 @@ from rasa.engine.graph import ExecutionContext, GraphComponent
 from rasa.engine.recipes.default_recipe import DefaultV1Recipe
 from rasa.engine.storage.resource import Resource
 from rasa.engine.storage.storage import ModelStorage
-from rasa.shared.constants import ROUTE_TO_CALM_SLOT
+from rasa.shared.constants import (
+    ROUTE_TO_CALM_SLOT,
+    PROMPT_CONFIG_KEY,
+    PROVIDER_CONFIG_KEY,
+    MODEL_CONFIG_KEY,
+    OPENAI_PROVIDER,
+    TIMEOUT_CONFIG_KEY,
+)
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.exceptions import InvalidConfigException, FileIOException
 from rasa.shared.nlu.constants import COMMANDS, TEXT
 from rasa.shared.nlu.training_data.message import Message
 from rasa.shared.nlu.training_data.training_data import TrainingData
-import rasa.shared.utils.io
 from rasa.shared.utils.llm import (
     DEFAULT_OPENAI_CHAT_MODEL_NAME,
     get_prompt_template,
     llm_factory,
+    try_instantiate_llm_client,
 )
+from rasa.utils.log_utils import log_llm
 
 LLM_BASED_ROUTER_PROMPT_FILE_NAME = "llm_based_router_prompt.jinja2"
 DEFAULT_COMMAND_PROMPT_TEMPLATE = importlib.resources.read_text(
     "rasa.dialogue_understanding.coexistence", "router_template.jinja2"
 )
 
-
 # Token ids for gpt 3.5 and gpt 4 corresponding to space + capitalized Letter
 A_TO_C_TOKEN_IDS_CHATGPT = [
     362,  # " A"
@@ -45,10 +54,10 @@ A_TO_C_TOKEN_IDS_CHATGPT = [
 ]
 
 DEFAULT_LLM_CONFIG = {
-    "_type": "openai",
-    "request_timeout": 7,
+    PROVIDER_CONFIG_KEY: OPENAI_PROVIDER,
+    MODEL_CONFIG_KEY: DEFAULT_OPENAI_CHAT_MODEL_NAME,
+    TIMEOUT_CONFIG_KEY: 7,
     "temperature": 0.0,
-    "model_name": DEFAULT_OPENAI_CHAT_MODEL_NAME,
     "max_tokens": 1,
     "logit_bias": {str(token_id): 100 for token_id in A_TO_C_TOKEN_IDS_CHATGPT},
 }
@@ -67,7 +76,7 @@ class LLMBasedRouter(GraphComponent):
     def get_default_config() -> Dict[str, Any]:
         """The component's default config (see parent class for full docstring)."""
         return {
-            "prompt": None,
+            PROMPT_CONFIG_KEY: None,
             CALM_ENTRY: {STICKY: None},
             NLU_ENTRY: {
                 NON_STICKY: "handles chitchat",
@@ -88,7 +97,7 @@ class LLMBasedRouter(GraphComponent):
         self.prompt_template = (
             prompt_template
             or get_prompt_template(
-                config.get("prompt"),
+                config.get(PROMPT_CONFIG_KEY),
                 DEFAULT_COMMAND_PROMPT_TEMPLATE,
             ).strip()
         )
@@ -120,6 +129,14 @@ class LLMBasedRouter(GraphComponent):
 
     def train(self, training_data: TrainingData) -> Resource:
         """Train the intent classifier on a data set."""
+        # Validate llm configuration
+        try_instantiate_llm_client(
+            self.config.get(LLM_CONFIG_KEY),
+            DEFAULT_LLM_CONFIG,
+            "llm_based_router.train",
+            "LLMBasedRouter",
+        )
+
         self.persist()
         return self._resource
 
@@ -144,7 +161,14 @@ class LLMBasedRouter(GraphComponent):
                 "llm_based_router.load.failed", error=e, resource=resource.name
             )
 
-        return cls(config, model_storage, resource, prompt_template=prompt_template)
+        router = cls(config, model_storage, resource, prompt_template=prompt_template)
+        try_instantiate_llm_client(
+            router.config.get(LLM_CONFIG_KEY),
+            DEFAULT_LLM_CONFIG,
+            "llm_based_router.load",
+            LLMBasedRouter.__name__,
+        )
+        return router
 
     @classmethod
     def create(
@@ -188,12 +212,27 @@ class LLMBasedRouter(GraphComponent):
         route_session_to_calm = tracker.get_slot(ROUTE_TO_CALM_SLOT)
         if route_session_to_calm is None:
             prompt = self.render_template(message)
-            structlogger.info("llm_based_router.prompt_rendered", prompt=prompt)
+            log_llm(
+                logger=structlogger,
+                log_module="LLMBasedRouter",
+                log_event="llm_based_router.prompt_rendered",
+                prompt=prompt,
+            )
             # generating answer
             answer = await self._generate_answer_using_llm(prompt)
-            structlogger.info("llm_based_router.llm_answer", answer=answer)
+            log_llm(
+                logger=structlogger,
+                log_module="LLMBasedRouter",
+                log_event="llm_based_router.llm_answer",
+                answer=answer,
+            )
             commands = self.parse_answer(answer)
-            structlogger.info("llm_based_router.predicated_commands", commands=commands)
+            log_llm(
+                logger=structlogger,
+                log_module="LLMBasedRouter",
+                log_event="llm_based_router.final_commands",
+                commands=commands,
+            )
             return commands
         elif route_session_to_calm is True:
             # don't set any commands so that a `LLMBasedCommandGenerator` is triggered
@@ -252,7 +291,8 @@ class LLMBasedRouter(GraphComponent):
         llm = llm_factory(self.config.get(LLM_CONFIG_KEY), DEFAULT_LLM_CONFIG)
 
         try:
-            return await llm.apredict(prompt)
+            llm_response = await llm.acompletion(prompt)
+            return llm_response.choices[0]
         except Exception as e:
             # unfortunately, langchain does not wrap LLM exceptions which means
             # we have to catch all exceptions here

rasa/dialogue_understanding/commands/__init__.py

@@ -9,6 +9,7 @@ from rasa.dialogue_understanding.commands.knowledge_answer_command import (
 from rasa.dialogue_understanding.commands.chit_chat_answer_command import (
     ChitChatAnswerCommand,
 )
+from rasa.dialogue_understanding.commands.restart_command import RestartCommand
 from rasa.dialogue_understanding.commands.skip_question_command import (
     SkipQuestionCommand,
 )
@@ -28,6 +29,9 @@ from rasa.dialogue_understanding.commands.correct_slots_command import (
 )
 from rasa.dialogue_understanding.commands.noop_command import NoopCommand
 from rasa.dialogue_understanding.commands.change_flow_command import ChangeFlowCommand
+from rasa.dialogue_understanding.commands.session_start_command import (
+    SessionStartCommand,
+)
 
 __all__ = [
     "Command",
@@ -46,4 +50,6 @@ __all__ = [
     "ErrorCommand",
     "NoopCommand",
     "ChangeFlowCommand",
+    "SessionStartCommand",
+    "RestartCommand",
 ]

rasa/dialogue_understanding/commands/restart_command.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, List
+
+from rasa.dialogue_understanding.commands import Command
+from rasa.dialogue_understanding.patterns.restart import RestartPatternFlowStackFrame
+from rasa.shared.core.events import Event
+from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.trackers import DialogueStateTracker
+
+
+@dataclass
+class RestartCommand(Command):
+    """A command to restart a session."""
+
+    @classmethod
+    def command(cls) -> str:
+        """Returns the command type."""
+        return "restart"
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> RestartCommand:
+        """Converts the dictionary to a command.
+
+        Returns:
+            The converted dictionary.
+        """
+        return RestartCommand()
+
+    def run_command_on_tracker(
+        self,
+        tracker: DialogueStateTracker,
+        all_flows: FlowsList,
+        original_tracker: DialogueStateTracker,
+    ) -> List[Event]:
+        """Runs the command on the tracker.
+
+        Args:
+            tracker: The tracker to run the command on.
+            all_flows: All flows in the assistant.
+            original_tracker: The tracker before any command was executed.
+
+        Returns:
+            The events to apply to the tracker.
+        """
+        stack = tracker.stack
+        stack.push(RestartPatternFlowStackFrame())
+        return tracker.create_stack_updated_events(stack)
+
+    def __hash__(self) -> int:
+        return hash(self.command())
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, RestartCommand):
+            return False
+
+        return True

rasa/dialogue_understanding/commands/session_start_command.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, List
+from rasa.dialogue_understanding.commands import Command
+from rasa.dialogue_understanding.patterns.session_start import (
+    SessionStartPatternFlowStackFrame,
+)
+from rasa.shared.core.events import Event
+from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.trackers import DialogueStateTracker
+
+
+@dataclass
+class SessionStartCommand(Command):
+    """A command to indicate the start of a session."""
+
+    @classmethod
+    def command(cls) -> str:
+        """Returns the command type."""
+        return "session start"
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> SessionStartCommand:
+        """Converts the dictionary to a command.
+
+        Returns:
+            The converted dictionary.
+        """
+        return SessionStartCommand()
+
+    def run_command_on_tracker(
+        self,
+        tracker: DialogueStateTracker,
+        all_flows: FlowsList,
+        original_tracker: DialogueStateTracker,
+    ) -> List[Event]:
+        """Runs the command on the tracker.
+
+        Args:
+            tracker: The tracker to run the command on.
+            all_flows: All flows in the assistant.
+            original_tracker: The tracker before any command was executed.
+
+        Returns:
+            The events to apply to the tracker.
+        """
+        stack = tracker.stack
+        stack.push(SessionStartPatternFlowStackFrame())
+        return tracker.create_stack_updated_events(stack)
+
+    def __hash__(self) -> int:
+        return hash(self.command())
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, SessionStartCommand):
+            return False
+
+        return True

rasa/dialogue_understanding/commands/utils.py

@@ -0,0 +1,40 @@
+from typing import Dict, Type
+
+from rasa.dialogue_understanding.commands import (
+    CancelFlowCommand,
+    CannotHandleCommand,
+    ChitChatAnswerCommand,
+    Command,
+    HumanHandoffCommand,
+    KnowledgeAnswerCommand,
+    SessionStartCommand,
+    SkipQuestionCommand,
+    RestartCommand,
+)
+from rasa.dialogue_understanding.patterns.cancel import CancelPatternFlowStackFrame
+from rasa.dialogue_understanding.patterns.cannot_handle import (
+    CannotHandlePatternFlowStackFrame,
+)
+from rasa.dialogue_understanding.patterns.chitchat import ChitchatPatternFlowStackFrame
+from rasa.dialogue_understanding.patterns.human_handoff import (
+    HumanHandoffPatternFlowStackFrame,
+)
+from rasa.dialogue_understanding.patterns.restart import RestartPatternFlowStackFrame
+from rasa.dialogue_understanding.patterns.search import SearchPatternFlowStackFrame
+from rasa.dialogue_understanding.patterns.session_start import (
+    SessionStartPatternFlowStackFrame,
+)
+from rasa.dialogue_understanding.patterns.skip_question import (
+    SkipQuestionPatternFlowStackFrame,
+)
+
+triggerable_pattern_to_command_class: Dict[str, Type[Command]] = {
+    SessionStartPatternFlowStackFrame.flow_id: SessionStartCommand,
+    CancelPatternFlowStackFrame.flow_id: CancelFlowCommand,
+    ChitchatPatternFlowStackFrame.flow_id: ChitChatAnswerCommand,
+    HumanHandoffPatternFlowStackFrame.flow_id: HumanHandoffCommand,
+    SearchPatternFlowStackFrame.flow_id: KnowledgeAnswerCommand,
+    SkipQuestionPatternFlowStackFrame.flow_id: SkipQuestionCommand,
+    CannotHandlePatternFlowStackFrame.flow_id: CannotHandleCommand,
+    RestartPatternFlowStackFrame.flow_id: RestartCommand,
+}

rasa/dialogue_understanding/generator/constants.py

@@ -1,14 +1,20 @@
+from rasa.shared.constants import (
+    PROVIDER_CONFIG_KEY,
+    OPENAI_PROVIDER,
+    MODEL_CONFIG_KEY,
+    TIMEOUT_CONFIG_KEY,
+)
 from rasa.shared.utils.llm import (
     DEFAULT_OPENAI_CHAT_MODEL_NAME_ADVANCED,
     DEFAULT_OPENAI_MAX_GENERATED_TOKENS,
 )
 
 DEFAULT_LLM_CONFIG = {
-    "_type": "openai",
-    "request_timeout": 7,
+    PROVIDER_CONFIG_KEY: OPENAI_PROVIDER,
+    MODEL_CONFIG_KEY: DEFAULT_OPENAI_CHAT_MODEL_NAME_ADVANCED,
     "temperature": 0.0,
-    "model_name": DEFAULT_OPENAI_CHAT_MODEL_NAME_ADVANCED,
     "max_tokens": DEFAULT_OPENAI_MAX_GENERATED_TOKENS,
+    TIMEOUT_CONFIG_KEY: 7,
 }
 
 LLM_CONFIG_KEY = "llm"
@@ -16,3 +22,4 @@ USER_INPUT_CONFIG_KEY = "user_input"
 
 FLOW_RETRIEVAL_KEY = "flow_retrieval"
 FLOW_RETRIEVAL_ACTIVE_KEY = "active"
+FLOW_RETRIEVAL_EMBEDDINGS_CONFIG_KEY = "embeddings"

rasa/dialogue_understanding/generator/flow_retrieval.py

@@ -25,16 +25,24 @@ import structlog
 from jinja2 import Template
 from langchain.docstore.document import Document
 from langchain.schema.embeddings import Embeddings
-from langchain.vectorstores.faiss import FAISS
-from langchain.vectorstores.utils import DistanceStrategy
+from langchain_community.vectorstores.faiss import FAISS
+from langchain_community.vectorstores.utils import DistanceStrategy
 from rasa.engine.storage.resource import Resource
 from rasa.engine.storage.storage import ModelStorage
+from rasa.shared.constants import (
+    EMBEDDINGS_CONFIG_KEY,
+    PROVIDER_CONFIG_KEY,
+    OPENAI_PROVIDER,
+)
 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 TEXT, FLOWS_FROM_SEMANTIC_SEARCH
 from rasa.shared.nlu.training_data.message import Message
 from rasa.shared.exceptions import ProviderClientAPIException
+from rasa.shared.providers.embedding._langchain_embedding_client_adapter import (
+    _LangchainEmbeddingClientAdapter,
+)
 from rasa.shared.utils.llm import (
     tracker_as_readable_transcript,
     embedder_factory,
@@ -42,15 +50,15 @@ from rasa.shared.utils.llm import (
     USER,
     get_prompt_template,
     allowed_values_for_slot,
+    try_instantiate_embedder,
 )
 
 DEFAULT_FLOW_DOCUMENT_TEMPLATE = importlib.resources.read_text(
     "rasa.dialogue_understanding.generator", "flow_document_template.jinja2"
 )
 
-EMBEDDINGS_CONFIG_KEY = "embeddings"
 DEFAULT_EMBEDDINGS_CONFIG = {
-    "_type": "openai",
+    PROVIDER_CONFIG_KEY: OPENAI_PROVIDER,
     "model": DEFAULT_OPENAI_EMBEDDING_MODEL_NAME,
 }
 
@@ -135,6 +143,12 @@ class FlowRetrieval:
         """Load flow retrieval with previously populated FAISS vector store."""
         # initialize base flow retrieval
         flow_retrieval = FlowRetrieval(config, model_storage, resource)
+        try_instantiate_embedder(
+            flow_retrieval.config.get(EMBEDDINGS_CONFIG_KEY),
+            DEFAULT_EMBEDDINGS_CONFIG,
+            "flow_retrieval.load",
+            FlowRetrieval.__name__,
+        )
         # load vector store
         vector_store = cls._load_vector_store(
             flow_retrieval.config, model_storage, resource
@@ -154,6 +168,7 @@ class FlowRetrieval:
                     folder_path=model_path,
                     embeddings=embeddings,
                     distance_strategy=DistanceStrategy.MAX_INNER_PRODUCT,
+                    allow_dangerous_deserialization=True,
                 )
         except Exception as e:
             structlogger.warning(
@@ -170,9 +185,10 @@ class FlowRetrieval:
         Returns:
             The embedder.
         """
-        return embedder_factory(
+        client = embedder_factory(
             config.get(EMBEDDINGS_CONFIG_KEY), DEFAULT_EMBEDDINGS_CONFIG
         )
+        return _LangchainEmbeddingClientAdapter(client)
 
     def persist(self) -> None:
         self._persist_vector_store()

rasa/dialogue_understanding/generator/llm_based_command_generator.py

@@ -32,8 +32,9 @@ from rasa.shared.nlu.constants import FLOWS_IN_PROMPT
 from rasa.shared.nlu.training_data.message import Message
 from rasa.shared.nlu.training_data.training_data import TrainingData
 from rasa.shared.utils.llm import (
-    llm_factory,
     allowed_values_for_slot,
+    llm_factory,
+    try_instantiate_llm_client,
 )
 from rasa.utils.log_utils import log_llm
 
@@ -167,6 +168,14 @@ class LLMBasedCommandGenerator(GraphComponent, CommandGenerator, ABC):
         """Train the llm based command generator. Stores all flows into a vector
         store.
         """
+        # Validate llm configuration
+        try_instantiate_llm_client(
+            self.config.get(LLM_CONFIG_KEY),
+            DEFAULT_LLM_CONFIG,
+            "llm_based_command_generator.train",
+            "LLMBasedCommandGenerator",
+        )
+
         # flow retrieval is populated with only user-defined flows
         try:
             if self.flow_retrieval is not None and not flows.is_empty():
@@ -174,7 +183,7 @@ class LLMBasedCommandGenerator(GraphComponent, CommandGenerator, ABC):
         except Exception as e:
             structlogger.error(
                 "llm_based_command_generator.train.failed",
-                event_info=("Flow retrieval store isinaccessible."),
+                event_info="Flow retrieval store is inaccessible.",
                 error=e,
             )
             raise
@@ -286,7 +295,8 @@ class LLMBasedCommandGenerator(GraphComponent, CommandGenerator, ABC):
         """
         llm = llm_factory(self.config.get(LLM_CONFIG_KEY), DEFAULT_LLM_CONFIG)
         try:
-            return await llm.apredict(prompt)
+            llm_response = await llm.acompletion(prompt)
+            return llm_response.choices[0]
         except Exception as e:
             # unfortunately, langchain does not wrap LLM exceptions which means
             # we have to catch all exceptions here