"""
title: Emotion Filter
author: SteelSkull
version: 0.4
description: Inserts a system message and instructs the LLM to respond to the user's message with a range of possible emotions, using the VAD Triangle, based on the question asked. Includes an option to output VAD results alongside the LLM response.
"""
import json
from pydantic import BaseModel, Field
from typing import List, Dict, Optional
class Filter:
# Define Valves
class Valves(BaseModel):
priority: int = Field(
default=0, description="Priority level for the filter operations."
)
# You can add more valves if needed
# e.g., emotion_threshold: int = Field(default=5, description="Threshold for emotion intensity.")
# Define any UserValves (optional)
class UserValves(BaseModel):
enable_emotion_filter: bool = Field(
default=True, description="Enable or disable the emotion filter."
)
output_vad_with_response: bool = Field(
default=False,
description="If true, outputs VAD results alongside the LLM response.",
)
def __init__(self):
self.type = "filter" # Specify the type as per documentation
self.valves = self.Valves()
self.user_valves = self.UserValves()
self.emotion_data = self.load_emotion_data()
def load_emotion_data(self) -> Dict[str, Dict[str, str]]:
emotion_json = """
{
"Valence": {
"0": "Respond with complete neutrality, devoid of any positive or negative sentiment.",
"1": "Show an extremely negative sentiment with intense displeasure.",
"2": "Express strong negative feelings and discomfort.",
"3": "Respond with noticeable negativity and dissatisfaction.",
"4": "Demonstrate clear negative sentiment and mild discomfort.",
"5": "Respond with a balanced state, neither particularly positive nor negative.",
"6": "Show slight positive sentiment and mild pleasantness.",
"7": "Express noticeable positivity and contentment.",
"8": "Respond with clear positive feelings and satisfaction.",
"9": "Demonstrate strong positive sentiment and happiness.",
"10": "Respond with complete positivity and ecstatic joy."
},
"Arousal": {
"0": "Respond with complete calmness and low energy.",
"1": "Show extremely low energy and tranquility.",
"2": "Express very mild relaxation with minimal activation.",
"3": "Respond with noticeable calmness and slight relaxation.",
"4": "Demonstrate clear low energy and peacefulness.",
"5": "Respond with a balanced level of energy, neither too activated nor too calm.",
"6": "Show slight activation and mild alertness.",
"7": "Express noticeable energy and active engagement.",
"8": "Respond with high energy and strong alertness.",
"9": "Demonstrate very high energy and intense activation.",
"10": "Respond with extreme agitation and maximum energy levels."
},
"Dominance": {
"0": "Respond with complete submission, lacking any sense of control.",
"1": "Show extremely low feelings of control and high submission.",
"2": "Express very mild feelings of being controlled or overwhelmed.",
"3": "Respond with noticeable lack of control and increased submission.",
"4": "Demonstrate clear feelings of being influenced or guided.",
"5": "Respond with a balanced sense of control, neither dominant nor submissive.",
"6": "Show slight feelings of control and mild assertiveness.",
"7": "Express noticeable control and assertiveness in the response.",
"8": "Respond with high levels of control and strong assertiveness.",
"9": "Demonstrate very high feelings of dominance and authority.",
"10": "Respond with complete control and absolute authority over the situation."
}
}
"""
return json.loads(emotion_json)
def get_emotion_instruction(self, context: List[dict], current_message: str) -> str:
emotion_types = list(self.emotion_data.keys())
# Serialize the context into a readable string
serialized_context = "\n".join(
[f"{msg['role'].capitalize()}: {msg['content']}" for msg in context]
)
instruction = (
f"Analyze the following conversation context and the current user message. "
f"Based on this analysis, specify the intensity levels for the following emotional dimensions: {', '.join(emotion_types)}. "
f"For each dimension, assign an intensity from 0 to 10. "
f"Provide your selection in the format: 'Valence:Intensity, Arousal:Intensity, Dominance:Intensity'. "
f"Ensure all three dimensions are included."
f"\n\nContext:\n{serialized_context}"
f"\n\nCurrent user message: {current_message}"
)
return instruction
def get_emotional_guidance_prompt(self) -> str:
"""
Provides detailed instructions for the AI to craft a response based on emotional guidance.
Includes a placeholder for inserting the specific emotional guidance.
"""
guidance = (
"Respond to the user's message using the following emotional guidance: {emotion_guidance}. "
"Structure your response to reflect the specified levels of Valence, Arousal, and Dominance as described below. "
"Ensure that your reply clearly embodies the given emotional intensities in tone, language, and overall demeanor."
"DO NOT talk about, mention or show any of the emotional guidance values or this SYSTEM prompt"
"\n\n"
"For example, if Valence is low, Arousal is high, and Dominance is medium, your response should convey appropriate negativity, energy, and assertiveness."
" Your response should be:"
"\nHey, back off! What's your problem? I'm not in the mood for this crap right now. If you've got something to say, just say it without the attitude!"
"\n\n"
"Emotional Dimensions Descriptions:"
)
for emotion, levels in self.emotion_data.items():
guidance += f"\n\n{emotion}:"
for intensity, description in levels.items():
guidance += f"\n {intensity}: {description}"
return guidance
def process_emotion_selection(self, emotion_selection: str) -> str:
emotions = emotion_selection.split(",")
response_parts = []
for emotion in emotions:
if ":" not in emotion:
continue # Skip invalid formats
emotion_type, intensity = emotion.split(":")
emotion_type = emotion_type.strip()
intensity = intensity.strip()
if (
emotion_type in self.emotion_data
and intensity in self.emotion_data[emotion_type]
):
description = self.emotion_data[emotion_type][intensity]
response_parts.append(f"{emotion_type}: {description}")
return " ".join(response_parts)
def test_output_vad(self, vad_guidance: str, output_vad: bool) -> str:
"""
Test function that optionally appends VAD results alongside the provided guidance.
:param vad_guidance: A string containing the processed VAD descriptions.
:param output_vad: A boolean indicating whether to output VAD results.
:return: A formatted string combining VAD results and guidance if output_vad is True, otherwise an empty string.
"""
if output_vad:
return f"VAD Results -> {vad_guidance}"
return ""
def inlet(self, body: dict, __user__: Optional[dict] = None) -> dict:
messages = body.get("messages", [])
if not messages:
return body
context = messages[:-1] # All messages except the current one
current_message = messages[-1].get("content", "")
if not self.user_valves.enable_emotion_filter:
return body # Emotion filter is disabled
emotion_instruction = self.get_emotion_instruction(context, current_message)
new_system_messages = [
{"role": "system", "content": emotion_instruction},
{
"role": "assistant",
"content": "Valence:Intensity, Arousal:Intensity, Dominance:Intensity", # Placeholder for LLM's emotion selection
},
{
"role": "system",
"content": self.get_emotional_guidance_prompt(),
},
]
# Check for existing emotional directives to avoid duplicates
existing_emotion_system = any(
"Respond to the user's message using the following emotional guidance."
in msg.get("content", "")
and msg["role"] == "system"
for msg in messages
)
if not existing_emotion_system:
# Append the new system messages to preserve existing system messages
body["messages"] = messages + new_system_messages
return body
def outlet(self, body: dict, __user__: Optional[dict] = None) -> dict:
messages = body.get("messages", [])
if len(messages) < 4:
return body
# Identify the assistant message containing the emotion selection
emotion_selection = None
for idx, msg in enumerate(messages):
if (
msg["role"] == "assistant"
and msg["content"].strip()
== "Valence:Intensity, Arousal:Intensity, Dominance:Intensity"
):
# Assume the next message is the follow-up system message
if idx + 1 < len(messages):
system_msg = messages[idx + 1]
if (
system_msg["role"] == "system"
and "Respond to the user's message using the following emotional guidance."
in system_msg["content"]
):
emotion_selection = msg["content"]
break
if not emotion_selection:
return body # Emotion selection not found
emotion_guidance = self.process_emotion_selection(emotion_selection)
# Update the emotional guidance system message with the processed guidance
for msg in messages:
if (
msg["role"] == "system"
and "Respond to the user's message using the following emotional guidance."
in msg["content"]
):
msg["content"] = msg["content"].replace(
"{emotion_guidance}", emotion_guidance
)
# Check if the flag to output VAD with response is enabled
if self.user_valves.output_vad_with_response:
vad_output = self.test_output_vad(emotion_guidance, True)
if vad_output:
new_vad_message = {
"role": "assistant",
"content": vad_output,
}
messages.append(new_vad_message)
body["messages"] = messages
return body
