Mood Modeling and Tracking

Update Summary

Changes Made

• Updated Mood Update Mechanism section with enhanced JSON extraction strategies
• Added details on safe LLM calling with retry mechanisms
• Expanded Mood Decay and Stability Controls with momentum and damping factors
• Enhanced Common Mood Dynamics Issues with new mitigation strategies
• Added Emotional Event Logging and Mood Blending sections
• Updated all code examples and diagrams to reflect current implementation

Table of Contents

1. Introduction
2. Mood Representation and Initialization
3. Mood Update Mechanism
4. Mood Decay and Stability Controls
5. Persona-Based Mood Modulation
6. Environmental and Action-Based Stimuli Processing
7. Integration with AGISystem and Memory Logging
8. Common Mood Dynamics Issues and Mitigation
9. Emotional Event Logging
10. Mood Blending
11. Tuning Mood Sensitivity and Decay Parameters
12. Conclusion

Introduction

The mood modeling subsystem in the RAVANA AGI framework enables emotionally intelligent behavior by dynamically tracking and updating internal mood states based on actions, environmental stimuli, and cognitive reflections. This document details the architecture, implementation, and operational dynamics of the mood modeling system, focusing on the EmotionalIntelligence and MoodProcessor classes. The system supports nuanced emotional responses through LLM-driven updates, persona-based modulation, and configurable decay mechanisms.

Section sources

• emotional_intellegence.py

Mood Representation and Initialization

The mood state is represented as a vector of named emotional dimensions, each with a continuous intensity value between 0.0 and 1.0. The system distinguishes between positive and negative moods, which are defined in the core configuration.

Mood Dimensions

The mood dimensions are categorized into three groups:

• Primary Emotions: Organized by emotional basis (joy, interest, sadness, anger, fear, surprise)
• Secondary Emotions: Complex emotional states derived from combinations
• All Moods: Combined set of primary and secondary emotions

These are defined in the emotional_intellegence.py file through configuration and initialization:

def _initialize_mood_dimensions(self):
    """Initialize expanded mood dimensions with primary, secondary, and complex emotions"""
    # Primary emotions from config
    primary_emotions = Config.POSITIVE_MOODS + Config.NEGATIVE_MOODS
    
    # Extended primary emotions from enhanced config
    emotion_config = {
        "joy_based": ["Confident", "Excited", "Inspired", "Satisfied"],
        "interest_based": ["Curious", "Reflective", "Intrigued", "Engaged"],
        "sadness_based": ["Disappointed", "Bored", "Low Energy", "Melancholic"],
        "anger_based": ["Frustrated", "Irritated", "Stuck", "Resentful"],
        "fear_based": ["Anxious", "Apprehensive", "Cautious", "Suspicious"],
        "surprise_based": ["Astonished", "Bewildered", "Amazed", "Shocked"]
    }
    
    # Secondary emotions
    secondary_emotions = [
        "Hopeful", "Grateful", "Proud", "Guilty", "Lonely", "Nostalgic", 
        "Embarrassed", "Jealous", "Relieved", "Surprised", "Envious", "Peaceful",
        "Compassionate", "Confused", "Optimistic", "Pessimistic"
    ]
    
    # Combine all emotions
    self.ALL_MOODS = list(set(primary_emotions + extended_primary + secondary_emotions))
    self.PRIMARY_MOODS = extended_primary
    self.SECONDARY_MOODS = secondary_emotions

The EmotionalIntelligence class initializes the mood vector by combining these categories and setting initial values to 0.0:

self.mood_vector: Dict[str, float] = {mood: 0.0 for mood in self.ALL_MOODS}

This creates a comprehensive mood space that evolves over time based on system interactions.

Enhanced JSON Extraction

The system now includes robust JSON extraction from LLM responses with multiple fallback strategies:

def _extract_json_from_response(self, response: str) -> Dict:
    """
    Extract JSON from LLM response with multiple fallback strategies.
    
    Args:
        response: Raw LLM response string
        
    Returns:
        Dictionary parsed from JSON, or empty dict if parsing fails
    """
    if not response or not response.strip():
        logger.error("Empty response received from LLM")
        return {}
        
    response = response.strip()
    
    # Strategy 1: Try to parse the entire response as JSON
    try:
        return json.loads(response)
    except json.JSONDecodeError:
        pass
        
    # Strategy 2: Look for JSON in markdown code blocks
    json_match = re.search(r'```(?:json)?\s*({.*?})\s*```', response, re.DOTALL)
    if json_match:
        try:
            json_str = json_match.group(1)
            return json.loads(json_str)
        except json.JSONDecodeError as e:
            logger.warning(f"Failed to parse JSON from code block: {e}")
            
    # Strategy 3: Look for any JSON-like structure
    json_match = re.search(r'({.*})', response, re.DOTALL)
    if json_match:
        try:
            json_str = json_match.group(1)
            return json.loads(json_str)
        except json.JSONDecodeError as e:
            logger.warning(f"Failed to parse extracted JSON structure: {e}")
            
    # Strategy 4: Handle common LLM response patterns
    # Remove common prefixes/suffixes
    cleaned_response = re.sub(r'^[^{]*', '', response)  # Remove everything before first {
    cleaned_response = re.sub(r'[^}]*$', '', cleaned_response)  # Remove everything after last }
    
    if cleaned_response:
        try:
            return json.loads(cleaned_response)
        except json.JSONDecodeError as e:
            logger.warning(f"Failed to parse cleaned response: {e}")
            
    logger.error(f"Could not extract valid JSON from LLM response: {response}")
    return {}

