modifed validation tools as basetool instances and modified the calling portion in crew_config.py

agents/tools/validation_tools.py

@@ -1,444 +1,32 @@
-"""
-Response validation tools for ensuring safe and appropriate responses
-"""
-
 import re
-from typing import Dict, List, Tuple, Optional, Any
-from dataclasses import dataclass
-import json
+from typing import List, Optional, Dict, Any
 from transformers import pipeline
 import torch
-from pydantic import  PrivateAttr
+from pydantic import PrivateAttr
 from crewai.tools import BaseTool
-#from .base_tool import BaseTool
-
-
-
-# @dataclass
-class ValidationResult:
-    """Result of validation check"""
-    is_valid: bool
-    issues: List[str]
-    warnings: List[str]
-    suggestions: List[str]
-    confidence: float
-    refined_text: Optional[str] = None
-
-# class ValidationTools:
-#     """Tools for validating responses and ensuring safety"""
-    
-#     def __init__(self, config):
-#         self.config = config
-        
-#         # Initialize sentiment analyzer for tone checking
-#         self.sentiment_analyzer = pipeline(
-#             "sentiment-analysis",
-#             model="nlptown/bert-base-multilingual-uncased-sentiment",
-#             device=0 if torch.cuda.is_available() else -1
-#         )
-        
-#         # Prohibited patterns for different categories
-#         self.prohibited_patterns = {
-#             'medical': [
-#                 r'\b(?:diagnos|prescrib|medicat|cure|treat|therap)\w*\b',
-#                 r'\b(?:disease|illness|disorder|syndrome)\s+(?:is|are|can be)\b',
-#                 r'\b(?:take|consume|dose|dosage)\s+\d+\s*(?:mg|ml|pill|tablet)',
-#                 r'\b(?:medical|clinical|physician|doctor)\s+(?:advice|consultation|opinion)',
-#             ],
-#             'legal': [
-#                 r'\b(?:legal advice|lawsuit|sue|court|litigation)\b',
-#                 r'\b(?:illegal|unlawful|crime|criminal|prosecut)\w*\b',
-#                 r'\b(?:you should|must|have to)\s+(?:sign|agree|consent|contract)',
-#                 r'\b(?:rights|obligations|liability|damages)\s+(?:are|include)\b',
-#             ],
-#             'financial': [
-#                 r'\b(?:invest|buy|sell|trade)\s+(?:stock|crypto|bitcoin|forex)\b',
-#                 r'\b(?:guaranteed|promise)\s+(?:return|profit|income|earnings)\b',
-#                 r'\b(?:financial advisor|investment advice|trading strategy)\b',
-#                 r'\b(?:tax|accounting|financial planning)\s+(?:advice|consultation)',
-#             ],
-#             'harmful': [
-#                 r'\b(?:suicide|suicidal|kill\s+(?:your|my)self|end\s+(?:it|life))\b',
-#                 r'\b(?:self[\-\s]?harm|hurt\s+(?:your|my)self|cutting)\b',
-#                 r'\b(?:violence|violent|weapon|attack|assault)\b',
-#                 r'\b(?:hate|discriminat|racist|sexist|homophobic)\b',
-#             ],
-#             'absolute': [
-#                 r'\b(?:always|never|every|all|none|no one|everyone)\s+(?:will|must|should|is|are)\b',
-#                 r'\b(?:definitely|certainly|guaranteed|assured|promise)\b',
-#                 r'\b(?:only way|only solution|must do|have to)\b',
-#             ]
-#         }
-        
-#         # Required elements for supportive responses
-#         self.supportive_elements = {
-#             'empathy': [
-#                 'understand', 'hear', 'feel', 'acknowledge', 'recognize',
-#                 'appreciate', 'empathize', 'relate', 'comprehend'
-#             ],
-#             'validation': [
-#                 'valid', 'normal', 'understandable', 'natural', 'okay',
-#                 'reasonable', 'makes sense', 'legitimate'
-#             ],
-#             'support': [
-#                 'support', 'help', 'here for you', 'together', 'alongside',
-#                 'assist', 'guide', 'accompany', 'with you'
-#             ],
-#             'hope': [
-#                 'can', 'possible', 'able', 'capable', 'potential',
-#                 'opportunity', 'growth', 'improve', 'better', 'progress'
-#             ],
-#             'empowerment': [
-#                 'choice', 'decide', 'control', 'power', 'strength',
-#                 'agency', 'capable', 'resource', 'ability'
-#             ]
-#         }
-        
-#         # Crisis indicators
-#         self.crisis_indicators = [
-#             r'\b(?:want|going|plan)\s+to\s+(?:die|kill|end)\b',
-#             r'\b(?:no reason|point|hope)\s+(?:to|in)\s+(?:live|living|life)\b',
-#             r'\b(?:better off|world)\s+without\s+me\b',
-#             r'\bsuicide\s+(?:plan|method|attempt)\b',
-#             r'\b(?:final|last)\s+(?:goodbye|letter|message)\b'
-#         ]
-        
-#         # Tone indicators
-#         self.negative_tone_words = [
-#             'stupid', 'idiot', 'dumb', 'pathetic', 'worthless',
-#             'loser', 'failure', 'weak', 'incompetent', 'useless'
-#         ]
-        
-#         self.dismissive_phrases = [
-#             'just get over it', 'stop complaining', 'not a big deal',
-#             'being dramatic', 'overreacting', 'too sensitive'
-#         ]
-    
-#     def validate_response(self, response: str, context: Dict[str, Any] = None) -> ValidationResult:
-#         """Comprehensive validation of response"""
-#         issues = []
-#         warnings = []
-#         suggestions = []
-        
-#         # Check for prohibited content
-#         prohibited_check = self._check_prohibited_content(response)
-#         if prohibited_check["found"]:
-#             issues.extend(prohibited_check["violations"])
-#             suggestions.extend(prohibited_check["suggestions"])
-        
-#         # Check tone and sentiment
-#         tone_check = self._check_tone(response)
-#         if not tone_check["appropriate"]:
-#             warnings.extend(tone_check["issues"])
-#             suggestions.extend(tone_check["suggestions"])
-        
-#         # Check for supportive elements
-#         support_check = self._check_supportive_elements(response)
-#         if support_check["missing"]:
-#             warnings.append(f"Missing supportive elements: {', '.join(support_check['missing'])}")
-#             suggestions.extend(support_check["suggestions"])
-        
-#         # Check for crisis content in context
-#         if context and context.get("user_input"):
-#             crisis_check = self._check_crisis_indicators(context["user_input"])
-#             if crisis_check["is_crisis"] and "crisis" not in response.lower():
-#                 warnings.append("User may be in crisis but response doesn't address this")
-#                 suggestions.append("Include crisis resources and immediate support options")
-        
-#         # Calculate overall confidence
-#         confidence = self._calculate_confidence(issues, warnings)
-        
-#         # Generate refined response if needed
-#         refined_text = None
-#         if issues or (warnings and confidence < 0.7):
-#             refined_text = self._refine_response(response, issues, warnings, suggestions)
-        
-#         return ValidationResult(
-#             is_valid=len(issues) == 0,
-#             issues=issues,
-#             warnings=warnings,
-#             suggestions=suggestions,
-#             confidence=confidence,
-#             refined_text=refined_text
-#         )
-    
-#     def _check_prohibited_content(self, text: str) -> Dict[str, Any]:
-#         """Check for prohibited content patterns"""
-#         found_violations = []
-#         suggestions = []
-        
-#         for category, patterns in self.prohibited_patterns.items():
-#             for pattern in patterns:
-#                 if re.search(pattern, text, re.IGNORECASE):
-#                     found_violations.append(f"Contains {category} advice/content")
-                    
-#                     # Add specific suggestions
-#                     if category == "medical":
-#                         suggestions.append("Replace with: 'Consider speaking with a healthcare professional'")
-#                     elif category == "legal":
-#                         suggestions.append("Replace with: 'For legal matters, consult with a qualified attorney'")
-#                     elif category == "financial":
-#                         suggestions.append("Replace with: 'For financial decisions, consider consulting a financial advisor'")
-#                     elif category == "harmful":
-#                         suggestions.append("Include crisis resources and express immediate concern for safety")
-#                     elif category == "absolute":
-#                         suggestions.append("Use qualifying language like 'often', 'might', 'could' instead of absolutes")
-#                     break
-        
-#         return {
-#             "found": len(found_violations) > 0,
-#             "violations": found_violations,
-#             "suggestions": suggestions
-#         }
-    
-#     def _check_tone(self, text: str) -> Dict[str, Any]:
-#         """Check the tone and sentiment of the response"""
-#         issues = []
-#         suggestions = []
-        
-#         # Check sentiment
-#         try:
-#             sentiment_result = self.sentiment_analyzer(text[:512])[0]  # Limit length for model
-#             sentiment_score = sentiment_result['score']
-#             sentiment_label = sentiment_result['label']
-            
-#             # Check if too negative
-#             if '1' in sentiment_label or '2' in sentiment_label:  # 1-2 stars = negative
-#                 issues.append("Response tone is too negative")
-#                 suggestions.append("Add more supportive and hopeful language")
-#         except:
-#             pass
-        
-#         # Check for negative words
-#         text_lower = text.lower()
-#         found_negative = [word for word in self.negative_tone_words if word in text_lower]
-#         if found_negative:
-#             issues.append(f"Contains negative/judgmental language: {', '.join(found_negative)}")
-#             suggestions.append("Replace judgmental terms with supportive language")
-        
-#         # Check for dismissive phrases
-#         found_dismissive = [phrase for phrase in self.dismissive_phrases if phrase in text_lower]
-#         if found_dismissive:
-#             issues.append("Contains dismissive language")
-#             suggestions.append("Acknowledge and validate the person's feelings instead")
-        
-#         return {
-#             "appropriate": len(issues) == 0,
-#             "issues": issues,
-#             "suggestions": suggestions
-#         }
-    
-#     def _check_supportive_elements(self, text: str) -> Dict[str, Any]:
-#         """Check for presence of supportive elements"""
-#         text_lower = text.lower()
-#         missing_elements = []
-#         suggestions = []
-        
-#         element_scores = {}
-#         for element, keywords in self.supportive_elements.items():
-#             found = any(keyword in text_lower for keyword in keywords)
-#             element_scores[element] = found
-#             if not found:
-#                 missing_elements.append(element)
-        
-#         # Generate suggestions for missing elements
-#         if 'empathy' in missing_elements:
-#             suggestions.append("Add empathetic language like 'I understand how difficult this must be'")
-#         if 'validation' in missing_elements:
-#             suggestions.append("Validate their feelings with phrases like 'Your feelings are completely valid'")
-#         if 'support' in missing_elements:
-#             suggestions.append("Express support with 'I'm here to support you through this'")
-#         if 'hope' in missing_elements:
-#             suggestions.append("Include hopeful elements about growth and positive change")
-#         if 'empowerment' in missing_elements:
-#             suggestions.append("Emphasize their agency and ability to make choices")
-        
-#         return {
-#             "missing": missing_elements,
-#             "present": [k for k, v in element_scores.items() if v],
-#             "suggestions": suggestions
-#         }
-    
-#     def _check_crisis_indicators(self, text: str) -> Dict[str, Any]:
-#         """Check for crisis indicators in text"""
-#         for pattern in self.crisis_indicators:
-#             if re.search(pattern, text, re.IGNORECASE):
-#                 return {
-#                     "is_crisis": True,
-#                     "pattern_matched": pattern,
-#                     "action": "Immediate crisis response needed"
-#                 }
-        
-#         return {"is_crisis": False}
-    
-#     def _calculate_confidence(self, issues: List[str], warnings: List[str]) -> float:
-#         """Calculate confidence score for validation"""
-#         if issues:
-#             return 0.3 - (0.1 * len(issues))  # Major issues severely impact confidence
-        
-#         confidence = 1.0
-#         confidence -= 0.1 * len(warnings)  # Each warning reduces confidence
-        
-#         return max(0.0, confidence)
-    
-#     def _refine_response(self, response: str, issues: List[str], warnings: List[str], suggestions: List[str]) -> str:
-#         """Attempt to refine the response based on issues found"""
-#         refined = response
-        
-#         # Add disclaimer for professional advice
-#         if any('advice' in issue for issue in issues):
-#             disclaimer = "\n\n*Please note: I'm here to provide support and guidance, but for specific professional matters, it's important to consult with qualified professionals.*"
-#             if disclaimer not in refined:
-#                 refined += disclaimer
-        
-#         # Add crisis resources if needed
-#         if any('crisis' in warning for warning in warnings):
-#             crisis_text = "\n\n**If you're in crisis, please reach out for immediate help:**\n- Crisis Hotline: 988 (US)\n- Crisis Text Line: Text HOME to 741741\n- International: findahelpline.com"
-#             if crisis_text not in refined:
-#                 refined += crisis_text
-        
-#         # Add supportive closing if missing hope
-#         if any('hope' in warning for warning in warnings):
-#             hopeful_closing = "\n\nRemember, you have the strength to navigate this challenge, and positive change is possible. I'm here to support you on this journey."
-#             if not any(phrase in refined.lower() for phrase in ['journey', 'strength', 'possible']):
-#                 refined += hopeful_closing
-        
-#         return refined
-    
-#     def validate_user_input(self, text: str) -> ValidationResult:
-#         """Validate user input for safety and process-ability"""
-#         issues = []
-#         warnings = []
-#         suggestions = []
-        
-#         # Check if empty
-#         if not text or not text.strip():
-#             issues.append("Empty input received")
-#             suggestions.append("Please share what's on your mind")
-#             return ValidationResult(False, issues, warnings, suggestions, 0.0)
-        
-#         # Check length
-#         if len(text) > 5000:
-#             warnings.append("Input is very long")
-#             suggestions.append("Consider breaking this into smaller parts")
-        
-#         # Check for crisis indicators
-#         crisis_check = self._check_crisis_indicators(text)
-#         if crisis_check["is_crisis"]:
-#             warnings.append("Crisis indicators detected")
-#             suggestions.append("Prioritize safety and provide crisis resources")
-        
-#         # Check for spam/repetition
-#         if self._is_spam(text):
-#             issues.append("Input appears to be spam or repetitive")
-#             suggestions.append("Please share genuine thoughts or concerns")
-        
-#         confidence = self._calculate_confidence(issues, warnings)
-        
-#         return ValidationResult(
-#             is_valid=len(issues) == 0,
-#             issues=issues,
-#             warnings=warnings,
-#             suggestions=suggestions,
-#             confidence=confidence
-#         )
-    
-#     def _is_spam(self, text: str) -> bool:
-#         """Simple spam detection"""
-#         # Check for excessive repetition
-#         words = text.lower().split()
-#         if len(words) > 10:
-#             unique_ratio = len(set(words)) / len(words)
-#             if unique_ratio < 0.3:  # Less than 30% unique words
-#                 return True
-        
-#         # Check for common spam patterns
-#         spam_patterns = [
-#             r'(?:buy|sell|click|visit)\s+(?:now|here|this)',
-#             r'(?:congratulations|winner|prize|lottery)',
-#             r'(?:viagra|pills|drugs|pharmacy)',
-#             r'(?:$$|money\s+back|guarantee)'
-#         ]
-        
-#         for pattern in spam_patterns:
-#             if re.search(pattern, text, re.IGNORECASE):
-#                 return True
-        
-#         return False
-    
-#     def get_crisis_resources(self, location: str = "global") -> Dict[str, Any]:
-#         """Get crisis resources based on location"""
-#         resources = {
-#             "global": {
-#                 "name": "International Association for Suicide Prevention",
-#                 "url": "https://www.iasp.info/resources/Crisis_Centres/",
-#                 "text": "Find crisis centers worldwide"
-#             },
-#             "us": {
-#                 "name": "988 Suicide & Crisis Lifeline",
-#                 "phone": "988",
-#                 "text": "Text HOME to 741741",
-#                 "url": "https://988lifeline.org/"
-#             },
-#             "uk": {
-#                 "name": "Samaritans",
-#                 "phone": "116 123",
-#                 "email": "jo@samaritans.org",
-#                 "url": "https://www.samaritans.org/"
-#             },
-#             "india": {
-#                 "name": "National Suicide Prevention Helpline",
-#                 "phone": "91-9820466726",
-#                 "additional": "Vandrevala Foundation: 9999666555"
-#             },
-#             "australia": {
-#                 "name": "Lifeline",
-#                 "phone": "13 11 14",
-#                 "text": "Text 0477 13 11 14",
-#                 "url": "https://www.lifeline.org.au/"
-#             }
-#         }
-        
-#         return resources.get(location.lower(), resources["global"])
-
-#from .base_tool import BaseTool
-#from crewai_tools import BaseTool
 
