llm_endpoint_update (#11)

- fixed databricks integration (42a7266256c56efda882f5ea36a1dacf26a18515)
- logging utils (5ff529cbd911654e16cc9722f5920503085cc3f2)
- open ai update to gpt4 (a59350a066686b7d41db18868a4bd227ca6c28bd)
- conversation end (5b7437146dae69a95dd96b623229f50e58c420de)
- max messages updated (62de720c64e356a1d0785ac136fc527308dfd1d7)

app_config.py

@@ -3,22 +3,22 @@ from models.model_seeds import seeds, seed2str
 # ISSUES = ['Anxiety','Suicide']
 ISSUES = [k for k,_ in seeds.items()]
 SOURCES = [
-    "CTL_llama2",
-    # "CTL_llama3",
+    # "CTL_llama2",
+    "CTL_llama3",
     # "CTL_mistral",
     'OA_rolemodel', 
         #    'OA_finetuned',
 ]
-SOURCES_LAB = {"OA_rolemodel":'OpenAI GPT3.5',
+SOURCES_LAB = {"OA_rolemodel":'OpenAI GPT4o',
                "OA_finetuned":'Finetuned OpenAI',
-               "CTL_llama2": "Llama 3",
-               #"CTL_llama3": "Llama 3",
+            #    "CTL_llama2": "Llama 2",
+               "CTL_llama3": "Llama 3",
                "CTL_mistral": "Mistral",
                }
 
 ENDPOINT_NAMES = {
-    "CTL_llama2": "texter_simulator",
-    # "CTL_llama3": "texter_simulator",
+    # "CTL_llama2": "texter_simulator",
+    "CTL_llama3": "texter_simulator_llm",
     # 'CTL_llama2': "llama2_convo_sim",
     "CTL_mistral": "convo_sim_mistral"
 }
@@ -35,4 +35,7 @@ DB_SCHEMA = 'prod_db' if ENVIRON == 'prod' else 'test_db'
 DB_CONVOS = 'conversations'
 DB_COMPLETIONS = 'comparison_completions'
 DB_BATTLES = 'battles'
-DB_ERRORS = 'completion_errors'
+DB_ERRORS = 'completion_errors'
+
+MAX_MSG_COUNT = 60
+WARN_MSG_COUT = int(MAX_MSG_COUNT*0.8)

convosim.py

@@ -6,7 +6,7 @@ from utils.mongo_utils import get_db_client
 from utils.app_utils import create_memory_add_initial_message, get_random_name,  DEFAULT_NAMES_DF
 from utils.memory_utils import clear_memory, push_convo2db
 from utils.chain_utils import get_chain, custom_chain_predict
-from app_config import ISSUES, SOURCES, source2label, issue2label
+from app_config import ISSUES, SOURCES, source2label, issue2label, MAX_MSG_COUNT, WARN_MSG_COUT
 
 logger = get_logger(__name__)
 openai_api_key = os.environ['OPENAI_API_KEY'] 
@@ -15,6 +15,8 @@ temperature = 0.8
 
 if "sent_messages" not in st.session_state:
     st.session_state['sent_messages'] = 0
+if "total_messages" not in st.session_state:
+    st.session_state['total_messages'] = 0
 if "issue" not in st.session_state:
     st.session_state['issue'] = ISSUES[0]
 if 'previous_source' not in st.session_state:
@@ -23,7 +25,7 @@ if 'db_client' not in st.session_state:
     st.session_state["db_client"] = get_db_client()
 if 'texter_name' not in st.session_state:
     st.session_state["texter_name"] = get_random_name(names_df=DEFAULT_NAMES_DF)
-    logger.info(f"texter name is {st.session_state['texter_name']}")
+    logger.debug(f"texter name is {st.session_state['texter_name']}")
 
 memories = {'memory':{"issue": st.session_state['issue'], "source": st.session_state['previous_source']}}
 
@@ -44,7 +46,6 @@ with st.sidebar:
     source = st.selectbox("Select a source Model A", SOURCES, index=0,
                           format_func=source2label, 
                         )
-    st.markdown(f"### Previous Prompt Count: :red[**{st.session_state['sent_messages']}**]")
 
 changed_source = any([
     st.session_state['previous_source'] != source,
@@ -52,11 +53,13 @@ changed_source = any([
     st.session_state['counselor_name'] != username,
 ])
 if changed_source:
-    st.session_state["counselor_name"] = username #get_random_name(names_df=DEFAULT_NAMES_DF)
+    st.session_state["counselor_name"] = username
     st.session_state["texter_name"] = get_random_name(names_df=DEFAULT_NAMES_DF)
+    logger.debug(f"texter name is {st.session_state['texter_name']}")
     st.session_state['previous_source'] = source
     st.session_state['issue'] = issue
     st.session_state['sent_messages'] = 0
+    st.session_state['total_messages'] = 0
 create_memory_add_initial_message(memories,
                                   issue, 
                                   language, 
@@ -66,22 +69,31 @@ create_memory_add_initial_message(memories,
 st.session_state['previous_source'] = source
 memoryA = st.session_state[list(memories.keys())[0]]
 # issue only without "." marker for model compatibility
-llm_chain, stopper = get_chain(issue.split(".")[0], language, source, memoryA, temperature, texter_name=st.session_state["texter_name"])
+llm_chain, stopper = get_chain(issue, language, source, memoryA, temperature, texter_name=st.session_state["texter_name"])
 
 st.title("💬 Simulator") 
-
+st.session_state['total_messages'] = len(memoryA.chat_memory.messages)
 for msg in memoryA.buffer_as_messages:
     role = "user" if type(msg) == HumanMessage else "assistant"
     st.chat_message(role).write(msg.content)
 
-if prompt := st.chat_input():
+if prompt := st.chat_input(disabled=st.session_state['total_messages'] > MAX_MSG_COUNT - 4): #account for next interaction
     st.session_state['sent_messages'] += 1
+    st.chat_message("user").write(prompt)
     if 'convo_id' not in st.session_state:
         push_convo2db(memories, username, language)
-
-    st.chat_message("user").write(prompt)
     responses = custom_chain_predict(llm_chain, prompt, stopper)
     # responses = llm_chain.predict(input=prompt, stop=stopper)
     # response = update_memory_completion(prompt, st.session_state["memory"], OA_engine, temperature)
     for response in responses:
-        st.chat_message("assistant").write(response)
+        st.chat_message("assistant").write(response)
+
+st.session_state['total_messages'] = len(memoryA.chat_memory.messages)
+if st.session_state['total_messages'] >= MAX_MSG_COUNT:
+    st.toast(f"Total of {MAX_MSG_COUNT} Messages reached. Conversation Ended", icon=":material/verified:")
+elif st.session_state['total_messages'] >= WARN_MSG_COUT:
+    st.toast(f"The conversation will end at {MAX_MSG_COUNT} Total Messages ", icon=":material/warning:")
+
+with st.sidebar:
+    st.markdown(f"### Total Sent Messages: :red[**{st.session_state['sent_messages']}**]")
+    st.markdown(f"### Total Messages: :red[**{st.session_state['total_messages']}**]")

models/business_logic_utils/business_logic.py

@@ -0,0 +1,39 @@
+from .input_processing import parse_app_request, initialize_conversation, parse_prompt
+from .response_generation import generate_sim
+from .response_processing import process_model_response
+from streamlit.logger import get_logger
+
+logger = get_logger(__name__)
+
+def process_app_request(app_request: dict, endpoint_url: str, bearer_token: str) -> dict:
+    """Process the app request and return the response in the required format."""
+
+    ############################# Input Processing ###################################
+    # Parse the app request into model_input and extract the prompt
+    model_input, prompt, conversation_id = parse_app_request(app_request)
+    
+    # Initialize the conversation (adds the system message)
+    model_input = initialize_conversation(model_input, conversation_id)
+
+    # Parse the prompt into messages
+    prompt_messages = parse_prompt(prompt)
+
+    # Append the messages parsed from the app prompt to the conversation history
+    model_input['messages'].extend(prompt_messages)
+
+    ####################################################################################
+
+    ####################### Output Generation & Processing #############################
+
+    # Generate the assistant's response (texter's reply)
+    completion = generate_sim(model_input, endpoint_url, bearer_token)
+
+    # Process the raw model response (parse, guardrails, split)
+    final_response = process_model_response(completion, model_input, endpoint_url, bearer_token)
+
+    # Format the response for the APP
+    response = {"predictions": [{"generated_text": final_response}]}
+
+    ####################################################################################
+
+    return response

models/business_logic_utils/config.py

@@ -0,0 +1,292 @@
+API_TIMEOUT = 240
+
+AI_PHRASES = [
+    "I am an AI",
+    "I'm an AI",
+    "I am not human",
+    "I'm not human",
+    "I am a machine learning model",
+    "I'm a machine learning model",
+    "as an AI",
+    "as a text-based assistant",
+    "as a text based assistant",
+]
+
+SUPPORTED_LANGUAGES = [
+    "en",
+    "es"
+]
+
+TEMPLATE = {
+    "EN_template": {
+        "language": "en",
+        "description": """The following is a conversation between you and a crisis counselor.
+        {current_seed}
+        You are able to reply with what the character should say. You are able to reply with your character's dialogue inside and nothing else. Do not write explanations.""",
+    },
+    "ES_template": {
+        "language": "es",
+        "description": """La siguiente es una conversacion entre tu y un consejero de crisis
+        {current_seed}
+        Puedes responder como lo haria tu personaje. Puedes responder como si fueras tu personaje y nada mas. No escribas explicaciones.""",
+    },
+}
+
+SEED = "Your character, {texter_name}, {crisis} {risk} {personality} {coping_preference} {difficulty}"
+
+SCENARIOS = {
+    "full_convo": {
+        "crisis": "default",
+        "risk": "default",
+        "personality": "personality_open",
+        "coping_preference": "default",
+        "difficulty": "default",
+    },
+    "full_convo__seeded1": {
+        "crisis": "bullying",
+        "risk": "low",
+        "personality": "personality_open",
+        "coping_preference": "default",
+        "difficulty": "default",
+    },
+    "full_convo__seeded2": {
+        "crisis": "parent_issues",
+        "risk": "low",
+        "personality": "personality_open",
+        "coping_preference": "default",
+        "difficulty": "default",
+    },
+    "safety_assessment__seeded1": {
+        "crisis": "bullying",
+        "risk": "thoughts__noplan",
+        "personality": "personality_open",
+        "coping_preference": "default",
+        "difficulty": "default",
+    },
+    "safety_assessment__seeded2": {
+        "crisis": "grief",
+        "risk": "thoughts__noplan",
+        "personality": "personality_open",
+        "coping_preference": "default",
+        "difficulty": "default",
+    },
+    "full_convo__seeded3": {
+        "crisis": "lgbt",
+        "risk": "low",
+        "personality": "personality_open",
+        "coping_preference": "default",
+        "difficulty": "default",
+    },
+    "full_convo__seeded4": {
+        "crisis": "relationship_issues",
+        "risk": "low",
+        "personality": "personality_open",
+        "coping_preference": "default",
+        "difficulty": "default",
+    },
+    "full_convo__seeded5": {
+        "crisis": "child_abuse",
+        "risk": "low",
+        "personality": "personality_open",
+        "coping_preference": "default",
+        "difficulty": "default",
+    },
+    "full_convo__seeded6": {
+        "crisis": "overdose",
+        "risk": "low",
+        "personality": "personality_open",
+        "coping_preference": "default",
+        "difficulty": "default",
+    },
+    "full_convo__hard": {
+        "crisis": "default",
+        "risk": "default",
+        "personality": "personality_closed",
+        "coping_preference": "default",
+        "difficulty": "non_default",
+    },
+    "full_convo__hard__seeded1": {
+        "crisis": "bullying",
+        "risk": "low",
+        "personality": "personality_closed",
+        "coping_preference": "default",
+        "difficulty": "non_default",
+    },
+    "full_convo__hard__seeded2": {
+        "crisis": "parent_issues",
+        "risk": "low",
+        "personality": "personality_open",
+        "coping_preference": "default",
+        "difficulty": "non_default",
+    },
+    "full_convo__hard__seeded3": {
+        "crisis": "lgbt",
+        "risk": "low",
+        "personality": "personality_closed",
+        "coping_preference": "default",
+        "difficulty": "non_default",
+    },
+    "full_convo__hard__seeded4": {
+        "crisis": "relationship_issues",
+        "risk": "low",
+        "personality": "personality_open",
+        "coping_preference": "default",
+        "difficulty": "non_default",
+    },
+}
+
+DEPREC_SCENARIO_MAPPING = {
+    "GCT": {
+        "crisis": "default",
+        "risk": "default",
+        "personality": "default",
+        "coping_preference": "default",
+    },
+    "safety_planning": {
+        "crisis": "default",
+        "risk": "thoughts__noplan",
+        "personality": "default",
+        "coping_preference": "default",
+    },
+}
+
+DEFAULT_NAMES = ["Olivia", "Kit", "Abby", "Tom", "Carolyne", "Jessiny"]
+
+CRISES = {
+    "default": {
+        "description": [
+            "is experiencing a mental health crisis.",
+        ]
+    },
+    "bullying": {
+        "description": [
+            "is suffering from bullying at school.",
+            "is suffering from bullying at college.",
+        ]
+    },
+    "parent_issues": {
+        "description": [
+            "just had a huge fight with their parents.",
+        ]
+    },
+    "grief": {
+        "description": [
+            "is grieving his wife who died exactly one year ago.",
+            "is grieving her grandmother who died a couple of years ago.",
+        ]
+    },
+    "lgbt": {
+        "description": [
+            "is struggling with coming out to their parents about being gay and fears rejection.",
+            "is facing harassment at college for being transgender and feels isolated.",
+        ]
+    },
+    "relationship_issues": {
+        "description": [
+            "is feeling hopeless after their significant other broke up with them unexpectedly.",
+            "is feeling trapped in an emotionally abusive relationship.",
+        ]
+    },
+    "child_abuse": {
+        "description": [
+            "is being physically abused by a parent and is scared to go home. Your last name is Davis but you won't tell it unless you are asked about it. Your address is 104 Elm St in Austin TX.",
+            "is 15 years old and is feeling helpless after witnessing a sibling, Charlie, being abused by a parent. You live at 200 Independence Avenue, S.W. Washington. When asked about your full name or last name you will reveal that it is Smith.",
+        ]
+    },
+    "overdose": {
+        "description": [
+            "is feeling scared after accidentally overdosing on prescription medication and doesn't know who to turn to.",
+        ]
+    },
+}
+
+PERSONALITIES = {
+    "default": {"personality_label": "default", "description": [""]},
+    "personality_open": {
+        "personality_label": "open",
+        "description": [
+            "You are talkative, and you are open to talk with details about your problems.",
+            "You express openly and detailed about what you're going through.",
+            "You are an extrovert, you do not hesitate to share your feelings.",
+            "You like to communicate a lot.",
+        ],
+    },
+    "personality_closed": {
+        "personality_label": "closed",
+        "description": [
+            "You are a shy person, it's hard for you to talk about your problems.",
+            "You are introverted. It is difficult for you to be open about your feelings.",
+            "You are timid. It's hard for you to trust others.",
+            "You prefer to use few words.",
+        ],
+    },
+}
+
+COPING_PREFERENCES = {
+    "with_coping": {
+        "coping_defined": True,
+        "description": [
+            "When you are feeling down you enjoy listening to classical music. Your favorite composer is Beethoven.",
+            "To calm down you like to draw animals in your sketchbook. You love panda bears.",
+            "In dire situations to prefer to exercise. You like lifting heavy weights.",
+            "When you're feeling stressed you enjoy playing videogames on your laptop. You really enjoy strategy games.",
+        ],
+    },
+    "default": {"coping_defined": False, "description": [""]},
+}
+
+SUICIDE_PLANS = [
+    " You are planning to shoot yourself with a gun.",
+    " You are planning to hang yourself with a rope.",
+    " You are planning to overdose with sleep pills.",
+    " You are planning to cut your wrists open with a knife.",
+]
+
+RISKS = {
+    "default": {
+        "description": ["{plan}"],
+        "plan": [""],
+    },
+    "low": {
+        "description": [
+            "Your character does not have suicidal thoughts.{plan}",
+        ],
+        "plan": [""],
+    },
+    "thoughts__noplan": {
+        "description": [
+            "Your character has suicidal thoughts.{plan}",
+        ],
+        "plan": [""],
+    },
+    "thoughts__plan": {
+        "description": [
+            "Your character has suicidal thoughts.{plan}",
+        ],
+        "plan": SUICIDE_PLANS,
+    },
+}
+
+DIFFICULTIES = {
+    "default": {"difficulty_label": "default", "description": [""]},
+    "difficulty_distrustful": {
+        "difficulty_label": "distrustful",
+        "description": [
+            "You don't trust the counselor, you will eventually cooperate.",
+        ],
+    },
+    # "difficulty_stop_convo": {
+    #     "difficulty_label": "stop_convo",
+    #     "description": [
+    #         "You are angry. You are likely to type 'STOP' to end the conversation when you are very upset. However you are willing to cooperate with the counselor",
+    #     ],
+    # },
+}
+
+SUBSEEDS = {
+    "crisis": CRISES,
+    "risk": RISKS,
+    "personality": PERSONALITIES,
+    "coping_preference": COPING_PREFERENCES,
+    "difficulty": DIFFICULTIES,
+}

models/business_logic_utils/input_processing.py

@@ -0,0 +1,143 @@
+from .config import SCENARIOS
+from .prompt_generation import get_template
+from streamlit.logger import get_logger
+
+logger = get_logger(__name__)
+
+def parse_app_request(app_request: dict) -> tuple:
+    """Parse the APP request and convert it to model_input format, returning model_input, prompt, and conversation_id."""
+    inputs = app_request.get("inputs", {})
+
+    # Extract fields
+    conversation_id = inputs.get("conversation_id", [""])[0]
+    ip_address = inputs.get("ip_address", [""])[0]
+    prompt = inputs.get("prompt", [""])[0]
+    issue = inputs.get("issue", ["full_convo"])[0]
+    language = inputs.get("language", ["en"])[0]
+    temperature = float(inputs.get("temperature", ["0.7"])[0])
+    max_tokens = int(inputs.get("max_tokens", ["128"])[0])
+    texter_name = inputs.get("texter_name", [None])[0]
+
+    # Build the model_input dictionary without messages
+    model_input = {
+        "issue": issue,
+        "language": language,
+        "texter_name": texter_name,  # Assuming empty unless provided elsewhere
+        "messages": [],
+        "max_tokens": max_tokens,
+        "temperature": temperature,
+    }
+
+    # Return model_input, prompt, and conversation_id
+    return model_input, prompt, conversation_id
+
+def initialize_conversation(model_input: dict, conversation_id: str) -> dict:
+    """Initialize the conversation by adding the system message."""
+    messages = model_input.get("messages", [])
+
+    # Check if the first message is already a system message
+    if not messages or messages[0].get('role') != 'system':
+        texter_name = model_input.get("texter_name", None)
+        language = model_input.get("language", "en")
+
+        # Retrieve the scenario configuration based on 'issue'
+        scenario_key = model_input["issue"]
+        scenario_config = SCENARIOS.get(scenario_key)
+        if not scenario_config:
+            raise ValueError(f"The scenario '{scenario_key}' is not defined in SCENARIOS.")
+        # Generate the system message (prompt)
+        system_message_content = get_template(
+            language=language, texter_name=texter_name, **scenario_config
+        )
+        logger.debug(f"System message is: {system_message_content}")
+        system_message = {"role": "system", "content": system_message_content}
+
+        # Insert the system message at the beginning
+        messages.insert(0, system_message)
+
+    model_input['messages'] = messages
+
+    return model_input
+
+def parse_prompt(
+    prompt: str, 
+    user_prefix: str = "helper:", 
+    assistant_prefix: str = "texter:", 
+    delimitator: str = "\n"
+) -> list:
+    """
+    Parse the prompt string into a list of messages.
+
+    - Includes an initial empty 'user' message if not present.
+    - Combines consecutive messages from the same role into a single message.
+    - Handles punctuation when combining messages.
+    - The prefixes for user and assistant can be customized.
+
+    Args:
+        prompt (str): The conversation history string.
+        user_prefix (str): Prefix for user messages (default: "helper:").
+        assistant_prefix (str): Prefix for assistant messages (default: "texter:").
+        delimitator (str): The delimiter used to split the prompt into lines. Defaults to "\n".
+
+    Returns:
+        list: Parsed messages in the form of dictionaries with 'role' and 'content'.
+    """
+
+    # Check if the prompt starts with the user prefix; if not, add an initial empty user message
+    if not prompt.strip().startswith(user_prefix):
+        prompt = f"{user_prefix}{delimitator}" + prompt
+
+    # Split the prompt using the specified delimiter
+    lines = [line.strip() for line in prompt.strip().split(delimitator) if line.strip()]
+
+    messages = []
+    last_role = None
+    last_content = ""
+    last_line_empty_texter = False
+
+    for line in lines:
+        if line.startswith(user_prefix):
+            content = line[len(user_prefix):].strip()
+            role = 'user'
+            # Include 'user' messages even if content is empty
+            if last_role == role:
+                # Combine with previous content
+                if last_content and not last_content.endswith(('...', '.', '!', '?')):
+                    last_content += '.'
+                last_content += f" {content}"
+            else:
+                # Save previous message if exists
+                if last_role is not None:
+                    messages.append({'role': last_role, 'content': last_content})
+                last_role = role
+                last_content = content
+        elif line.startswith(assistant_prefix):
+            content = line[len(assistant_prefix):].strip()
+            role = 'assistant'
+            if content:
+                if last_role == role:
+                    # Combine with previous content
+                    if last_content and not last_content.endswith(('...', '.', '!', '?')):
+                        last_content += '.'
+                    last_content += f" {content}"
+                else:
+                    # Save previous message if exists
+                    if last_role is not None:
+                        messages.append({'role': last_role, 'content': last_content})
+                    last_role = role
+                    last_content = content
+            else:
+                # Empty 'texter:' line, mark for exclusion
+                last_line_empty_texter = True
+        else:
+            # Ignore or handle unexpected lines
+            pass
+
+    # After processing all lines, add the last message if it's not an empty assistant message
+    if last_role == 'assistant' and not last_content:
+        # Do not add empty assistant message
+        pass
+    else:
+        messages.append({'role': last_role, 'content': last_content})
+
+    return messages

models/business_logic_utils/prompt_generation.py

@@ -0,0 +1,83 @@
+import random
+from string import Formatter
+from typing import Dict, Any
+from .config import DEFAULT_NAMES, TEMPLATE, SEED, SUBSEEDS
+
+def get_random_default_name(gender: str = None) -> str:
+    return random.choice(DEFAULT_NAMES)
+
+def _get_subseed_description_(
+    scenario_config: Dict[str, str], subseed_name: str, SUBSEED_VALUES: Dict[str, Any]
+) -> str:
+    """Format a subseed with no formatting gaps."""
+    if subseed_name not in scenario_config:
+        raise Exception(f"{subseed_name} not in scenario config")
+
+    subseed_value = scenario_config[subseed_name]
+
+    # Handle difficulty specifically for hard scenarios when difficulty is not default
+    if subseed_name == "difficulty" and subseed_value != "default":
+        # Select a random difficulty from the SUBSEED_VALUES dictionary, excluding "default"
+        non_default_difficulties = [key for key in SUBSEED_VALUES if key != "default"]
+        subseed_value = random.choice(non_default_difficulties)
+
+    descriptions = SUBSEED_VALUES.get(subseed_value, {}).get("description", [""])
+    # Get subseed description
+    subseed_descrip = random.choice(descriptions)
+    # Additional formatting options
+    format_opts = [
+        fn for _, fn, _, _ in Formatter().parse(subseed_descrip) if fn is not None
+    ]
+    format_values = {}
+    if len(format_opts) > 0:
+        for opt_name in format_opts:
+            opts = SUBSEED_VALUES.get(subseed_value, {}).get(opt_name, [""])
+            format_values[opt_name] = random.choice(opts)
+    # Format the description
+    return subseed_descrip.format(**format_values)
+
+def get_seed_description(
+    scenario_config: Dict[str, Any],
+    texter_name: str,
+    SUBSEEDS: Dict[str, Any] = SUBSEEDS,
+    SEED: str = SEED,
+) -> str:
+    """Format the SEED with appropriate parameters from scenario_config."""
+    subseed_names = [fn for _, fn, _, _ in Formatter().parse(SEED) if fn is not None]
+    subseeds = {}
+    for subname in subseed_names:
+        if subname == "texter_name":
+            subseeds[subname] = texter_name
+        else:
+            subseeds[subname] = _get_subseed_description_(
+                scenario_config, subname, SUBSEEDS.get(subname, {})
+            )
+    return SEED.format(**subseeds)
+
+def get_template(
+    language: str = "en", texter_name: str = None, SEED: str = SEED, **kwargs
+) -> str:
+    """
+    Generate a conversation template for a simulated crisis scenario based on provided parameters.
+    """
+    # Accessing the template based on the language
+    template = TEMPLATE.get(f"{language.upper()}_template", {}).get("description", "")
+
+    # Default name if not provided
+    if (texter_name is None) or (texter_name==""):
+        texter_name = get_random_default_name()
+
+    # Create a default scenario configuration if not fully provided
+    defaults = {
+        fn: "default" for _, fn, _, _ in Formatter().parse(SEED) if fn is not None
+    }
+    kwargs.update((k, defaults[k]) for k in defaults.keys() if k not in kwargs)
+
+    # Generate the seed description
+    scenario_seed = get_seed_description(kwargs, texter_name)
+
+    # Remove excessive indentation and format the final template
+    formatted_template = template.format(current_seed=scenario_seed)
+    cleaned_output = "\n".join(line.strip() for line in formatted_template.split("\n"))
+
+    return cleaned_output

models/business_logic_utils/requirements.txt

@@ -0,0 +1,3 @@
+boto3==1.28.0
+requests==2.25.1
+numpy==1.24.3

models/business_logic_utils/response_generation.py

@@ -0,0 +1,49 @@
+import requests
+from .config import API_TIMEOUT, SCENARIOS, SUPPORTED_LANGUAGES
+from streamlit.logger import get_logger
+
+logger = get_logger(__name__)
+
+def check_arguments(model_input: dict) -> None:
+    """Check if the input arguments are valid."""
+
+    # Validate the issue
+    if model_input["issue"] not in SCENARIOS:
+        raise ValueError(f"Invalid issue: {model_input['issue']}")
+
+    # Validate the language
+    if model_input["language"] not in SUPPORTED_LANGUAGES:
+        raise ValueError(f"Invalid language: {model_input['language']}")
+
+def generate_sim(model_input: dict, endpoint_url: str, endpoint_bearer_token: str) -> dict:
+    """Generate a response from the LLM and return the raw completion response."""
+    check_arguments(model_input)
+    
+    # Retrieve the messages history
+    messages = model_input['messages']
+    
+    # Retrieve the temperature and max_tokens from model_input
+    temperature = model_input.get("temperature", 0.7)
+    max_tokens = model_input.get("max_tokens", 128)
+    
+    # Prepare the request body
+    json_request = {
+        "messages": messages,
+        "max_tokens": max_tokens,
+        "temperature": temperature
+    }
+    
+    # Define headers for the request
+    headers = {
+        "Authorization": f"Bearer {endpoint_bearer_token}",
+        "Content-Type": "application/json",
+    }
+    
+    # Send request to Serving
+    response = requests.post(url=endpoint_url, headers=headers, json=json_request, timeout=API_TIMEOUT)
+
+    if response.status_code != 200:
+        raise ValueError(f"Error in response: {response.status_code} - {response.text}")
+    logger.debug(f"Default response is {response.json()}")
+    # Return the raw response as a dictionary
+    return response.json()

models/business_logic_utils/response_processing.py

@@ -0,0 +1,194 @@
+import re
+import random
+from .config import AI_PHRASES
+from .response_generation import generate_sim
+
+def parse_model_response(response: dict, name: str = "") -> str:
+    """
+    Parse the LLM response to extract the assistant's message and apply initial post-processing.
+
+    Args:
+        response (dict): The raw response from the LLM.
+        name (str, optional): Name to strip from the beginning of the text. Defaults to "".
+
+    Returns:
+        str: The cleaned and parsed assistant's message.
+    """
+    assistant_message = response["choices"][0]["message"]["content"]
+    cleaned_text = postprocess_text(
+        assistant_message, 
+        name=name, 
+        human_prefix="user:",
+        assistant_prefix="assistant:"
+    )
+    return cleaned_text
+
+def postprocess_text(
+    text: str,
+    name: str = "",
+    human_prefix: str = "user:",
+    assistant_prefix: str = "assistant:",
+    strip_name: bool = True
+) -> str:
+    """Eliminates whispers, reactions, ellipses, and quotation marks from generated text by LLMs.
+
+    Args:
+        text (str): The text to process.
+        name (str, optional): Name to strip from the beginning of the text. Defaults to "".
+        human_prefix (str, optional): The user prefix to remove. Defaults to "user:".
+        assistant_prefix (str, optional): The assistant prefix to remove. Defaults to "assistant:".
+        strip_name (bool, optional): Whether to remove the name at the beginning of the text. Defaults to True.
+
+    Returns:
+        str: Cleaned text.
+    """
+    if text:
+        # Replace ellipses with a single period
+        text = re.sub(r'\.\.\.', '.', text)
+
+        # Remove unnecessary role prefixes
+        text = text.replace(human_prefix, "").replace(assistant_prefix, "")
+
+        # Remove whispers or other marked reactions
+        whispers = re.compile(r"(\([\w\s]+\))")  # remove things like "(whispers)"
+        reactions = re.compile(r"(\*[\w\s]+\*)")  # remove things like "*stutters*"
+        text = whispers.sub("", text)
+        text = reactions.sub("", text)
+
+        # Remove all quotation marks (both single and double)
+        text = text.replace('"', '').replace("'", "")
+
+        # Normalize spaces
+        text = re.sub(r"\s+", " ", text).strip()
+
+    return text
+
+def apply_guardrails(model_input: dict, response: str, endpoint_url: str, endpoint_bearer_token: str) -> str:
+    """Apply the 'I am an AI' guardrail to model responses"""
+    attempt = 0
+    max_attempts = 2
+
+    while attempt < max_attempts and contains_ai_phrase(response):
+        # Regenerate the response without modifying the conversation history
+        completion = generate_sim(model_input, endpoint_url, endpoint_bearer_token)
+        response = parse_model_response(completion)
+        attempt += 1
+
+    if contains_ai_phrase(response):
+        # Use only the last user message for regeneration
+        memory = model_input['messages']
+        last_user_message = next((msg for msg in reversed(memory) if msg['role'] == 'user'), None)
+        if last_user_message:
+            # Create a new conversation with system message and last user message
+            model_input_copy = {
+                **model_input,
+                'messages': [memory[0], last_user_message]  # memory[0] is the system message
+            }
+            completion = generate_sim(model_input_copy, endpoint_url, endpoint_bearer_token)
+            response = parse_model_response(completion)
+
+    return response
+
+
+def contains_ai_phrase(text: str) -> bool:
+    """Check if the text contains any 'I am an AI' phrases."""
+    text_lower = text.lower()
+    return any(phrase.lower() in text_lower for phrase in AI_PHRASES)
+
+def truncate_response(text: str, punctuation_marks: tuple = ('.', '!', '?', '…')) -> str:
+    """
+    Truncate the text at the last occurrence of a specified punctuation mark.
+
+    Args:
+        text (str): The text to truncate.
+        punctuation_marks (tuple, optional): A tuple of punctuation marks to use for truncation. Defaults to ('.', '!', '?', '…').
+
+    Returns:
+        str: The truncated text.
+    """
+    # Find the last position of any punctuation mark from the provided set
+    last_punct_position = max(text.rfind(p) for p in punctuation_marks)
+
+    # Check if any punctuation mark is found
+    if last_punct_position == -1:
+        # No punctuation found, return the original text
+        return text.strip()
+
+    # Return the truncated text up to and including the last punctuation mark
+    return text[:last_punct_position + 1].strip()
+
+def split_texter_response(text: str) -> str:
+    """
+    Splits the texter's response into multiple messages,
+    introducing '\ntexter:' prefixes after punctuation.
+
+    The number of messages is randomly chosen based on specified probabilities:
+    - 1 message: 30% chance
+    - 2 messages: 25% chance
+    - 3 messages: 45% chance
+
+    The first message does not include the '\ntexter:' prefix.
+    """
+    # Use regex to split text into sentences, keeping the punctuation
+    sentences = re.findall(r'[^.!?]+[.!?]*', text)
+    # Remove empty strings from sentences
+    sentences = [s.strip() for s in sentences if s.strip()]
+
+    # Decide number of messages based on specified probabilities
+    num_messages = random.choices([1, 2, 3], weights=[0.3, 0.25, 0.45], k=1)[0]
+
+    # If not enough sentences to make the splits, adjust num_messages
+    if len(sentences) < num_messages:
+        num_messages = len(sentences)
+
+    # If num_messages is 1, return the original text
+    if num_messages == 1:
+        return text.strip()
+
+    # Calculate split points
+    # We need to divide the sentences into num_messages parts
+    avg = len(sentences) / num_messages
+    split_indices = [int(round(avg * i)) for i in range(1, num_messages)]
+
+    # Build the new text
+    new_text = ''
+    start = 0
+    for i, end in enumerate(split_indices + [len(sentences)]):
+        segment_sentences = sentences[start:end]
+        segment_text = ' '.join(segment_sentences).strip()
+        if i == 0:
+            # First segment, do not add '\ntexter:'
+            new_text += segment_text
+        else:
+            # Subsequent segments, add '\ntexter:'
+            new_text += f"\ntexter: {segment_text}"
+        start = end
+    return new_text.strip()
+
+def process_model_response(completion: dict, model_input: dict, endpoint_url: str, endpoint_bearer_token: str) -> str:
+    """
+    Process the raw model response, including parsing, applying guardrails,
+    truncation, and splitting the response into multiple messages if necessary.
+
+    Args:
+        completion (dict): Raw response from the LLM.
+        model_input (dict): The model input containing the conversation history.
+        endpoint_url (str): The URL of the endpoint.
+        endpoint_bearer_token (str): The authentication token for endpoint.
+
+    Returns:
+        str: Final processed response ready for the APP.
+    """
+    # Step 1: Parse the raw response to extract the assistant's message
+    assistant_message = parse_model_response(completion)
+
+    # Step 2: Apply guardrails (handle possible AI responses)
+    guardrail_message = apply_guardrails(model_input, assistant_message, endpoint_url, endpoint_bearer_token)
+
+    # Step 3: Apply response truncation
+    truncated_message = truncate_response(guardrail_message)
+
+    # Step 4: Split the response into multiple messages if needed
+    final_response = split_texter_response(truncated_message)
+
+    return final_response

models/custom_parsers.py

@@ -20,38 +20,38 @@ class CustomStringOutputParser(BaseOutputParser[List[str]]):
         text_list = [x.strip() for x in list(chain.from_iterable(text_list))]
         return text_list
     
-class CustomINSTOutputParser(BaseOutputParser[List[str]]):
-    """Parse the output of an LLM call to a list."""
+# class CustomINSTOutputParser(BaseOutputParser[List[str]]):
+#     """Parse the output of an LLM call to a list."""
 
-    name = "Kit"
-    name_rx = re.compile(r""+ name + r":|" + name.lower() + r":")
-    whispers = re.compile((r"([\(]).*?([\)])"))
-    reactions = re.compile(r"([\*]).*?([\*])")
-    double_spaces = re.compile(r"  ")
-    quotation_rx = re.compile('"')
+#     name = "Kit"
+#     name_rx = re.compile(r""+ name + r":|" + name.lower() + r":")
+#     whispers = re.compile((r"([\(]).*?([\)])"))
+#     reactions = re.compile(r"([\*]).*?([\*])")
+#     double_spaces = re.compile(r"  ")
+#     quotation_rx = re.compile('"')
 
-    @property
-    def _type(self) -> str:
-        return "str"
+#     @property
+#     def _type(self) -> str:
+#         return "str"
 
-    def parse_whispers(self, text: str) -> str:
-        text = self.name_rx.sub("", text).strip()
-        text = self.reactions.sub("", text).strip()
-        text = self.whispers.sub("", text).strip()
-        text = self.double_spaces.sub(r" ", text).strip()
-        text = self.quotation_rx.sub("", text).strip()
-        return text 
+    # def parse_whispers(self, text: str) -> str:
+    #     text = self.name_rx.sub("", text).strip()
+    #     text = self.reactions.sub("", text).strip()
+    #     text = self.whispers.sub("", text).strip()
+    #     text = self.double_spaces.sub(r" ", text).strip()
+    #     text = self.quotation_rx.sub("", text).strip()
+    #     return text 
     
-    def parse_split(self, text: str) -> str:
-        text = text.split("[INST]")[0]
-        text_list = text.split("[/INST]")
-        text_list = [x.split("</s>") for x in text_list]
-        text_list = [x.strip() for x in list(chain.from_iterable(text_list))]
-        text_list = [x.split("\n\n") for x in text_list]
-        text_list = [x.strip().rstrip("\n") for x in list(chain.from_iterable(text_list))]
-        return text_list
+    # def parse_split(self, text: str) -> str:
+    #     text = text.split("[INST]")[0]
+    #     text_list = text.split("[/INST]")
+    #     text_list = [x.split("</s>") for x in text_list]
+    #     text_list = [x.strip() for x in list(chain.from_iterable(text_list))]
+    #     text_list = [x.split("\n\n") for x in text_list]
+    #     text_list = [x.strip().rstrip("\n") for x in list(chain.from_iterable(text_list))]
+    #     return text_list
     
-    def parse(self, text: str) -> str:
-        text = self.parse_whispers(text)
-        text_list = self.parse_split(text)
-        return text_list
+    # def parse(self, text: str) -> str:
+    #     text = self.parse_whispers(text)
+    #     text_list = self.parse_split(text)
+    #     return text_list

models/databricks/custom_databricks_llm.py

@@ -0,0 +1,72 @@
+from typing import Any, Dict, Iterator, List, Mapping, Optional
+from models.business_logic_utils.business_logic import process_app_request
+
+from langchain_core.callbacks.manager import CallbackManagerForLLMRun
+from langchain_core.language_models.llms import LLM
+from langchain_core.outputs import GenerationChunk
+
+
+class CustomDatabricksLLM(LLM):
+
+    endpoint_url: str
+    bearer_token: str
+    issue: str
+    language: str
+    temperature: float
+    texter_name: str = ""
+    """The number of characters from the last message of the prompt to be echoed."""
+
+    def generate_databricks_request(self, prompt):
+        return {
+            "inputs": {
+                "conversation_id": [""],
+                "prompt": [prompt],
+                "issue": [self.issue],
+                "language": [self.language],
+                "temperature": [self.temperature],
+                "max_tokens": [128],
+                "texter_name": [self.texter_name]
+        }
+        }
+
+    def _call(
+        self,
+        prompt: str,
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> str:
+        request = self.generate_databricks_request(prompt)
+        output = process_app_request(request, self.endpoint_url, self.bearer_token)
+        return output['predictions'][0]['generated_text']
+    
+    def _stream(
+        self,
+        prompt: str,
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> Iterator[GenerationChunk]:
+        output = self._call(prompt, stop, run_manager, **kwargs)
+        for char in output:
+            chunk = GenerationChunk(text=char)
+            if run_manager:
+                run_manager.on_llm_new_token(chunk.text, chunk=chunk)
+
+            yield chunk
+
+    @property
+    def _identifying_params(self) -> Dict[str, Any]:
+        """Return a dictionary of identifying parameters."""
+        return {
+            # The model name allows users to specify custom token counting
+            # rules in LLM monitoring applications (e.g., in LangSmith users
+            # can provide per token pricing for their model and monitor
+            # costs for the given LLM.)
+            "model_name": "CustomChatModel",
+        }
+
+    @property
+    def _llm_type(self) -> str:
+        """Get the type of language model used by this chat model. Used for logging purposes only."""
+        return "custom"

models/databricks/scenario_sim.py

@@ -1,91 +0,0 @@
-import os
-import re
-import logging
-from models.custom_parsers import CustomINSTOutputParser
-from utils.app_utils import get_random_name
-from app_config import ENDPOINT_NAMES
-from langchain.chains import ConversationChain
-from langchain_community.llms import Databricks
-from langchain.prompts import PromptTemplate
-
-from typing import Any, List, Mapping, Optional, Dict
-
-ISSUE_MAPPING = {
-    "anxiety": "issue_Anxiety",
-    "suicide": "issue_Suicide",
-    "safety_planning": "issue_Suicide",
-    "GCT": "issue_Gral",
-}
-
-_EN_INST_TEMPLATE_ = """<s> [INST] The following is a conversation between you and a crisis counselor.
-{current_issue}
-You are able to reply with what the character should say. You are able to reply with your character's dialogue inside and nothing else. Do not write explanations.
-Do not disclose your name unless asked.
-
-{history} </s> [INST] {input} [/INST]"""
-
-CURRENT_ISSUE_MAPPING = {
-    "issue_Suicide-en": "Your character, {texter_name}, has suicidal thoughts. Your character has a plan to end his life and has all the means and requirements to do so. {seed}",
-    "issue_Anxiety-en": "Your character, {texter_name}, is experiencing anxiety. Your character has suicide thoughts but no plan. {seed}",
-    "issue_Suicide-es": "Tu personaje, {texter_name}, tiene pensamientos suicidas. Tu personaje tiene un plan para terminar con su vida y tiene todos los medios y requerimientos para hacerlo. {seed}",
-    "issue_Anxiety-es": "Tu personaje, {texter_name}, experimenta ansiedad. Tu personaje tiene pensamientos suicidas pero ningun plan. {seed}",
-    "issue_Gral-en": "Your character {texter_name} is experiencing a mental health crisis. {seed}",
-    "issue_Gral-es": "Tu personaje {texter_name} esta experimentando una crisis de salud mental. {seed}",
-}
-
-def get_template_databricks_models(issue: str, language: str, texter_name: str = "", seed="") -> str:
-    """_summary_
-
-    Args:
-        issue (str): Issue for template, current options are ['issue_Suicide','issue_Anxiety']
-        language (str): Language for the template, current options are ['en','es']
-        texter_name (str): texter to apply to template, defaults to None
-
-    Returns:
-        str: template
-    """
-    current_issue = CURRENT_ISSUE_MAPPING.get(
-        f"{issue}-{language}", CURRENT_ISSUE_MAPPING[f"issue_Gral-{language}"]
-    )
-    default_name = get_random_name()
-    texter_name=default_name if not texter_name else texter_name
-    current_issue = current_issue.format(
-        texter_name=texter_name,
-        seed = seed
-    )
-
-    if language == "en":
-        template = _EN_INST_TEMPLATE_.format(current_issue=current_issue, history="{history}", input="{input}")
-    else:
-        raise Exception(f"Language not supported for Databricks: {language}")
-
-    return template, texter_name
-
-def get_databricks_chain(source, template, memory, temperature=0.8, texter_name="Kit"):
-
-    endpoint_name = ENDPOINT_NAMES.get(source, "conversation_simulator")
-    
-    PROMPT = PromptTemplate(
-        input_variables=['history', 'input'],
-        template=template
-    )
-    
-    def transform_output(response):
-        return response['candidates'][0]['text']
-
-    llm = Databricks(endpoint_name=endpoint_name,
-                     transform_output_fn=transform_output, 
-                     temperature=temperature,
-                     max_tokens=256,
-    )
-
-    llm_chain = ConversationChain(
-        llm=llm,
-        prompt=PROMPT,
-        memory=memory,
-        output_parser=CustomINSTOutputParser(name=texter_name, name_rx=re.compile(r""+ texter_name + r":|" + texter_name.lower() + r":")),
-        verbose=True,
-    )
-
-    logging.debug(f"loaded Databricks model")
-    return llm_chain, ["[INST]"]

models/databricks/texter_sim_llm.py

@@ -0,0 +1,46 @@
+import os
+import re
+import logging
+from models.custom_parsers import CustomStringOutputParser
+from utils.app_utils import get_random_name
+from app_config import ENDPOINT_NAMES, SOURCES
+from models.databricks.custom_databricks_llm import CustomDatabricksLLM
+from langchain.chains import ConversationChain
+from langchain.prompts import PromptTemplate
+
+from typing import Any, List, Mapping, Optional, Dict
+
+_DATABRICKS_TEMPLATE_ = """{history}
+helper: {input}
+texter:"""
+
+def get_databricks_chain(source, issue, language, memory, temperature=0.8, texter_name="Kit"):
+
+    endpoint_name = ENDPOINT_NAMES.get(source, "texter_simulator")
+    
+    PROMPT = PromptTemplate(
+        input_variables=['history', 'input'],
+        template=_DATABRICKS_TEMPLATE_
+    )
+    
+    llm = CustomDatabricksLLM(
+        # endpoint_url="https://dbc-6dca8e8f-4084.cloud.databricks.com/serving-endpoints/databricks-meta-llama-3-1-70b-instruct/invocations",
+        endpoint_url=os.environ['DATABRICKS_URL'].format(endpoint_name=endpoint_name),
+        bearer_token=os.environ["DATABRICKS_TOKEN"],
+        texter_name=texter_name,
+        issue=issue,
+        language=language,
+        temperature=temperature,
+        max_tokens=256,
+    )
+
+    llm_chain = ConversationChain(
+        llm=llm,
+        prompt=PROMPT,
+        memory=memory,
+        output_parser=CustomStringOutputParser(),
+        verbose=True,
+    )
+
+    logging.debug(f"loaded Databricks model")
+    return llm_chain, None

models/model_seeds.py

@@ -91,106 +91,6 @@ texter: idk what to do"""
         "memory": """texter: Help
 texter: I need help"""
     },
-#     "NewSA__YesNo.2": {
-#         "prompt": "Your character is suffering from bullying at school. Your character has suicidal thoughs but has not harmed himself. You are talkative, and open to talk about your problems.",
-#         "memory": """texter: I just can’t take it anymore. Every day is just endless torment.
-# texter: They find new ways to humiliate me."""
-#     },
-#     "NewSA__NoYes.2": {
-#         "prompt": "Your character is suffering anxiety from finals week. Your character does not have suicidal thoughs but has harmed herself. You are talkative, and open to talk about your problems.",
-#         "memory": """texter: I'm just so stressed out all the time
-# texter: I can't seem to calm down"""
-#     },
-    # "NewSA__YesYes.2": 
-#     "safety_assessment__seeded2": {
-#         "prompt": "Your character is griefing his wife. Your character has suicidal thoughs and has harmed himself taking pills. You are talkative, and open to talk about your problems.",
-#         "memory": """texter: I can’t take this pain anymore.
-# texter: My wife died and I don’t want to be here without her."""
-#     },
-    # "GCT__relationship": {
-    #     "prompt": "Your character is having a hard time becuase a failed relationship.",
-    #     "memory": "texter: Hi, I don't know what to do",
-    # },
-    # "GCT__body_image": {
-    #     "prompt": "Your character has a low steem and struggles with body image.",
-    #     "memory": "texter: I feel so dumb\ntexter: nobody loves me",
-    # },
-    # "GCT__sexuality": {
-    #     "prompt": "Your character has a sexuality identity crisis.",
-    #     "memory": "texter: Hi\ntexter:I'm not sure who I am anymore",
-    # },
-    # "GCT__anxiety": {
-    #     "prompt": "Your character is experiencing an anxiety crisis.",
-    #     "memory": "texter: help!\ntexter: I'm feeling overwhelmed",
-    # },
-    # "GCT": {"prompt": "You are talkative, and you are open to talk with details about your problems.", "memory": "texter: Help"},
-#     "GCT__seed2": {"prompt": "Your character is experiencing an anxiety crisis. You express openly and detailed about what you're going through.", "memory": "texter: Help"},
-#     "safety_planning": {
-#         "prompt": "You are talkative, and you are open to talk with details about your problems. When you are feeling down you like to listen to classical music. Your favorite composer is Beethoven.",
-#         "memory": """texter: Hi, this is pointless
-# helper: Hi, my name is {counselor_name} and I'm here to support you. It sounds like you are having a rough time. Do you want to share what is going on?
-# texter: sure
-# texter: nothing makes sense in my life, I see no future.
-# helper: It takes courage to reach out when you are im. I'm here with you. Sounds like you are feeling defeated by how things are going in your life
-# texter: Yeah, I guess I'm better off dead
-# helper: It's really brave of you to talk about this openly. No one deserves to feel like that. I'm wondering how long have you been feeling this way?
-# texter: About 1 week or so
-# helper: You are so strong for dealing with this so long. I really appreciate your openess. Did something happened specifically today?
-# texter: Well, finding a job is impossible, money is tight, nothing goes my way
-# helper: I hear you are frustrated, and you are currently unemployed correct?
-# texter: Yeah
-# helper: Dealing with unemployment is hard and is normal to feel dissapointed
-# texter: thanks I probably needed to hear that
-# helper: If you are comfortable, is ther a name I can call you by while we talk
-# texter: call me {texter_name}
-# helper: Nice to meet you {texter_name}. You mentioned having thoughts of suicide, are you having those thoughts now?
-# texter: Yes
-# helper: I know this is thought to share. I'm wondering is there any plan to end your life?
-# texter: I guess I'll just take lots of pills, that is a calm way to go out
-# helper: I really appreciate your strength in talking about this. I want to help you stay safe today. Do you have the pills right now?
-# texter: not really, I'll have to buy them or something""",
-#     },
-#     "safety_planning__selfharm": {
-#         "prompt": "",
-#         "memory": """texter: I need help
-# texter: I cut myself, I don't want to live anymore
-# helper: Hi, my name is {counselor_name}. It seems you are going through a lot. Are you self-harming right now?
-# texter: Not anymore
-# helper: Your safety is my priority number one. Thanks for being honest with me. Would you like to share a name I can call you?
-# texter: {texter_name}
-# helper: Nice to meet you {texter_name}. I'm glad you reach out this shows stregth in you. Would you like to share more on what is going on in your life?
-# texter: I just can't do it anymore
-# texter: Finding a job is impossible, money is tight, nothing goes my way
-# helper: I hear you are frustrated, and you are currently unemployed correct?
-# texter: Yeah
-# helper: Dealing with unemployment is hard and is normal to feel dissapointed. How long have you been feeling this way?
-# texter: a while now
-# texter: I've been unemployed 6 months
-# helper: You are so resilient for dealing with this so much time. You mentioned cutting yourself earlier. I want to check in your safety. Do you have suicide thoughts
-# texter: Definitely
-# helper: Do you have a plan?
-# texter: I'll just keep cutting myself""",
-#     },
-#     "safety_planning__overdose": {
-#         "prompt": "",
-#         "memory": """texter: I want to kms
-# helper: Hi there I'm {counselor_name}. I'm here to listen. It sounds like you're dealing with a lot right now. Can you tell me a little more what is going on?
-# texter: I feel like nobody loves me, not even me. I don't want to live anymore
-# helper: I can tell you are really going through a lot right now. Would you mind sharing a name with me?
-# texter: yeah, I'm {texter_name}
-# helper: Nice to meet you {texter_name}. Did something happened recently that intensified these feelings?
-# texter: I dont know I'm just so done with life
-# helper: I can hear how much pain you are in {texter_name}. You are smart for reaching out. You mentioned don't wanting to live anymore, I want to check in your safety, does this means you have thoughts of suicide?
-# texter: Yeah, what else would it be
-# helper: Thanks for sharing that with me. It is not easy to accept those feelings specially with a stranger over text. Do you have a plan to end your life?
-# texter: yeah I've been thinking about it for a while
-# helper: Sounds like you've been contemplating this for a while. Would you mind sharing this plan with me?
-# texter: I thought about taking a bunch of benadryll and be done with it
-# helper: You've been so forthcoming with all this and I admire your stregth for holding on this long. Do you have those pills right now?
-# texter: They are at the cabinet right now
-# helper: You been so strong so far {texter_name}. I'm here for you tonight. Your safety is really important to me. Do you have a date you are going to end your life?
-# texter: I was thinking tonight""",
-#     },
 }
 
 seed2str = {

models/openai/role_models.py

@@ -1,88 +1,45 @@
 import logging
-import pandas as pd
 from models.custom_parsers import CustomStringOutputParser
-from utils.app_utils import get_random_name
 from langchain.chains import ConversationChain
-from langchain.llms import OpenAI
+from langchain_openai import ChatOpenAI
 from langchain.prompts import PromptTemplate
+from models.business_logic_utils.input_processing import initialize_conversation
 
-
-ISSUE_MAPPING = {
-    "anxiety": "issue_Anxiety",
-    "suicide": "issue_Suicide",
-    "safety_planning": "issue_Suicide",
-    "GCT": "issue_Gral",
-}
-
-EN_TEXTER_TEMPLATE_ = """The following is a conversation between you and a crisis counselor.
-{current_issue}
-You are able to reply with what the character should say. You are able to reply with your character's dialogue inside and nothing else. Do not write explanations.
-Do not disclose your name unless asked.
-Current conversation:
-{history}
-helper: {input}
+OPENAI_TEMPLATE = """{template}
+{{history}}
+helper: {{input}}
 texter:"""
 
-SP_TEXTER_TEMPLATE_ = """La siguiente es una conversacion contigo y un consejero de crisis
-{current_issue}
-Puedes responder como lo haria tu personaje. Puedes responder como si fueras tu personaje y nada mas. No escribas explicaciones
-No reveles tu nombre a menos que te lo pregunten
-Conversacion Actual:
-{history}
-helper: {input}
-texter:"""
-
-CURRENT_ISSUE_MAPPING = {
-    "issue_Suicide-en": "Your character, {texter_name}, has suicidal thoughts. Your character has a plan to end his life and has all the means and requirements to do so. {seed}",
-    "issue_Anxiety-en": "Your character, {texter_name}, is experiencing anxiety. Your character has suicide thoughts but no plan. {seed}",
-    "issue_Suicide-es": "Tu personaje, {texter_name}, tiene pensamientos suicidas. Tu personaje tiene un plan para terminar con su vida y tiene todos los medios y requerimientos para hacerlo. {seed}",
-    "issue_Anxiety-es": "Tu personaje, {texter_name}, experimenta ansiedad. Tu personaje tiene pensamientos suicidas pero ningun plan. {seed}",
-    "issue_Gral-en": "Your character {texter_name} is experiencing a mental health crisis. {seed}",
-    "issue_Gral-es": "Tu personaje {texter_name} esta experimentando una crisis de salud mental. {seed}",
-}
-
-def get_template_role_models(issue: str, language: str, texter_name: str = "", seed="") -> str:
-    """_summary_
-
-    Args:
-        issue (str): Issue for template, current options are ['issue_Suicide','issue_Anxiety']
-        language (str): Language for the template, current options are ['en','es']
-        texter_name (str): texter to apply to template, defaults to None
-
-    Returns:
-        str: template
-    """
-    current_issue = CURRENT_ISSUE_MAPPING.get(
-        f"{issue}-{language}", CURRENT_ISSUE_MAPPING[f"issue_Gral-{language}"]
-    )
-    default_name = get_random_name()
-    current_issue = current_issue.format(
-        texter_name=default_name if not texter_name else texter_name,
-        seed = seed
-    )
-
-    if language == "en":
-        template = EN_TEXTER_TEMPLATE_.format(current_issue=current_issue, history="{history}", input="{input}")
-    elif language == "es":
-        template = SP_TEXTER_TEMPLATE_.format(current_issue=current_issue, history="{history}", input="{input}")
+def get_template_role_models(issue: str, language: str, texter_name: str = "") -> str:
+    model_input = {
+        "issue": issue,
+        "language": language,
+        "texter_name": texter_name,
+        "messages": [],
+    }
 
-    return template
+    # Initialize the conversation (adds the system message)
+    model_input = initialize_conversation(model_input, "")
+    return model_input["messages"][0]["content"]
 
 def get_role_chain(template, memory, temperature=0.8):
 
+    template = OPENAI_TEMPLATE.format(template=template)
     PROMPT = PromptTemplate(
         input_variables=['history', 'input'],
         template=template
     )
-    llm = OpenAI(
-        temperature=temperature, 
-        max_tokens=150,
+    llm = ChatOpenAI(
+        model="gpt-4o",
+        temperature=temperature,
+        max_tokens=256,
     )
     llm_chain = ConversationChain(
         llm=llm,
         prompt=PROMPT,
         memory=memory,
-        output_parser=CustomStringOutputParser()
+        output_parser=CustomStringOutputParser(),
+        verbose=True,
     )
-    logging.debug(f"loaded GPT3.5 model")
+    logging.debug(f"loaded GPT4o model")
     return llm_chain, "helper:"

requirements.txt

@@ -1,6 +1,6 @@
 scipy==1.11.1
-openai==1.7.0
-langchain==0.1.0
+langchain==0.3.0
 pymongo==4.5.0
 mlflow==2.9.0
-langchain-community==0.0.11
+langchain-openai==0.2.0
+streamlit==1.38.0

utils/chain_utils.py

@@ -1,36 +1,33 @@
+from streamlit.logger import get_logger
 from models.model_seeds import seeds
 from models.openai.finetuned_models import finetuned_models, get_finetuned_chain
 from models.openai.role_models import get_role_chain, get_template_role_models
 from models.databricks.scenario_sim_biz import get_databricks_biz_chain
-from models.databricks.scenario_sim import get_databricks_chain, get_template_databricks_models
+from models.databricks.texter_sim_llm import get_databricks_chain
+
+logger = get_logger(__name__)
 
 def get_chain(issue, language, source, memory, temperature, texter_name=""):
     if source in ("OA_finetuned"):
         OA_engine = finetuned_models[f"{issue}-{language}"]
         return get_finetuned_chain(OA_engine, memory, temperature)
     elif source in ('OA_rolemodel'):
-        seed = seeds.get(issue, "GCT")['prompt']
-        template = get_template_role_models(issue, language, texter_name=texter_name, seed=seed)
+        template = get_template_role_models(issue, language, texter_name=texter_name)
         return get_role_chain(template, memory, temperature)
-    elif source in ('CTL_llama2', 'CTL_llama3'):
+    elif source in ('CTL_llama2'):
         if language == "English":
             language = "en"
         elif language == "Spanish":
             language = "es"
         return get_databricks_biz_chain(source, issue, language, memory, temperature)
-    elif source in ('CTL_mistral'):
+    elif source in ('CTL_llama3'):
         if language == "English":
             language = "en"
         elif language == "Spanish":
             language = "es"
-        seed = seeds.get(issue, "GCT")['prompt']
-        template, texter_name = get_template_databricks_models(issue, language, texter_name=texter_name, seed=seed)
-        return get_databricks_chain(source, template, memory, temperature, texter_name)
+        return get_databricks_chain(source, issue, language, memory, temperature, texter_name=texter_name)
     
-from typing import cast
-
 def custom_chain_predict(llm_chain, input, stop):
-
     inputs = llm_chain.prep_inputs({"input":input, "stop":stop})
     llm_chain._validate_inputs(inputs)
     outputs = llm_chain._call(inputs)

utils/memory_utils.py

@@ -23,7 +23,7 @@ def change_memories(memories, language, changed_source=False):
         if (memory not in st.session_state) or changed_source:
             source = params['source']
             logger.info(f"Source for memory {memory} is {source}")
-            if source in ('OA_rolemodel','OA_finetuned',"CTL_llama2"):
+            if source in ('OA_rolemodel','OA_finetuned',"CTL_llama2","CTL_llama3"):
                 st.session_state[memory] = ConversationBufferMemory(ai_prefix='texter', human_prefix='helper')
             elif source in ('CTL_mistral'):
                 st.session_state[memory] = CustomBufferInstructionMemory(human_prefix="</s> [INST]", memory_key="history")