Safe LLM Calling

The system uses safe_call_llm for improved error handling and reliability:

def safe_call_llm(prompt: str, timeout: int = 30, retries: int = 3, backoff_factor: float = 0.5, **kwargs) -> str:
    """
    Wrap a single LLM call with retry/backoff and timeout.
    """
    last_exc = None
    for attempt in range(1, retries + 1):
        try:
            # BLOCKING call with timeout
            result = call_llm(prompt, **kwargs)
            if not result or result.strip() == "":
                raise RuntimeError("Empty response from LLM")
            return result
        except Exception as e:
            last_exc = e
            wait = backoff_factor * (2 ** (attempt - 1))
            logger.warning(f"LLM call failed (attempt {attempt}/{retries}): {e!r}, retrying in {wait:.1f}s")
            time.sleep(wait)
    
    logger.error(f"LLM call permanently failed after {retries} attempts: {last_exc!r}")
    return f"[LLM Error: {last_exc}]"

Example Update Calculation

When an action result contains {"task_completed": True}, and the configuration defines:

{
  "mood_updates": {
    "task_completed": {
      "Confident": 0.25,
      "Satisfied": 0.2,
      "Content": 0.1
    }
  }
}

The system applies:

• Confident: 0.0 → 0.25 (after decay)
• Satisfied: 0.0 → 0.2 (after decay)
• Content: 0.0 → 0.1 (after decay)

Section sources

• mood_processor.py
• emotional_intellegence.py

Mood Decay and Stability Controls

To prevent emotional stagnation and ensure responsiveness to new stimuli, the system implements automatic mood decay with enhanced stability controls. This simulates emotional fading over time in the absence of reinforcing events.

Enhanced Decay Implementation

The decay_moods method reduces all mood intensities by a fixed amount with stability thresholds:

def decay_moods(self, decay: float = 0.05):
    """Enhanced mood decay with stability controls"""
    logger.debug(f"Decaying all moods by {decay}")
    stability_threshold = self.config.get("mood_dynamics", {}).get("stability_threshold", 0.3)
    
    for mood in self.mood_vector:
        # Apply stronger decay to moods above stability threshold
        current_value = self.mood_vector[mood]
        if current_value > stability_threshold:
            effective_decay = decay * 1.5  # Stronger decay for high-intensity moods
        else:
            effective_decay = decay
            
        self.mood_vector[mood] = max(0.0, current_value - effective_decay)
        
        # Reduce momentum as well
        self.mood_momentum[mood] = self.mood_momentum[mood] * 0.9

Momentum and Damping

The system implements emotional momentum to prevent rapid mood swings:

def update_mood(self, mood: str, delta: float):
    """Enhanced mood update with momentum and persona adaptation"""
    logger.debug(f"Updating mood '{mood}' by {delta}")
    if mood in self.mood_vector:
        # Apply persona multiplier
        multiplier = self.persona.get("mood_multipliers", {}).get(mood, 1.0)
        
        # Apply momentum factor to prevent rapid mood swings
        momentum_effect = self.mood_momentum.get(mood, 0.0) * self.momentum_factor
        adjusted_delta = (delta * multiplier) + momentum_effect
        
        # Update mood with damping to prevent oscillations
        new_value = max(0.0, self.mood_vector[mood] + adjusted_delta)
        self.mood_vector[mood] = new_value * self.damping_factor
        
        # Update momentum
        self.mood_momentum[mood] = self.mood_momentum[mood] * 0.8 + adjusted_delta * 0.2

Stability Mechanisms

• Non-Negative Constraint: Mood values are clamped at 0.0 to prevent negative intensities.
• Decay Timing: Decay occurs before updates, ensuring new stimuli are applied to a slightly diminished state.
• Dominant Mood Tracking: The system identifies the most intense mood using get_dominant_mood():

def get_dominant_mood(self) -> str:
    return max(self.mood_vector, key=lambda m: self.mood_vector[m])

This prevents oscillation by providing a stable reference for behavioral influence.