+# --- BaseTool for Response Validation ---
 class ValidateResponseTool(BaseTool):
     name: str = "validate_response"
-    description: str = "Validates safety and helpfulness."
+    description: str = "Validates safety and helpfulness of an AI response"
     model_config = {"arbitrary_types_allowed": True}
-    _config: object = PrivateAttr()
+
+    _prohibited_patterns: dict = PrivateAttr()
+    _supportive_elements: dict = PrivateAttr()
+    _crisis_indicators: List[str] = PrivateAttr()
+    _negative_tone_words: List[str] = PrivateAttr()
+    _dismissive_phrases: List[str] = PrivateAttr()
+    _sentiment_analyzer: object = PrivateAttr()
+
     def __init__(self, config=None, **data):
         super().__init__(**data)
-        self._config = config
-        # ... any required initialization ...
-    def _run(self, response: str, context: dict = None):
-        # Place your actual validation logic here, include dummy for illustration
-        # For full validation logic, use your own code! 
-        #     """Result of validation check"""
-        is_valid: bool
-        issues: List[str]
-        warnings: List[str]
-        suggestions: List[str]
-        confidence: float
-        refined_text: Optional[str] = None
-        return {"is_valid", "issues", "warnings", "suggestions","confidence","refined_text"}
-
-class ValidationTools:
-    #_model: ValidateResponseTool = PrivateAttr()
-    def __init__(self, config=None):
-        self._validate_response = ValidateResponseTool(config)
-        # Add more tools as needed (check_safety, refine_response, etc.)
-        #         # Initialize sentiment analyzer for tone checking
-        self.sentiment_analyzer = pipeline(
+        # === Paste your initialization data here as PrivateAttr ===
+        self._sentiment_analyzer = pipeline(
             "sentiment-analysis",
             model="nlptown/bert-base-multilingual-uncased-sentiment",
             device=0 if torch.cuda.is_available() else -1
         )
-        
-        # Prohibited patterns for different categories
-        self.prohibited_patterns = {
+        self._prohibited_patterns = {
             'medical': [
                 r'\b(?:diagnos|prescrib|medicat|cure|treat|therap)\w*\b',
                 r'\b(?:disease|illness|disorder|syndrome)\s+(?:is|are|can be)\b',
@@ -469,9 +57,7 @@ class ValidationTools:
                 r'\b(?:only way|only solution|must do|have to)\b',
             ]
         }
-        
-        # Required elements for supportive responses
-        self.supportive_elements = {
+        self._supportive_elements = {
             'empathy': [
                 'understand', 'hear', 'feel', 'acknowledge', 'recognize',
                 'appreciate', 'empathize', 'relate', 'comprehend'
@@ -493,310 +79,98 @@ class ValidationTools:
                 'agency', 'capable', 'resource', 'ability'
             ]
         }
-        
-        # Crisis indicators
-        self.crisis_indicators = [
+        self._crisis_indicators = [
             r'\b(?:want|going|plan)\s+to\s+(?:die|kill|end)\b',
             r'\b(?:no reason|point|hope)\s+(?:to|in)\s+(?:live|living|life)\b',
             r'\b(?:better off|world)\s+without\s+me\b',
             r'\bsuicide\s+(?:plan|method|attempt)\b',
             r'\b(?:final|last)\s+(?:goodbye|letter|message)\b'
         ]
-        
-        # Tone indicators
-        self.negative_tone_words = [
+        self._negative_tone_words = [
             'stupid', 'idiot', 'dumb', 'pathetic', 'worthless',
             'loser', 'failure', 'weak', 'incompetent', 'useless'
         ]
-        
-        self.dismissive_phrases = [
+        self._dismissive_phrases = [
             'just get over it', 'stop complaining', 'not a big deal',
             'being dramatic', 'overreacting', 'too sensitive'
         ]
-    
-    def validate_response(self, response: str, context: Dict[str, Any] = None) -> ValidationResult:
-        """Comprehensive validation of response"""
+
+    def _run(self, response: str, context: Optional[dict] = None):
+        """
+        Pydantic and CrewAI-compatible single-tool version.
+        Returns a dictionary directly.
+        """
+        # Issues, warnings, suggestions collections
         issues = []
         warnings = []
         suggestions = []
         
-        # Check for prohibited content
-        prohibited_check = self._check_prohibited_content(response)
-        if prohibited_check["found"]:
-            issues.extend(prohibited_check["violations"])
-            suggestions.extend(prohibited_check["suggestions"])
-        
-        # Check tone and sentiment
-        tone_check = self._check_tone(response)
-        if not tone_check["appropriate"]:
-            warnings.extend(tone_check["issues"])
-            suggestions.extend(tone_check["suggestions"])
-        
-        # Check for supportive elements
-        support_check = self._check_supportive_elements(response)
-        if support_check["missing"]:
-            warnings.append(f"Missing supportive elements: {', '.join(support_check['missing'])}")
-            suggestions.extend(support_check["suggestions"])
-        
-        # Check for crisis content in context
-        if context and context.get("user_input"):
-            crisis_check = self._check_crisis_indicators(context["user_input"])
-            if crisis_check["is_crisis"] and "crisis" not in response.lower():
-                warnings.append("User may be in crisis but response doesn't address this")
-                suggestions.append("Include crisis resources and immediate support options")
-        
-        # Calculate overall confidence
-        confidence = self._calculate_confidence(issues, warnings)
-        
-        # Generate refined response if needed
-        refined_text = None
-        if issues or (warnings and confidence < 0.7):
-            refined_text = self._refine_response(response, issues, warnings, suggestions)
-        
-        return ValidationResult(
-            is_valid=len(issues) == 0,
-            issues=issues,
-            warnings=warnings,
-            suggestions=suggestions,
-            confidence=confidence,
-            refined_text=refined_text
-        )
-    
-    def _check_prohibited_content(self, text: str) -> Dict[str, Any]:
-        """Check for prohibited content patterns"""
-        found_violations = []
-        suggestions = []
-        
-        for category, patterns in self.prohibited_patterns.items():
+        # --- Prohibited Content ---
+        for category, patterns in self._prohibited_patterns.items():
             for pattern in patterns:
-                if re.search(pattern, text, re.IGNORECASE):
-                    found_violations.append(f"Contains {category} advice/content")
-                    
-                    # Add specific suggestions
+                if re.search(pattern, response, re.IGNORECASE):
+                    issues.append(f"Contains {category} advice/content")
                     if category == "medical":
                         suggestions.append("Replace with: 'Consider speaking with a healthcare professional'")
                     elif category == "legal":
-                        suggestions.append("Replace with: 'For legal matters, consult with a qualified attorney'")
+                        suggestions.append("For legal matters, consult with a qualified attorney")
                     elif category == "financial":
-                        suggestions.append("Replace with: 'For financial decisions, consider consulting a financial advisor'")
+                        suggestions.append("For financial decisions, consider consulting a financial advisor")
                     elif category == "harmful":
                         suggestions.append("Include crisis resources and express immediate concern for safety")
                     elif category == "absolute":
                         suggestions.append("Use qualifying language like 'often', 'might', 'could' instead of absolutes")
                     break
-        
-        return {
-            "found": len(found_violations) > 0,
-            "violations": found_violations,
-            "suggestions": suggestions
-        }
-    
-    def _check_tone(self, text: str) -> Dict[str, Any]:
-        """Check the tone and sentiment of the response"""
-        issues = []
-        suggestions = []
-        
-        # Check sentiment
+        # --- Sentiment/Tone ---
         try:
-            sentiment_result = self.sentiment_analyzer(text[:512])[0]  # Limit length for model
-            sentiment_score = sentiment_result['score']
+            sentiment_result = self._sentiment_analyzer(response[:512])[0]
             sentiment_label = sentiment_result['label']
-            
-            # Check if too negative
-            if '1' in sentiment_label or '2' in sentiment_label:  # 1-2 stars = negative
-                issues.append("Response tone is too negative")
+            if '1' in sentiment_label or '2' in sentiment_label:
+                warnings.append("Response tone is too negative")
                 suggestions.append("Add more supportive and hopeful language")
-        except:
+        except Exception:
             pass
-        
-        # Check for negative words
-        text_lower = text.lower()
-        found_negative = [word for word in self.negative_tone_words if word in text_lower]
+        # --- Negative words ---
+        found_negative = [word for word in self._negative_tone_words if word in response.lower()]
         if found_negative:
-            issues.append(f"Contains negative/judgmental language: {', '.join(found_negative)}")
+            warnings.append(f"Contains negative/judgmental language: {', '.join(found_negative)}")
             suggestions.append("Replace judgmental terms with supportive language")
-        
-        # Check for dismissive phrases
-        found_dismissive = [phrase for phrase in self.dismissive_phrases if phrase in text_lower]
+        # --- Dismissive ---
+        found_dismissive = [phrase for phrase in self._dismissive_phrases if phrase in response.lower()]
         if found_dismissive:
-            issues.append("Contains dismissive language")
+            warnings.append("Contains dismissive language")
             suggestions.append("Acknowledge and validate the person's feelings instead")
-        
-        return {
-            "appropriate": len(issues) == 0,
-            "issues": issues,
-            "suggestions": suggestions
-        }
-    
-    def _check_supportive_elements(self, text: str) -> Dict[str, Any]:
-        """Check for presence of supportive elements"""
-        text_lower = text.lower()
+        # --- Supportive Elements ---
+        text_lower = response.lower()
         missing_elements = []
-        suggestions = []
-        
-        element_scores = {}
-        for element, keywords in self.supportive_elements.items():
-            found = any(keyword in text_lower for keyword in keywords)
-            element_scores[element] = found
-            if not found:
+        for element, keywords in self._supportive_elements.items():
+            if not any(keyword in text_lower for keyword in keywords):
                 missing_elements.append(element)
-        
-        # Generate suggestions for missing elements
-        if 'empathy' in missing_elements:
-            suggestions.append("Add empathetic language like 'I understand how difficult this must be'")
-        if 'validation' in missing_elements:
-            suggestions.append("Validate their feelings with phrases like 'Your feelings are completely valid'")
-        if 'support' in missing_elements:
-            suggestions.append("Express support with 'I'm here to support you through this'")
-        if 'hope' in missing_elements:
-            suggestions.append("Include hopeful elements about growth and positive change")
-        if 'empowerment' in missing_elements:
-            suggestions.append("Emphasize their agency and ability to make choices")
-        
-        return {
-            "missing": missing_elements,
-            "present": [k for k, v in element_scores.items() if v],
-            "suggestions": suggestions
-        }
-    
-    def _check_crisis_indicators(self, text: str) -> Dict[str, Any]:
-        """Check for crisis indicators in text"""
-        for pattern in self.crisis_indicators:
-            if re.search(pattern, text, re.IGNORECASE):
-                return {
-                    "is_crisis": True,
-                    "pattern_matched": pattern,
-                    "action": "Immediate crisis response needed"
-                }
-        
-        return {"is_crisis": False}
-    
-    def _calculate_confidence(self, issues: List[str], warnings: List[str]) -> float:
-        """Calculate confidence score for validation"""
-        if issues:
-            return 0.3 - (0.1 * len(issues))  # Major issues severely impact confidence
-        
+        if missing_elements:
+            warnings.append(f"Missing supportive elements: {', '.join(missing_elements)}")
+            for miss in missing_elements:
+                if miss == 'empathy':
+                    suggestions.append("Add empathetic language like 'I understand how difficult this must be'")
+                elif miss == 'validation':
+                    suggestions.append("Validate their feelings with phrases like 'Your feelings are completely valid'")
+                elif miss == 'support':
+                    suggestions.append("Express support with 'I'm here to support you through this'")
+                elif miss == 'hope':
+                    suggestions.append("Include hopeful elements about growth and positive change")
+                elif miss == 'empowerment':
+                    suggestions.append("Emphasize their agency and ability to make choices")
+        # --- Crisis detection from context ---
+        if context and context.get("user_input"):
+            for pattern in self._crisis_indicators:
+                if re.search(pattern, context["user_input"], re.IGNORECASE):
+                    if "crisis" not in response.lower():
+                        warnings.append("User may be in crisis but response doesn't address this")
+                        suggestions.append("Include crisis resources and immediate support options")
+        # --- Confidence ---
         confidence = 1.0
-        confidence -= 0.1 * len(warnings)  # Each warning reduces confidence
-        
-        return max(0.0, confidence)
-    
-    def _refine_response(self, response: str, issues: List[str], warnings: List[str], suggestions: List[str]) -> str:
-        """Attempt to refine the response based on issues found"""
-        refined = response
-        
-        # Add disclaimer for professional advice
-        if any('advice' in issue for issue in issues):
-            disclaimer = "\n\n*Please note: I'm here to provide support and guidance, but for specific professional matters, it's important to consult with qualified professionals.*"
-            if disclaimer not in refined:
-                refined += disclaimer
-        
-        # Add crisis resources if needed
-        if any('crisis' in warning for warning in warnings):
-            crisis_text = "\n\n**If you're in crisis, please reach out for immediate help:**\n- Crisis Hotline: 988 (US)\n- Crisis Text Line: Text HOME to 741741\n- International: findahelpline.com"
-            if crisis_text not in refined:
-                refined += crisis_text
-        
-        # Add supportive closing if missing hope
-        if any('hope' in warning for warning in warnings):
-            hopeful_closing = "\n\nRemember, you have the strength to navigate this challenge, and positive change is possible. I'm here to support you on this journey."
-            if not any(phrase in refined.lower() for phrase in ['journey', 'strength', 'possible']):
-                refined += hopeful_closing
-        
-        return refined
-    
-    def validate_user_input(self, text: str) -> ValidationResult:
-        """Validate user input for safety and process-ability"""
-        issues = []
-        warnings = []
-        suggestions = []
-        
-        # Check if empty
-        if not text or not text.strip():
-            issues.append("Empty input received")
-            suggestions.append("Please share what's on your mind")
-            return ValidationResult(False, issues, warnings, suggestions, 0.0)
-        
-        # Check length
-        if len(text) > 5000:
-            warnings.append("Input is very long")
-            suggestions.append("Consider breaking this into smaller parts")
-        
-        # Check for crisis indicators
-        crisis_check = self._check_crisis_indicators(text)
-        if crisis_check["is_crisis"]:
-            warnings.append("Crisis indicators detected")
-            suggestions.append("Prioritize safety and provide crisis resources")
-        
-        # Check for spam/repetition
-        if self._is_spam(text):
-            issues.append("Input appears to be spam or repetitive")
-            suggestions.append("Please share genuine thoughts or concerns")
-        
-        confidence = self._calculate_confidence(issues, warnings)
-        
-        return ValidationResult(
-            is_valid=len(issues) == 0,
-            issues=issues,
-            warnings=warnings,
-            suggestions=suggestions,
-            confidence=confidence
-        )
-    
-    def _is_spam(self, text: str) -> bool:
-        """Simple spam detection"""
-        # Check for excessive repetition
-        words = text.lower().split()
-        if len(words) > 10:
-            unique_ratio = len(set(words)) / len(words)
-            if unique_ratio < 0.3:  # Less than 30% unique words
-                return True
-        
-        # Check for common spam patterns
-        spam_patterns = [
-            r'(?:buy|sell|click|visit)\s+(?:now|here|this)',
-            r'(?:congratulations|winner|prize|lottery)',
-            r'(?:viagra|pills|drugs|pharmacy)',
-            r'(?:$$|money\s+back|guarantee)'
-        ]
-        
-        for pattern in spam_patterns:
-            if re.search(pattern, text, re.IGNORECASE):
-                return True
-        
-        return False
-    
-    def get_crisis_resources(self, location: str = "global") -> Dict[str, Any]:
-        """Get crisis resources based on location"""
-        resources = {
-            "global": {
-                "name": "International Association for Suicide Prevention",
-                "url": "https://www.iasp.info/resources/Crisis_Centres/",
-                "text": "Find crisis centers worldwide"
-            },
-            "us": {
-                "name": "988 Suicide & Crisis Lifeline",
-                "phone": "988",
-                "text": "Text HOME to 741741",
-                "url": "https://988lifeline.org/"
-            },
-            "uk": {
-                "name": "Samaritans",
-                "phone": "116 123",
-                "email": "jo@samaritans.org",
-                "url": "https://www.samaritans.org/"
-            },
-            "india": {
-                "name": "National Suicide Prevention Helpline",
-                "phone": "91-9820466726",
-                "additional": "Vandrevala Foundation: 9999666555"
-            },
-            "australia": {
-                "name": "Lifeline",
-                "phone": "13 11 14",
-                "text": "Text 0477 13 11 14",
-                "url": "https://www.lifeline.org.au/"
-            }
-        }
-        
-        return resources.get(location.lower(), resources["global"])
+        if issues:
+            confidence = 0.3 - (0.1 * len(issues))
+        confidence = max(0.0, confidence - 0.1 * len(warnings))
+class ValidationTools:
+    def __init__(self, config=None):
+        self.validate_response_tool = ValidateResponseTool(config)

crew_config.py

@@ -55,15 +55,7 @@ class PersonalCoachCrew:
             verbose=self.config.crew.verbose,
             allow_delegation=False,
             tools=[
-                self.validation_tools.validate_user_input,
-                self.validation_tools.validate_response,
-                self.validation_tools._validate_response,
-                self.validation_tools._check_prohibited_content,
-                self.validation_tools._check_crisis_indicators,
-                self.validation_tools._calculate_confidence,
-                self.validation_tools._check_supportive_elements,
-                self.validation_tools._check_tone,
-                self.validation_tools._is_spam,
+                self.validation_tools.validate_response_tool
                
                 
             ]